[llvm-commits] CVS: llvm-test/MultiSource/Applications/SIBsim4/COPYRIGHT Makefile SIBsim4.1 align.c align.h misc.c misc.h sim4.h sim4.init.c sim4b1.c sim4b1.h x.fa y.fa
Nick Lewycky
nicholas at mxc.ca
Thu Feb 15 15:46:26 PST 2007
Changes in directory llvm-test/MultiSource/Applications/SIBsim4:
COPYRIGHT added (r1.1)
Makefile added (r1.1)
SIBsim4.1 added (r1.1)
align.c added (r1.1)
align.h added (r1.1)
misc.c added (r1.1)
misc.h added (r1.1)
sim4.h added (r1.1)
sim4.init.c added (r1.1)
sim4b1.c added (r1.1)
sim4b1.h added (r1.1)
x.fa added (r1.1)
y.fa added (r1.1)
---
Log message:
Add SIBsim4 to the test suite.
---
Diffs of the changes: (+12959 -0)
COPYRIGHT | 82 +
Makefile | 9
SIBsim4.1 | 142 +
align.c | 561 +++++++
align.h | 20
misc.c | 70
misc.h | 26
sim4.h | 166 ++
sim4.init.c | 699 +++++++++
sim4b1.c | 2487 ++++++++++++++++++++++++++++++++++
sim4b1.h | 23
x.fa | 4340 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
y.fa | 4334 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
13 files changed, 12959 insertions(+)
Index: llvm-test/MultiSource/Applications/SIBsim4/COPYRIGHT
diff -c /dev/null llvm-test/MultiSource/Applications/SIBsim4/COPYRIGHT:1.1
*** /dev/null Thu Feb 15 17:46:19 2007
--- llvm-test/MultiSource/Applications/SIBsim4/COPYRIGHT Thu Feb 15 17:46:09 2007
***************
*** 0 ****
--- 1,82 ----
+ This package (SIBsim4) implements a variation of the Sim4 algorithm,
+ as described below, originally written by Liliana Florea and Scott
+ Schwartz. The modifications were written by Claudio Lottaz and
+ Christian Iseli, while working for the Swiss Institute of
+ Bioinformatics and the Ludwig Institute for Cancer Research.
+
+ The modifications are Copyright (c) Swiss Institute of Bioinformatics,
+ and Ludwig Institute for Cancer Research (LICR), 2001-2004. For the
+ purposes of this copyright, the Swiss Institute of Bioinformatics acts
+ on behalf of its partner, LICR.
+
+ The resulting, modified, package is licensed under the terms of the
+ GNU General Public License as published by the Free Software
+ Foundation; either version 2 of the License, or (at your option) any
+ later version.
+
+ Below is the original copyright notice.
+
+ -----------------------------------------------------------------------
+
+ This package implements the Sim4 algorithm for aligning expressed DNA
+ with genomic sequences, described in the paper:
+
+ L. Florea, G. Hartzell, Z. Zhang, G. Rubin, and W. Miller (1998)
+ "A computer program for aligning a cDNA sequence with a genomic DNA sequence."
+ Genome Research 8, 967-974.
+
+
+ Portions copyright by:
+
+ Copyright (C) 1998-2001 Liliana Florea
+ Copyright (C) 1998-2001 Scott Schwartz
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+ # The following files were written by Liliana Florea:
+
+ Xtend1.c
+ Xtend1.h
+ align.c
+ align.h
+ sim4.h
+ sim4.init.c
+ sim4b1.c
+ sim4b1.h
+ splice.c
+ splice.h
+
+ # The following files were written by Scott Schwartz:
+
+ args.c
+ args.h
+ charvec.c
+ charvec.h
+ discrim.c
+ discrim.h
+ dna.c
+ dna.h
+ encoding.c
+ encoding.h
+ libc.h
+ misc.c
+ misc.h
+ prnt.c
+ prnt.h
+ psublast.h
+ seq.c
+ seq.h
+ seq_read.c
+ types.h
Index: llvm-test/MultiSource/Applications/SIBsim4/Makefile
diff -c /dev/null llvm-test/MultiSource/Applications/SIBsim4/Makefile:1.1
*** /dev/null Thu Feb 15 17:46:25 2007
--- llvm-test/MultiSource/Applications/SIBsim4/Makefile Thu Feb 15 17:46:09 2007
***************
*** 0 ****
--- 1,9 ----
+ LEVEL = ../../..
+ PROG = SIBsim4
+
+ CPPFLAGS =
+ LDFLAGS =
+
+ RUN_OPTIONS="$(PROJ_SRC_DIR)/x.fa $(PROJ_SRC_DIR)/y.fa -A4"
+
+ include ../../Makefile.multisrc
Index: llvm-test/MultiSource/Applications/SIBsim4/SIBsim4.1
diff -c /dev/null llvm-test/MultiSource/Applications/SIBsim4/SIBsim4.1:1.1
*** /dev/null Thu Feb 15 17:46:25 2007
--- llvm-test/MultiSource/Applications/SIBsim4/SIBsim4.1 Thu Feb 15 17:46:09 2007
***************
*** 0 ****
--- 1,142 ----
+ .\" $Id: SIBsim4.1,v 1.1 2007/02/15 23:46:09 nicholas Exp $
+ .\" Christian Iseli, LICR ITO, Christian.Iseli at licr.org
+ .\"
+ .\" Copyright (c) 2004-2006 Swiss Institute of Bioinformatics.
+ .\"
+ .TH SIBsim4 1 "January 2006" Bioinformatics "User Manuals"
+ .SH NAME
+ SIBsim4 \- align RNA sequences with a DNA sequence, allowing for introns
+ .SH SYNOPSIS
+ .B SIBsim4 [
+ .I options
+ .B ]
+ .I dna rna_db
+ .SH DESCRIPTION
+ .B SIBsim4
+ is a similarity-based tool for aligning a collection of expressed
+ sequences (EST, mRNA) with a genomic DNA sequence.
+
+ Launching
+ .B SIBsim4
+ without any arguments will print the options list, along with their
+ default values.
+
+ .B SIBsim4
+ employs a blast-based technique to first determine the basic
+ matching blocks representing the "exon cores". In this first stage, it
+ detects all possible exact matches of W-mers (i.e., DNA words of size
+ W) between the two sequences and extends them to maximal scoring
+ gap-free segments. In the second stage, the exon cores are extended
+ into the adjacent as-yet-unmatched fragments using greedy alignment
+ algorithms, and heuristics are used to favor configurations that
+ conform to the splice-site recognition signals (e.g., GT-AG). If
+ necessary, the process is repeated with less stringent parameters on
+ the unmatched fragments.
+
+ By default,
+ .B SIBsim4
+ searches both strands and reports the best matches,
+ measured by the number of matching nucleotides found in the alignment.
+ The
+ .B R
+ command line option can be used to restrict the search to one
+ orientation (strand) only.
+
+ Currently, four major alignment display options are supported,
+ controlled by the
+ .B A
+ option. By default, only the endpoints, overall similarity, and
+ orientation of the introns are reported. An arrow sign ('->' or '<-')
+ indicates the orientation of the intron. The sign `==' marks the
+ absence from the alignment of a cDNA fragment starting at that
+ position.
+
+ In the description below, the term
+ .B MSP
+ denotes a maximal scoring pair, that is, a pair of highly similar
+ fragments in the two sequences, obtained during the blast-like
+ procedure by extending a W-mer hit by matches and perhaps a few
+ mismatches.
+
+ .SH OPTIONS
+ .IP "-A <int>"
+ output format
+ 0: exon endpoints only
+ 1: alignment text
+ 3: both exon endpoints and alignment text
+ 4: both exon endpoints and alignment text with polyA info
+
+ Note that 2 is unimplemented.
+
+ Default value is 0.
+ .IP "-C <int>"
+ MSP score threshold for the second pass.
+
+ Default value is 12.
+ .IP "-c <int>"
+ minimum score cutoff value. Alignments which have scores below this value
+ are not reported.
+
+ Default value is 50.
+ .IP "-E <int>"
+ cutoff value.
+
+ Default value is 3.
+ .IP "-f <int>"
+ score filter in percent. When multiple hits are detected for the same RNA
+ element, only those having a score within this percentage of the maximal
+ score for that RNA element are reported. Setting this value to 0 disables
+ filtering and all hits will be reported, provided their score is above the
+ cutoff value specified through the
+ .B c
+ option.
+
+ Default value is 75.
+ .IP "-g <int>"
+ join exons when gap on genomic and RNA have lengths which
+ differ at most by this percentage.
+
+ Default value is 10.
+ .IP "-I <int>"
+ window width in which to search for intron splicing.
+
+ Default value is 6.
+ .IP "-K <int>"
+ MSP score threshold for the first pass.
+
+ Default value is 16.
+ .IP "-L <str>"
+ a comma separated list of forward splice-types.
+
+ Default value is "GTAG,GCAG,GTAC,ATAC".
+ .IP "-M <int>"
+ scoring splice sites, evaluate match within M nucleotides.
+
+ Default value is 10.
+ .IP "-o <int>"
+ when printing results, offset nt positions in dna sequence by this amount.
+
+ Default value is 0.
+ .IP "-q <int>"
+ penalty for a nucleotide mismatch.
+
+ Default value is -5.
+ .IP "-R <int>"
+ direction of search
+ 0: search the '+' (direct) strand only
+ 1: search the '-' strand only
+ 2: search both strands
+
+ Default value is 2.
+ .IP "-r <int>"
+ reward for a nucleotide match.
+
+ Default value is 1.
+ .IP "-W <int>"
+ word size.
+
+ Default value is 12.
+ .IP "-X <int>"
+ value for terminating word extensions.
+
+ Default value is 12.
Index: llvm-test/MultiSource/Applications/SIBsim4/align.c
diff -c /dev/null llvm-test/MultiSource/Applications/SIBsim4/align.c:1.1
*** /dev/null Thu Feb 15 17:46:25 2007
--- llvm-test/MultiSource/Applications/SIBsim4/align.c Thu Feb 15 17:46:09 2007
***************
*** 0 ****
--- 1,561 ----
+ /* $Id: align.c,v 1.1 2007/02/15 23:46:09 nicholas Exp $
+ *
+ * Christian Iseli, LICR ITO, Christian.Iseli at licr.org
+ *
+ * Copyright (c) 2001-2006 Swiss Institute of Bioinformatics.
+ * Copyright (C) 1998-2001 Liliana Florea.
+ */
+ #include <stdio.h>
+ #include <stdlib.h>
+ #include <assert.h>
+ #include <limits.h>
+ #include "sim4.h"
+ #include "sim4b1.h"
+ #include "align.h"
+ #include "misc.h"
+
+ static int snake(uchar *,uchar *,int, int, int, int);
+ static int rsnake(uchar *,uchar *,int, int, int, int, int, int);
+
+
+ void
+ align_path(uchar *seq1, uchar *seq2, int i1, int j1, int i2, int j2, int dist,
+ edit_script_p_t *head, edit_script_p_t *tail, int M, int N)
+ {
+
+ int *last_d, *temp_d, /* forward vectors */
+ *rlast_d, *rtemp_d; /* backward vectors */
+
+ edit_script_p_t head1, tail1, head2, tail2;
+ int midc, rmidc;
+ int start, lower, upper;
+ int rstart, rlower, rupper;
+ int c, k, row;
+ int mi, mj, tmp, ll, uu;
+ char flag;
+
+ *head = *tail = NULL;
+
+ /* Boundary cases */
+ if (i1 == i2) {
+ if (j1 == j2) *head = NULL;
+ else {
+ head1 = (edit_script_p_t) xmalloc(sizeof(edit_script_t));
+ head1->op_type = INSERT;
+ head1->num = j2-j1;
+ head1->next = NULL;
+ *head = *tail = head1;
+ }
+ return;
+ }
+
+ if (j1 == j2) {
+ head1 = (edit_script_p_t) xmalloc(sizeof(edit_script_t));
+ head1->op_type = DELETE;
+ head1->num = i2-i1;
+ head1->next = NULL;
+ *head = *tail = head1;
+ return;
+ }
+
+ if (dist <= 1) {
+ start = j1-i1;
+ if (j2-i2 == j1-i1) {
+ head1 = (edit_script_p_t) xmalloc(sizeof(edit_script_t));
+ head1->op_type = SUBSTITUTE;
+ head1->num = i2-i1;
+ head1->next = NULL;
+ *head = *tail = head1;
+ } else if (j2-j1 == i2-i1+1) {
+
+ tmp = snake(seq1,seq2,start,i1,i2,j2);
+ if (tmp>i1) {
+ head1 = (edit_script_p_t) xmalloc(sizeof(edit_script_t));
+ head1->op_type = SUBSTITUTE;
+ head1->num = tmp-i1;
+ *head = head1;
+ }
+ head2 = (edit_script_p_t) xmalloc(sizeof(edit_script_t));
+ head2->op_type = INSERT;
+ head2->num = 1;
+
+ if (*head) head1->next = head2;
+ else *head = head2;
+ *tail = head2;
+ head2->next = NULL;
+
+ if (i2-tmp) {
+ head1 = head2;
+ *tail = head2 = (edit_script_p_t) xmalloc(sizeof(edit_script_t));
+ head2->op_type = SUBSTITUTE;
+ head2->num = i2-tmp;
+ head2->next = NULL;
+ head1->next = head2;
+ }
+ } else if (j2-j1+1 == i2-i1) {
+
+ tmp = snake(seq1,seq2,start,i1,i2,j2);
+ if (tmp>i1) {
+ head1 = (edit_script_p_t) xmalloc(sizeof(edit_script_t));
+ head1->op_type = SUBSTITUTE;
+ head1->num = tmp-i1;
+ *head = head1;
+ }
+ head2 = (edit_script_p_t) xmalloc(sizeof(edit_script_t));
+ head2->op_type = DELETE;
+ head2->num = 1;
+
+ if (*head) head1->next = head2;
+ else *head = head2;
+ *tail = head2;
+ head2->next = NULL;
+
+ if (i2>tmp+1) {
+ head1 = head2;
+ *tail = head2 = (edit_script_p_t) xmalloc(sizeof(edit_script_t));
+ head2->op_type = SUBSTITUTE;
+ head2->num = i2-tmp-1;
+ head2->next = NULL;
+ head1->next = head2;
+ }
+ } else {
+ fprintf(stderr,
+ "align.c: warning: something wrong when aligning.");
+ }
+ return;
+ }
+
+ /* Divide the problem at the middle cost */
+ midc = dist/2;
+ rmidc = dist - midc;
+
+ /* Compute the boundary diagonals */
+ start = j1 - i1;
+ lower = max(j1-i2, start-midc);
+ upper = min(j2-i1, start+midc);
+ rstart = j2-i2;
+ rlower = max(j1-i2, rstart-rmidc);
+ rupper = min(j2-i1, rstart+rmidc);
+
+ /* Allocate space for forward vectors */
+ last_d = (int *)xmalloc((upper-lower+1)*sizeof(int)) - lower;
+ temp_d = (int *)xmalloc((upper-lower+1)*sizeof(int)) - lower;
+
+ for (k=lower; k<=upper; k++) last_d[k] = -1;
+ last_d[start] = snake(seq1,seq2,start,i1,i2,j2);
+
+ /* Forward computation */
+ for (c=1; c<=midc; ++c) {
+ ll = max(lower,start-c);
+ uu = min(upper,start+c);
+ for (k=ll; k<=uu; ++k) {
+ if (k == ll) {
+ /* DELETE : down from (k+1,c-1) */
+ row = last_d[k+1]+1;
+ } else if (k == uu) {
+ /* INSERT : right from (k-1,c-1) */
+ row = last_d[k-1];
+ } else if ((last_d[k]>=last_d[k+1]) &&
+ (last_d[k]+1>=last_d[k-1])) {
+ /* SUBSTITUTE */
+ row = last_d[k]+1;
+ } else if ((last_d[k+1]+1>=last_d[k-1]) &&
+ (last_d[k+1]>=last_d[k])) {
+ /* DELETE */
+ row = last_d[k+1]+1;
+ } else {
+ /* INSERT */
+ row = last_d[k-1];
+ }
+
+ temp_d[k] = snake(seq1,seq2,k,row,i2,j2);
+ }
+ for (k=ll; k<=uu; ++k)
+ last_d[k] = temp_d[k];
+ }
+
+ /* Allocate space for backward vectors */
+ rlast_d = (int *)xmalloc((rupper-rlower+1)*sizeof(int)) - rlower;
+ rtemp_d = (int *)xmalloc((rupper-rlower+1)*sizeof(int)) - rlower;
+
+ for (k=rlower; k<=rupper; k++) rlast_d[k] = i2+1;
+ rlast_d[rstart] = rsnake(seq1,seq2,rstart,i2,i1,j1,M,N);
+
+ /* Backward computation */
+ for (c=1; c<=rmidc; ++c) {
+ ll = max(rlower,rstart-c);
+ uu = min(rupper,rstart+c);
+ for (k=ll; k<=uu; ++k) {
+ if (k == ll) {
+ /* INSERT : left from (k+1,c-1) */
+ row = rlast_d[k+1];
+ } else if (k == uu) {
+ /* DELETE : up from (k-1,c-1) */
+ row = rlast_d[k-1]-1;
+ } else if ((rlast_d[k]-1<=rlast_d[k+1]) &&
+ (rlast_d[k]-1<=rlast_d[k-1]-1)) {
+ /* SUBSTITUTE */
+ row = rlast_d[k]-1;
+ } else if ((rlast_d[k-1]-1<=rlast_d[k+1]) &&
+ (rlast_d[k-1]-1<=rlast_d[k]-1)) {
+ /* DELETE */
+ row = rlast_d[k-1]-1;
+ } else {
+ /* INSERT */
+ row = rlast_d[k+1];
+ }
+
+ rtemp_d[k] = rsnake(seq1,seq2,k,row,i1,j1,M,N);
+ }
+ for (k=ll; k<=uu; ++k)
+ rlast_d[k] = rtemp_d[k];
+ }
+
+ /* Find (mi, mj) such that the distance from (i1, j1) to (mi, mj) is
+ midc and the distance from (mi, mj) to (i2, j2) is rmidc.
+ */
+
+ flag = 0;
+ mi = i1; mj = j1;
+ ll = max(lower,rlower); uu = min(upper,rupper);
+ for (k=ll; k<=uu; ++k) {
+ if (last_d[k]>=rlast_d[k]) {
+ if (last_d[k]-i1>=i2-rlast_d[k]) {
+ mi = last_d[k]; mj = k+mi;
+ } else {
+ mi = rlast_d[k]; mj = k+mi;
+ }
+ flag = 1;
+
+ break;
+ }
+ }
+ free(last_d+lower); free(rlast_d+rlower);
+ free(temp_d+lower); free(rtemp_d+rlower);
+
+ if (flag) {
+ /* Find a path from (i1,j1) to (mi,mj) */
+ align_path(seq1,seq2,i1,j1,mi,mj,midc,&head1,&tail1,M,N);
+
+ /* Find a path from (mi,mj) to (i2,j2) */
+ align_path(seq1,seq2,mi,mj,i2,j2,rmidc,&head2,&tail2,M,N);
+
+ /* Join these two paths together */
+ if (head1) tail1->next = head2;
+ else head1 = head2;
+ } else {
+ fprintf(stderr,
+ "align.c: warning: something wrong when dividing\n");
+ head1 = NULL;
+ }
+ *head = head1;
+ if (head2) *tail = tail2;
+ else *tail = tail1;
+ }
+
+
+ int
+ align_get_dist(uchar *seq1, uchar *seq2, int i1, int j1, int i2, int j2,
+ int limit)
+ {
+ int *last_d, *temp_d;
+ int goal_diag, ll, uu;
+ int c, k, row;
+ int start, lower, upper;
+
+ /* Compute the boundary diagonals */
+ start = j1 - i1;
+ lower = max(j1-i2, start-limit);
+ upper = min(j2-i1, start+limit);
+ goal_diag = j2-i2;
+
+ if (goal_diag > upper || goal_diag < lower)
+ return -1;
+
+ /* Allocate space for forward vectors */
+ last_d = (int *)xmalloc((upper-lower+1)*sizeof(int)) - lower;
+ temp_d = (int *)xmalloc((upper-lower+1)*sizeof(int)) - lower;
+
+ /* Initialization */
+ for (k=lower; k<=upper; ++k) last_d[k] = INT_MIN;
+ last_d[start] = snake(seq1,seq2,start, i1, i2, j2);
+
+ if (last_d[goal_diag] >= i2) {
+ /* Free working vectors */
+ free(last_d+lower);
+ free(temp_d+lower);
+ return 0;
+ }
+
+ for (c=1; c<=limit; ++c) {
+ ll = max(lower,start-c); uu = min(upper, start+c);
+ for (k=ll; k<=uu; ++k) {
+ if (k == ll)
+ row = last_d[k+1]+1; /* DELETE */
+ else if (k == uu)
+ row = last_d[k-1]; /* INSERT */
+ else if ((last_d[k]>=last_d[k+1]) &&
+ (last_d[k]+1>=last_d[k-1]))
+ row = last_d[k]+1; /*SUBSTITUTE */
+ else if ((last_d[k+1]+1>=last_d[k-1]) &&
+ (last_d[k+1]>=last_d[k]))
+ row = last_d[k+1]+1; /* DELETE */
+ else
+ row = last_d[k-1]; /* INSERT */
+
+ temp_d[k] = snake(seq1,seq2,k,row,i2,j2);
+ }
+
+ for (k=ll; k<=uu; ++k) last_d[k] = temp_d[k];
+
+ if (last_d[goal_diag] >= i2) {
+ /* Free working vectors */
+ free(last_d+lower);
+ free(temp_d+lower);
+ return c;
+ }
+ }
+
+ /* Ran out of distance limit */
+ return -1;
+ }
+
+ /* Condense_both_Ends -- merge contiguous operations of the same type */
+ /* together; return both new ends of the chain. */
+ void Condense_both_Ends (edit_script_p_t *head, edit_script_p_t *tail,
+ edit_script_p_t *prev)
+ {
+ edit_script_p_t tp, tp1;
+
+ tp = *head; *prev = NULL;
+ while (tp != NULL) {
+ while (((tp1 = tp->next) != NULL) && (tp->op_type == tp1->op_type)) {
+ tp->num = tp->num + tp1->num;
+ tp->next = tp1->next;
+ free(tp1);
+ }
+ if (tp->next) *prev = tp;
+ else *tail = tp;
+ tp = tp->next;
+ }
+ }
+
+ void S2A(edit_script_p_t head, int *S, int flag)
+ {
+ edit_script_p_t tp;
+ int *lastS, i;
+
+ tp = head;
+ lastS = S;
+ while (tp != NULL) {
+ /*
+ printf("tp->op_type=%d, tp->num=%d\n",tp->op_type, tp->num);
+ */
+ if (tp->op_type == SUBSTITUTE) {
+ for (i=0; i<tp->num; ++i) *lastS++ = 0;
+ } else if (tp->op_type == INSERT) {
+ *lastS++ = (!flag) ? tp->num : (0-tp->num);
+ } else { /* DELETE */
+ *lastS++ = (!flag) ? (0 - tp->num) : tp->num;
+ }
+ tp = tp->next;
+ }
+ *(S-1) = lastS - S;
+ }
+
+ /* Alignment display routine */
+
+ static uchar ALINE[51], BLINE[51], CLINE[51];
+
+ static int
+ get_pos_width(collec_p_t eCol)
+ {
+ unsigned int last = eCol->e.exon[eCol->nb - 1]->to1 + options.dnaOffset;
+ unsigned int w = 1;
+ while ((last = last / 10) > 0)
+ w += 1;
+ if (w < 7)
+ w = 7;
+ return w;
+ }
+
+ void
+ IDISPLAY(uchar *A, uchar *B, unsigned int M, unsigned int N,
+ int *S, unsigned int AP, unsigned int BP, collec_p_t eCol,
+ int direction)
+ {
+ uchar *a, *b, *c, sign;
+ int op, index, starti;
+ unsigned int i, j, lines, ap, bp, pWidth;
+ unsigned int ii = 0;
+ exon_p_t ep;
+
+ assert(eCol->nb > 0);
+
+ pWidth = get_pos_width(eCol);
+ /* find the starting exon for this alignment */
+ while (ii < eCol->nb
+ && ((ep = eCol->e.exon[ii])->from1 != AP || ep->from2 != BP))
+ ii += 1;
+ if (ii >= eCol->nb)
+ fatal("align.c: Alignment fragment not found.\n");
+ i = j = op = lines = index = 0;
+ sign = '*';
+ ap = AP;
+ bp = BP;
+ a = ALINE;
+ b = BLINE;
+ c = CLINE;
+ starti = (ii < eCol->nb - 1) ? (int) ep->to1 + 1 : -1;
+
+ while (i < M || j < N) {
+ if (op == 0 && *S == 0) {
+ op = *S++;
+ *a = A[++i];
+ *b = B[++j];
+ *c++ = (*a++ == *b++) ? '|' : ' ';
+ } else {
+ if (op == 0)
+ op = *S++;
+ if (op > 0) {
+ *a++ = ' ';
+ *b++ = B[++j];
+ *c++ = '-';
+ op--;
+ } else {
+ if ((int) (i + AP) == starti) {
+ /* detected intron */
+ if (ep->type < 0 || direction == 0)
+ sign = '=';
+ else if (direction > 0)
+ sign = '>';
+ else
+ sign = '<';
+ ii += 1;
+ ep = (ii < eCol->nb) ? eCol->e.exon[ii] : NULL;
+ starti = (ii < eCol->nb - 1) ? (int) ep->to1 + 1 : -1;
+ index = 1;
+ *c++ = sign;
+ *a++ = A[++i];
+ *b++ = ' ';
+ op++;
+ } else if (!index) {
+ *c++ = '-';
+ *a++ = A[++i];
+ *b++ = ' ';
+ op++;
+ } else {
+ /* not the first deletion in the intron */
+ switch (index) {
+ case 0:
+ case 1:
+ case 2:
+ *a++ = A[++i];
+ *b++ = ' ';
+ *c++ = sign;
+ op++;
+ index++;
+ break;
+ case 3:
+ case 4:
+ *a++ = '.';
+ *b++ = ' ';
+ *c++ = '.';
+ i++;
+ op++;
+ index++;
+ break;
+ case 5:
+ *a++ = '.';
+ *b++ = ' ';
+ *c++ = '.';
+ i += (-op) - 3;
+ op = -3;
+ index++;
+ break;
+ case 6:
+ case 7:
+ *a++ = A[++i];
+ *b++ = ' ';
+ *c++ = sign;
+ op++;
+ index++;
+ break;
+ case 8:
+ *a++ = A[++i];
+ *b++ = ' ';
+ *c++ = sign;
+ op++;
+ index = 0;
+ break;
+ }
+ }
+ }
+ }
+ if (a >= ALINE + 50 || (i >= M && j >= N)) {
+ *a = *b = *c = '\0';
+ printf("\n%*u ", pWidth, 50 * lines++);
+ for (b = ALINE + 10; b <= a; b += 10)
+ printf(" . :");
+ if (b <= a + 5)
+ printf(" .");
+ printf("\n%*u %s\n%*s %s\n%*u %s\n",
+ pWidth, ap + options.dnaOffset, ALINE,
+ pWidth, " ", CLINE,
+ pWidth, bp, BLINE);
+ ap = AP + i;
+ bp = BP + j;
+ a = ALINE;
+ b = BLINE;
+ c = CLINE;
+ }
+ }
+ }
+
+ void
+ Free_script(edit_script_p_t head)
+ {
+ edit_script_p_t tp, tp1;
+
+ tp = head;
+ while (tp != NULL) {
+ tp1 = tp->next;
+ free(tp);
+ tp = tp1;
+ }
+ }
+
+ static int
+ snake(uchar *seq1, uchar *seq2, int k, int x, int endx, int endy)
+ {
+ int y;
+
+ if (x<0) return x;
+ y = x+k;
+ while (x<endx && y<endy && seq1[x]==seq2[y]) {
+ ++x; ++y;
+ }
+ return x;
+ }
+
+
+ static int
+ rsnake(uchar *seq1, uchar *seq2, int k, int x, int startx, int starty,
+ int M, int N)
+ {
+ int y;
+
+ if (x > M)
+ return x;
+ if (startx < 0 || starty < 0)
+ fprintf(stderr, "TROUBLE!!! startx: %5d, starty: %5d\n",startx, starty);
+ if (x + k > N)
+ fprintf(stderr, "TROUBLE!!! x: %5d, y: %5d\n",x,x+k);
+
+ y = x + k;
+ while (x > startx && y > starty && seq1[x - 1] == seq2[y - 1]) {
+ x -= 1;
+ y -= 1;
+ }
+ return x;
+ }
Index: llvm-test/MultiSource/Applications/SIBsim4/align.h
diff -c /dev/null llvm-test/MultiSource/Applications/SIBsim4/align.h:1.1
*** /dev/null Thu Feb 15 17:46:25 2007
--- llvm-test/MultiSource/Applications/SIBsim4/align.h Thu Feb 15 17:46:09 2007
***************
*** 0 ****
--- 1,20 ----
+ /* $Id: align.h,v 1.1 2007/02/15 23:46:09 nicholas Exp $
+ *
+ * Christian Iseli, LICR ITO, Christian.Iseli at licr.org
+ *
+ * Copyright (c) 2001-2004 Swiss Institute of Bioinformatics.
+ * Copyright (C) 1998-2001 Liliana Florea.
+ */
+ #ifndef SCRIPTLIB_H
+ #define SCRIPTLIB_H
+ extern void align_path(uchar *,uchar *,int,int,int,int,int,edit_script_p_t*,
+ edit_script_p_t*, int,int);
+ extern int align_get_dist(uchar *,uchar *,int, int, int, int, int);
+ extern void Condense_both_Ends(edit_script_p_t *, edit_script_p_t *,
+ edit_script_p_t*);
+ extern void S2A(edit_script_p_t, int *, int);
+ extern void IDISPLAY(uchar *, uchar *, unsigned int, unsigned int, int *,
+ unsigned int, unsigned int, collec_p_t, int);
+ extern void Free_script(edit_script_p_t);
+
+ #endif /* SCRIPTLIB_H */
Index: llvm-test/MultiSource/Applications/SIBsim4/misc.c
diff -c /dev/null llvm-test/MultiSource/Applications/SIBsim4/misc.c:1.1
*** /dev/null Thu Feb 15 17:46:25 2007
--- llvm-test/MultiSource/Applications/SIBsim4/misc.c Thu Feb 15 17:46:09 2007
***************
*** 0 ****
--- 1,70 ----
+ /* $Id: misc.c,v 1.1 2007/02/15 23:46:09 nicholas Exp $
+ *
+ * Christian Iseli, LICR ITO, Christian.Iseli at licr.org
+ *
+ * Copyright (c) 2001-2005 Swiss Institute of Bioinformatics.
+ * Copyright (C) 1998-2001 Liliana Florea.
+ * Copyright (C) 1998-2001 Scott Schwartz.
+ */
+
+ #include <stdio.h>
+ #include <stdlib.h>
+ #include <stdarg.h>
+ #include <string.h>
+ #include <errno.h>
+ #include "misc.h"
+
+ /* format message, print it, and die */
+ void
+ fatal(const char *fmt, ...)
+ {
+ extern char *argv0;
+ extern char dna_seq_head[256];
+ extern char rna_seq_head[256];
+ va_list ap;
+ va_start(ap, fmt);
+ fflush(stdout);
+ if (argv0) {
+ char *p = strrchr(argv0, '/');
+ fprintf(stderr, "%s: ", p ? p+1 : argv0);
+ }
+ vfprintf(stderr, fmt, ap);
+ va_end(ap);
+ fprintf(stderr, "\n while processing:\n%.256s\n%.256s\n",
+ dna_seq_head, rna_seq_head);
+ #ifdef DEBUG
+ abort();
+ #else
+ exit(1);
+ #endif
+ }
+
+ void *
+ xmalloc(size_t size)
+ {
+ void *res = malloc(size);
+ if (res == NULL)
+ fatal("malloc of %zd failed: %s (%d)\n", size, strerror(errno),
+ errno);
+ return res;
+ }
+
+ void *
+ xcalloc(size_t nmemb, size_t size)
+ {
+ void *res = calloc(nmemb, size);
+ if (res == NULL)
+ fatal("calloc of %zd, %zd failed: %s (%d)\n", nmemb, size,
+ strerror(errno), errno);
+ return res;
+ }
+
+ void *
+ xrealloc(void *ptr, size_t size)
+ {
+ void *res = realloc(ptr, size);
+ if (res == NULL)
+ fatal("realloc of %p to %zd failed: %s (%d)\n", ptr, size,
+ strerror(errno), errno);
+ return res;
+ }
Index: llvm-test/MultiSource/Applications/SIBsim4/misc.h
diff -c /dev/null llvm-test/MultiSource/Applications/SIBsim4/misc.h:1.1
*** /dev/null Thu Feb 15 17:46:25 2007
--- llvm-test/MultiSource/Applications/SIBsim4/misc.h Thu Feb 15 17:46:09 2007
***************
*** 0 ****
--- 1,26 ----
+ /* $Id: misc.h,v 1.1 2007/02/15 23:46:09 nicholas Exp $
+ *
+ * Christian Iseli, LICR ITO, Christian.Iseli at licr.org
+ *
+ * Copyright (c) 2001-2004 Swiss Institute of Bioinformatics.
+ * Copyright (C) 1998-2001 Liliana Florea.
+ * Copyright (C) 1998-2001 Scott Schwartz.
+ */
+
+ #ifndef SIM_MISC_H
+ #define SIM_MISC_H
+
+ #ifdef __GNUC__
+ void
+ fatal(const char *fmt, ...)
+ __attribute__ ((format (printf, 1, 2) , __noreturn__));
+ #else
+ void
+ fatal(const char *fmt, ...);
+ #endif
+
+ void *xmalloc(size_t size);
+ void *xcalloc(size_t nmemb, size_t size);
+ void *xrealloc(void *ptr, size_t size);
+
+ #endif
Index: llvm-test/MultiSource/Applications/SIBsim4/sim4.h
diff -c /dev/null llvm-test/MultiSource/Applications/SIBsim4/sim4.h:1.1
*** /dev/null Thu Feb 15 17:46:25 2007
--- llvm-test/MultiSource/Applications/SIBsim4/sim4.h Thu Feb 15 17:46:09 2007
***************
*** 0 ****
--- 1,166 ----
+ /* $Id: sim4.h,v 1.1 2007/02/15 23:46:09 nicholas Exp $
+ *
+ * Christian Iseli, LICR ITO, Christian.Iseli at licr.org
+ *
+ * Copyright (c) 2001-2006 Swiss Institute of Bioinformatics.
+ * Copyright (C) 1998-2001 Liliana Florea.
+ */
+
+ #ifndef SIM4_H
+ #define SIM4_H
+
+ #define DIST_CUTOFF 3
+ #define DEFAULT_GAPPCT 10
+ #define MIN_INTRON 30
+ #define MAX_GRINIT 500
+ #define MATCH_CUTOFF 50
+ #define DEFAULT_FILTER 75
+ #define DEFAULT_W 12
+ #define DEFAULT_X 12
+ #define DEFAULT_K 15
+ #define DEFAULT_C 15
+ #define P (.2)
+ #define MATCH 1
+ #define MISMATCH (-5)
+ #define DELETE 1
+ #define INSERT 2
+ #define SUBSTITUTE 3
+ #define BUF_SIZE 4096
+ #define NACHARS 128
+ #define HASH_SIZE (1 << 19)
+ #define HASH_MASK (HASH_SIZE - 1)
+
+ #define min(x, y) ((x > y) ? (y) : (x))
+ #define max(x, y) ((x < y) ? (y) : (x))
+
+
+ /* data structures */
+
+ typedef unsigned char uchar;
+
+ typedef struct _hash_node_t {
+ unsigned int ecode; /* integer encoding of the word */
+ int pos; /* positions where word hits query sequence */
+ } hash_node_t, *hash_node_p_t;
+
+ typedef struct _hash_env_t {
+ void **hashtab;
+ uchar *seq;
+ unsigned int len;
+ int *next_pos;
+ unsigned int mask;
+ unsigned int W;
+ } hash_env_t, *hash_env_p_t;
+
+ typedef struct _read_buf_t {
+ char *line;
+ unsigned int lmax;
+ unsigned int lc;
+ unsigned int ic;
+ char in[BUF_SIZE];
+ } read_buf_t, *read_buf_p_t;
+
+ typedef struct _seq_t {
+ const char *fName;
+ char *header;
+ unsigned char *seq;
+ read_buf_t rb;
+ int fd;
+ unsigned int len;
+ unsigned int maxHead;
+ unsigned int max;
+ } seq_t, *seq_p_t;
+
+ typedef struct _exon_t {
+ unsigned int from1, from2, to1, to2;
+ unsigned int score;
+ unsigned int Score;
+ unsigned int top : 1;
+ unsigned int bot : 1;
+ int prev : 30;
+ int direction : 2;
+ unsigned int splScore : 22;
+ int type : 8;
+ } exon_t, *exon_p_t;
+
+ typedef struct _sim4_stats {
+ unsigned int nmatches;
+ int polyA_cut;
+ int polyT_cut;
+ } sim4_stats_t, *sim4_stats_p_t;
+
+ /* used only in the alignment stage */
+ typedef struct _edit_script {
+ struct _edit_script *next;
+ int num; /* Number of operations */
+ char op_type; /* SUB, INS, or DEL */
+ } edit_script_t, *edit_script_p_t;
+
+ typedef struct _edit_script_list {
+ struct _edit_script_list *next_script;
+ edit_script_p_t script;
+ unsigned int offset1, offset2;
+ unsigned int len1, len2;
+ int score;
+ } edit_script_list_t, *edit_script_list_p_t;
+
+ typedef union _collec_elt_t {
+ void **elt;
+ exon_p_t *exon;
+ struct _result_t **result;
+ } collec_elt_t;
+
+ typedef struct _collec_t {
+ collec_elt_t e;
+ unsigned int nb;
+ unsigned int size;
+ } collec_t, *collec_p_t;
+
+ typedef struct _result_t {
+ edit_script_list_p_t sList;
+ collec_t eCol;
+ unsigned int dStart;
+ unsigned int dLen;
+ int direction;
+ sim4_stats_t st;
+ } result_t, *result_p_t;
+
+ typedef struct _junction_t {
+ uchar fwd[4];
+ uchar rev[4];
+ } junction_t, *junction_p_t;
+
+ typedef struct _splice_score_t {
+ unsigned int to1;
+ unsigned int to2;
+ unsigned int nFrom1;
+ unsigned int type;
+ unsigned int score;
+ unsigned int splScore;
+ int direction;
+ } splice_score_t, *splice_score_p_t;
+
+ typedef struct _options_t {
+ char *splice_type_list;
+ junction_p_t splice;
+ unsigned int nbSplice;
+ int ali_flag;
+ unsigned int C;
+ int cutoff;
+ unsigned int gapPct;
+ unsigned int intron_window;
+ unsigned int K;
+ unsigned int scoreSplice_window;
+ int mismatchScore;
+ int reverse;
+ int matchScore;
+ int W;
+ int X;
+ unsigned int dnaOffset;
+ unsigned int filterPct;
+ unsigned int minScore_cutoff;
+ } options_t;
+ extern options_t options;
+ extern char *argv0;
+
+ #endif
Index: llvm-test/MultiSource/Applications/SIBsim4/sim4.init.c
diff -c /dev/null llvm-test/MultiSource/Applications/SIBsim4/sim4.init.c:1.1
*** /dev/null Thu Feb 15 17:46:25 2007
--- llvm-test/MultiSource/Applications/SIBsim4/sim4.init.c Thu Feb 15 17:46:09 2007
***************
*** 0 ****
--- 1,699 ----
+ /* $Id: sim4.init.c,v 1.1 2007/02/15 23:46:09 nicholas Exp $
+ *
+ * Christian Iseli, LICR ITO, Christian.Iseli at licr.org
+ *
+ * Copyright (c) 2001-2006 Swiss Institute of Bioinformatics.
+ * Copyright (C) 1998-2001 Liliana Florea.
+ */
+
+ /*
+ * TODO
+ * - See why tst23 is split
+ * - See why tst50 has strange alignment
+ */
+
+ /*
+ * sim4 - Align a cDNA sequence with a genomic sequence for it.
+ *
+ * The basic command syntax is
+ *
+ * sim4 [options] dna.seq rna.seq
+ *
+ * where dna.seq names a file containing a DNA sequence and rna.seq
+ * names a file containing one or more RNA sequences.
+ * The files are to be in FASTA format. Thus a typical sequence file
+ * might begin:
+ *
+ * >BOVHBPP3I Bovine beta-globin psi-3 pseudogene, 5' end.
+ * GGAGAATAAAGTTTCTGAGTCTAGACACACTGGATCAGCCAATCACAGATGAAGGGCACT
+ * GAGGAACAGGAGTGCATCTTACATTCCCCCAAACCAATGAACTTGTATTATGCCCTGGGC
+ */
+
+ #ifdef __sun
+ #define _XOPEN_SOURCE /* tell sun we want getopt, etc. */
+ #define _XPG5 /* and we want snprintf */
+ #endif
+ #include <sys/types.h>
+ #include <sys/stat.h>
+ #include <fcntl.h>
+ #include <stdlib.h>
+ #include <stdio.h>
+ #include <unistd.h>
+ #include <string.h>
+ #include <ctype.h>
+ #include <errno.h>
+ #include <locale.h>
+ #include <signal.h>
+ #include "sim4.h"
+ #include "align.h"
+ #include "misc.h"
+ #include "sim4b1.h"
+ #if defined(DEBUG) && (DEBUG > 1)
+ #include <mcheck.h>
+ #endif
+
+
+ static void init_seq(const char *, seq_p_t);
+ static int get_next_seq(seq_p_t, unsigned int, int);
+ static void seq_revcomp_inplace(seq_p_t);
+ static void print_align_lat(uchar *, uchar *, result_p_t);
+ static void print_polyA_info(seq_p_t, seq_p_t, collec_p_t, sim4_stats_p_t);
+ static void print_res(result_p_t, int, seq_p_t, seq_p_t);
+ static void init_splice_junctions(void);
+ static void bug_handler(int);
+ #ifdef DEBUG
+ static void free_seq(seq_p_t);
+ #endif
+
+ static const char Usage[] =
+ "%s [options] dna est_db\n\n"
+ "This is SIBsim4 version 0.14.\n\n"
+ #ifdef DEBUG
+ "Debug version\n\n"
+ #endif
+ "Available options (default value in braces[]):\n"
+ " -A <int> output format\n"
+ " 0: exon endpoints only\n"
+ " 1: alignment text\n"
+ " 3: both exon endpoints and alignment text\n"
+ " 4: both exon endpoints and alignment text with polyA info\n"
+ " Note that 2 is unimplemented [%d]\n"
+ " -C <int> MSP score threshold for the second pass [%d]\n"
+ " -c <int> minimum score cutoff [%d]\n"
+ " -E <int> cutoff value [%d]\n"
+ " -f <int> score filter in percent (0 to disable filtering) [%d]\n"
+ " -g <int> join exons when gap on genomic and RNA have lengths which\n"
+ " differ at most by this percentage [%d]\n"
+ " -I <int> window width in which to search for intron splicing [%d]\n"
+ " -K <int> MSP score threshold for the first pass [%d]\n"
+ " -L <str> a comma separated list of forward splice-types [%s]\n"
+ " -M <int> scoring splice sites, evaluate match within M nucleotides [%d]\n"
+ " -o <int> offset nt positions in dna sequence by this amount [%u]\n"
+ " -q <int> penalty for a nucleotide mismatch [%d]\n"
+ " -R <int> direction of search\n"
+ " 0: search the '+' (direct) strand only\n"
+ " 1: search the '-' strand only\n"
+ " 2: search both strands and report the best match\n"
+ " [%d]\n"
+ " -r <int> reward for a nucleotide match [%d]\n"
+ " -W <int> word size [%d]\n"
+ " -X <int> value for terminating word extensions [%d]\n";
+
+ options_t options;
+ char *argv0;
+ char dna_seq_head[256];
+ char rna_seq_head[256];
+
+ int
+ main(int argc, char *argv[])
+ {
+ int count;
+ seq_t seq1, seq2;
+ hash_env_t he;
+ collec_t res, rev_res;
+ #if defined(DEBUG) && (DEBUG > 1)
+ mcheck(NULL);
+ mtrace();
+ #endif
+ argv0 = argv[0];
+ if (setlocale(LC_ALL, "POSIX") == NULL)
+ fprintf(stderr, "%s: Warning: could not set locale to POSIX\n", argv[0]);
+ signal(SIGSEGV, bug_handler);
+ signal(SIGBUS, bug_handler);
+ /* Default options. */
+ options.C = DEFAULT_C;
+ options.cutoff = DIST_CUTOFF;
+ options.gapPct = DEFAULT_GAPPCT;
+ options.intron_window = 6;
+ options.K = DEFAULT_K;
+ options.splice_type_list = "GTAG,GCAG,GTAC,ATAC";
+ options.nbSplice = 4;
+ options.scoreSplice_window = 10;
+ options.mismatchScore = MISMATCH;
+ options.reverse = 2;
+ options.matchScore = MATCH;
+ options.W = DEFAULT_W;
+ options.X = DEFAULT_X;
+ options.filterPct = DEFAULT_FILTER;
+ options.minScore_cutoff = MATCH_CUTOFF;
+ while (1) {
+ int c = getopt(argc, argv, "A:C:c:E:f:g:I:K:L:M:o:q:R:r:W:X:");
+ if (c == -1)
+ break;
+ switch (c) {
+ case 'A':
+ options.ali_flag = atoi(optarg);
+ if (options.ali_flag < 0 || options.ali_flag > 4)
+ fatal("A must be one of 0, 1, 2, 3, or 4.\n");
+ break;
+ case 'C': {
+ int val = atoi(optarg);
+ if (val < 0)
+ fatal("Value for option C must be non-negative.\n");
+ options.C = val;
+ break;
+ }
+ case 'c': {
+ int val = atoi(optarg);
+ if (val < 0)
+ fatal("Value for option c must be non-negative.\n");
+ options.minScore_cutoff = val;
+ break;
+ }
+ case 'E':
+ options.cutoff = atoi(optarg);
+ if (options.cutoff < 3 || options.cutoff > 10)
+ fatal("Cutoff (E) must be within [3,10].\n");
+ break;
+ case 'f':
+ options.filterPct = atoi(optarg);
+ if (options.filterPct > 100)
+ fatal("Filter in percent (f) must be within [0,100].\n");
+ break;
+ case 'g':
+ options.gapPct = atoi(optarg);
+ break;
+ case 'I':
+ options.intron_window = atoi(optarg);
+ break;
+ case 'K': {
+ int val = atoi(optarg);
+ if (val < 0)
+ fatal("Value for option K must be non-negative.\n");
+ options.K = val;
+ break;
+ }
+ case 'L': {
+ size_t i;
+ size_t len = strlen(optarg);
+ options.splice_type_list = optarg;
+ options.nbSplice = 1;
+ if (len % 5 != 4)
+ fatal("Splice types list has illegal length (%zu)\n", len);
+ for (i = 0; i < len; i++)
+ if (i % 5 == 4) {
+ if (options.splice_type_list[i] != ',')
+ fatal("Comma expected instead of %c at position %zu"
+ "in splice types list.\n",
+ options.splice_type_list[i], i);
+ options.nbSplice += 1;
+ } else {
+ if (options.splice_type_list[i] != 'A'
+ && options.splice_type_list[i] != 'C'
+ && options.splice_type_list[i] != 'G'
+ && options.splice_type_list[i] != 'T')
+ fatal("Expected 'A', 'C', 'G' or 'T' instead of '%c' at"
+ "position %zu in splice types list.\n",
+ options.splice_type_list[i], i);
+ }
+ break;
+ }
+ case 'M': {
+ int val = atoi(optarg);
+ if (val < 0)
+ fatal("Value for option M must be non-negative.\n");
+ options.scoreSplice_window = val;
+ break;
+ }
+ case 'o':
+ options.dnaOffset = atoi(optarg);
+ break;
+ case 'q':
+ options.mismatchScore = atoi(optarg);
+ break;
+ case 'R':
+ options.reverse = atoi(optarg);
+ if (options.reverse < 0 || options.reverse > 2)
+ fatal("R must be one of 0, 1, or 2.\n");
+ break;
+ case 'r':
+ options.matchScore = atoi(optarg);
+ break;
+ case 'W':
+ options.W = atoi(optarg);
+ if (options.W < 1 || options.W > 15)
+ fatal("W must be within [1,15].\n");
+ break;
+ case 'X':
+ options.X = atoi(optarg);
+ if (options.X < 1)
+ fatal("X must be positive.\n");
+ break;
+ case '?':
+ break;
+ default:
+ fprintf(stderr, "?? getopt returned character code 0%o ??\n", c);
+ }
+ }
+ if (optind + 2 != argc) {
+ fprintf(stderr, Usage, argv[0], options.ali_flag, options.C,
+ options.minScore_cutoff, options.cutoff,
+ options.filterPct, options.gapPct, options.intron_window,
+ options.K, options.splice_type_list, options.scoreSplice_window,
+ options.dnaOffset, options.mismatchScore, options.reverse,
+ options.matchScore, options.W, options.X);
+ return 1;
+ }
+
+ /* read seq1 */
+ init_seq(argv[optind], &seq1);
+ if (get_next_seq(&seq1, options.dnaOffset, 1) != 0)
+ fatal("Cannot read sequence from %s.\n", argv[optind]);
+ strncpy(dna_seq_head, seq1.header, 256);
+
+ /* read seq2 */
+ init_seq(argv[optind + 1], &seq2);
+ if (get_next_seq(&seq2, 0, 0) != 0)
+ fatal("Cannot read sequence from %s.\n", argv[optind + 1]);
+
+ init_encoding();
+ init_hash_env(&he, options.W, seq1.seq, seq1.len);
+ init_col(&res, 1);
+ init_col(&rev_res, 1);
+ bld_table(&he);
+ init_splice_junctions();
+
+ count = 0;
+ while (!count || get_next_seq(&seq2, 0, 0) == 0) {
+ unsigned int curRes;
+ strncpy(rna_seq_head, seq2.header, 256);
+ ++count;
+
+ switch (options.reverse) {
+ case 0:
+ SIM4(&he, &seq2, &res);
+ break;
+ case 2:
+ SIM4(&he, &seq2, &res);
+ case 1:
+ seq_revcomp_inplace(&seq2);
+ SIM4(&he, &seq2, &rev_res);
+ break;
+ default:
+ fatal ("Unrecognized request for EST orientation.\n");
+ }
+ /* Keep only the best matches, according to filterPct. */
+ if (options.filterPct > 0) {
+ unsigned int max_nmatches = 0;
+ for (curRes = 0; curRes < rev_res.nb; curRes++) {
+ result_p_t r = rev_res.e.result[curRes];
+ if (r->st.nmatches > max_nmatches)
+ max_nmatches = r->st.nmatches;
+ }
+ for (curRes = 0; curRes < res.nb; curRes++) {
+ result_p_t r = res.e.result[curRes];
+ if (r->st.nmatches > max_nmatches)
+ max_nmatches = r->st.nmatches;
+ }
+ max_nmatches = (max_nmatches * options.filterPct) / 100;
+ for (curRes = 0; curRes < rev_res.nb; curRes++) {
+ result_p_t r = rev_res.e.result[curRes];
+ if (r->st.nmatches < max_nmatches)
+ r->st.nmatches = 0;
+ }
+ for (curRes = 0; curRes < res.nb; curRes++) {
+ result_p_t r = res.e.result[curRes];
+ if (r->st.nmatches < max_nmatches)
+ r->st.nmatches = 0;
+ }
+ }
+ /* Now, print results. */
+ for (curRes = 0; curRes < rev_res.nb; curRes++)
+ print_res(rev_res.e.result[curRes], 1, &seq1, &seq2);
+ rev_res.nb = 0;
+ if (options.reverse && options.ali_flag)
+ /* reverse-complement back seq2 for alignment */
+ seq_revcomp_inplace(&seq2);
+ for (curRes = 0; curRes < res.nb; curRes++)
+ print_res(res.e.result[curRes], 0, &seq1, &seq2);
+ res.nb = 0;
+ }
+ #ifdef DEBUG
+ fprintf(stderr, "DEBUG mode: freeing all memory...\n");
+ fflush(stdout);
+ fflush(stderr);
+ free_hash_env(&he);
+ free_seq(&seq1);
+ free_seq(&seq2);
+ free(options.splice);
+ free(res.e.elt);
+ free(rev_res.e.elt);
+ #endif
+ return 0;
+ }
+
+ static const unsigned char dna_complement[256] =
+ " "
+ " TVGH CD M KN YSA BWXR tvgh cd m kn ysa bwxr "
+ " "
+ " ";
+ /* ................................................................ */
+ /* @ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~. */
+ /* ................................................................ */
+ /* ................................................................ */
+
+ static void
+ init_splice_junctions(void)
+ {
+ unsigned int i;
+ options.splice = (junction_p_t) xmalloc(options.nbSplice
+ * sizeof(junction_t));
+ for (i = 0; i < options.nbSplice; i++) {
+ unsigned int j;
+ for (j = 0; j < 4; j++) {
+ uchar c = options.splice_type_list[i * 5 + j];
+ options.splice[i].fwd[j] = c;
+ options.splice[i].rev[3 - j] = dna_complement[c];
+ }
+ }
+ #ifdef DEBUG
+ for (i = 0; i < options.nbSplice; i++)
+ fprintf(stderr, "Splice[%u]: %.4s %.4s\n",
+ i, options.splice[i].fwd, options.splice[i].rev);
+ #endif
+ }
+
+ static void
+ print_res(result_p_t res, int rev, seq_p_t seq1, seq_p_t seq2)
+ {
+ unsigned int i;
+ if (res->st.nmatches >= options.minScore_cutoff) {
+ printf("\n%s%s\n", seq1->header, seq2->header);
+ if (rev)
+ printf("(complement)\n\n");
+ switch (options.ali_flag) {
+ case 0:
+ print_exons(&res->eCol, res->direction);
+ break;
+ case 1:
+ print_align_lat(seq1->seq, seq2->seq, res);
+ break;
+ case 3:
+ print_exons(&res->eCol, res->direction);
+ print_align_lat(seq1->seq, seq2->seq, res);
+ break;
+ case 4:
+ print_exons(&res->eCol, res->direction);
+ print_polyA_info(seq1, seq2, &res->eCol, &res->st);
+ print_align_lat(seq1->seq, seq2->seq, res);
+ break;
+ default:
+ fatal("Unrecognized option for alignment output.\n");
+ }
+ printf("\n");
+ }
+ for (i = 0; i < res->eCol.nb; i++)
+ free(res->eCol.e.elt[i]);
+ free(res->eCol.e.elt);
+ if (res->sList)
+ free_align(res->sList);
+ free(res);
+ }
+
+ static void
+ print_polyA_info(seq_p_t s1, seq_p_t s2, collec_p_t eCol,
+ sim4_stats_p_t st)
+ {
+ if (st->polyA_cut) {
+ unsigned int cnt = 0, cntDna = 0, pos, i, scanLen = 50;
+ char *pSig, buf[51];
+ exon_p_t e = eCol->e.exon[eCol->nb - 1];
+ for (pos = 0; pos < 10 && e->to2 + pos < s2->len; pos++)
+ if (s2->seq[e->to2 + pos] == 'A')
+ cnt += 1;
+ while (e->to2 + pos < s2->len && s2->seq[e->to2 + pos] == 'A') {
+ pos += 1;
+ cnt += 1;
+ }
+ for (i = 0; i < s1->len && i < pos; i++)
+ if (s1->seq[e->to1 + i] == 'A')
+ cntDna += 1;
+ printf("\nPolyA site %u nt, %u/%u A's %u\n R %.*s %u\n D %*.*s %u\n",
+ pos, cnt, cntDna, e->to1 + 1 + options.dnaOffset,
+ pos, s2->seq + e->to2, e->to2 + 1,
+ pos, i, s1->seq + e->to1, e->to1 + 1 + options.dnaOffset);
+ if (e->to1 < scanLen)
+ scanLen = e->to1;
+ strncpy(buf, (char *) s1->seq + e->to1 - scanLen, scanLen);
+ buf[scanLen] = 0;
+ pSig = strstr(buf, "AATAAA");
+ if (pSig == NULL)
+ pSig = strstr(buf, "ATTAAA");
+ if (pSig != NULL)
+ printf("PolyA signal %u\n",
+ (unsigned int) (pSig - buf + e->to1 - scanLen + 1
+ + options.dnaOffset));
+ }
+ if (st->polyT_cut) {
+ unsigned int cnt = 0, cntDna = 0, pos, i;
+ char *pSig, buf[51];
+ exon_p_t e = eCol->e.exon[0];
+ for (pos = 0; pos < 10 && pos < e->from2 - 1; pos++)
+ if (s2->seq[e->from2 - 2 - pos] == 'T')
+ cnt += 1;
+ while (pos < e->from2 - 1 && s2->seq[e->from2 - 2 - pos] == 'T') {
+ pos += 1;
+ cnt += 1;
+ }
+ for (i = 0; i < e->from1 - 1 && i < pos; i++)
+ if (s1->seq[e->from1 - 2 - i] == 'T')
+ cntDna += 1;
+ printf("\nPolyA site %u nt, %u/%u A's %u minus strand\n R %.*s %u\n D %*.*s %u\n",
+ pos, cnt, cntDna, e->from1 - 1 + options.dnaOffset,
+ pos, s2->seq + (e->from2 - 1 - pos), e->from2 - 1,
+ pos, i, s1->seq + (e->from1 - 1 - i),
+ e->from1 - 1 + options.dnaOffset);
+ strncpy(buf, (char *) s1->seq + e->from1 - 1, 50);
+ buf[50] = 0;
+ pSig = strstr(buf, "TTTATT");
+ if (pSig == NULL)
+ pSig = strstr(buf, "TTTAAT");
+ if (pSig != NULL)
+ printf("PolyA signal %u minus strand\n",
+ (unsigned int) (pSig - buf + e->from1 + 5 + options.dnaOffset));
+ }
+ }
+
+ static void
+ print_align_lat(uchar *seq1, uchar *seq2, result_p_t r)
+ {
+ int *S;
+ edit_script_list_p_t head, aligns;
+
+ if (r->sList == NULL)
+ return;
+ aligns = r->sList;
+ while (aligns != NULL) {
+ head = aligns;
+ aligns = aligns->next_script;
+ S = (int *) xmalloc((2 * head->len2 + 1 + 1) * sizeof(int));
+ S++;
+ S2A(head->script, S, 0);
+ Free_script(head->script);
+ IDISPLAY(seq1 + head->offset1 - 1 - 1, seq2 + head->offset2 - 1 - 1,
+ head->len1, head->len2, S,
+ head->offset1, head->offset2, &r->eCol, r->direction);
+ free(S - 1);
+ free(head);
+ }
+ r->sList = NULL;
+ }
+
+ #ifdef DEBUG
+ static void
+ free_buf(read_buf_p_t b)
+ {
+ free(b->line);
+ }
+
+ static void
+ free_seq(seq_p_t sp)
+ {
+ free(sp->seq);
+ free(sp->header);
+ free_buf(&sp->rb);
+ if (sp->fName != NULL)
+ close(sp->fd);
+ }
+ #endif
+
+ static void
+ grow_read_buf(read_buf_p_t b)
+ {
+ b->lmax += BUF_SIZE;
+ b->line = xrealloc(b->line, b->lmax * sizeof(char));
+ }
+
+ static char *
+ shuffle_line(read_buf_p_t b, size_t *cur)
+ {
+ if (b->ic == 0 || *cur >= b->ic)
+ return NULL;
+ /* Make sure we have enough room in line. */
+ if (b->lmax <= b->lc + (b->ic - *cur))
+ grow_read_buf(b);
+ while (*cur < b->ic && b->in[*cur] != '\n')
+ b->line[b->lc++] = b->in[(*cur)++];
+ if (*cur < b->ic) {
+ /* Ok, we have our string. */
+ /* Copy the newline. */
+ b->line[b->lc++] = b->in[(*cur)++];
+ /* We should be fine, since we read BUF_SIZE -1 at most... */
+ b->line[b->lc] = 0;
+ /* Adjust the input buffer. */
+ if (*cur < b->ic) {
+ memmove(b->in, b->in + *cur, (b->ic - *cur) * sizeof(char));
+ b->ic -= *cur;
+ } else
+ b->ic = 0;
+ *cur = 0;
+ return b->line;
+ }
+ /* Go read some more. */
+ b->ic = 0, *cur = 0;
+ return NULL;
+ }
+
+ static char *
+ read_line_buf(read_buf_p_t b, int fd)
+ {
+ char *s = NULL;
+ ssize_t rc;
+ size_t cur = 0;
+ b->lc = 0;
+ if ((s = shuffle_line(b, &cur)) != NULL)
+ return s;
+ do {
+ if ((rc = read(fd, b->in + b->ic, BUF_SIZE - b->ic - 1)) == -1) {
+ if (errno != EINTR)
+ fatal("Could not read from %d: %s(%d)\n",
+ fd, strerror(errno), errno);
+ } else
+ b->ic += rc;
+ s = shuffle_line(b, &cur);
+ if (s == NULL && rc == 0) {
+ /* Got to the EOF... */
+ b->line[b->lc] = 0;
+ s = b->line;
+ }
+ } while (s == NULL);
+ return s;
+ }
+
+ static void
+ init_buf(read_buf_p_t b)
+ {
+ b->line = xmalloc(BUF_SIZE * sizeof(char));
+ b->lmax = BUF_SIZE;
+ b->lc = 0;
+ b->ic = 0;
+ }
+
+ static void
+ init_seq(const char *fName, seq_p_t sp)
+ {
+ sp->fName = fName;
+ sp->header = NULL;
+ sp->seq = NULL;
+ init_buf(&sp->rb);
+ if (fName != NULL) {
+ sp->fd = open(fName, O_RDONLY);
+ if (sp->fd == -1)
+ fatal("Could not open file %s: %s(%d)\n",
+ fName, strerror(errno), errno);
+ } else
+ sp->fd = 0;
+ sp->len = 0;
+ sp->maxHead = 0;
+ sp->max = 0;
+ read_line_buf(&sp->rb, sp->fd);
+ }
+
+ static int
+ get_next_seq(seq_p_t sp, unsigned int offset, int warnMultiSeq)
+ {
+ const int lenStr = 24;
+ unsigned int headerLen;
+ char *buf = sp->rb.line;
+ int res;
+ while (sp->rb.lc > 0 && buf[0] != '>')
+ buf = read_line_buf(&sp->rb, sp->fd);
+ if (sp->rb.lc == 0)
+ return -1;
+ /* We have the FASTA header. */
+ if (sp->rb.lc + lenStr + 1 > sp->maxHead) {
+ sp->maxHead = sp->rb.lc + lenStr + 1;
+ sp->header = (char *) xrealloc(sp->header, sp->maxHead * sizeof(char));
+ }
+ headerLen = sp->rb.lc;
+ memcpy(sp->header, buf, (sp->rb.lc + 1) * sizeof(char));
+ sp->len = 0;
+ buf = read_line_buf(&sp->rb, sp->fd);
+ while (sp->rb.lc > 0 && buf[0] != '>') {
+ unsigned char c;
+ /* Make sure we have enough room for this additional line. */
+ if (sp->len + sp->rb.lc + 1 > sp->max) {
+ sp->max = max(sp->len + sp->rb.lc + 1,
+ sp->max + 0x40000);
+ sp->seq = (unsigned char *)
+ xrealloc(sp->seq, sp->max * sizeof(unsigned char));
+ }
+ while ((c = *buf++) != 0) {
+ if (isupper(c)) {
+ sp->seq[sp->len++] = c;
+ } else if (islower(c)) {
+ sp->seq[sp->len++] = toupper(c);
+ }
+ }
+ buf = read_line_buf(&sp->rb, sp->fd);
+ }
+ if (warnMultiSeq && sp->rb.lc > 0)
+ fprintf(stderr, "\n"
+ "*** WARNING ***\n"
+ "*** there appears to be several sequences in the DNA ***\n"
+ "*** sequence file. Only the first one will be used, ***\n"
+ "*** which might not be what was intended. ***\n"
+ "\n");
+ sp->seq[sp->len] = 0;
+ buf = strstr(sp->header, "; LEN=");
+ if (buf) {
+ char *s = buf + 6;
+ headerLen -= 6;
+ while (isdigit(*s)) {
+ s += 1;
+ headerLen -= 1;
+ }
+ while (*s)
+ *buf++ = *s++;
+ }
+ buf = sp->header + headerLen - 1;
+ while (iscntrl(*buf) || isspace(*buf))
+ buf -= 1;
+ res = snprintf(buf + 1, lenStr, "; LEN=%u\n", sp->len + offset);
+ if (res < 0 || res >= lenStr)
+ fatal("Sequence too long: %u\n", sp->len);
+ return 0;
+ }
+
+ static void
+ seq_revcomp_inplace(seq_p_t seq)
+ {
+ unsigned char *s = seq->seq;
+ unsigned char *t = seq->seq + seq->len;
+ unsigned char c;
+ while (s < t) {
+ c = dna_complement[*--t];
+ *t = dna_complement[*s];
+ *s++ = c;
+ }
+ }
+
+ static void
+ bug_handler(int signum)
+ {
+ fflush(stdout);
+ fflush(stderr);
+ fprintf(stderr, "\nCaught signal %d while processing:\n%.256s\n%.256s\n",
+ signum, dna_seq_head, rna_seq_head);
+ abort();
+ }
Index: llvm-test/MultiSource/Applications/SIBsim4/sim4b1.c
diff -c /dev/null llvm-test/MultiSource/Applications/SIBsim4/sim4b1.c:1.1
*** /dev/null Thu Feb 15 17:46:25 2007
--- llvm-test/MultiSource/Applications/SIBsim4/sim4b1.c Thu Feb 15 17:46:09 2007
***************
*** 0 ****
--- 1,2487 ----
+ /* $Id: sim4b1.c,v 1.1 2007/02/15 23:46:09 nicholas Exp $
+ *
+ * Christian Iseli, LICR ITO, Christian.Iseli at licr.org
+ *
+ * Copyright (c) 2001-2006 Swiss Institute of Bioinformatics.
+ * Copyright (C) 1998-2001 Liliana Florea.
+ */
+
+ #define _GNU_SOURCE 1
+
+ #include <stdio.h>
+ #include <stdlib.h>
+ #include <string.h>
+ #include <math.h>
+ #include <assert.h>
+ #include <search.h>
+ #include <ctype.h>
+ #include "sim4.h"
+ #include "sim4b1.h"
+ #include "align.h"
+ #include "misc.h"
+
+ int encoding[NACHARS];
+
+ static void merge(collec_p_t, collec_p_t, unsigned int, unsigned int);
+ static void slide_intron(result_p_t, uchar *, uchar *);
+ static void compact_exons(collec_p_t, unsigned int);
+ static int greedy(uchar *, uchar *, unsigned int, unsigned int,
+ unsigned int, unsigned int, unsigned int, collec_p_t);
+ static int extend_bw(uchar *,uchar *,int,int,int,int,int *,int *, int);
+ static int extend_fw(uchar *,uchar *,int,int,int,int,int *,int *, int);
+ static int pluri_align(uchar *, uchar *, unsigned int *, collec_p_t,
+ edit_script_list_p_t *, int, int);
+ static exon_p_t new_exon(unsigned int, unsigned int,
+ unsigned int,unsigned int);
+ static void extend_hit(int, int, hash_env_p_t, const uchar * const,
+ unsigned int, int, collec_p_t, int *);
+ static int msp_compare(const void *, const void *);
+ static int msp_rna_compare(const void *, const void *);
+ static void search(hash_env_p_t, uchar *,
+ unsigned int, int, collec_p_t);
+ static void trim_small_repeated_msps(collec_p_t);
+ static void combine_msps(collec_p_t);
+ static int link_msps(collec_p_t, unsigned int, unsigned int);
+ static void msp2exons(exon_p_t *, int, collec_p_t, int);
+ static void exon_cores(hash_env_p_t, uchar *, unsigned int, int, int, int,
+ collec_p_t, collec_p_t, collec_p_t);
+ static int good_ratio(int, int);
+ static void swap_seqs(collec_p_t);
+ static int SWscore(uchar *, uchar *, unsigned int);
+
+ #ifdef DEBUG
+ static void debug_print_exons(collec_p_t, const char *,
+ const unsigned char *, const unsigned char *);
+ #endif
+
+ static int
+ is_polyAT_exon_p(exon_p_t e, const unsigned char *s)
+ {
+ unsigned int cntA = 0;
+ unsigned int cntC = 0;
+ unsigned int cntG = 0;
+ unsigned int cntT = 0;
+ unsigned int cntN = 0;
+ unsigned int i;
+ unsigned int len = e->to2 - e->from2 + 1;
+ for (i = e->from2 - 1; i < e->to2; i++)
+ switch (s[i]) {
+ case 'A':
+ cntA += 1;
+ break;
+ case 'C':
+ cntC += 1;
+ break;
+ case 'G':
+ cntG += 1;
+ break;
+ case 'T':
+ cntT += 1;
+ break;
+ default:
+ cntN += 1;
+ }
+ len -= cntN;
+ if (len < MIN_INTRON) {
+ if ((cntA * 10) / len >= 7
+ || ((cntA + cntG) * 10) / len >= 8
+ || (cntT * 10) / len >= 7
+ || ((cntT + cntC) * 10) / len >= 8)
+ return 1;
+ } else {
+ if ((cntA * 10) / len >= 8
+ || ((cntA + cntG) * 100) / len >= 95
+ || (cntT * 10) / len >= 8
+ || ((cntT + cntC) * 100) / len >= 95)
+ return 1;
+ }
+ return 0;
+ }
+
+ static void
+ kill_polyA(result_p_t res, const unsigned char *s1, const unsigned char *s2)
+ {
+ unsigned int i;
+ collec_p_t eCol = &res->eCol;
+ /* Stupid initialization below to avoid spurious uninitialized warning
+ * from GCC... */
+ struct {int score; unsigned int cnt; unsigned int d;} best = best;
+ i = 0;
+ while (i < eCol->nb && is_polyAT_exon_p(eCol->e.exon[i], s2))
+ i += 1;
+ if (i > 0) {
+ unsigned int j;
+ for (j = 0; j < i; j++)
+ free(eCol->e.exon[j]);
+ memmove(eCol->e.elt, eCol->e.elt + i,
+ (eCol->nb - i) * sizeof(void *));
+ eCol->nb -= i;
+ }
+ i = 0;
+ while (i < eCol->nb
+ && is_polyAT_exon_p(eCol->e.exon[eCol->nb - i - 1], s2))
+ i += 1;
+ if (i > 0) {
+ unsigned int j;
+ for (j = eCol->nb - i; j < eCol->nb; j++)
+ free(eCol->e.exon[j]);
+ eCol->nb -= i;
+ }
+ if (eCol->nb > 0) {
+ exon_p_t e = eCol->e.exon[eCol->nb - 1];
+ unsigned int cntAs1 = 0, cntAs2 = 0, j = 0;
+ int score = 0;
+ const unsigned char *s = s2 + e->to2;
+ best.score = 0;
+ while (*s && best.score - score < 10) {
+ j += 1;
+ switch (*s) {
+ case 'A':
+ cntAs2 += 1;
+ score += 1;
+ if (score > best.score) {
+ best.score = score;
+ best.cnt = cntAs2;
+ best.d = j;
+ }
+ break;
+ case 'N':
+ break;
+ default:
+ score -= 2;
+ }
+ s += 1;
+ }
+ if (best.score > 0 && best.cnt >= 8 && (best.cnt * 10) / best.d >= 8) {
+ s = s1 + e->to1;
+ j = 0;
+ while (*s && j < best.d) {
+ j += 1;
+ if (*s == 'A')
+ cntAs1 += 1;
+ s += 1;
+ }
+ if (j > 0 && (cntAs1 * 10) / j < 8) {
+ res->st.polyA_cut = 1;
+ }
+ }
+ }
+ if (eCol->nb > 0) {
+ exon_p_t e = eCol->e.exon[0];
+ unsigned int cntTs1 = 0, cntTs2 = 0, j = 0;
+ int score = 0;
+ const unsigned char *s = s2 + e->from2 - 2;
+ best.score = 0;
+ while (s >= s2 && best.score - score < 10) {
+ j += 1;
+ switch (*s) {
+ case 'T':
+ cntTs2 += 1;
+ score += 1;
+ if (score > best.score) {
+ best.score = score;
+ best.cnt = cntTs2;
+ best.d = j;
+ }
+ break;
+ case 'N':
+ break;
+ default:
+ score -= 2;
+ }
+ s -= 1;
+ }
+ if (best.score > 0 && best.cnt >= 8 && (best.cnt * 10) / best.d >= 8) {
+ s = s1 + e->from1 - 2;
+ j = 0;
+ while (s >= s1 && j < best.d) {
+ j += 1;
+ if (*s == 'T')
+ cntTs1 += 1;
+ s -= 1;
+ }
+ if (j > 0 && (cntTs1 * 10) / j < 8) {
+ res->st.polyT_cut = 1;
+ }
+ }
+ }
+ }
+
+ static void
+ grow_exon_left(exon_p_t e, uchar *s1, uchar *s2)
+ {
+ uchar *p1 = s1 + e->from1 - 2;
+ uchar *p2 = s2 + e->from2 - 2;
+ while (p1 >= s1 && p2 >= s2 && *p1 == *p2) {
+ p1 -= 1;
+ p2 -= 1;
+ e->from1 -= 1;
+ e->from2 -= 1;
+ }
+ }
+
+ static void
+ grow_exon_right(exon_p_t e, uchar *s1, unsigned int l1,
+ uchar *s2, unsigned int l2)
+ {
+ while (e->to1 < l1 && e->to2 < l2 && s1[e->to1] == s2[e->to2]) {
+ e->to1 += 1;
+ e->to2 += 1;
+ }
+ }
+
+ /* seq1 = genomic DNA (text); seq2 = cDNA */
+ void
+ SIM4(hash_env_p_t he, seq_p_t seq2, collec_p_t res)
+ {
+ collec_t mCol;
+ collec_t tem_eCol;
+ int align_status;
+ unsigned int curRes;
+
+ if (he->len == 0 || seq2->len == 0)
+ return;
+ init_col(&mCol, 5);
+ /* Compute the distance between two sequences A and B */
+ exon_cores(he, seq2->seq, seq2->len, 1, 1, options.K, &mCol, res, NULL);
+ init_col(&tem_eCol, 0);
+ for (curRes = 0; curRes < res->nb; curRes++) {
+ result_p_t r = res->e.result[curRes];
+ collec_p_t eCol = &r->eCol;
+ sim4_stats_p_t st = &r->st;
+ #ifdef DEBUG
+ debug_print_exons(eCol, "LSIS", he->seq, seq2->seq);
+ #endif
+ /* Chase down polyA tails. */
+ st->polyA_cut = 0;
+ st->polyT_cut = 0;
+ kill_polyA(r, he->seq, seq2->seq);
+ #ifdef DEBUG
+ debug_print_exons(eCol, "LSIS 2", he->seq, seq2->seq);
+ #endif
+ if (eCol->nb == 0)
+ continue;
+ /* Look at the first exon, and try to extend it backward. */
+ if (!st->polyT_cut && eCol->e.exon[0]->from2 > 1) {
+ exon_p_t e = eCol->e.exon[0];
+ unsigned int i = 0;
+ if (e->from2 - 1 > (MIN_INTRON << 1)
+ && e->from1 - 1 > r->dStart) {
+ hash_env_t tem_he;
+ #ifdef DEBUG
+ fprintf(stderr, "Find new exons (head) %d %d\n", e->from1, e->from2);
+ #endif
+ init_hash_env(&tem_he, min(10, he->W), seq2->seq, e->from2 - 1);
+ bld_table(&tem_he);
+ exon_cores(&tem_he, he->seq + r->dStart, e->from1 - r->dStart - 1,
+ 1, r->dStart + 1, options.C, &mCol, NULL, &tem_eCol);
+ free_hash_env(&tem_he);
+ /* Insert new exons (merging if needed), swaping seqs. */
+ if (tem_eCol.nb > 0) {
+ swap_seqs(&tem_eCol);
+ grow_exon_right(tem_eCol.e.exon[tem_eCol.nb - 1],
+ he->seq, he->len, seq2->seq, seq2->len);
+ merge(eCol, &tem_eCol, 0, he->W);
+ tem_eCol.nb = 0;
+ e = eCol->e.exon[0];
+ }
+ }
+ while (i < eCol->nb && is_polyAT_exon_p(eCol->e.exon[i], seq2->seq))
+ i += 1;
+ if (i > 0) {
+ unsigned int j;
+ for (j = 0; j < i; j++)
+ free(eCol->e.exon[j]);
+ memmove(eCol->e.elt, eCol->e.elt + i,
+ (eCol->nb - i) * sizeof(void *));
+ eCol->nb -= i;
+ if (eCol->nb == 0)
+ continue;
+ e = eCol->e.exon[0];
+ }
+ if (e->from2 - 1 > 0) {
+ int diff = min(e->from2 - 1, MAX_GRINIT >> 1);
+ int u = min(4 * diff, (int) e->from1 - 1);
+ int I, J, cost;
+ #ifdef DEBUG
+ fprintf(stderr, "extend_bw from %d\n", e->from2);
+ #endif
+ cost = extend_bw(seq2->seq + e->from2 - 1 - diff,
+ he->seq + e->from1 - 1 - u,
+ diff, u, e->from2 - 1 - diff, e->from1 - 1 - u,
+ &I, &J, he->W);
+ #ifdef DEBUG
+ fprintf(stderr, "extend_bw returned %d, I: %d J: %d\n", cost, I, J);
+ #endif
+ if (((int) e->from2 - 1 - I) * options.matchScore
+ + cost * options.mismatchScore >= 0) {
+ e->from2 = I + 1;
+ e->from1 = J + 1;
+ }
+ }
+ }
+ /* Look at the last exon, and try to extend it forward. */
+ if (!st->polyA_cut && eCol->e.exon[eCol->nb - 1]->to2 < seq2->len) {
+ exon_p_t e = eCol->e.exon[eCol->nb - 1];
+ unsigned int i = 0;
+ if (seq2->len - e->to2 > (MIN_INTRON << 1)
+ && e->to1 < r->dStart + r->dLen) {
+ hash_env_t tem_he;
+ #ifdef DEBUG
+ fprintf(stderr, "Find new exons (tail) %d %d\n", e->to1, e->to2);
+ #endif
+ init_hash_env(&tem_he, min(10, he->W),
+ seq2->seq + e->to2, seq2->len - e->to2);
+ bld_table(&tem_he);
+ exon_cores(&tem_he, he->seq + e->to1, r->dStart + r->dLen - e->to1,
+ e->to2 + 1, e->to1 + 1, options.C, &mCol, NULL, &tem_eCol);
+ free_hash_env(&tem_he);
+ /* Append new exons (merging if needed), swaping seqs. */
+ if (tem_eCol.nb > 0) {
+ swap_seqs(&tem_eCol);
+ grow_exon_left(tem_eCol.e.exon[0], he->seq, seq2->seq);
+ merge(eCol, &tem_eCol, eCol->nb, he->W);
+ tem_eCol.nb = 0;
+ e = eCol->e.exon[eCol->nb - 1];
+ }
+ }
+ while (i < eCol->nb
+ && is_polyAT_exon_p(eCol->e.exon[eCol->nb - i - 1], seq2->seq))
+ i += 1;
+ if (i > 0) {
+ unsigned int j;
+ for (j = eCol->nb - i; j < eCol->nb; j++)
+ free(eCol->e.exon[j]);
+ eCol->nb -= i;
+ if (eCol->nb == 0)
+ continue;
+ e = eCol->e.exon[eCol->nb - 1];
+ }
+ if (seq2->len - e->to2 > 0) {
+ int diff = min(seq2->len - e->to2, MAX_GRINIT >> 1);
+ int cost, I, J;
+ #ifdef DEBUG
+ fprintf(stderr, "extend_fw from %d (%d)\n", e->to2, diff);
+ #endif
+ cost = extend_fw(seq2->seq + e->to2, he->seq + e->to1, diff,
+ min(4 * diff, (int) (he->len - e->to1)),
+ e->to2, e->to1, &I, &J, he->W);
+ #ifdef DEBUG
+ fprintf(stderr, "extend_fw returned %d, I: %d J: %d\n", cost, I, J);
+ #endif
+ if ((I - (int) e->to2) * options.matchScore
+ + cost * options.mismatchScore >= 0) {
+ e->to2 = I;
+ e->to1 = J;
+ }
+ }
+ }
+ /* Proceed in case of several exons. */
+ if (eCol->nb > 1) {
+ unsigned int i;
+ for (i = 1; i < eCol->nb; i++) {
+ exon_p_t cur = eCol->e.exon[i - 1];
+ exon_p_t next = eCol->e.exon[i];
+ int diff = next->from2 - cur->to2 - 1;
+ if (diff > 0) {
+ /* bridge the gap (provided there is one...) */
+ if (next->from1 - 1 > cur->to1) {
+ hash_env_t tem_he;
+ if (diff <= MAX_GRINIT) {
+ int cost;
+ #ifdef DEBUG
+ fprintf(stderr, "Trying greedy %d %d\n",
+ cur->to2, next->from2);
+ #endif
+ cost = greedy(seq2->seq + cur->to2, he->seq + cur->to1, diff,
+ next->from1 - cur->to1 - 1,
+ cur->to2, cur->to1, he->W, &tem_eCol);
+ if (tem_eCol.nb > 0
+ && cost <= max(he->W, P * diff + 1)) {
+ grow_exon_left(tem_eCol.e.exon[0], he->seq, seq2->seq);
+ grow_exon_right(tem_eCol.e.exon[tem_eCol.nb - 1],
+ he->seq, he->len, seq2->seq, seq2->len);
+ merge(eCol, &tem_eCol, i, he->W);
+ tem_eCol.nb = 0;
+ i -= 1;
+ continue;
+ }
+ }
+ #ifdef DEBUG
+ fprintf(stderr, "Find new exons %d %d\n",
+ cur->to1, next->from1);
+ #endif
+ init_hash_env(&tem_he, min(8, he->W), he->seq + cur->to1,
+ next->from1 - cur->to1 - 1);
+ bld_table(&tem_he);
+ exon_cores(&tem_he, seq2->seq + cur->to2, diff, cur->to1 + 1,
+ cur->to2 + 1, options.C, &mCol, NULL, &tem_eCol);
+ free_hash_env(&tem_he);
+ if (tem_eCol.nb > 0) {
+ grow_exon_left(tem_eCol.e.exon[0], he->seq, seq2->seq);
+ grow_exon_right(tem_eCol.e.exon[tem_eCol.nb - 1],
+ he->seq, he->len, seq2->seq, seq2->len);
+ merge(eCol, &tem_eCol, i, he->W);
+ tem_eCol.nb = 0;
+ i -= 1;
+ }
+ }
+ }
+ }
+ }
+ /* Re-check for polyA. */
+ kill_polyA(r, he->seq, seq2->seq);
+
+ /* just printing ... */
+ #ifdef DEBUG
+ debug_print_exons(eCol, "EXTENSIONS", he->seq, seq2->seq);
+ #endif
+
+ /* compaction step; note: it resets the right end of the list to */
+ /* the last item in the block list */
+ compact_exons(eCol, he->W);
+
+ /* just printing ... */
+ #ifdef DEBUG
+ debug_print_exons(eCol, "NORMALIZATION", he->seq, seq2->seq);
+ #endif
+
+ /* eliminate marginal small blocks at the start of the sequence; */
+ if (eCol->nb > 0) {
+ unsigned int i = 0;
+ while (i < eCol->nb) {
+ exon_p_t e = eCol->e.exon[i];
+ if (e->to2 - e->from2 + 1 >= he->W)
+ break;
+ free(e);
+ i += 1;
+ }
+ if (i > 0) {
+ memmove(eCol->e.elt, eCol->e.elt + i,
+ (eCol->nb - i) * sizeof(void *));
+ eCol->nb -= i;
+ }
+ }
+
+ /* eliminate marginal small blocks at the end of the sequence */
+ if (eCol->nb > 0) {
+ int i = eCol->nb - 1;
+ while (i >= 0) {
+ exon_p_t e = eCol->e.exon[i];
+ if (e->to2 - e->from2 + 1 >= he->W)
+ break;
+ free(e);
+ i -= 1;
+ eCol->nb -= 1;
+ }
+ }
+
+ /* Slide exon boundaries for optimal intron signals */
+ slide_intron(r, he->seq, seq2->seq);
+
+ /* */
+ align_status = pluri_align(he->seq, seq2->seq, &(st->nmatches), eCol,
+ &r->sList, he->len, seq2->len);
+ if (align_status != 0 || !options.ali_flag) {
+ free_align(r->sList);
+ r->sList = NULL;
+ }
+ }
+ free(mCol.e.elt);
+ free(tem_eCol.e.elt);
+ }
+
+ void
+ init_col(collec_p_t c, unsigned int size)
+ {
+ c->size = size;
+ c->nb = 0;
+ if (size > 0)
+ c->e.elt = (void **) xmalloc(size * sizeof(void *));
+ else
+ c->e.elt = NULL;
+ }
+
+ static void
+ add_col_elt(collec_p_t c, void *elt)
+ {
+ if (c->size <= c->nb) {
+ c->size += 5;
+ c->e.elt = (void **) xrealloc(c->e.elt, c->size * sizeof(void *));
+ }
+ c->e.elt[c->nb++] = elt;
+ }
+
+ #ifdef DEBUG
+ static void
+ debug_msps(hash_env_p_t he, uchar *s2, collec_p_t mCol, char *title)
+ {
+ unsigned int j;
+ fputs(title, stderr);
+ for (j = 0; j < mCol->nb; ++j) {
+ exon_p_t m = mCol->e.exon[j];
+ fprintf(stderr, "[%d] %d-%d %d-%d, %d %d\n", j,
+ m->from1, m->to1, m->from2, m->to2, m->score, m->Score);
+ }
+ if (he == NULL)
+ return;
+ for (j = 0; j < mCol->nb; ++j) {
+ exon_p_t m = mCol->e.exon[j];
+ fprintf(stderr, "%.10s %.*s %.10s\n%.10s %.*s %.10s\n",
+ (m->from1 >= 10)
+ ? he->seq + m->from1 - 10
+ : he->seq,
+ m->to1 - m->from1 + 1, he->seq + m->from1,
+ he->seq + m->to1 + 1,
+ (m->from2 >= 10)
+ ? s2 + m->from2 - 10
+ : s2,
+ m->to2 - m->from2 + 1, s2 + m->from2,
+ s2 + m->to2 + 1);
+ }
+ }
+
+ static void
+ debug_organized_msps(collec_p_t mCol, int last_msp, char *title)
+ {
+ int i;
+ fputs(title, stderr);
+ for (i = last_msp; i >= 0; i = mCol->e.exon[i]->prev) {
+ exon_p_t m = mCol->e.exon[i];
+ fprintf(stderr, "[%d] %d-%d %d-%d, %d %d\n", i,
+ m->from1, m->to1, m->from2, m->to2, m->score, m->Score);
+ }
+ }
+ #endif
+
+ static void
+ exon_cores(hash_env_p_t he, uchar *s2, unsigned int len2,
+ int offset1, int offset2, int K,
+ collec_p_t mCol, collec_p_t res, collec_p_t eCol)
+ {
+ unsigned int j;
+ int last_msp;
+ int swapped = eCol != NULL; /* True when sequences were swapped. */
+
+ search(he, s2, len2, K, mCol);
+ #ifdef DEBUG
+ debug_msps(he, s2, mCol, "==== unsorted MSPs\n");
+ #endif
+ /* Kill small repeated segments. */
+ qsort(mCol->e.exon, mCol->nb, sizeof(exon_p_t), msp_rna_compare);
+ trim_small_repeated_msps(mCol);
+ #ifdef DEBUG
+ debug_msps(he, s2, mCol, "==== sorted MSPs\n");
+ #endif
+ /* sort in order of mp->pos1. */
+ qsort(mCol->e.exon, mCol->nb, sizeof(exon_p_t), msp_compare);
+ combine_msps(mCol);
+ #ifdef DEBUG
+ debug_msps(NULL, NULL, mCol, "==== sorted, combined MSPs\n");
+ #endif
+ /* Check for duplicated genes if requested. */
+ if (eCol == NULL) {
+ result_p_t r;
+ unsigned int minMPos = len2;
+ unsigned int maxMPos = 0;
+ unsigned int cov;
+ unsigned int globScore;
+ int tested = 0;
+ assert(res != NULL);
+ for (j = 0; j < mCol->nb; j++) {
+ exon_p_t m = mCol->e.exon[j];
+ if (m->from2 < minMPos)
+ minMPos = m->from2;
+ if (m->to2 > maxMPos)
+ maxMPos = m->to2;
+ }
+ cov = maxMPos - minMPos + 1;
+ cov = cov / 4;
+ minMPos += cov;
+ if (maxMPos > cov)
+ maxMPos -= cov;
+ for (j = 0; j < mCol->nb; j++) {
+ exon_p_t m = mCol->e.exon[j];
+ m->bot = m->from2 < minMPos;
+ m->top = m->to2 > maxMPos;
+ }
+ #ifdef DEBUG
+ fprintf(stderr, "==== top, max: %d\n", maxMPos);
+ for (j = 0; j < mCol->nb; ++j) {
+ exon_p_t m = mCol->e.exon[j];
+ fprintf(stderr, "[%d] %d-%d %d-%d, %d %d, %d\n", j,
+ m->from1, m->to1, m->from2, m->to2,
+ m->score, m->Score, m->top);
+ }
+ #endif
+ last_msp = link_msps(mCol, 0, mCol->nb);
+ if (last_msp < 0)
+ return;
+ globScore = mCol->e.exon[last_msp]->Score;
+ /* When filtering above 50%, check that both pieces have good scores.
+ When filtering below 50%, check that one of the pieces has 75%. */
+ if (options.filterPct >= 50) {
+ globScore = globScore * options.filterPct / 100;
+ } else {
+ globScore -= globScore / 4;
+ }
+ /* See if we have split points, and if the parts have good scores. */
+ minMPos = 0;
+ maxMPos = 0;
+ for (j = 1; j < mCol->nb; j++) {
+ exon_p_t p = mCol->e.exon[j - 1];
+ exon_p_t m = mCol->e.exon[j];
+ if ((p->top && !m->top)
+ || (!p->bot && m->bot)
+ || (p->top && m->bot)) {
+ /* We have a split. */
+ int lLast;
+ unsigned int lScore, rScore;
+ tested = 1;
+ lLast = link_msps(mCol, minMPos, j);
+ assert(lLast >= 0);
+ lScore = mCol->e.exon[lLast]->Score;
+ last_msp = link_msps(mCol, j, mCol->nb);
+ assert(last_msp >= 0);
+ rScore = mCol->e.exon[last_msp]->Score;
+ #ifdef DEBUG
+ fprintf(stderr,
+ "glob: %d, l: %d, r: %d, minP: %d, maxP: %d, j: %d\n",
+ globScore, lScore, rScore, minMPos, maxMPos, j);
+ #endif
+ if ((options.filterPct >= 50
+ && lScore >= globScore
+ && rScore >= globScore)
+ || (options.filterPct < 50
+ && (lScore >= globScore || rScore >= globScore))) {
+ unsigned int k;
+ /* Good split. Store it for processing. */
+ add_col_elt(res, xcalloc(1, sizeof(result_t)));
+ r = res->e.result[res->nb - 1];
+ r->dStart = maxMPos;
+ r->dLen = m->from1 - maxMPos;
+ eCol = &r->eCol;
+ #ifdef DEBUG
+ fprintf(stderr, "dStart: %u, dLen: %u\n", r->dStart, r->dLen);
+ debug_organized_msps(mCol, lLast, "==== organized MSPs (part)\n");
+ #endif
+ init_col(eCol, j - minMPos);
+ msp2exons(mCol->e.exon, lLast, eCol, 0);
+ for (k = 0; k < eCol->nb; k++) {
+ exon_p_t e = eCol->e.exon[k];
+ e->to1 += offset1;
+ e->from1 += offset1;
+ e->to2 += offset2;
+ e->from2 += offset2;
+ }
+ minMPos = j;
+ maxMPos = mCol->e.exon[lLast]->to1;
+ tested = 0;
+ }
+ }
+ }
+ if (tested)
+ last_msp = link_msps(mCol, minMPos, mCol->nb);
+ add_col_elt(res, xcalloc(1, sizeof(result_t)));
+ r = res->e.result[res->nb - 1];
+ r->dStart = maxMPos;
+ r->dLen = he->len - maxMPos;
+ #ifdef DEBUG
+ fprintf(stderr, "dStart: %u, dLen: %u\n", r->dStart, r->dLen);
+ #endif
+ eCol = &r->eCol;
+ } else
+ last_msp = link_msps(mCol, 0, mCol->nb);
+ /* organize Blast hits (MSPs) into exons */
+ #ifdef DEBUG
+ debug_organized_msps(mCol, last_msp, "==== organized MSPs\n");
+ #endif
+ if (eCol->size == 0)
+ init_col(eCol, mCol->nb);
+ msp2exons(mCol->e.exon, last_msp, eCol, swapped);
+ for (j = 0; j < eCol->nb; j++) {
+ exon_p_t e = eCol->e.exon[j];
+ e->to1 += offset1;
+ e->from1 += offset1;
+ e->to2 += offset2;
+ e->from2 += offset2;
+ }
+ mCol->nb = 0;
+ }
+
+ static inline int
+ lies_after_p(exon_p_t a, exon_p_t b)
+ {
+ /* When we have some overlap, make sure it is only a small part. */
+ /* ------------------
+ ---------------------
+ | p1 | p2 | p3 | */
+
+ if (b->from1 > a->to1) {
+ unsigned int p1;
+ unsigned int p2;
+ unsigned int p3;
+ if (b->from2 > a->to2)
+ return 1;
+ if (b->from2 < a->from2 || b->to2 < a->to2)
+ return 0;
+ p1 = b->from2 - a->from2;
+ p2 = a->to2 - b->from2;
+ p3 = b->to2 - a->to2;
+ if (p1 > p2 && p3 > p2 && p1 > options.K && p3 > options.K)
+ return 1;
+ } else if (b->from2 > a->to2) {
+ unsigned int p1;
+ unsigned int p2;
+ unsigned int p3;
+ if (b->from1 < a->from1 || b->to1 < a->to1)
+ return 0;
+ p1 = b->from1 - a->from1;
+ p2 = a->to1 - b->from1;
+ p3 = b->to1 - a->to1;
+ if (p1 > p2 && p3 > p2 && p1 > options.K && p3 > options.K)
+ return 1;
+ }
+ return 0;
+ }
+
+ #define SMALL_EXON 50
+ #define MIN_REPEAT 20
+ #define JITTER_FACTOR 5
+
+ static void
+ trim_small_repeated_msps(collec_p_t mCol)
+ {
+ unsigned int i = 0;
+ while (i < mCol->nb) {
+ exon_p_t m = mCol->e.exon[i];
+ unsigned int j, k, end;
+ if (m->to2 - m->from2 >= SMALL_EXON) {
+ i += 1;
+ continue;
+ }
+ end = m->to2 + JITTER_FACTOR;
+ j = i + 1;
+ while (j < mCol->nb && mCol->e.exon[j]->to2 <= end)
+ j += 1;
+ if (j - i < MIN_REPEAT) {
+ i += 1;
+ continue;
+ }
+ for (k = i; k < j; k++)
+ free(mCol->e.exon[k]);
+ memmove(mCol->e.exon + i, mCol->e.exon + j,
+ (mCol->nb - j) * sizeof(exon_p_t));
+ mCol->nb -= (j - i);
+ }
+ }
+
+ static void
+ combine_msps(collec_p_t mCol)
+ {
+ unsigned int i = 0;
+ while (i < mCol->nb) {
+ exon_p_t m = mCol->e.exon[i];
+ unsigned int ovl = 0;
+ unsigned int j;
+ for (j = i + 1; j < mCol->nb; j++) {
+ exon_p_t n = mCol->e.exon[j];
+ unsigned int o = 0;
+ if (n->from2 <= m->to2 + 1)
+ ovl = m->to2 - n->from2 + 2;
+ if (n->from1 > m->from1
+ && n->from1 <= m->to1 + 1)
+ o = m->to1 - n->from1 + 2;
+ if ((ovl == 0) == (o == 0)
+ && abs((int) ovl - (int) o) <= 10)
+ break;
+ ovl = 0;
+ }
+ if (ovl != 0) {
+ exon_p_t n = mCol->e.exon[j];
+ unsigned int nScore = m->score + n->score;
+ if (nScore >= ovl + 1)
+ nScore -= ovl + 1;
+ else
+ nScore = 0;
+ m->from1 = min(m->from1, n->from1);
+ m->from2 = min(m->from2, n->from2);
+ m->to1 = max(m->to1, n->to1);
+ m->to2 = max(m->to2, n->to2);
+ if (nScore > m->score)
+ m->score = nScore;
+ mCol->nb -= 1;
+ free(n);
+ memmove(mCol->e.exon + j, mCol->e.exon + j + 1,
+ (mCol->nb - j) * sizeof(exon_p_t));
+ } else
+ i += 1;
+ }
+ }
+
+ static int
+ link_msps(collec_p_t mCol, unsigned int start, unsigned int stop)
+ {
+ struct {
+ unsigned int elt;
+ unsigned int score;
+ } best;
+ unsigned int i;
+ if (start >= stop)
+ return -1;
+ memset(&best, 0, sizeof(best));
+ for (i = start; i < stop; i++) {
+ exon_p_t m = mCol->e.exon[i];
+ m->Score = 0;
+ m->prev = -1;
+ }
+ for (i = start; i < stop; i++) {
+ exon_p_t m = mCol->e.exon[i];
+ unsigned int j;
+ m->Score += m->score;
+ if (m->Score > best.score) {
+ best.score = m->Score;
+ best.elt = i;
+ }
+ for (j = i + 1; j < stop; j++) {
+ exon_p_t n = mCol->e.exon[j];
+ if (lies_after_p(m, n) && m->Score >= n->Score) {
+ unsigned int penalty;
+ penalty = abs(n->from1 - m->from1) >> 15;
+ penalty += abs(n->from2 - m->from2) >> 15;
+ if (penalty < m->Score) {
+ n->Score = m->Score - penalty;
+ n->prev = i;
+ }
+ }
+ }
+ }
+ return best.elt;
+ }
+
+ void
+ init_encoding(void)
+ {
+ unsigned int i;
+ for (i = 0; i < NACHARS; i++)
+ encoding[i] = 4;
+ encoding['A'] = 0;
+ encoding['C'] = 1;
+ encoding['G'] = 2;
+ encoding['T'] = 3;
+ }
+
+ void
+ init_hash_env(hash_env_p_t he, unsigned int W, uchar *seq, unsigned int len)
+ {
+ he->W = W;
+ he->seq = seq;
+ he->len = len;
+ he->mask = (1 << (W + W - 2)) - 1;
+ he->next_pos = (int *) xmalloc((len + 1) * sizeof(int));
+ he->hashtab = (void **)
+ xcalloc(HASH_SIZE, sizeof(void *));
+ }
+
+ #ifndef __GLIBC__
+ void
+ tdestroy(void *VROOT, void(*FREEFCT)(void *))
+ {
+ }
+ #endif
+
+ void
+ free_hash_env(hash_env_p_t he)
+ {
+ unsigned int hval;
+ free(he->next_pos);
+ for (hval = 0; hval < HASH_SIZE; hval++) {
+ tdestroy(he->hashtab[hval], free);
+ }
+ free(he->hashtab);
+ }
+
+ static int
+ hash_node_compare(const void *a, const void *b)
+ {
+ const hash_node_p_t ha = (hash_node_p_t) a, hb = (hash_node_p_t)b;
+ if (ha->ecode < hb->ecode)
+ return -1;
+ if (ha->ecode > hb->ecode)
+ return 1;
+ return 0;
+ }
+
+ /* add_word - add a word to the table of critical words */
+ static inline void
+ add_word(hash_env_p_t he, unsigned int ecode, unsigned int pos)
+ {
+ hash_node_p_t h = (hash_node_p_t) xmalloc(sizeof(hash_node_t));
+ hash_node_p_t *key;
+
+ h->ecode = ecode;
+ key = tsearch(h, he->hashtab + (ecode & HASH_MASK), hash_node_compare);
+ assert(key != NULL);
+ if (*key != h) {
+ free(h);
+ he->next_pos[pos] = (*key)->pos;
+ } else {
+ he->next_pos[pos] = -1;
+ }
+ (*key)->pos = pos;
+ }
+
+ /* ----------- build table of W-tuples in one of the sequences ------------*/
+ void
+ bld_table(hash_env_p_t he)
+ {
+ unsigned int ecode;
+ unsigned int i = 0;
+ uchar *t;
+ /* skip any word containing an N/X */
+ t = he->seq;
+ while (i < he->len) {
+ unsigned int j;
+ restart:
+ ecode = 0;
+ for (j = 1; j < he->W && i < he->len; j++) {
+ unsigned int tmp = encoding[*t++];
+ i += 1;
+ if (tmp > 3) goto restart;
+ ecode = (ecode << 2) + tmp;
+ }
+
+ while (i < he->len) {
+ unsigned int tmp = encoding[*t++];
+ i += 1;
+ if (tmp > 3) goto restart;
+ ecode = ((ecode & he->mask) << 2) + tmp;
+ add_word(he, ecode, i);
+ }
+ }
+ }
+
+ /* ----------------------- search the other sequence ---------------------*/
+
+ static void
+ search(hash_env_p_t he, uchar *s2, unsigned int len2, int K,
+ collec_p_t mCol)
+ {
+ uchar *t;
+ unsigned int i = 0;
+ int *allocated = xcalloc(he->len + len2 + 1, sizeof(int));
+ int *diag_lev = allocated + he->len;
+ t = s2;
+ while (i < len2) {
+ unsigned int j;
+ hash_node_t hn;
+ restart:
+ hn.ecode = 0;
+ for (j = 1; j < he->W && i < len2; j++) {
+ unsigned int tmp = encoding[*t++];
+ i += 1;
+ if (tmp > 3) goto restart;
+ hn.ecode = (hn.ecode << 2) + tmp;
+ }
+ while (i < len2) {
+ unsigned int tmp = encoding[*t++];
+ hash_node_p_t *key;
+ i += 1;
+ if (tmp > 3) goto restart;
+ hn.ecode = ((hn.ecode & he->mask) << 2) + tmp;
+ key = tfind(&hn, he->hashtab + (hn.ecode & HASH_MASK),
+ hash_node_compare);
+ if (key != NULL) {
+ int p;
+ for (p = (*key)->pos; p >= 0; p = he->next_pos[p])
+ extend_hit(p, i, he, s2, len2, K, mCol, diag_lev);
+ }
+ }
+ }
+ free(allocated);
+ }
+
+ /* extend_hit - extend a word-sized hit to a longer match */
+ static void
+ extend_hit(int pos1, int pos2, hash_env_p_t he, const uchar * const s2,
+ unsigned int len2, int K, collec_p_t mCol, int *diag_lev)
+ {
+ const uchar *beg2, *beg1, *end1, *q, *s;
+ int right_sum, left_sum, sum, diag, score;
+
+ diag = pos2 - pos1;
+ if (diag_lev[diag] > pos1)
+ return;
+
+ /* extend to the right */
+ left_sum = sum = 0;
+ q = he->seq + pos1;
+ s = s2 + pos2;
+ end1 = q;
+ while (s < s2 + len2
+ && q < he->seq + he->len
+ && sum >= left_sum - options.X) {
+ sum += ((*s++ == *q++)
+ ? options.matchScore
+ : options.mismatchScore);
+ if (sum > left_sum) {
+ left_sum = sum;
+ end1 = q;
+ }
+ }
+
+ /* extend to the left */
+ right_sum = sum = 0;
+ beg1 = q = (he->seq + pos1) - he->W;
+ beg2 = s = (s2 + pos2) - he->W;
+ while ((s > s2) && (q > he->seq) && sum >= right_sum - options.X) {
+ sum += ((*(--s) == *(--q))
+ ? options.matchScore
+ : options.mismatchScore);
+ if (sum > right_sum) {
+ right_sum = sum;
+ beg2 = s;
+ beg1 = q;
+ }
+ }
+
+ score = he->W + left_sum + right_sum;
+ if (score >= K) {
+ add_col_elt(mCol,
+ new_exon(beg1 - he->seq, beg2 - s2,
+ end1 - he->seq - 1, beg2 - s2 + end1 - beg1 - 1));
+ mCol->e.exon[mCol->nb - 1]->score = score;
+ }
+ diag_lev[diag] = (end1 - he->seq) + he->W;
+ }
+
+ /* ---------------------------- sort the MSPs ----------------------------*/
+
+ /* msp_compare - determine ordering relationship between two MSPs */
+ static int
+ msp_compare(const void *a, const void *b)
+ {
+ exon_p_t ki = * (exon_p_t *) a, kj = * (exon_p_t *) b;
+
+ if (ki->from1 > kj->from1)
+ return 1;
+ if (ki->from1 < kj->from1)
+ return -1;
+ if (ki->from2 > kj->from2)
+ return 1;
+ if (ki->from2 < kj->from2)
+ return -1;
+ return 0;
+ }
+
+ /* msp_rna_compare - determine RNA ordering relationship between two MSPs */
+ static int
+ msp_rna_compare(const void *a, const void *b)
+ {
+ exon_p_t ki = * (exon_p_t *) a, kj = * (exon_p_t *) b;
+
+ if (ki->from2 > kj->from2)
+ return 1;
+ if (ki->from2 < kj->from2)
+ return -1;
+ if (ki->to2 > kj->to2)
+ return -1;
+ if (ki->to2 < kj->to2)
+ return 1;
+ return 0;
+ }
+
+ /* --------------------- organize the MSPs into exons ---------------------*/
+
+ static void
+ msp2exons(exon_p_t *msp, int last_msp, collec_p_t eCol, int swapped)
+ {
+ while (last_msp >= 0) {
+ exon_p_t mp = msp[last_msp];
+ if (eCol->nb > 0) {
+ /* See if we merge with next exon (we go in reverse). */
+ exon_p_t next = eCol->e.exon[eCol->nb - 1];
+ if (!swapped
+ && next->from1 < mp->to1 + MIN_INTRON
+ && next->from2 > mp->to2 - 1) {
+ next->to1 = max(next->to1, mp->to1);
+ next->to2 = max(next->to2, mp->to2);
+ next->from1 = min(next->from1, mp->from1);
+ next->from2 = min(next->from2, mp->from2);
+ last_msp = mp->prev;
+ free(mp);
+ continue;
+ }
+ }
+ add_col_elt(eCol, mp);
+ last_msp = mp->prev;
+ }
+ /* Now, need to reverse the exons... */
+ if (eCol->nb > 1) {
+ unsigned int i, j;
+ for (i = 0, j = eCol->nb - 1; j > i; i++, j--) {
+ exon_p_t e = eCol->e.exon[i];
+ eCol->e.exon[i] = eCol->e.exon[j];
+ eCol->e.exon[j] = e;
+ }
+ }
+ }
+
+ /* ---------------------- print endpoints of exons --------------------*/
+
+ void
+ print_exons(collec_p_t eCol, int direction)
+ {
+ unsigned int i;
+ unsigned int last = eCol->nb - 1;
+ exon_p_t cur;
+ assert(eCol->nb > 0);
+ for (i = 0; i < last; i++) {
+ cur = eCol->e.exon[i];
+ if (direction == 0 || cur->type < 0)
+ printf("%u-%u (%u-%u) %u%% ==\n",
+ cur->from1 + options.dnaOffset, cur->to1 + options.dnaOffset,
+ cur->from2, cur->to2, cur->score);
+ else
+ printf("%u-%u (%u-%u) %u%% %s (%.2s/%.2s) %u\n",
+ cur->from1 + options.dnaOffset, cur->to1 + options.dnaOffset,
+ cur->from2, cur->to2, cur->score,
+ direction > 0 ? "->" : "<-",
+ options.splice[cur->type].fwd,
+ options.splice[cur->type].fwd + 2,
+ cur->splScore);
+ }
+ cur = eCol->e.exon[last];
+ printf("%u-%u (%u-%u) %u%%\n",
+ cur->from1 + options.dnaOffset, cur->to1 + options.dnaOffset,
+ cur->from2, cur->to2, cur->score);
+ }
+
+ static int
+ pluri_align(uchar *seq1, uchar *seq2, unsigned int *num_matches,
+ collec_p_t eCol, edit_script_list_p_t *Aligns, int M, int N)
+ {
+ exon_t eFake;
+ exon_p_t cur = &eFake;
+ int diff, end1, end2, ali_dist;
+ unsigned int nmatches = 0;
+ edit_script_p_t head;
+ int ii;
+
+ head = NULL;
+ *Aligns = NULL;
+ ali_dist = 0;
+ end1 = M;
+ end2 = N;
+ eFake.from1 = M + 1;
+ eFake.from2 = N + 1;
+ eFake.to1 = 0;
+ eFake.to2 = 0;
+
+ for (ii = eCol->nb - 1; ii >= 0; ii--) {
+ exon_p_t prev = eCol->e.exon[ii];
+ edit_script_p_t left, right, prevE, tmp_script;
+ uchar *a, *b;
+ int tmpi, di_count, alen;
+ if ((diff = cur->from2 - prev->to2 - 1) != 0) {
+ if (cur->to1) {
+ edit_script_list_p_t
+ enew = (edit_script_list_p_t) xmalloc(sizeof(edit_script_list_t));
+ enew->next_script = *Aligns;
+ *Aligns = enew;
+ enew->script = head;
+ enew->offset1 = cur->from1;
+ enew->offset2 = cur->from2;
+ enew->len1 = end1 - enew->offset1 + 1;
+ enew->len2 = end2 - enew->offset2 + 1;
+ enew->score = ali_dist;
+ ali_dist = 0;
+ head = NULL;
+ }
+ end1 = prev->to1;
+ end2 = prev->to2;
+ } else if ((diff = cur->from1 - prev->to1 - 1) != 0
+ && cur->to1) {
+ edit_script_p_t new = (edit_script_p_t) xmalloc(sizeof(edit_script_t));
+ new->op_type = DELETE;
+ new->num = diff;
+ new->next = head;
+ head = new;
+ } else if (diff)
+ end1 = prev->to1;
+
+ diff = align_get_dist(seq1, seq2, prev->from1 - 1, prev->from2 - 1,
+ prev->to1, prev->to2,
+ max(1000, .2 * (prev->to2 - prev->from2 + 1)));
+
+ if (diff < 0)
+ return -1;
+
+ align_path(seq1, seq2, prev->from1 - 1, prev->from2 - 1,
+ prev->to1, prev->to2, diff, &left, &right, M, N);
+ if (right == NULL)
+ return -1;
+ Condense_both_Ends(&left, &right, &prevE);
+
+ if (!cur->to1 && right->op_type == DELETE) {
+ /* remove gaps at end of alignment */
+ diff -= 0 + right->num; /* subtract GAP_OPEN = 0 */
+ prev->to1 -= right->num;
+ end1 -= right->num;
+ if (head && (head->op_type == DELETE))
+ head->num += right->num;
+ free(right);
+ prevE->next = NULL;
+ right = prevE;
+ }
+ if (ii == 0 && left && (left->op_type == DELETE)) {
+ diff -= 0 + left->num; /* subtract GAP_OPEN = 0 */
+ prev->from1 += left->num;
+ tmp_script = left->next;
+ if (right == left)
+ right = tmp_script;
+ free(left);
+ left = tmp_script;
+ }
+
+ ali_dist += diff;
+
+ a = seq1 + prev->from1 - 1;
+ b = seq2 + prev->from2 - 1;
+ tmpi = di_count = 0;
+ tmp_script = left;
+ while (tmp_script) {
+ switch (tmp_script->op_type) {
+ case DELETE:
+ di_count += tmp_script->num;
+ tmpi += tmp_script->num;
+ a += tmp_script->num;
+ break;
+ case INSERT:
+ di_count += tmp_script->num;
+ tmpi += tmp_script->num;
+ b += tmp_script->num;
+ break;
+ case SUBSTITUTE:
+ {
+ int j;
+ for (j = 0; j < tmp_script->num; ++j, ++a, ++b)
+ if (*a != *b)
+ tmpi++;
+ else
+ nmatches++;
+ break;
+ }
+ }
+ tmp_script = tmp_script->next;
+ }
+ alen = (int) ((prev->to1 - prev->from1 + 1
+ + prev->to2 - prev->from2 + 1 + di_count)
+ / (double) 2);
+ prev->score = ((alen - tmpi) * 100) / alen;
+ right->next = head;
+ head = left;
+ cur = prev;
+ }
+
+ /* at the beginning of the sequences */
+ if ((diff = cur->from2 - 1) != 0 && diff != N) {
+ edit_script_list_p_t
+ enew = (edit_script_list_p_t) xmalloc(sizeof(edit_script_list_t));
+ enew->next_script = *Aligns;
+ *Aligns = enew;
+ enew->offset1 = cur->from1;
+ enew->offset2 = cur->from2;
+ enew->len1 = end1 - enew->offset1 + 1;
+ enew->len2 = end2 - enew->offset2 + 1;
+ enew->script = head;
+ enew->score = ali_dist;
+ } else if (diff != N) {
+ /* modified to cut introns at the beginning of the sequence */
+ edit_script_list_p_t
+ enew = (edit_script_list_p_t) xmalloc(sizeof(edit_script_list_t));
+ enew->next_script = *Aligns;
+ *Aligns = enew;
+ enew->offset1 = cur->from1;
+ enew->offset2 = 1;
+ enew->len1 = end1 - enew->offset1 + 1;
+ enew->len2 = end2 - enew->offset2 + 1;
+ enew->script = head;
+ enew->score = ali_dist;
+ }
+ *num_matches = nmatches;
+ return 0;
+ }
+
+ static exon_p_t
+ new_exon(unsigned int f1, unsigned int f2, unsigned int t1, unsigned int t2)
+ {
+ exon_p_t e = (exon_p_t) xmalloc(sizeof(exon_t));
+ e->from1 = f1;
+ e->from2 = f2;
+ e->to1 = t1;
+ e->to2 = t2;
+ return e;
+ }
+
+ /* FIXME: why are s1 and s2 reversed here, wrt SIM4 ??? */
+ static int
+ greedy(uchar *s1, uchar *s2, unsigned int m, unsigned int n,
+ unsigned int offset1, unsigned int offset2, unsigned int W,
+ collec_p_t eCol)
+ {
+ int col, /* column number */
+ k, /* current diagonal */
+ blower,flower, /* boundaries for searching diagonals */
+ bupper,fupper,
+ row, /* row number */
+ DELTA, /* n-m */
+ B_ORIGIN, F_ORIGIN;
+ unsigned int d, /* current distance */
+ max_d, /* bound on size of edit script */
+ Cost,
+ MAX_D,
+ i;
+ int back, forth; /* backward and forward limits at exit */
+ int *blast_d, *flast_d, /* rows containing the last d (at crt step, d-1) */
+ *btemp_d, *ftemp_d; /* rows containing tmp values for the last d */
+ int *min_row, *min_diag, /* min (b)/ max (f) row (and diagonal) */
+ *max_row, *max_diag; /* reached for cost d=0, ... m. */
+
+ /* No point trying to span megabase-sized holes... */
+ if (n >= 1000000)
+ return 0;
+ DELTA = n - m;
+ /*max_d = MAX_D = m+1; */
+ max_d = MAX_D = max(W, (unsigned int) (P * m + 1));
+
+ if (DELTA < 0) {
+ if (m <= min(W, (1 + P) * n)) {
+ add_col_elt(eCol,
+ new_exon(offset2 + 1, offset1 + 1,
+ offset2 + n, offset1 + m));
+ return m - n + (unsigned int) (P * n + 1);
+ } else {
+ return max(W, (unsigned int) (P * m + 1)) + 1;
+ }
+ }
+
+ F_ORIGIN = MAX_D;
+ B_ORIGIN = MAX_D - DELTA;
+ for (row = m, col = n;
+ row > 0 && col > 0 && (s1[row - 1] == s2[col - 1]);
+ row--,col--)
+ /*LINTED empty loop body*/;
+
+ if (row == 0) {
+ /* hit last row; stop search */
+ add_col_elt(eCol,
+ new_exon(offset2 - m + n + 1, offset1 + 1,
+ offset2 + n, offset1 + m));
+ return 0;
+ }
+
+ blast_d = (int *) xmalloc((MAX_D + n + 1) * sizeof(int));
+ btemp_d = (int *) xmalloc((MAX_D + n + 1) * sizeof(int));
+
+ for (i = 0; i <= MAX_D + n; ++i) {
+ blast_d[i] = m + 1;
+ btemp_d[i] = m + 1;
+ }
+ blast_d[B_ORIGIN + DELTA] = row;
+
+ blower = B_ORIGIN + DELTA - 1;
+ bupper = B_ORIGIN + DELTA + 1;
+
+ for (row = 0;
+ (unsigned int) row < n
+ && (unsigned int) row < m
+ && (s1[row] == s2[row]);
+ row++)
+ /*LINTED empty loop body*/;
+
+ if ((unsigned int) row == m) {
+ /* hit last row; stop search */
+ add_col_elt(eCol,
+ new_exon(offset2 + 1, offset1 + 1,
+ offset2 + m, offset1 + m));
+ free(blast_d);
+ free(btemp_d);
+ return 0;
+ }
+
+ flast_d = (int *) xmalloc((MAX_D + n + 1) * sizeof(int));
+ ftemp_d = (int *) xmalloc((MAX_D + n + 1) * sizeof(int));
+
+ for (i = 0; i <= MAX_D + n; ++i) {
+ flast_d[i] = -1;
+ ftemp_d[i] = -1;
+ }
+ flast_d[F_ORIGIN] = row;
+
+ flower = F_ORIGIN - 1;
+ fupper = F_ORIGIN + 1;
+
+ max_row = (int *) xmalloc((MAX_D + 1) * sizeof(int));
+ min_row = (int *) xmalloc((MAX_D + 1) * sizeof(int));
+ max_diag = (int *) xmalloc((MAX_D + 1) * sizeof(int));
+ min_diag = (int *) xmalloc((MAX_D + 1) * sizeof(int));
+
+ for (d = 1; d <= MAX_D; d++) {
+ min_row[d] = m + 1;
+ max_row[d] = -1;
+ }
+ min_row[0] = blast_d[B_ORIGIN + DELTA];
+ min_diag[0] = B_ORIGIN + DELTA;
+ max_row[0] = flast_d[F_ORIGIN];
+ max_diag[0] = F_ORIGIN;
+
+ back = forth = -1;
+
+ d = 1;
+ while (d <= max_d) {
+
+ /* for each relevant diagonal ... */
+ for (k = blower; k <= bupper; k++) {
+ /* process the next edit instruction */
+
+ /* find a d on diagonal k */
+ if (k == -((int) d) + DELTA + B_ORIGIN) {
+
+ /* move left from the last d-1 on diagonal k+1 */
+ row = blast_d[k + 1]; /* INSERT */
+ } else if (k == (int) d + DELTA + B_ORIGIN) {
+
+ /* move up from the last d-1 on diagonal k-1 */
+ row = blast_d[k - 1] - 1; /* DELETE */
+ } else if ((blast_d[k] <= blast_d[k + 1])
+ && (blast_d[k] - 1 <= blast_d[k - 1])) {
+
+ /* substitution */
+ row = blast_d[k] - 1; /* SUBSTITUTE */
+
+ } else if ((blast_d[k - 1] <= blast_d[k + 1] - 1)
+ && (blast_d[k - 1] <= blast_d[k] - 1)) {
+ /* move right from the last d-1 on diagonal k-1 */
+ row = blast_d[k - 1] - 1; /* DELETE */
+ } else {
+ /* move left from the last d-1 on diagonal k+1 */
+ row = blast_d[k + 1]; /* INSERT */
+ }
+ /* code common to the three cases */
+ col = row + k - B_ORIGIN;
+
+ /* slide up the diagonal */
+ while (row > 0 && col > 0 && (s1[row - 1] == s2[col - 1])) {
+ --row;
+ --col;
+ }
+ btemp_d[k] = row;
+
+ /* if (row == 0 || col == 0) max_d = d; */
+
+ } /* for k */
+
+ min_row[d] = btemp_d[DELTA + B_ORIGIN];
+ min_diag[d] = DELTA + B_ORIGIN;
+ for (k = blower; k <= bupper; ++k) {
+ blast_d[k] = btemp_d[k];
+ btemp_d[k] = m + 1;
+ if (blast_d[k] < min_row[d]) {
+ min_row[d] = blast_d[k];
+ min_diag[d] = k;
+ }
+ }
+
+ /* record cell, if paths overlap with minimum combined cost */
+ /* obs: it suffices to search up to Cost=min(d-1,(max_d-d)) */
+ for (Cost = 0; Cost < d; Cost++) {
+ if ((min_row[d] <= max_row[Cost])
+ && ((max_d > d + Cost) || (max_d == d + Cost && (forth < 0)))) {
+ max_d = d + Cost;
+ back = d;
+ forth = Cost;
+ break;
+ }
+ }
+
+ --blower; ++bupper;
+
+ /* for each relevant diagonal ... */
+ for (k = flower; k <= fupper; k++) {
+ /* process the next edit instruction */
+
+ /* find a d on diagonal k */
+ if (k == -((int) d) + F_ORIGIN) {
+ /* move down from the last d-1 on diagonal k+1 */
+ row = flast_d[k + 1] + 1; /* DELETE */
+
+ } else if (k == (int) d + F_ORIGIN) {
+ /* move right from the last d-1 on diagonal k-1 */
+ row = flast_d[k - 1]; /* INSERT */
+
+ } else if ((flast_d[k] >= flast_d[k + 1])
+ && (flast_d[k] + 1 >= flast_d[k - 1])) {
+
+ /* substitution */
+ row = flast_d[k] + 1; /* SUBSTITUTE */
+
+ } else if ((flast_d[k + 1] + 1 >= flast_d[k - 1])
+ && (flast_d[k + 1] >= flast_d[k])) {
+
+ /* move left from the last d-1 on diagonal k+1 */
+ row = flast_d[k + 1] + 1; /* DELETE */
+ } else {
+ /* move right from the last d-1 on diagonal k-1 */
+ row = flast_d[k - 1]; /* INSERT */
+ }
+ /* code common to the three cases */
+ col = row + k - F_ORIGIN;
+
+ /* slide down the diagonal */
+ if (row >= 0)
+ while ((unsigned int) row < m
+ && (unsigned int) col < n
+ && (s1[row] == s2[col])) {
+ ++row;
+ ++col;
+ }
+ ftemp_d[k] = row;
+
+ /* if (row == m || col == n) max_d = d; */
+ } /* for k */
+
+ max_row[d] = ftemp_d[F_ORIGIN];
+ max_diag[d] = F_ORIGIN;
+ for (k = flower; k <= fupper; ++k) {
+ flast_d[k] = ftemp_d[k];
+ ftemp_d[k] = -1;
+ if (flast_d[k] > max_row[d]) {
+ max_row[d] = flast_d[k];
+ max_diag[d] = k;
+ }
+ }
+
+ /* record backward and forward limits, if minimum combined
+ * cost in overlapping. Note: it suffices to search up to
+ * Cost=min(d,(max_d-d)).
+ */
+ for (Cost = 0; Cost <= d; Cost++) {
+ if ((min_row[Cost] <= max_row[d])
+ && ((max_d > d + Cost) || (max_d == d + Cost && (forth < 0)))) {
+ max_d = d + Cost;
+ back = Cost;
+ forth = d;
+ break;
+ }
+ }
+ --flower; ++fupper;
+
+ ++d; /* for d */
+ }
+
+ if (d > MAX_D) {
+ free(blast_d); free(btemp_d);
+ free(flast_d); free(ftemp_d);
+ free(min_row); free(min_diag);
+ free(max_row); free(max_diag);
+
+ return d;
+ }
+ /*fin:*/
+ {
+ unsigned int p1, p2, q1, q2;
+ if ((int) m - min_row[back] >= max_row[forth]) {
+ p1 = min_row[back];
+ p2 = min_row[back] + max_diag[forth] - F_ORIGIN;
+ q1 = min_row[back];
+ q2 = min_row[back] + min_diag[back] - B_ORIGIN;
+ } else {
+ p1 = max_row[forth];
+ p2 = max_row[forth] + max_diag[forth] - F_ORIGIN;
+ q1 = max_row[forth];
+ q2 = max_row[forth] + min_diag[back] - B_ORIGIN;
+ }
+ assert(q1 > 0 || p1 < m);
+ if (q1 > 0)
+ add_col_elt(eCol,
+ new_exon(offset2 + 1, offset1 + 1,
+ offset2 + p2, offset1 + p1));
+ if (p1 < m)
+ add_col_elt(eCol,
+ new_exon(offset2 + q2 + 1, offset1 + q1 + 1,
+ offset2 + n, offset1 + m));
+ }
+
+ free(blast_d); free(btemp_d);
+ free(flast_d); free(ftemp_d);
+ free(min_row); free(min_diag);
+ free(max_row); free(max_diag);
+
+ return back + forth;
+ }
+
+ static int
+ about_same_gap_p(unsigned int to1, unsigned int nFrom1,
+ unsigned int to2, unsigned int nFrom2)
+ {
+ unsigned int g1, g2, d;
+ if (nFrom1 <= to1 || nFrom2 <= to2)
+ return 0;
+ g1 = nFrom1 - to1 - 1;
+ g2 = nFrom2 - to2 - 1;
+ if (g2 > g1) {
+ unsigned int tem = g1;
+ g1 = g2;
+ g2 = tem;
+ }
+ d = g1 - g2;
+ if ((d * 100) / g1 <= options.gapPct)
+ return 1;
+ return 0;
+ }
+
+ /* operates on a list sorted in increasing order of exon coordinates */
+ static void
+ compact_exons(collec_p_t eCol, unsigned int W)
+ {
+ unsigned int i = 1;
+ /* Kill stupid overlaping exons. */
+ while (i < eCol->nb) {
+ exon_p_t cur = eCol->e.exon[i - 1];
+ exon_p_t next = eCol->e.exon[i];
+ unsigned int diff = next->from2 - cur->from2;
+ if (diff <= options.intron_window) {
+ eCol->nb -= 1;
+ if (cur->to2 > next->to2) {
+ free(next);
+ memmove(eCol->e.exon + i, eCol->e.exon + i + 1,
+ (eCol->nb - i) * sizeof(exon_p_t));
+ if (i < eCol->nb) {
+ next = eCol->e.exon[i];
+ cur->to1 += diff;
+ cur->to2 += diff;
+ next->from1 -= diff;
+ next->from2 -= diff;
+ }
+ } else {
+ free(cur);
+ memmove(eCol->e.exon + i - 1, eCol->e.exon + i,
+ (eCol->nb - i + 1) * sizeof(exon_p_t));
+ if (i > 1) {
+ cur = eCol->e.exon[i - 2];
+ cur->to1 += diff;
+ cur->to2 += diff;
+ next->from1 -= diff;
+ next->from2 -= diff;
+ }
+ }
+ } else
+ i += 1;
+ }
+ for (i = 1; i < eCol->nb; i++) {
+ exon_p_t cur = eCol->e.exon[i - 1];
+ exon_p_t next = eCol->e.exon[i];
+ if ((next->from1 < cur->to1 + 1 + MIN_INTRON
+ && next->from2 <= cur->to2 + 1 + W)
+ || about_same_gap_p(cur->to1, next->from1,
+ cur->to2, next->from2)) {
+ /* merge blocks cur and next */
+ cur->to1 = next->to1;
+ cur->to2 = next->to2;
+ free(next);
+ eCol->nb -= 1;
+ memmove(eCol->e.elt + i, eCol->e.elt + i + 1,
+ (eCol->nb - i) * sizeof(void *));
+ i -= 1;
+ }
+ }
+ }
+
+ static int
+ good_ratio(int length, int W)
+ {
+ if (length<=W/2) return 2;
+ else if (length<2*W) return options.cutoff;
+ else return (int)(.75*P*length+1);
+ }
+
+ static int
+ extend_bw(uchar *s1, uchar *s2, int m, int n, int offset1, int offset2,
+ int *line1, int *line2, int W)
+ {
+ int col, /* column number */
+ row, /* row number */
+ max_d, /* bound on the length of the edit script */
+ d, /* current compressed distance */
+ k, /* current diagonal */
+ DELTA, /* n-m */
+ ORIGIN,
+ lower,
+ upper;
+ int *last_d, *temp_d; /* column containing the last p */
+ int *min_row, *min_diag; /* min (b)/ max (f) row (and diagonal) */
+ /* reached for cost d=0, ... m. */
+ DELTA = n-m;
+ max_d = m+1;
+
+ ORIGIN = m;
+ for (row=m, col=n; row>0 && col>0 && (s1[row-1]==s2[col-1]); row--,col--)
+ /*LINTED empty loop body*/;
+
+ if ((row == 0) || (col == 0)) {
+ *line1 = row+offset1;
+ *line2 = col+offset2;
+
+ return 0;
+ }
+
+ last_d = (int *)xmalloc((m+n+1)*sizeof(int));
+ temp_d = (int *)xmalloc((m+n+1)*sizeof(int));
+
+ for (k=0; k<=m+n; ++k) last_d[k]=m+1;
+ last_d[ORIGIN+DELTA] = row;
+
+ lower = ORIGIN + DELTA - 1;
+ upper = ORIGIN + DELTA + 1;
+
+ min_row = (int *)xmalloc((m+1)*sizeof(int));
+ min_diag = (int *)xmalloc((m+1)*sizeof(int));
+
+ for (d=1; d<=m; d++)
+ min_row[d] = m+1;
+
+ min_row[0] = last_d[ORIGIN+DELTA];
+ min_diag[0] = ORIGIN + DELTA;
+
+ d = 0;
+ while ((++d<=max_d) &&
+ ((d-1<=good_ratio(m-min_row[d-1], W)) ||
+ ((d>=2) && (d-2<=good_ratio(m-min_row[d-2], W))))) {
+
+ /* for each relevant diagonal ... */
+ for (k = lower; k <= upper; k++) {
+
+ /* find a d on diagonal k */
+ if (k==-d+DELTA+ORIGIN) {
+ /* move down from the last d-1 on diagonal k+1 */
+ row = last_d[k+1];
+ /* op = INSERT; */
+
+ } else if (k==d+DELTA+ORIGIN) {
+ /* move right from the last d-1 on diagonal k-1 */
+ row = last_d[k-1]-1;
+ /* op = DELETE; */
+
+ } else if ((last_d[k]-1<=last_d[k+1]) &&
+ (last_d[k]-1<=last_d[k-1]-1)) {
+ /* substitution */
+ row = last_d[k]-1;
+ /* op = SUBSTITUTE; */
+
+ } else if ((last_d[k-1]-1<=last_d[k+1]) &&
+ (last_d[k-1]-1<=last_d[k]-1)) {
+ /* move right from the last d-1 on diagonal k-1 */
+ row = last_d[k-1]-1;
+ /* op = DELETE; */
+
+ } else {
+ /* move left from the last d-1 on diagonal k+1 */
+ row = last_d[k+1];
+ /* op = INSERT; */
+
+ }
+
+ /* code common to the three cases */
+ /* slide down the diagonal */
+
+ col = row+k-ORIGIN;
+
+ while ((row > 0) && (col > 0) && (s1[row-1]==s2[col-1])) {
+ row--; col--;
+ }
+
+ temp_d[k] = row;
+
+ if ((row == 0) && (col == 0)) {
+ /* hit southeast corner; have the answer */
+
+ free(last_d); free(temp_d);
+ free(min_row); free(min_diag);
+
+ *line1 = row+offset1;
+ *line2 = col+offset2;
+
+ return d;
+ }
+ if (row == 0) {
+ /* hit first row; don't look further */
+
+ free(last_d); free(temp_d);
+ free(min_row); free(min_diag);
+
+ *line1 = row+offset1;
+ *line2 = col+offset2;
+
+ return d;
+ }
+
+ if (col == 0) {
+ /* hit last column; don't look further */
+ free(last_d); free(temp_d);
+ free(min_row); free(min_diag);
+
+ *line1 = row+offset1;
+ *line2 = col+offset2;
+
+ return d;
+ }
+ }
+
+ min_row[d] = last_d[ORIGIN+DELTA];
+ min_diag[d] = ORIGIN+DELTA;
+ for (k=lower; k<=upper; ++k)
+ if (temp_d[k]<min_row[d]) {
+ min_row[d] = temp_d[k];
+ min_diag[d] = k;
+ }
+
+ for (k=lower; k<=upper; k++) {
+ last_d[k] = temp_d[k];
+ }
+
+ --lower;
+ ++upper;
+ }
+
+ /* report here the previous maximal match, stored in min_diag and min_row */
+ while ((d>0) && (min_row[d-1]-min_row[d]<3))
+ d--;
+
+ *line1 = min_row[d]+offset1;
+ *line2 = min_row[d]+min_diag[d]-ORIGIN+offset2;
+
+ free(min_row);
+ free(min_diag);
+ free(last_d);
+ free(temp_d);
+
+ return d;
+ }
+
+
+ static int
+ extend_fw(uchar *s1, uchar *s2, int m, int n, int offset1, int offset2,
+ int *line1, int *line2, int W)
+ {
+ int col, /* column number */
+ row, /* row number */
+ max_d, /* bound on the length of the edit script */
+ d, /* current compressed distance */
+ k, /* current diagonal */
+ ORIGIN,
+ lower,
+ upper;
+ int *last_d, *temp_d; /* column containing the last p */
+ int *max_row, *max_diag; /* min (b)/ max (f) row (and diagonal) */
+ /* reached for cost d=0, ... m. */
+ max_d = m+1;
+
+ ORIGIN = m;
+ for (row=0, col=0; col<n && row<m && (s1[row]==s2[col]); row++, col++)
+ /*LINTED empty loop body*/;
+
+ if (row == m) {
+ *line1 = row+offset1;
+ *line2 = col+offset2;
+
+ return 0;
+ }
+ if (col == n) {
+ *line1 = row+offset1;
+ *line2 = col+offset2;
+
+ return 0;
+ }
+
+ last_d = (int *)xmalloc((m+n+1)*sizeof(int));
+ temp_d = (int *)xmalloc((m+n+1)*sizeof(int));
+
+ for (k=0; k<=m+n; ++k) last_d[k]=-1;
+ last_d[ORIGIN] = row;
+
+ lower = ORIGIN - 1;
+ upper = ORIGIN + 1;
+
+ max_row = (int *)xmalloc((m+1)*sizeof(int));
+ max_diag = (int *)xmalloc((m+1)*sizeof(int));
+
+ for (d=1; d<=m; d++)
+ max_row[d] = -1;
+
+ max_row[0] = last_d[ORIGIN];
+ max_diag[0] = ORIGIN;
+
+ d = 0;
+ while ((++d<=max_d) &&
+ ((d-1<=good_ratio(max_row[d-1], W)) ||
+ ((d>=2) && (d-2<=good_ratio(max_row[d-2], W))))) {
+
+ /* for each relevant diagonal ... */
+ for (k = lower; k <= upper; k++) {
+
+ /* find a d on diagonal k */
+ if (k==-d+ORIGIN) {
+
+ /* move down from the last d-1 on diagonal k+1 */
+ row = last_d[k+1]+1;
+ /* op = DELETE; */
+ } else if (k==d+ORIGIN) {
+
+ /* move right from the last d-1 on diagonal k-1 */
+ row = last_d[k-1];
+ /* op = INSERT; */
+ } else if ((last_d[k]>=last_d[k+1]) &&
+ (last_d[k]+1>=last_d[k-1])) {
+
+ /* substitution */
+ row = last_d[k]+1;
+ /* op = SUBSTITUTE; */
+ } else if ((last_d[k+1]+1>=last_d[k-1]) &&
+ (last_d[k+1]>=last_d[k])) {
+
+ /* move down from the last d-1 on diagonal k+1 */
+ row = last_d[k+1]+1;
+ /* op = DELETE; */
+ } else {
+
+ /* move right from the last d-1 on diagonal k-1 */
+ row = last_d[k-1];
+ /* op = INSERT; */
+ }
+
+ /* code common to the three cases */
+ /* slide down the diagonal */
+
+ col = row+k-ORIGIN;
+
+ if (row>=0)
+ while ((row < m) && (col < n) && (s1[row]==s2[col])) {
+ row++; col++;
+ }
+
+ temp_d[k] = row;
+
+ if ((row == m) && (col == n)) {
+ /* hit southeast corner; have the answer */
+ free(last_d); free(temp_d);
+ free(max_row); free(max_diag);
+ *line1 = row+offset1;
+ *line2 = col+offset2;
+ return d;
+ }
+ if (row == m) {
+ /* hit last row; don't look further */
+ free(temp_d); free(last_d);
+ free(max_row); free(max_diag);
+ *line1 = row+offset1;
+ *line2 = col+offset2;
+ return d;
+ }
+
+ if (col == n) {
+ /* hit last column; don't look further */
+ free(temp_d); free(last_d);
+ free(max_row); free(max_diag);
+ *line1 = row+offset1;
+ *line2 = col+offset2;
+ return d;
+ }
+ }
+ max_row[d] = last_d[ORIGIN];
+ max_diag[d] = ORIGIN;
+ for (k=lower; k<=upper; ++k)
+ if (temp_d[k]>max_row[d]) {
+ max_row[d] = temp_d[k];
+ max_diag[d] = k;
+ }
+
+ for (k=lower; k<=upper; k++) {
+ last_d[k] = temp_d[k];
+ }
+
+ --lower;
+ ++upper;
+ }
+
+ /* report here the previous maximal match, stored in max_diag and max_row */
+
+ while ((d>0) && (max_row[d]-max_row[d-1]<3))
+ d--;
+
+ *line1 = max_row[d]+offset1;
+ *line2 = max_row[d]+max_diag[d]-ORIGIN+offset2;
+ free(max_row);
+ free(max_diag);
+ free(last_d);
+ free(temp_d);
+ return d;
+
+ /*
+ if ((d>2) && (max_row[d-1]-max_row[d-2]<3)) {
+ *line1 = max_row[d-2]+offset1;
+ *line2 = max_row[d-2]+max_diag[d-2]-ORIGIN+offset2;
+
+ free(max_row); free(max_diag);
+ free(last_d); free(temp_d);
+
+ return d-2;
+ }
+
+ *line1 = max_row[d-1]+offset1;
+ *line2 = max_row[d-1]+max_diag[d-1]-ORIGIN+offset2;
+
+ free(max_row);
+ free(max_diag);
+ free(last_d);
+ free(temp_d);
+
+ return d-1;
+ */
+ }
+
+ static void
+ swap_seqs(collec_p_t eCol)
+ {
+ unsigned int i;
+ for (i = 0; i < eCol->nb; i++) {
+ exon_p_t e = eCol->e.exon[i];
+ int tem = e->from1;
+ e->from1 = e->from2;
+ e->from2 = tem;
+ tem = e->to1;
+ e->to1 = e->to2;
+ e->to2 = tem;
+ }
+ }
+
+ static void
+ merge(collec_p_t eCol, collec_p_t aCol, unsigned int pos, unsigned int W)
+ {
+ unsigned int last = pos + aCol->nb;
+ unsigned int i;
+ if (aCol->nb == 0)
+ return;
+ /* Make enough room. */
+ if (eCol->nb + aCol->nb > eCol->size) {
+ eCol->size = eCol->nb + aCol->nb;
+ eCol->e.elt = (void **) xrealloc(eCol->e.elt, eCol->size * sizeof(void *));
+ }
+ /* Insert the new exons. */
+ memmove(eCol->e.elt + last,
+ eCol->e.elt + pos, (eCol->nb - pos) * sizeof(void *));
+ memcpy(eCol->e.elt + pos, aCol->e.elt, aCol->nb * sizeof(void *));
+ eCol->nb += aCol->nb;
+ if (last < eCol->nb)
+ last += 1;
+ if (pos == 0)
+ pos += 1;
+ for (i = pos; i < last; i++) {
+ exon_p_t cur = eCol->e.exon[i - 1];
+ exon_p_t next = eCol->e.exon[i];
+ /* Check for new exons that migth have gobbled up existing ones. */
+ if (next->from2 <= cur->from2) {
+ free(cur);
+ memmove(eCol->e.elt + i - 1, eCol->e.elt + i,
+ (eCol->nb - i) * sizeof(void *));
+ eCol->nb -= 1;
+ last -= 1;
+ i -= 1;
+ continue;
+ }
+ if (cur->to2 >= next->to2) {
+ free(next);
+ eCol->nb -= 1;
+ memmove(eCol->e.elt + i, eCol->e.elt + i + 1,
+ (eCol->nb - i) * sizeof(void *));
+ last -= 1;
+ i -= 1;
+ continue;
+ }
+ if (next->from1 < cur->to1 + 1 + MIN_INTRON
+ && next->from2 <= cur->to2 + 1 + W) {
+ /* merge blocks cur and next */
+ cur->from1 = min(cur->from1, next->from1);
+ cur->from2 = min(cur->from2, next->from2);
+ cur->to1 = max(next->to1, cur->to1);
+ cur->to2 = max(next->to2, cur->to2);
+ free(next);
+ eCol->nb -= 1;
+ memmove(eCol->e.elt + i, eCol->e.elt + i + 1,
+ (eCol->nb - i) * sizeof(void *));
+ last -= 1;
+ i -= 1;
+ }
+ }
+ }
+
+ void
+ free_align(edit_script_list_p_t aligns)
+ {
+ edit_script_list_p_t head;
+
+ head = aligns;
+
+ while ((head=aligns)!=NULL) {
+ aligns = aligns->next_script;
+ Free_script(head->script);
+ free(head);
+ }
+ }
+
+ #ifdef DEBUG
+ static void
+ debug_print_exons(collec_p_t eCol, const char *label,
+ const unsigned char *s1, const unsigned char *s2)
+ {
+ unsigned int i;
+
+ fprintf(stderr, "\n====================%s:\n\n", label);
+ for (i = 0; i < eCol->nb; i++) {
+ exon_p_t e = eCol->e.exon[i];
+ fprintf(stderr, " [ %u, %u, %u, %u ]\n",
+ e->from1, e->from2, e->to1, e->to2);
+ }
+ for (i = 0; i < eCol->nb; i++) {
+ exon_p_t e = eCol->e.exon[i];
+ int len1 = e->to1 - e->from1 + 1;
+ int len2 = e->to2 - e->from2 + 1;
+ if (len1 > 1) {
+ fprintf(stderr, "%.10s %.*s %.10s\n%.10s %.*s %.10s\n",
+ (e->from1 > 10)
+ ? s1 + e->from1 - 11
+ : s1 + e->from1 - 1,
+ len1, s1 + e->from1 - 1,
+ s1 + e->to1,
+ (e->from2 > 10)
+ ? s2 + e->from2 - 11
+ : s2 + e->from2 - 1,
+ len2, s2 + e->from2 - 1,
+ s2 + e->to2);
+ if (e->from1 > 1 && e->from2 > 1
+ && s1[e->from1 - 2] == s2[e->from2 - 2])
+ fprintf(stderr, "WARNING: further left match: %c\n",
+ s1[e->from1 - 2]);
+ if (s1[e->to1] != 0 && s1[e->to1] == s2[e->to2])
+ fprintf(stderr, "WARNING: further right match: %c\n",
+ s1[e->to1]);
+ }
+ }
+ }
+ #endif
+
+ static int
+ perfect_spl_p(uchar *seq1, uchar *seq2, splice_score_p_t splS)
+ {
+ unsigned int score, j;
+ uchar splice[4];
+ score = SWscore(seq1 + splS->to1 - options.scoreSplice_window,
+ seq2 + splS->to2 - options.scoreSplice_window,
+ options.scoreSplice_window);
+ if (score < options.scoreSplice_window)
+ return 0;
+ score = SWscore(seq1 + splS->nFrom1 - 1, seq2 + splS->to2,
+ options.scoreSplice_window);
+ if (score < options.scoreSplice_window)
+ return 0;
+ memcpy(splice, seq1 + splS->to1, 2);
+ memcpy(splice + 2, seq1 + splS->nFrom1 - 3, 2);
+ for (j = 0; j < options.nbSplice; j++) {
+ if (memcmp(splice, options.splice[j].fwd, 4) == 0) {
+ splS->type = j;
+ splS->direction = 1;
+ return 1;
+ }
+ if (memcmp(splice, options.splice[j].rev, 4) == 0) {
+ splS->type = j;
+ splS->direction = -1;
+ return 1;
+ }
+ }
+ return 0;
+ }
+
+ static int
+ splice_score_compare(const void *a, const void *b)
+ {
+ const splice_score_p_t sa = (splice_score_p_t) a;
+ const splice_score_p_t sb = (splice_score_p_t) b;
+ if (sa->score < sb->score)
+ return -1;
+ if (sa->score > sb->score)
+ return 1;
+ if (sa->splScore < sb->splScore)
+ return -1;
+ if (sa->splScore > sb->splScore)
+ return 1;
+ if (sa->type > sb->type)
+ return -1;
+ if (sa->type < sb->type)
+ return 1;
+ return 0;
+ }
+
+ static void
+ compute_max_score_1(uchar *seq1, uchar *seq2, splice_score_p_t splS,
+ unsigned int type, unsigned int to1, unsigned int to2,
+ unsigned int nFrom1, uchar *s, uchar *jct, int dir)
+ {
+ int j;
+
+ memcpy(s + options.scoreSplice_window, jct, 4);
+ for (j = - options.intron_window; j <= (int) options.intron_window; j++) {
+ splice_score_t curL, curR;
+ int i;
+ curL.type = curR.type = type;
+ curL.splScore = curR.splScore = 0;
+ curL.score = curR.score = 0;
+ memcpy(s, seq2 + to2 - options.scoreSplice_window + j,
+ options.scoreSplice_window);
+ memcpy(s + options.scoreSplice_window + 4, seq2 + to2 + j,
+ options.scoreSplice_window);
+ for (i = -1; i <= 1; i++) {
+ splice_score_t cur;
+ cur.type = type;
+ cur.splScore = 0;
+ if (seq1[to1 + j + i] == jct[0])
+ cur.splScore += 1;
+ if (seq1[to1 + j + i + 1] == jct[1])
+ cur.splScore += 1;
+ cur.score = SWscore(seq1 + to1 - options.scoreSplice_window
+ + j + i, s, options.scoreSplice_window + 2);
+ if (splice_score_compare(&cur, &curL) > 0) {
+ curL.score = cur.score;
+ curL.splScore = cur.splScore;
+ curL.to1 = to1 + j + i;
+ }
+ cur.splScore = 0;
+ if (seq1[nFrom1 - 3 + j + i] == jct[2])
+ cur.splScore += 1;
+ if (seq1[nFrom1 - 2 + j + i] == jct[3])
+ cur.splScore += 1;
+ cur.score = SWscore(seq1 + nFrom1 - 3 + j + i,
+ s + options.scoreSplice_window + 2,
+ options.scoreSplice_window + 2);
+ if (splice_score_compare(&cur, &curR) > 0) {
+ curR.score = cur.score;
+ curR.splScore = cur.splScore;
+ curR.nFrom1 = nFrom1 + j + i;
+ }
+ }
+ curL.score += curR.score;
+ curL.splScore += curR.splScore;
+ if (splice_score_compare(&curL, splS) > 0) {
+ splS->score = curL.score;
+ splS->splScore = curL.splScore;
+ splS->to1 = curL.to1;
+ splS->to2 = to2 + j;
+ splS->nFrom1 = curR.nFrom1;
+ splS->type = type;
+ splS->direction = dir;
+ }
+ }
+ }
+
+ /* FIXME : Frame shifts are a real pain. Look at BM149342 for
+ * example. The scoring is not quite right in that case. */
+ static void
+ compute_max_score(uchar *seq1, uchar *seq2, splice_score_p_t splS,
+ int direction)
+ {
+ unsigned int k;
+ unsigned int to1 = splS->to1;
+ unsigned int to2 = splS->to2;
+ unsigned int nFrom1 = splS->nFrom1;
+ uchar *s = (uchar *) xmalloc((options.scoreSplice_window * 2 + 4)
+ * sizeof(uchar));
+ splS->score = 0;
+ splS->splScore = 0;
+ splS->type = -1;
+ for (k = 0; k < options.nbSplice; k++) {
+ if (direction >= 0)
+ compute_max_score_1(seq1, seq2, splS, k, to1, to2, nFrom1, s,
+ options.splice[k].fwd, 1);
+ if (direction <= 0)
+ compute_max_score_1(seq1, seq2, splS, k, to1, to2, nFrom1, s,
+ options.splice[k].rev, -1);
+ }
+ free(s);
+ }
+
+ static void
+ slide_intron(result_p_t r, uchar *seq1, uchar *seq2)
+ {
+ unsigned int i;
+
+ /* First, try to get direction through perfect splices. */
+ for (i = 1; i < r->eCol.nb; i++) {
+ exon_p_t cur = r->eCol.e.exon[i - 1];
+ exon_p_t next = r->eCol.e.exon[i];
+ splice_score_t splS;
+ cur->type = -1;
+ cur->direction = 0;
+ cur->splScore = 0;
+ if (next->from2 - cur->to2 != 1)
+ continue;
+ splS.to1 = cur->to1;
+ splS.to2 = cur->to2;
+ splS.nFrom1 = next->from1;
+ if (perfect_spl_p(seq1, seq2, &splS)) {
+ r->direction += splS.direction;
+ cur->direction = splS.direction;
+ cur->type = splS.type;
+ cur->splScore = 4 + options.scoreSplice_window * 2;
+ }
+ }
+ /* Second, go through overlaping exons. */
+ for (i = 1; i < r->eCol.nb; i++) {
+ exon_p_t cur = r->eCol.e.exon[i - 1];
+ exon_p_t next = r->eCol.e.exon[i];
+ splice_score_p_t splS;
+ unsigned int nb, j, nbP = 0;
+ if (next->from2 > cur->to2)
+ continue;
+ nb = cur->to2 - next->from2 + 2;
+ splS = (splice_score_p_t) xmalloc(nb * sizeof(splice_score_t));
+ for (j = 0; j < nb; j++) {
+ splS[j].to1 = cur->to1 - nb + j + 1;
+ splS[j].to2 = cur->to2 - nb + j + 1;
+ splS[j].nFrom1 = next->from1 + j;
+ if (perfect_spl_p(seq1, seq2, splS + j))
+ nbP += 1;
+ else
+ splS[j].direction = 0;
+ }
+ if (nbP == 1)
+ for (j = 0; j < nb; j++)
+ if (splS[j].direction != 0) {
+ r->direction += splS[j].direction;
+ cur->direction = splS[j].direction;
+ cur->type = splS[j].type;
+ cur->splScore = 4 + options.scoreSplice_window * 2;
+ cur->to1 = splS[j].to1;
+ cur->to2 = splS[j].to2;
+ next->from2 = cur->to2 + 1;
+ next->from1 = splS[j].nFrom1;
+ }
+ free(splS);
+ }
+ /* In case we are still undecided... */
+ if (r->direction == 0) {
+ unsigned int fwd = 0, rev = 0;
+ for (i = 1; i < r->eCol.nb; i++) {
+ exon_p_t cur = r->eCol.e.exon[i - 1];
+ exon_p_t next = r->eCol.e.exon[i];
+ splice_score_t max, cs;
+ unsigned int nb, j;
+ if (cur->to2 + 1 < next->from2)
+ continue;
+ if (cur->direction > 0) {
+ fwd += cur->splScore;
+ continue;
+ }
+ if (cur->direction < 0) {
+ rev += cur->splScore;
+ continue;
+ }
+ nb = cur->to2 - next->from2 + 2;
+ max.type = -1;
+ max.score = 0;
+ max.splScore = 0;
+ for (j = 0; j < nb; j++) {
+ cs.to1 = cur->to1 - nb + j + 1;
+ cs.to2 = cur->to2 - nb + j + 1;
+ cs.nFrom1 = next->from1 + j;
+ compute_max_score(seq1, seq2, &cs, 0);
+ if (splice_score_compare(&cs, &max) > 0)
+ max = cs;
+ }
+ if (max.direction > 0)
+ fwd += max.score;
+ if (max.direction < 0)
+ rev += max.score;
+ }
+ if (fwd >= rev)
+ r->direction = 1;
+ else
+ r->direction = -1;
+ }
+ for (i = 1; i < r->eCol.nb; i++) {
+ exon_p_t cur = r->eCol.e.exon[i - 1];
+ exon_p_t next = r->eCol.e.exon[i];
+ splice_score_t max, cs;
+ unsigned int nb, j;
+ if ((cur->type >= 0 && cur->direction * r->direction > 0)
+ || cur->to2 + 1 < next->from2)
+ continue;
+ nb = cur->to2 - next->from2 + 2;
+ max.type = -1;
+ max.score = 0;
+ max.splScore = 0;
+ for (j = 0; j < nb; j++) {
+ cs.to1 = cur->to1 - nb + j + 1;
+ cs.to2 = cur->to2 - nb + j + 1;
+ cs.nFrom1 = next->from1 + j;
+ compute_max_score(seq1, seq2, &cs, r->direction);
+ if (splice_score_compare(&cs, &max) > 0)
+ max = cs;
+ }
+ cur->direction = max.direction;
+ cur->type = max.type;
+ cur->splScore = max.score;
+ cur->to1 = max.to1;
+ cur->to2 = max.to2;
+ next->from2 = cur->to2 + 1;
+ next->from1 = max.nFrom1;
+ #ifdef DEBUG
+ fprintf(stderr, "Resolving intron %d %u %u %u %u scores: %u %u %u\n"
+ "%.10s ... %.10s\n"
+ "%.18s...%.18s\n",
+ r->direction, cur->to2, next->from2, cur->to1, next->from1,
+ max.score, max.splScore, max.type,
+ seq2 + cur->to2 - 10, seq2 + next->from2 - 1,
+ seq1 + cur->to1 - 10, seq1 + next->from1 - 9);
+ #endif
+ }
+ }
+
+ /* Compute some sort of score, using a Smith/Waterman style algorithm,
+ * but allowing for only one gap.
+ * We use a matrix of this form:
+ * T C A G T ...
+ * +----------------------
+ * A |
+ * | +===+
+ * T | | 2 |
+ * | +===+ |
+ * C | | 0 1 |
+ * | +=======+
+ * A |
+ * |
+ * T |
+ */
+ static int
+ SWscore(uchar *s1, uchar *s2, unsigned int len)
+ {
+ unsigned int i;
+ int score[3];
+ score[0] = score[2] = 0;
+ score[1] = *s1 == *s2 ? 1 : 0;
+ for (i = 1; i < len; i++) {
+ score[0] = max(score[0] + (s1[i - 1] == s2[i] ? 1 : 0), score[1]);
+ score[2] = max(score[2] + (s1[i] == s2[i - 1] ? 1 : 0), score[1]);
+ score[1] = max(max(score[0] - 1, score[2] - 1),
+ score[1] + (s1[i] == s2[i] ? 1 : 0));
+ }
+ return score[1];
+ }
Index: llvm-test/MultiSource/Applications/SIBsim4/sim4b1.h
diff -c /dev/null llvm-test/MultiSource/Applications/SIBsim4/sim4b1.h:1.1
*** /dev/null Thu Feb 15 17:46:25 2007
--- llvm-test/MultiSource/Applications/SIBsim4/sim4b1.h Thu Feb 15 17:46:09 2007
***************
*** 0 ****
--- 1,23 ----
+ /* $Id: sim4b1.h,v 1.1 2007/02/15 23:46:09 nicholas Exp $
+ *
+ * Christian Iseli, LICR ITO, Christian.Iseli at licr.org
+ *
+ * Copyright (c) 2001-2004 Swiss Institute of Bioinformatics.
+ * Copyright (C) 1998-2001 Liliana Florea.
+ */
+
+ #ifndef SIM4B1_H
+ #define SIM4B1_H
+
+ extern int encoding[NACHARS];
+ #define CODE_CNT 5
+
+ void free_align(edit_script_list_p_t);
+ void print_exons(collec_p_t, int);
+ void SIM4(hash_env_p_t, seq_p_t, collec_p_t);
+ void init_encoding(void);
+ void init_hash_env(hash_env_p_t, unsigned int, uchar *, unsigned int);
+ void free_hash_env(hash_env_p_t);
+ void bld_table(hash_env_p_t);
+ void init_col(collec_p_t, unsigned int);
+ #endif /* SIM4B1_H */
Index: llvm-test/MultiSource/Applications/SIBsim4/x.fa
diff -c /dev/null llvm-test/MultiSource/Applications/SIBsim4/x.fa:1.1
*** /dev/null Thu Feb 15 17:46:25 2007
--- llvm-test/MultiSource/Applications/SIBsim4/x.fa Thu Feb 15 17:46:09 2007
***************
*** 0 ****
--- 1,4340 ----
+ >4.143962167-143965267 Slice, no description
+ GGCGCGGGCAGCGGGCAGAGCTGGTCACGTTGTGCTGGGGGGGGTCCGCGCGCCCTGCAG
+ TCCCGAACCCGCTACGCGCTCCGTCGGCCCGCCCGCCCGCCATGGAGCCTGGCCCCGACG
+ GCCCAGCCGCGCCCGGCCCCGCCGCCATCCGTGAGGGCTGGTTCCGAGAGACCTGCAGCC
+ TGTGGCCCGGCCAGGCCCTGTCGCTGCAAGTGGAGCAGCTGCTTCACCACCGGCGATCGC
+ GGTACCAAGACATCCTCGTCTTCCGCAGGTATGGCCCGCCGCGCGCCGGTGCAGCTGTCA
+ GAAGTTCTGCGCTGGGCCCGGCCCTGCGTCCACGTGTCACTATCGGGACACGTCAGCCGA
+ GGGGACCCCGGGACCCACCCAGCCCCCACACGTGGCTCGCCTGCCACGTGTCACCCCGAA
+ TGCCCACCCCTGGACCCCATGGCGGCCACGTGCACGCCCAGGGAGGACAGGGACCTAACC
+ TCCCAGTGTCCCAGGACCCACGTCCCCGACTGTCTCTGCCCGCAGTAAAACCTACGGCAA
+ CGTGCTGGTTCTGGATGGCGTCATCCAGTGTACTGAGAGGGATGAGTTCTCCTACCAGGA
+ GATGATCGCCAACCTGCCGCTCTGCAGCCACCCCAACCCGCGGAAGGTACCGCATTGCCC
+ CTGGGTTCAGCCCTGAGCTCGGGGTCCTAGAAAAGCATGTCGGGCTGACACTAGGTGAGG
+ ATGTTTGGGGGCAGATGCTACCCAGATGACTGTCAGAAAATGCGGGTCGGTCAGGATGAA
+ TAGAGCTCCTGGGAGAGCTGGTCTCCTTAGAAGCCCCGAGAGGGGAACCCAGGCTGCCAG
+ GAAGGACCCCGTGGCACAGAAGCGTTCTGGAGAGTAGAGAATGACTCAGAGTCCTGTAGC
+ TGGGAAGATCAGGTTCTGTGGGAGTGGGCCTGCTCAGTCCTGACTTGTCCTTCCCTGGCC
+ CAGGTGCTGATCATCGGGGGTGGAGATGGGGGCGTCCTACGGGAAGTGGTGAAGCACCCC
+ TCTGTGGAGTCGGTGGTCCAGTGCGAGATTGATGAGGTGGGTGCAGTCCAGGAGGCCTGG
+ ATTTGAGTCACCAGAGTCAGCTCTGTCCCATCCTGACTCTGCACCCCGAGGCGCAATGTT
+ CTTACCATCCCTGCCCTGTTTCCTCAGTCTGAAAAGAGGGTTCAGTAGGAAAACCAGATT
+ GTTAAGGCCTGGCACACACCACACCATGGATGTTAACTCTTAGTGCTTTCAGAGCCCAGG
+ CAGAGCCAGAGAGCTCAACAACTTATGGCATCTCCCCTTGAGACCCAGCATGGTTTTAGT
+ GAGCACTTACTGTATGCTGAGTGTTACCCAAGGTGCTGGGTTGATACGGCCATGGACAGG
+ TGAGCCCCTGAGTGTAGAGCTGGTGTTTGGGTTGGAGAAGACACCATAACACAGCATGAC
+ ATGATGAGGCCAGACAGGGATAAAAGATATGGAGAACACAGGCTGATAGGAAGTGTGCAG
+ CCACGCATGCTTACAGCCCCAGCACTTGGGTAGAAGCAGGACGATCAAGAGTTTGAGGCC
+ AGCGTGAGTTATCTGAGACCATCTCTCAAAAATGCAGAAGCTCAGATGGGACTTGGTCTG
+ CAGGGAGTTGAGGCCTGAAAACCATGAAGAGCTGAGGTGGTGTAGATCTGGGGGAAAGGG
+ TTTTCAAAAGAGAAGACTTGTCCAAAGAAACCCCACCAGGAGTCCCCAGCCTCTAGTCCA
+ GCCCAGCCCTTCCTCTCCCCCCTCTTCAGGATGTCATTGAAGTCTCTAAGAAGTTCCTGC
+ CTGGCATGGCCGTTGGCTTCTCCAGCTCAAAGCTGACTCTCCACGTGGGCGATGGCTTTG
+ AGTTCATGAAACAGAACCAAGATGCCTTTGACGTCATCATCACCGACTCCTCAGACCCCA
+ TGGGTGAGCCAGGGCACGCGCGTCCTGCAGCACACAGCAGCCCCAGACTAGAGCCATGTG
+ ATGATGGAGGCCTGAGGACGGTGGGGGTCTAGCCTTGGTCCATAGTGACCTCTGCTTCCT
+ CTTTGGCTTCTTCCCTGTGCTTGTTGGCCAGCATCCGGGTGTGCTATGGTGCAGTGGGGG
+ AGGGTTTGAATGCAGGGCCTCCCAGGTGCTAAGGCAGTAGGGGGCCACATCCCACAAACA
+ TGGGTCCAGCACCTGCTTTGCCACTGAGCTGCTGTGGGTGACTGTGGCCTGGAGGTCTCA
+ GGCAGGATGGCCATGCTCTACCCCTCTAGGCCCTGCTGAGAGCCTCTTCAAGGAGTCCTA
+ TTACCAGCTCATGAAGACAGCACTCAAAGAAGATGGCATCCTGTGCTGCCAGGGTGAGTG
+ CCAGTGGCTGCACCTGGACCTCATCAAGGAGATGAGGCACTTCTGCAAATCTCTCTTCCC
+ CGTGGTGGACTACGCCTACTGTAGCATTCCTACCTATCCCAGCGGCCAGATCGGCTTCAT
+ GCTGTGTAGCAAAAACCCGGTGAGCTGGGGGTGACTGCCTGCAGGGTGGGGCGAGGGCAG
+ GCACTAAGAGCCCCATCTTGATGCTCTTTGTCCCTGGTTCCCAGAGCACCAACTTCCGGG
+ AGCCAGTGCAGCAGTTGACACAGGCCCAGGTGGAGCAGATGCAGCTGAAATACTATAACT
+ CGGACATGCACCGTGCCGCCTTCGTACTGCCCGAGTTCACCCGGAAGGTGAGTGGCCTGC
+ CAGGCTCCCTGCTGGGCCTCATCCTGCACAGCTTGCACATCCTCCTGACTGCCTTCATGT
+ CCCACCAGGCCCTCAATGACATAAGCTGAATCCAGGTGCCACTGTGACACCACCCGAGAC
+ CTCAATCGGATTGGACCAAGGATCTTCCAAGTTGTCTGGGGACCACCAGTCCTGGACCAG
+ ACTCCCAGATGACTCTTGCCCACCAACCAAGTGTTACAGGCCCCACGATGCTGCCTGGCC
+ TGGCCTGGCCTGGCCTGCCCTGCTGGGTGGACTCAGTCTCTGTCTGTCTATCTCTGTGGC
+ GTTCAGCCCCACGCCTATACCAGCTCTGTACAGCACCGCCTATGCCCTGTGACCCAACAA
+ AATACATGTGTATTTATAACAAGCTCAGTCATGACCTCTGA
+ CGACAATGCACGACAGAGGAAGCAGAACAGATATTTAGATTGCCTCTCATTTTCTCTCCCATATTATAGG
+ GAGAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTCTTTGATTTTTTGGCAACCCAAAA
+ TGGTGGCGGATGAACGAGATGATAATATATTCAAGTTGCCGCTAATCAGAAATAAATTCATTGCAACGTT
+ AAATACAGCACAATATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTAATGAGTGCCTCTCG
+ TTCTCTGTCTTATATTACCGCAAACCCAAAAAGACAATACACGACAGAGAGAGAGAGCAGCGGAGATATT
+ TAGATTGCCTATTAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTCTCTATATAATGAC
+ TGCCTCTCATTCTGTCTTATTTTACCGCAAACCCAAATCGACAATGCACGACAGAGGAAGCAGAACAGAT
+ ATTTAGATTGCCTCTCATTTTCTCTCCCATATTATAGGGAGAAATATGATCGCGTATGCGAGAGTAGTGC
+ CAACATATTGTGCTCTTTGATTTTTTGGCAACCCAAAATGGTGGCGGATGAACGAGATGATAATATATTC
+ AAGTTGCCGCTAATCAGAAATAAATTCATTGCAACGTTAAATACAGCACAATATATGATCGCGTATGCGA
+ GAGTAGTGCCAACATATTGTGCTAATGAGTGCCTCTCGTTCTCTGTCTTATATTACCGCAAACCCAAAAA
+ GACAATACACGACAGAGAGAGAGAGCAGCGGAGATATTTAGATTGCCTATTAAATATGATCGCGTATGCG
+ AGAGTAGTGCCAACATATTGTGCTCTCTATATAATGACTGCCTCTCATTCTGTCTTATTTTACCGCAAAC
+ CCAAATCGACAATGCACGACAGAGGAAGCAGAACAGATATTTAGATTGCCTCTCATTTTCTCTCCCATAT
+ TATAGGGAGAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTCTTTGATTTTTTGGCAAC
+ CCAAAATGGTGGCGGATGAACGAGATGATAATATATTCAAGTTGCCGCTAATCAGAAATAAATTCATTGC
+ AACGTTAAATACAGCACAATATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTAATGAGTGC
+ CTCTCGTTCTCTGTCTTATATTACCGCAAACCCAAAAAGACAATACACGACAGAGAGAGAGAGCAGCGGA
+ GATATTTAGATTGCCTATTAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTCTCTATAT
+ AATGACTGCCTCTCATTCTGTCTTATTTTACCGCAAACCCAAATCGACAATGCACGACAGAGGAAGCAGA
+ ACAGATATTTAGATTGCCTCTCATTTTCTCTCCCATATTATAGGGAGAAATATGATCGCGTATGCGAGAG
+ TAGTGCCAACATATTGTGCTCTTTGATTTTTTGGCAACCCAAAATGGTGGCGGATGAACGAGATGATAAT
+ ATATTCAAGTTGCCGCTAATCAGAAATAAATTCATTGCAACGTTAAATACAGCACAATATATGATCGCGT
+ ATGCGAGAGTAGTGCCAACATATTGTGCTAATGAGTGCCTCTCGTTCTCTGTCTTATATTACCGCAAACC
+ CAAAAAGACAATACACGACAGAGAGAGAGAGCAGCGGAGATATTTAGATTGCCTATTAAATATGATCGCG
+ TATGCGAGAGTAGTGCCAACATATTGTGCTCTCTATATAATGACTGCCTCTCATTCTGTCTTATTTTACC
+ GCAAACCCAAATCGACAATGCACGACAGAGGAAGCAGAACAGATATTTAGATTGCCTCTCATTTTCTCTC
+ CCATATTATAGGGAGAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTCTTTGATTTTTT
+ GGCAACCCAAAATGGTGGCGGATGAACGAGATGATAATATATTCAAGTTGCCGCTAATCAGAAATAAATT
+ CATTGCAACGTTAAATACAGCACAATATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTAAT
+ GAGTGCCTCTCGTTCTCTGTCTTATATTACCGCAAACCCAAAAAGACAATACACGACAGAGAGAGAGAGC
+ AGCGGAGATATTTAGATTGCCTATTAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTCT
+ CTATATAATGACTGCCTCTCATTCTGTCTTATTTTACCGCAAACCCAAATCGACAATGCACGACAGAGGA
+ AGCAGAACAGATATTTAGATTGCCTCTCATTTTCTCTCCCATATTATAGGGAGAAATATGATCGCGTATG
+ CGAGAGTAGTGCCAACATATTGTGCTCTTTGATTTTTTGGCAACCCAAAATGGTGGCGGATGAACGAGAT
+ GATAATATATTCAAGTTGCCGCTAATCAGAAATAAATTCATTGCAACGTTAAATACAGCACAATATATGA
+ TCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTAATGAGTGCCTCTCGTTCTCTGTCTTATATTACCG
+ CAAACCCAAAAAGACAATACACGACAGAGAGAGAGAGCAGCGGAGATATTTAGATTGCCTATTAAATATG
+ ATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTCTCTATATAATGACTGCCTCTCATTCTGTCTTAT
+ TTTACCGCAAACCCAAATCGACAATGCACGACAGAGGAAGCAGAACAGATATTTAGATTGCCTCTCATTT
+ TCTCTCCCATATTATAGGGAGAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTCTTTGA
+ TTTTTTGGCAACCCAAAATGGTGGCGGATGAACGAGATGATAATATATTCAAGTTGCCGCTAATCAGAAA
+ TAAATTCATTGCAACGTTAAATACAGCACAATATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGT
+ GCTAATGAGTGCCTCTCGTTCTCTGTCTTATATTACCGCAAACCCAAAAAGACAATACACGACAGAGAGA
+ GAGAGCAGCGGAGATATTTAGATTGCCTATTAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTG
+ TGCTCTCTATATAATGACTGCCTCTCATTCTGTCTTATTTTACCGCAAACCCAAATCGACAATGCACGAC
+ AGAGGAAGCAGAACAGATATTTAGATTGCCTCTCATTTTCTCTCCCATATTATAGGGAGAAATATGATCG
+ CGTATGCGAGAGTAGTGCCAACATATTGTGCTCTTTGATTTTTTGGCAACCCAAAATGGTGGCGGATGAA
+ CGAGATGATAATATATTCAAGTTGCCGCTAATCAGAAATAAATTCATTGCAACGTTAAATACAGCACAAT
+ ATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTAATGAGTGCCTCTCGTTCTCTGTCTTATA
+ TTACCGCAAACCCAAAAAGACAATACACGACAGAGAGAGAGAGCAGCGGAGATATTTAGATTGCCTATTA
+ AATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTCTCTATATAATGACTGCCTCTCATTCTG
+ TCTTATTTTACCGCAAACCCAAATCGACAATGCACGACAGAGGAAGCAGAACAGATATTTAGATTGCCTC
+ TCATTTTCTCTCCCATATTATAGGGAGAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCT
+ CTTTGATTTTTTGGCAACCCAAAATGGTGGCGGATGAACGAGATGATAATATATTCAAGTTGCCGCTAAT
+ CAGAAATAAATTCATTGCAACGTTAAATACAGCACAATATATGATCGCGTATGCGAGAGTAGTGCCAACA
+ TATTGTGCTAATGAGTGCCTCTCGTTCTCTGTCTTATATTACCGCAAACCCAAAAAGACAATACACGACA
+ GAGAGAGAGAGCAGCGGAGATATTTAGATTGCCTATTAAATATGATCGCGTATGCGAGAGTAGTGCCAAC
+ ATATTGTGCTCTCTATATAATGACTGCCTCTCATTCTGTCTTATTTTACCGCAAACCCAAATCGACAATG
+ CACGACAGAGGAAGCAGAACAGATATTTAGATTGCCTCTCATTTTCTCTCCCATATTATAGGGAGAAATA
+ TGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTCTTTGATTTTTTGGCAACCCAAAATGGTGGCG
+ GATGAACGAGATGATAATATATTCAAGTTGCCGCTAATCAGAAATAAATTCATTGCAACGTTAAATACAG
+ CACAATATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTAATGAGTGCCTCTCGTTCTCTGT
+ CTTATATTACCGCAAACCCAAAAAGACAATACACGACAGAGAGAGAGAGCAGCGGAGATATTTAGATTGC
+ CTATTAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTCTCTATATAATGACTGCCTCTC
+ ATTCTGTCTTATTTTACCGCAAACCCAAATCGACAATGCACGACAGAGGAAGCAGAACAGATATTTAGAT
+ TGCCTCTCATTTTCTCTCCCATATTATAGGGAGAAATATGATCGCGTATGCGAGAGTAGTGCCAACATAT
+ TGTGCTCTTTGATTTTTTGGCAACCCAAAATGGTGGCGGATGAACGAGATGATAATATATTCAAGTTGCC
+ GCTAATCAGAAATAAATTCATTGCAACGTTAAATACAGCACAATATATGATCGCGTATGCGAGAGTAGTG
+ CCAACATATTGTGCTAATGAGTGCCTCTCGTTCTCTGTCTTATATTACCGCAAACCCAAAAAGACAATAC
+ ACGACAGAGAGAGAGAGCAGCGGAGATATTTAGATTGCCTATTAAATATGATCGCGTATGCGAGAGTAGT
+ GCCAACATATTGTGCTCTCTATATAATGACTGCCTCTCATTCTGTCTTATTTTACCGCAAACCCAAATCG
+ ACAATGCACGACAGAGGAAGCAGAACAGATATTTAGATTGCCTCTCATTTTCTCTCCCATATTATAGGGT
+ GAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGATCTTCGATTTTTTGGCAACCCAAAATG
+ GAGGCGGACGAACGAGATGATAATGATAAGATGATTCAAAAAGACAATGCACGACAGAGAGAGCAGAAAA
+ GATAATTAAATTGCCCCTCATTTTCTCTGGCAAATTGTAGGGTGAATTATGATCGCGTATGCGAGAGTGG
+ TGCCAACATATTGTGCTCTTCGATTTTTTGGCAACCCAAAATGGAGGCGGATGAACGAGATGATAATATT
+ TTCAAGTTGCCGCTAATCAAAAATAAATTCCTTGCAACATAAAATAAAGCACAAAATGCCCGCTCAAAAA
+ AAGGCATGAATATATAAGCTCGAACATAGAACATAGGCTTGAACATATAATGACTGCCTTTCATTCTCTA
+ TCTTATATTACCGCAAACACAAAATGACAATGCACGACATAGAGAGAAAGAGAGATATTCAGATTGCCTC
+ TCATTGTCTCACCCATATTATGGGAACCAAATATGAGCACGTATGCGAGAGGAGTGCCAACATATTGTGC
+ TCTACGATTTTTTTGCAACCCAAAATGGCGGCGTACGAACGAGATGATAATATATTCAAATTGCCGCTAA
+ TCAGAAGCAAGTTTATTGCAATGTTCAGTGCAGCGCAAAATGGCCGCTCAAGAAAAGGCTCGAATATATA
+ TTGCCTGCCTCTCATTCACTCTCTTTTATTACCGCAAGACCAAAATGACAATGTACAACAGAGAGAGCAA
+ GAGAGATATTTAGATTGCCTCTCCTTGTCTCTCCCATATTATAGAGACCGAAAATGATTGCGTATGCGAG
+ AAGAGTGCCATTGTATTGAGCTCCTCGACCCAAAATAGCGTCGGACGAACGAGATTATATATTTAAAATG
+ CCGATCATTTTCTCATCCATATAAATACTACCGAAAATGACTGTCTAAAGGTACTCATCGACTATATTTA
+ AATCTGTGTATTTCTGTGAATAGATTGACCTTTGCAATTTTTAACGGCATTGTCTATTAAATTAATATAA
+ TTTTCTTTTTTGATGAATATTTAACCGAACATTTACTTGAAATTAAATTATAAAATTGGTTAAATAATGT
+ TGAAATCTTACTTTCAGCTAAATGGGGCTATTTTGCAAGGGTTCCATCATGACATTGGTAAATAATTTTT
+ AAAGAATTAATTGTAAGTTCCAATAGACTGGAAATTATTTTGCAATATCATTCTTATCCCTATTTCCAAA
+ AGCGAATTATTAGTTGCGTGAAAATCAGAAGGAAAATTATTTAACGTGTTATGCCACGCCAAATAGCCGC
+ GCAATAGGAAGCTAGACTATATAATGACTGCAACGAAAATTGTAAATTCCAATTAAAAGGATATTATTGT
+ GCGATTTCACTTTAATTCTTATTTCAAAAAAGTTAATTATTAGTTGACGGAAATCAGAACGAATTTCACC
+ GCAACGTCTTATGCAGCACAAAATGGCGGCGCAAAAGGATGGTTGCATATACAATAACTTCATCTCATTC
+ AATCTCTCCTATATTACCGCAAACTCGAAAGCCAAAACACGAATGATGAAGAGGGATAGATTTTATTGGG
+ ACAAAAATGATAGGTCACGCGAGAGGAGTGGTCTAAATTTTACTCTCACAAAAATGTTGGCAATACAAAA
+ TGGCGGCGGAATGAAGAGGTGAAAATATATTAAAATTGCCGCTCATTTTCTTCGCGGTAGAATTAGGACT
+ GAACGTTGCCGGGTATAGGATCTCTATTGATGGCCTTTACTTATAAAGTGTATTTCTACAGATCAAATTA
+ CTTTTTACTCTTTATCAATATTTAAATATTATAAATTGATTTAGTTAAAATACAATTCGAACAATCTTTT
+ CTCCAAATAATAATAATGTTTAATACCTATTTGCGCATATGCGTTTATTTTTGGGATTTAATTTTAACAT
+ TTTTCAACAAAACCGTTACAAATGTAATTTTAAATCAGGAAACGACTTTGGTATGAAAATATGTTTTTTT
+ GTGCGCTTTTAAACATGTAACTGCTCTTTTGTGCTGTTTTATTGAATGCTATCACAGCGTAAAATTTTAG
+ TTTTAATACCAATACATTGGGAATAATTTGCGATTTCATTCTATTCTTATGCCCAAATAAGGAAATAGTT
+ TCCGGCAAAAAATCAGAATTTAGCTTTTACAAAAACTAGAGAGGAGAGGACAATATTATAATTGTAGACC
+ GTTTTAAACACTTTAAAATGTTTAACCATTTATCAATTATTCTACTAAATGTAGGTGATTTTATTTATTA
+ GAATACGAATTCTTTATCTGAATCGAACTAAGTAAGCCTAAGCGCTTAGGAAAAATACATACTTGACGAG
+ TAGAGTGAAATAATTACAAATATTAGACATATCCATTGCTACTCGCATGTAGAGATTTCCACTTATGTTT
+ TCTCTACTTTCAGCAACCGAGAAGAGAACCCACGTTTGAACAAGTATCGGCGTGTGGACAACAGCTATCC
+ CCGCTTCATAACGAATGAGGCTGCCGAGGACCTGATTTACAAGAAGTCCATGGGCGAGCGGGATCAGCCA
+ CAGAGCTCAGAGCGGATCTCAATATTTAATCCGCCAGTATACACGCAGCACCAGGTGCGCAATGAAGCCC
+ CCTACATACCCACCACATTTGACCTCCTCTCAGACGATGAGGAGTCGTCACAGAGAGTTGCCAACGCCGG
+ GCCATCTTTCAGGCCCTTGACTTACTCGGATGCTGTGCGTCTAAGCCAGAATGGCTTCGCCAACTCCCGC
+ GTAAGTGGGCACTCCAGCTATACGGTGCGCAGACCACCGGCACTAGTTGACAGAAGCATTCTATCCCAGG
+ AAATGGAGCGCATGGACCAAGAGCAGTATATCTACCTTATCCGTACCGCAGCCCAAAGTAATTCCGTGGG
+ CAGTCACTACGCCGAACCGGTTACTGATAACTCGGAGGTCAAGAAAGTCAGTGAAACCAACAAAAGGTAA
+ ATAAATTTTTTATATCCATCCATATCCGAATCAGTGGCAATAATGCAAAATGCTGATTTTATCACCAATT
+ AGTGACGCACCACAGCCGTTAACCCCTCAACCTACCAGACTCACCAGAACAGAATCCTTGCACCGTCGTT
+ TTGCCAGCTGCGTCAACTTAAATGATGACTTCGCCGAGCAATTTAAAGCAAGAGCGGCGGACTGTGAAGA
+ GAAATCCAAACATCGTCTTAGATTAGCTGAAGAGCAGAGGCTTTTTTCGAATTTCAGTGCTATAAAGAAC
+ ATAGATGAACTCCGTGCCTATGAACGAAAAGTAGTGGAAAACATATTCCAGTCTTGTATCGCCCACAAGC
+ CCATTTTTGTACTCGGGCCCTTGGACAAGCCAAATGTGAAGAAAGTGACCAAGCTCATTCCGTTAACAGA
+ GGAGCACCACGATCGCTTTAACGAAATTACACAGGATGATAAATCGACGGTATGGCAACGAATATATTGA
+ TGTCTTTCGTACCCATTGAAAACGTTGTGGTGCTTGCGCTTTAAAATCTTATATTAGGAAATTATTTTTA
+ AATTTAACCTACACATAACTACCGAAGACATATGCACGTTTATTAATGGGAAATGGCTTAACGACGAGGT
+ CATTAACTTTTACATGTCCTTGCTGACAGAACGGTCGGAGAAGAGATCTGGCGTACTTCCCGCCACTTAC
+ GCCATAAACACATTCTTCGTGCCCCGCCTCCTGCAAGCTGGGCATGCAGGCATTAAGCGCTGGACTCGCA
+ AAGTGGACTTGTTCAGCAAGGACATAATCCCGGTACCAGTGCACTGCAACGGCGTCCACTGGTGCATGGC
+ CATCATACACTTGCGGAACAAGACAATCCGGTATTATGACTCAAAGGGAAAGCCAAACCGACCAGTGCTG
+ GACGCTCTAGAGAAATATCTACGCGAAGAGTCAATATTCAAGCCCAAAAAGCAGTTTGATACCAGCGATT
+ TTGTTATTGAGAGCGTGCAGAATATACCACGACAGTTAGATGGCAGCGATTGCGGTATCTTCAGCTGCAT
+ GTTCGCCGAGTATATAACGTGTGATGTGCCAATTACCTTTACCCAGTCGGAAATGTTGTACTTCCGCAAG
+ AAGATGGCTCTAGAAATCGTCGACGGAGAGTTGTGACAGTAGAATCACACAGCTACGCAAGAATGTGGAG
+ AATCCAGTTTAGTTATTTTTACAAATCTTACGTAAACACTCCAAGCATGAATTCGCAACAAGTGCTTAGC
+ TATTTAATTGAATTGAGCTGGCCGAGAGATGTGCTGGTGCAATAACTTGTTCTCATATCTGATTGTAACA
+ GAGAATCTAGTTTTTCAATAAAATTTCCCCAAGTAAAAACAATGCGAATAGGGACGTATTAATTGCCGAA
+ TCTCTTCGAGTTAATAATTAATTTTTACAATACAGCAAGCTGAGAATATGCAATTGTAATGTCCAATTCA
+ ATATTTGTAATTTACTATTTTAAGCCTAACTCTTATCTAGGGATTACTCGATTCCAACTATATTAGAGTA
+ GAAGAAAACAATTTATTGTAACGAAGTACAAAGATCATTCTAGAAAATCACTCATACAAACCTCTAAGGC
+ TCAAAACCGAGGTATGATCTTTAAATAAGTCAAAATTAGGAGTTTTCAGTTTGAGACCTACAACTAAATA
+ GATCGGTGTTCTTCCACAAAATATTGTAAAGCCAGTTTGTTAAATAAAATACATGTTTTATTAATAATCC
+ TAAGCTAAATACTCAATTATATACTTTATATGGTCGGAAAAGCTTCCTTCTGCCTGTAACATACTTCTCA
+ ACGAATCTACAATACTATTGTATATACTATACCTTTTACTATACGAGTAACGGAGTAACGGAGGAGAATG
+ CAAAAAAGCTAAGAACAAAACAATTACTACAAATCGTCAGGAATTTTAAAATACTTTACAATTGAATATA
+ AAGCCGTAGGATTTCTAAAATTAAATTACATTATGTACTAAAGTACTTGAAGGCTCATTAACTTACTTCT
+ CATATTGACATATTTTCTTCCCTCTAAAACTCATAAAAACCATAATTTTTTAATTGCACCTGTGTAGAAT
+ GCAAAAATTACATTTGTGAGTATCATCAAAATGTAGCCTTTTTTAACTGACGTATTAGCCAAAGAATTAA
+ ATACATGTAATTTCGTGCTAAAAAAGTTTGCAATTTCATTTTACGAAATATTCTACAATTAATTTGAAAC
+ ACGCTTTTAATTTTAAGTAGTTTTCTTATTGAGGATTTGATACAACAAATTCTTTTGAACTTCAAGGTCT
+ TTTTTCTCCCCATCCTTGCATCAGGCTATTTTTTGTACTCCTAATTTGTTCATCATAATAAAGCAAATTG
+ TTGTTGTCCTAATTTTGTAAGGGCATTTTTTTGTATCACAATATTTTAACCGAAAATAAAAGAAATTTAA
+ AAAATGTGGGCACGACAATTTTTTTATAATCTTTGAACGGTCATACGAACGGAAATGAAAGACACCAGCG
+ CTGTTTCTATCCCTTAAAACCCAAATGTTCCTATATAATTTGAATTATTTATCCAAAATAAAGACCATTT
+ TAATATACAATTTATTAAATGGGGACGGACCAATTTATCGGTATTTGTGTTTATACGGACGAACAGAAGT
+ AATTAATCGGCATGTTATCCAGGTTGCGTTTTAATATTTTACAATCGGCCTTAAATGTCAACTTTTATCC
+ TTTGTACCTTTCTACAAATATCATGTTTCGTTTCATCATACGGGTAAAGGGTATAAAGTCACTACGCGAA
+ AATACATGAAAACATTACATAAAATCATAAATAATTATATGGTTTTGGAACAACAACATCGCTTAAGCCA
+ AATAAAAAATGAATATTTTATATTATCATTCTGTCATTTCTGTTTGTATGTAAATCGCGTTTAATTTAAT
+ TTAATTTTTTTGCGTTCCTATTTTGCTGTCCCCGTTCGATTTTTAGTGAGACATGTTTGTAATTATAGAT
+ TAAATTACATCAGGACTAGTACTCGTTTGCGTCGTATTTCTGTAAAGGTATAAAATAATTAGTAGGTTAC
+ GGCTTCTGTCAATGTTAAAATTGGCTTTCTTCAGGCGCTGTTTTTGGCGTTCCTATTTTGTTGTCTCCGT
+ TCGTTTTTTCATGAGAAATGTTTGTAATTATAGATTTAATTACAACAGAACTAGTACTCGTTTCCGTCGT
+ ATTTCTGTTAGGTAAAAAAAAAAAATTAGTAGGTTAAAGCTTATGTCAATGTTTCTTGTAGAAGCACACC
+ TTTTCGATTCCAAGTCCTCTAAATTAGAAATATTAATATTTGGAATTTCACTCATGTTTACGGTAGTACT
+ GGCTTTGTTGGTTTGCGTGCTAAGTACAGATAGGCGACCTACATTTTCATAGAGATGACAGAAAAAAAAA
+ GTTATGTACAGATATAATGTGGGCCCGTGCTTTTAAAATAAGATAAAAGTATATATTTAAAGTTGTTTGG
+ TGCGTATACTTAAAATCAAGTTTTTAAAAAGTAAATTTTTATAAGAATTATGTTGCCGAAAGTAACTAAT
+ GTCGAAACGAAAACATTTAAATGTAGATACGTACAAAACAGCAAATTAAAATAGGTGGAATAATGTTAGT
+ AAATAAATGATTACTCACCAATGGTTTCCTCTGTATTAATAGAACACAAAGTGGTGGTCGTCATATTTAA
+ ATGGTCGCGCACCGAGTCAACGGTAATATCGCCAATAGAGCTGCTGATAGTCTCGTTAGCTTGATTAGGT
+ GAATTTGAAATGTTGACTCCATTAACTTGCTGAACACTATTTCTTCCAACGTTTTCCTCTGCAGGCCTTG
+ TGCATATTGAAATGCCTGATGGATTTTTAATTTCATATGTATTCACAACTTCATCACATGCGTAGGTTTC
+ CTTATTATTCTCTGCATCATTTTCTTCCAACACAGACTCTTCATTTTCTAATGGTTCTACTGGAACAACG
+ CCAGTGGGTTGCACGACTCTGGACGTGGCTAAAGCAATACGCTGCAGTTCAGAAGAAGACATCATATACA
+ GTGCTTCTCCAGAGTTTGTAAAGCAAAGTGACGAAACTCCACTGAAAAGTTAAAATACAGTATTAGGTCC
+ AAAAAATTAAAATAATAGCACTATGCGTGACTTACTTAATGTCTTCCCGTCGCACTGCTGCGGCATTCAG
+ CTGTCTTTTTAATTCAGGTACTGATAAAACCATGATATCGCCCATATTCGTTAAACATATCAATGCTGTT
+ TCGTTATATACATCTCCACGACTTACAGCCAAGCTTCCACTGATATTAGGATCCGCCTCTCCATCGCCAT
+ GTGAACGCGTGGACTTAGTTGGGCTACAACCGTGCATACTCTGCAGTGTTTCCGGGGATATGCGACAACT
+ AAACGAACCAAAATGGATGCGGCGAATCCGAGCACCTTCGTTAGCGGTAAGCTTATATTTGTTAATCGGC
+ TTTAGTTGCGGAAGTGAAAACACCTTGAACTGTTCCTCGGAAGCAATAAGTACACGATGCGGTGGACTCC
+ CGTTTTCACCGGCGTTCAGCTGATCGACAGGGCTACCCGCCTGATCAAAAATAGAAATACCCACCACAGG
+ AGCACGATGTTTTAATTGTATTTCTTTAGCAAGCTGCGCAGAAATTCGGCGGGGCATGTGTGGTGGTGCA
+ TTGCCACTTGCCGACGGGACGGCAGTTGCCGCGGTCTGCGCTGGTGGCAAATGCAGAAGGAAAACCGAGA
+ CTGTACTGGCATTTGTTGCTGACCACAAAGTTGGCGACGTTATGTTGACTGAAAATGTAAAAATTATACA
+ ACAAATTAGATGTACATATACAGAACACCAAAAGAATAGACGCTACAGTCGAGTTACCCATTACAGAAAT
+ AGTAGGAGGATAGGTGAAATTTTAAAAACAAAATTTGCCATATAGATCGAAATCGCGAAAACAAAAAGAC
+ TATGATTTAATTAGTTTAAGAACTGTTTTCCAACTAGTAAATGAAACGAAATCAATATCAATAAAATATA
+ TTGTCAAACCAGAGTAAATGCAAAAGCACTTTTAACACTTATAGCATATCGATAGACTAGCAAGGAATAT
+ TGTAATGACTGAATTTCTTTCTAAGGACGGACATAGTCAAATGTAGTCGGCTGTTTAAACTGATCATAAA
+ TACATATACCTTTAAAACTTTGATCAATATATCCAATGCATAAAAATTTGTTGCACAAAAATATAATTAA
+ AGCTCTGGGCGTCCCAAAATGAAAAGCACTGTATGTTTTTAGCTTTTGGGTTCAATTCTCGCGAGGCCGT
+ GGTTCAGAGACTATTTCCGTTACCTTTTTTTTTTTTTATCGTTACATCAAAACTAATAACAGTACAAAAT
+ GTTGATTACCATTAGTAACATAAGTTTTGGCAAATAGTAAACATCGCACCATGGATCCTAGCCCGTCATC
+ TGCACAACGAGCCTCTATTTGCCTCTCGACGGGTCTTGCTTCCAGCTGTAGGATTGTGAATTTAATATAA
+ AAGACTAGTTGAGTATATATTATCTTACTAACCGTTGTTGGTACTTGATTGCTCTGGTTGGTCCTGGTCG
+ ATCGACCCTTGCGAAGCTTTCTAAATGACTCCCTCAATGATTTCTTAAAAGACTTTCGACGAGACAGCTG
+ CTCTCCTGCTCCAGTAAGATCATTTGGGTTTAAAGTGCAGCGATGAAATACTGGAACAAAGTTTTTGAAG
+ TCAAAGAGAACTAAGCCGTGCGCAGTCCCACCAGATACTAGGCCCCAGCTTGCTTCGAGTGCCATGCATG
+ TTATGCTGGCTGGCGGCAAAACTTGCAGTACTCCCGATATATTTACACCACGTTCCGTCGTAGGAATTGC
+ TTCTCCGTCTAATAAGTTCGATCGCACGTTTAACTGATCGTGACCCTTCCACACAAATCCATCACGATCG
+ CTGACCAAATTCATTGAAATGTATTTTAAAGACACTTTTTCGGGTAAGTCTATGAAGTCGGCTATAACTA
+ TTTGGCCCGCTGTGCCACCAACAATAAGTTGTCCGGTTTTTGGGCAGAATGCTATTTTCTTCACTGCTAA
+ ACGAGGGTCATCTGAATAAGGATCAAAAAGTCCTGATTTCCGAAATGGCGGTTCTCCTTCATCGACTTGT
+ TCCGCACTCATATCTGCAGCTGCGTCATCTCGGAAGTCTGACTCACTTCCAAAAATGCTGCTAGTTTTAA
+ AATTATAAATTGGTTTAAGCAACACTCCAGTGCAGTCCCAAAATTTAACAGAACCATCTTCGTGACCAGT
+ TAACAAAATCTCATAAAGCTTAGTCGCGTCCTCTTCTACAGATTCTTCTAAGTTATCCGGGAGAGTACCG
+ CCAGTGATAGGCCAGCTAATATTGCTATAGTCAATGTCTTGTTCATCTCCAGCTCTTAAAATACTTTCAT
+ ATACCGACTGTACGACTTCAGAAGCAAGGTAATTGCAAGTGACAGCTGATGCATGGACAGAGTGAAGATA
+ TGGCGCTTTGATAGCACAAATATTAGGGTCAGTAAGATCGTAAGCGCAGAGTTCCTCTTCAAGTAGTACA
+ ACAAGAACTTCAGCGACATCTCTATTATTTTCAAAGGTCACAAAAAAGTCAATCACTTTAGACGTAAAGT
+ CAAGACACACTTTGTGTCCATCGCTGGCGTGAACGGACACACAATTGTGATCACCATATGCTGACCGTGG
+ CATGCCGCCGGAAAAAACAATTACATCGTTGGATCTAAAAGAACGAGAAATTAGTACACATCTAAAAAAC
+ TTTGTGTTTAAGTTATATTAACCTTCGCTTGCCTTTGTACAGTCGATTTATGCTTTTGCATGGATCAGGT
+ CCATAAGGCACATAATTAACATTCGACGGCGGTTCTGGGTTATCTATGCTCCAAGTGGCGTATGAACCAT
+ CAGCGTGGTACCAGGTAAATTCAGATCCTTCGAAGTTCACTGTAAGACCAACGCTCTGTCCATGTCCAGG
+ GGCTATGTATGCTCGCTGGACAGATGCGCTTTCAAAATCCCACAAAACACAAAGGCCGCGATTGTATGCA
+ ACTAGAAGTTTGCTAGGGGAGTTTGGAAGTTGGCGGATTGACTCAATTGCACCAGGATTTAGCTTGTAGG
+ CTGGTGGCACCTGCTCTAGCACAACGTCATGGTAAATTACAGGCTCCTTAATGGTAAATGTATGTAAATC
+ CAGTTGATAGATGTTTCCACCTTCTGTTCCAATCCATAGCAGATCCTTACTGAGAGAACAGCACAGCGAT
+ GAAACTTTTTTAAGTTTGCCGTCAAACGGTAGTGTTTTGATTGGCAGCAACGTTGCTCCAACTGGCTCCC
+ ATAGAATTAATTGATTCGCTGCCGTCAACGAAAGTATGCGACCAGTTCCATACACCCATTCAAGTAATTG
+ TACATTAAGCTCCGATGCTGAATTGTTTAACAAAGTATGCTGACCGTACAATTCAACTCCGGGTTGACCG
+ AAAACTTTTAAAGCCCCTGTTTGCGTCCCTATTGCCATAAGTTTCAAAACTGGATCATACGCAAGAGCCG
+ AAGGCTTATGAGGAAAGCCATGCTGTGCCGTCTAAAAGAAAAAAATATTAAAAAGTTTCAAAAAGCAATT
+ ACAGATTCTTAATAATTCAAAATTGTTTGGTTCATTTCTTAATTGTAAAAGGGTTTTCCAAAACATTCTA
+ GTTTTTTCAGTTCCCAAGATCTGGTAAATCGTCAGATTACTTGCCACTTTATAGAGTCGGGAACGCTTTC
+ TTAAACCATTTACATACTTTTACCGAATCTAATACAGCATTTTTCTTTACAATTAACGGGAATAAAAACC
+ TCAATAAATATTGAGGTTTGAATTTAAATTAAGTTCAAAAAGCGCCCAAAGCTTTAAATGCTGCTCTTAA
+ GTATGTCTCTTATAAACATCACTGTAGACAGCAGTCCCTACTATCATACTATATTTACATTGATCGAAAA
+ AAGGTTTGGTAAATCTTATCTAATTGTATAAATTGTATTTTTATACAAAAAAAGTTTTAAGAAGTTGCTA
+ TCAGATCTCGTTATGAGTTGATTTTGTTTGATTCATATTGCAGGTGTATTTGGATTTCTAACGCAGTTAC
+ AGGCGAATAAATTCTTTTTCTTTTGACTTTAAAATCTTATCAATTTTACGCCGTCTATGACATACTTATT
+ TTGTGCCTGAAATAAGGGTGTTTGTGAAACCAAGCCATTTACCCAACCCATTAAGCACATAAAAGCAATC
+ TTATCAGCTCCCCCCTCTTTCTGGAGCTGGATGGCGATTACCTCTGACCTACTTTTATTTGTTTAATAAC
+ ATGTTTATACTAACATGGGATAAAAAAAATTCTTATAAAATTTCATATACGTATATTTATTAAACTATTA
+ TGGTAATAGGGAAACATCTATGGTATATTTAATTCGAAAATATTTAAAAGGAATGGACAACATTACGAGC
+ ACAACGATATAATAGAATTTTTAAAGTAGCCAAAAACAGGCGGTGGAAAAAGACACTCACAAAATCAACA
+ AAGCTTCAGGTACCTCCTCATATTTGGCACCGCATAGAAGGAGTGCACAAAAGAAACGAGCAAAAAAGCA
+ CCGTAACCTTTTTTATGCGGTGCTTTGTGGCGCGAGTCTACAAAATACTGTGTGTGTATGCGGTTTACTT
+ GTAGTTGCGGTGGAAAAAATTTACCTAAATGTTAATGCCCAAAAGTATGCACATAGGAGAAGACATAACA
+ AAAGATTGAAAAGGAGGTATTTATTTATTCTTAATAAATTATAAGCTTTCTTCTAACTTCCATAAAAATG
+ TATTTACCACCCAGGATCAAAATAAATGACACCCCACAAAATATACCAATCGGCTACATATACGAAAAAA
+ AAAAAATAAAATAGAATGGAAAGAGAAAATTGTTTGTTGTACCTTACGATAAGCAAAAAGGTCCTTCTGT
+ AGGCGGTGTCTGTCAGCACTGGGCTGCTGCCCTTTTCCTCTGATAAACTTTAACATAATTGGTTATGCTC
+ TTGTGGTGGGTTGGTTTCGATGAATAAATATGTATACTAATTGTGGCCGTATTTATTCTAAACTGAAAAT
+ AATAAATAAAAATTAATCACATTTTCAATAAGTAAAAAATTAAAAAGGAACTTGTATATTTTTTCACTCT
+ TATGAATAAAACCGAGAAATTAAATTTAGGTAATACTATTAATACCTTTTATAGATACGGACGATACGTT
+ TAATATTATTCTGGTATACTTTAATCAAAATTTGTTTAACAAAAAGGGTTTTACATTCTTGGTCATAGGA
+ AATTCAGTGGACAGATAGATCTTGGCTCCCAAGATTTTCCAAACTAGTTGTGCTTATTTTCTTAAAACTT
+ CAAAGATTTGCATGTAGGCAGTTTAATAAACATGTTTGTACATATGTATATGTACATTAGGAAAAATGAG
+ ATGCAAGATGAGCGATCTGTACTCTTTGCAATGTGTATGTATGTACATATGTACCTCCCTTTAATGAACT
+ AGCAATTCCGTCACGCACACGAAATATTTTTTTATTTGTAAATCTTTTTTTAAGTTTGTTTAAACAATTT
+ AGTTACTATTAAAGCTCTGAAATTCATAAATAAATAATAATAAATGTATTAATTATGACAAAAAACAACT
+ TAAAACATATACGTTTATTTTTGTAAAAGCGTTTTAGGCAAACGCTAGCTGGTCGGTACTAATATTTTTT
+ CGAAGACTGTATACCGTATACATACATTTATGTACGTAGGTATGTATCCGTGAGTAAGCTGAGGTGCAAA
+ ACCGTATCACCATTTGCTTTTCGGCTGATAACCAATACCAAGTAAGTCAACTGTTTCCCAAATGTATCTG
+ CATAACAAGGTGATGACCTAATTTTGAGTACATACCGATCTTTACAGTTGACCAGCTTTGCGATTGCATA
+ CCGGTATCTGTTTATTCACATATACACACACAAATTGCGTGTTAGACAGACAGCAAAATGACGACTGTTA
+ ACTGTTGGCGTGGCTGACTCACCGACTACGCCTCTATGCTAAGAACATACATATTTGTGGACACTTTATT
+ TAAGAAGTTTGAAATATAAATCAATTGCCTAATCAGTAATACTGTTGTTGAGCCCTTTACCTTTATGTAT
+ TTCCGTTTGTACGGTTAAGGCGGTGGCCGAGTAATTTTTTGAACTATTTTATTTGCTCACCAACACGCAT
+ AAGTTTGTATGTATTCTTATGTTGAGAAACGCCCGCACTGTTCTTCACATCGTTGCTTTAAATGAGAATA
+ AATGAAATAAACGTGTCAACCAAGAACACACAGATAATAATACGACCGGTCAGAGCTTAACCGTGTATCT
+ GTTTTATAAAACGTGAACAATATTATTAGCCCAAAACGATATGCGCGTCATTTTAACACACACAAAGTCG
+ CGATCGGTGGGTCTAGTGTGCCCGTGTATCTCTATCGAAAAAATCATATATTTTTTAGAAGGTATATTTT
+ CCATGACTGACTGGAATGGGTGGAGAACATCGCTTTGGGAGTGAAACTCCGCTATAAATTGTCATTTGTT
+ TTTATAGCAACCTTTTTGATATGGTCGCCAACTTTTATATAATTATAATAATAATTTTTGTAATTAATCA
+ CCGCTGTCGCACGAAAAATTTAGGAAATGTGCCAACGAGCGGAATTTTTCGGAACGATCGATGTTTTACC
+ ATAACCTGCTATATAAATTGTGAACCACATTTTCAACACAAAACTAGATGTGCTTCATTTATAACGCAAT
+ GTCGTGATTTTGTGGGCAGTGTGACCATGTCCAATCTGCGTTCAAGTAAAACCATATTTAGTGACACAAA
+ CTTTCCATTACAAAATACCAAACAACTTTAAATTTGTTGTTGCATCAAACTTTTTCTTTCTATACATATA
+ ATATTGCGGGTGTATTTGGATTTCTAACGCAGTTACAGGCGAATAAACTCATTTTCTTTTGACTTTAAAA
+ TCTTATCAATTTTACGCCGTCTATGACATACTTATTTTGTACCTGAAATAAGGGTGTTTGTGAAACCAAG
+ CCACTTACCCAACCCATTAGGTACATAAACGCAATCTTATCAGCTCCCCCCTCTTTCTGGAGCTGGATGG
+ CGATTACCTCTGACCTACTTTTATTTGTTGAATAACATGTTTATACTAACATAGGATAAAAAAAATTTCA
+ TATACGTATATTTATTAAACTATTATGGTAATAGGGAAACATCTATGGTATATTTAATTCGAAAATATTT
+ AAAAGGAATGGACAACATTACGAGCACAACGATATAATAGAATTTTTAAAGTAGCCAATACACAAAAATA
+ TGCTGTGGAAAAAGACACTCACAAAATCAACCAAGCTTCAGGTACCTCCTCATATTTGGCACCGCATAGA
+ AGGAGTGCACAAAAGAAACGAGCAAAAAAGCACCGTAACCTTTTTTATGCGGTGCTTTGTGGCGCGAGTC
+ TACAAAATACTGTGTGTGTATGCGGTTTACTTGTAGTTGCGGTGGAAAAAATTTACCTAAATGTTAATGC
+ CCAAAAGTATGCACATAGGAGAAGACATAACAAAAGATTCAAAAGGAGGTATTTATTTATTCCTCATAAA
+ TTATAAGCTTTCTTCTAACTTCCATAAAAATGTATTTACCACCCAAGATCAAAATAAATGACCCCACAAA
+ ATATACCAATCGGCTACAAATACTTAAAAAAAAAAAAATAGAACGGAAAGAGAAAATTGTTTGTTTTACC
+ TTACGATGTAGCGTTGTCTGTCAGCACTGGGCTGCTGCCCTTTTCCTCTGATAAACTTTAACATGATTGG
+ TTATGCTCTTGTGGTGGTTTGGTTTTGATGAATAAATAAGTATATTAATTGTGGCCGAATTTATTCTAAA
+ CTGAAAATAATAATAAAAATTAATCAAATTTTCAATAAGTAAAAAATTAAAAAGGAACTTGTATATTTTT
+ TCACTCTTATGAATAAAACCGAGAATTTAAATTTAGGTAATACTATTAATACCTTTTATAGATACGGACG
+ ATACGTTTAATATTATTCTGGTATACTTTAATCAAAATTTGTTTAACAAAAAGGGTTTTACATTCTTGAA
+ GTCATAGGAAAATCAGTGGACAGATAGATCTTGGCTCCCAAGATTTTCCAAACTAGTTGTGCTTATTTTC
+ TTAAAACTTCAAAGATTTGCATGTAGGCAGTTTAATAAACATGTTTGTACATATGTATATGTACATTAGG
+ AAAAATGAAATGATGAGCGATCTGTACTCTTTGCAATGTGTATGTATGTACATATGTACCTCCCTTTAAT
+ GAACTAGCAATTCCGTCACGCACACGAAATATTTTTTTATTTGTAAATCTTTTTTAAAGTTTGTTTAAAC
+ AATTTAGTTACTATTAAAGCTCTAAAATTCATAAATAAATAATAATAAATGTATTAATTAGGACAAAAAA
+ CAACTTAAAACATATACGTTTATTTTTGTAAAAGCGTTTTAGGCAAACGCTAGCTGGTCGGTACTAATAT
+ TTTTTCTAAGACTGTATACCGTATACATACATTTATGTACGTAGGTATGTATCCGTGAGTAAGCTGAGGT
+ GCAAAACCGTATCACCATTTGCTTTTCGGCTGATAACCAATACCAAGTAAGTCAACTGTTTCCCAAATGT
+ ATCTGCATAACAAGGTGATGACCTAATTTTGAGTACATACCGATCTTTACAGTTGACCAGCTTTGCGATT
+ GCATACCGGTATCTGTTTATTCACATATACACACACAAATTGCGTGTTAGACAGACAGCAAAATGACGAC
+ TGTTAACTGTTGGCGTGGCTGACTCACCGACTACGCCTCTATGCTAAGAACATACATATTTGTGGACACT
+ TTATTTAAGAAGTTTGAAATATAAATCAATTGCCTAATCAGTAATACTGTTGTTGAGCCCTTTACCTTTA
+ TGTATTTCCGTTTGTACGGTTAAGGCGGTGGCCGAGTAATTTTTTGAACTATTTTATTTGCTCACCATCA
+ CGCATAAGTTTGTATGTATTCTTATGTTGAGAAACGCCCGCACTGTTCTTCACATCGTTGCTTTAAATGA
+ GAATAAATGAAATAAACGTGTCAACCAAGAACACACAGATAATAATACGACCGGTCAGAGCTTAACCGTG
+ TATCTGTTTTATAAAACGTGAACAATATTATTAGCCCAAAACGATATGCGCGTCATTTTAACACACACAA
+ AGTCGCGATCGGTGGGTCTAGTGTGCCCGTGTATCTCTATCGAAAAAATCATATATTTTTTAGAAGGTAT
+ ATTTACCATGACTGACTGGAATGGGTGGAGAACATCGCTTTGGGAGTGAAACTCCGCTATAAATTGCCAT
+ TTGTTTTTATAGCAACCTTTTTGATATGGTCGCCAACTTTTATATAATTATAATAATTTTTGTATATATA
+ ATCATAATAATATCATATAATAATCACCGCTGTCGCACGAAAAATTTAGAAAATGTGCCAACGAGCGGAA
+ TTTTTCGGAACGATCGATGTTTTACCATAACCTGCTATATAAATTGTGAACCACTTTCTTAACACAAAAC
+ TAGATGTGCTTCATTTATAACGCAATGTTGTGATTTGTGGGCAGTGTGACCATGTCCAATCCGCTTTCAA
+ GTAAAACCATATATTGCCACAAACTTTCCCATACAAAATACCAAACAACTGTAAAATTTGTTGTTGCATC
+ AAACTTTTTATTTCAATACATATAATTTCATGTGCACTAAAGTGATTATTTTGTATTTGCATTTAAAAAT
+ TTCTGTGATTAATTGTCAATACGGAATGTATGTGAGGAAGGATTGCCGTCGTTATCCATCTGGTCCATAA
+ ATTCGTCTAAACGCTGCAGAGATTCAAGAGCTTCCCGAGATTCTTCGTCTTCAATATTATTTAATTTTGC
+ AGAACTGTTTGGAAACTCAGTGTGGACGATGTCTAGCTGACCATGATCTGTTTCAGGTGCCCCGTAGCTT
+ CCGTATATTTCCCGAAGCGTTGCGCGGGTAAGATTTAACTCGCGCATTCCAAAACTCATTTTTTGAGCAA
+ CCTCAGCAGCCTCGCGTCTATTGGCCTTTCGCTTATCATGGGAAAGTTGCTCGGCATTAGTGCGAAGCAT
+ TGACCCACTTGACGCCGACGACCAAGAGGAGGCGGCCGACTTGCGGGAGCGCTTGATTATTTGGCGGCAC
+ TTGTTGGTAATCCCACCGACGATCTCGGATACCAGGGCTGTGGCTCCTAGAAAGTAGCCCAGTGCCATGA
+ GCAGGAACATTCCTTCTGTGTCCGCTGTAGTCAATTGGCGCTCTTCCTGAATTATTTCGCGTAAGGAATT
+ CGAAGAACTTGCCTGGAGCAGGCGTCCTGAAGATGATCGCTGCATGACCCAGCTTACCTCGTTATTGATT
+ TTTGCAATAAGACCACTTTGCTGGGCAAGTAATATCATCGAGTCGATTTTGATTTTATACACTGACTCTC
+ GGGGAAACAGAAATCCTATTTGGAAAAGAGCAAAACACTCTTCACTCAAATGAAGCGCCGATCGGCGGGA
+ AATATTTCTAAAAGAGGATATCGTTTACGGTGGGAAGATTAAAAATAAAGGATCGATCTTACTCATCTGA
+ AAAATTTGACTGCACCAGGTATTCGAGCTGAGCCTTTGAGCCAAGAAAGGCATAGTTCCAAAAGAAGCTC
+ TGGGTAACGTTGCCAATGCCCTCATCTACGGACCCGACAAACTCCATTTTCTTGTACAATCTAGACGTCG
+ GTATATGGGTCGAGTTCTGGAACCAGGTCTCCCAGCCACCATTGTCTTTAAGTAAGAAGCCCAAATATTA
+ TATACAAATGTAGCGAGCCTAACCTTTTCTTACTCAGGGTTCCAACGCGAAAGAACAATCCCAGCAGATC
+ CAACACAGAGTCAACGGTGTCCGGAAAAGCTGGCAACGTTACGAATGCTATGATGGAACCTGTGTAGCAA
+ GATGTAATGATAATTGTAAAGAGCCAATATGCTCCAATTAGAAGGCGTGTGGAATTTTTCCGCGTGTTGC
+ TCCACGAGTATTTTCCGGTGAAGGAGAAAGCGTTTGTGAACATGCCAAATACATACCAGAACATGTTTTC
+ TACCTCACCCCAATTACCCATTAAATGGCTAAGTGTCAAACGGTCGGTAAAAACTATCGGAAATATTCCA
+ CCGAGGTAAACGCAAATCAGAGCGACCCAGACTGGCCATTGGAACGGTCCCATTATGGCTCTGTATTTCG
+ GCAGCGCCTTCGATGCAAGTGTTATGAAAGCTGCACAATCGGGTGAGTGCCCCACCGACATGGCTGAGTC
+ CATCAGCCGTTCCTGTGTTATATATATACCGGACATACCAATGTCTACTGTTCTTTCTATAATCTGTTCC
+ TGGATGGTGTCTACTACCCCGCGCGTATTCGACCGTGTTGGGGTCTCAGTGATATCTATCGAAAAGTTTA
+ GCCGCTTAGATATCATTGTCAGCAGACGAAATTCAACTCCGTCCCAACGCAACTGGCCCATTCCTGAGGA
+ ATCTAAAGTGCGAATTCGAAAAATAAACGGCGGCTGATTTGCGGCTGAAATTTGAAATCTGTGTCCCGCA
+ AACCCAAATTGAAACTTCGATGGGAAAAGATTTATATGTGGACGTGACAAAGCTCCCTTTATCCAGCTGG
+ TTAGCACTACCGGAGTGTTTGAGCCAAGTCCATCTGCATAGAGCTTGTGGGTGTAGAGTACGTATGGGCG
+ CTCCTGTGTGAAGCGCATTATTTGTTACAAAAACGTATCCCTATTAAGCAATACTCACGCGCATCGGGTC
+ AGCCATGAGCGATTCCCCAATAACTAGTAAATTTACAATGTTTGAGGATAGCTCCGAAGACAAAAAATCA
+ CGAAGTCTCCATTGGGTGGACCTTGAGACAAGAACTACACGACTTTCAGTTTGCGGGCCTAAAATCTTTC
+ GCGTCATTAATGGGTCCGAAAGGAAAAGAATGTAGCTTTTGCAATTGCAATCTATATGGCTCGTAAAACG
+ TTTATTTTTTGCTTCGTAGTCTGCATTGATTTCCCCGTGGTAGAAAGTAATAGGAATAGTCTGAAAAGTA
+ AATAAAATTGTATTCATACCCGTTATTCGTAGAGTAAAAGGGTATACGAGATTCTTTAAAATAAATGTTA
+ CAAGTACAAGGGAGCGTTTTCGACTATGTAAAGTATATACATTCTACATACATATTGATTCTATAAGGAT
+ CAATAGCCAAGTCGATATGGTCCGTATGAACGTCGAAATCCCAGGAACTATAAAAGCTAGAAATTTGAGA
+ TTAAGCACTCACATTCCAAAAACAAAGACGCAGCGAATGTTTGTTAAATGATGTAACTAATGATTTTATG
+ CTATATAATTTTGATATATCTGCGAGAACCTATTTAAACACGATTACTAACGAATGTCTGTTGCTTATAC
+ GGATACGATATGGCCTGATATGGCTATCGCCCAGTTCAGGTCCATAAGGTGTACAGATTACATGTAAATA
+ CCTATATTGATAAAAAATGTAGTGAACTCATTATATAACCTTAGTTTGATATTTTAAATGCAATGTTCTT
+ ATGTATTAGTGCACTAAAGGCTTCTTTCGAGCTTACCTTGAACAAATTCTCTAGAATTAATCCGTCAGAT
+ TTTTCCACAAAGCTATCATAATATATGACCGGTGGGCATTTATTGAGGTACTCTTGGGCAATTTTGTTAA
+ CCAACCCAACCAATGAGTTAGTCTGCTCGAAGTTATAGGAATTTACGTGAAACTTACTGGCCAAAAGTTC
+ ACCTCGTGGCCTTGGATTGCCTTGAAATGTAGGGACAATACGGCGTTTTTGACGGAACTCGTTTTCATTA
+ TTACCATCGCACATTCCCACACCAAAAATTTCTTTGTTTAATTGATAATGGTTGATAAGCCGTCGGCTAA
+ TACACTTCTCTTGATAACTAGCGGATCTATCCCCTTCAATTGAAAAGGCTTGCGCGGTAAATAAGACCAG
+ AGCTACCCAATAATATGACATATCGAGCGCAAGTTTGGAGTTCGATGTGTTTTCAGCTGTGAGCCTTTTC
+ CCCTTTTATACCCCTATATAGATTGAAAGCTTGCACGCTAGGGTTCATCACCTCCATAATTATATAGGGT
+ TTATTATCGTGGTTAATGCAAGAACGGTAATTGTAACACCTGCAGCAAATATTTCATGTCGGTACAATCA
+ GAATCAGACTTTTTTTTTGCTGTATTTAGAAATATTCCAATGTTGAAAAATAATAAAAATTGTAATATTT
+ CATTTTATTGTTACATTTATATTGTTACAAAATCTAGCATAAAATATTTAATTCACTCGCATTTCTATTT
+ TTTTTATTTTGCGCCTGCTCTTTAAGTTTAAATTATATTTTTTGCGTGCCCTTATTAGTTATCCCGCTTG
+ CACTATTTAATCACCATGTCTAATTATTGGATGTGGAATCCTCGTAATACTTTCGCATATTATTGAATGG
+ TTCACGGCAGGCGTGCATGTCGTTTCATTTAACTAAATTAAATAATTTAATTTGCAGAGACCGTCTCAAT
+ TCTGGGAATCAACTTATTTACCCTTTTTCGCGTTTTTTATTCTCTTCAATTGACTGCCTTTGCGTATCCA
+ TTAGTTAGGACTAAGGCTATAAAGTTTTTGTTAAACTTTTTAAAGATTTTAATTTAAAAAATAATACATT
+ ACGACTAAACAAATTTAGCGCTCATTATTTTTAGACTCACACCAATAAAATAACTTAAACTTGAAACCGC
+ ACTGGTTAATCTTAATGCACCCAAACCCAATACCAATTTGGCTTTGACAATATTTTCATTAAAAATACGC
+ AGTTTAAGTGGGAAAAAGGAGGCTTGAGCCAATCTAATAATACATAAATTCAGCTGTATCTCTTTATCAC
+ ATGTAAACAAAAAATTATATTAGCCTAATACCTAAATGCGTTCTTGGTGTGTGGACTTGATGCATCCAAA
+ TCATACTTGTAATTTTATTATTTTCAAAGACTCGGTGCACCAATTACGCCTTTTATTAGTACTTATTAAA
+ ATAGGGTTCTATGCCTAATTGATTTCCGTTTACAAGGGTCGTGCAGCGATTGCGTGCTCAATGTATCGTA
+ AATATCTATAGGAATATACAGAATGGTATGGAGTATGCAAAAGGGAATAAATAATTTGTATTAACATGCT
+ GCAAAAATGTAACTAGGCTCCTTTTAAAGAATTAGCTAAAATGACGAAATTGTTAGAAAACATTTTAACG
+ AGTGAACTCCGTATTTTGAGCTCAAATGTTTATCGCTTTTATATTTCAGTATCTTGGATTGTCAGGTGTC
+ CCTTTTGCCTATTGATGGTCCATCCGCAAATGGTCAACGCGAGACTATTGATTTCCAGTCTTACGCTGCC
+ GGCTCTTCAACTTCATTATCGATTCGGGAAGATCGAATTCCAGATTTTCCAGTCCAGGGGTAAATGTCGG
+ GGCATGGTTGACACGTTTTCATGTACCGGACGCCGGACTTGTGCCACAAATTACACACTTTTGGGTTGTT
+ GCAGCGTTTGGGCCGATCCTTGTTGATATTCAATTGTTTTTTTTGGTTTTAATTGGTTTCCTGAACTAGA
+ TTGTTAATCAACTGTGTATACCTACCGAATAATCGCACTGAAATGGTTGGAATGAGTTTATGCGTGATAT
+ CGGTGTAGGGTCTCGCACCCATTGAAGCGCTTGCCAGTTGGTTATTATCCACACATCTTGCATTGCATTG
+ ATGGCATCAAGAAATTTAATAAAGCCCTCTTTGTGATGGGGCTGGGTAAACCATGCAGCGTGGTAAAACA
+ AGCCAAATGGTGCTCTAAAATACATAGATGAAGAAATTAAATAAGCCATAGGGCCATTGTTTCAAATTTA
+ AACCTAAATTAAGAGTTTCAGTAGAGGTTTACCTGTTTGTAGTGTAATGACGTTCAAAGTTCTTCATAAT
+ CATCTTTGTCACTCCATCTGCATCACTAGGGTTGGAACAGGCATCGCCCATAGAACAGCGGCCTCCGTTA
+ AGGTCCTGCCACATGACCATAGGTACCTGCCACACCCCAGGATAGGAACGGGTCGGGCAAGGCGGAATCA
+ TGCAGTCGTGGAATATCTTGTAGTCAAGCGTGTAGGGCCAGGAGGGTGGTCGGTTTTCGTAGACAGGCAT
+ GGAAGAGTCGTAGGTGAAGTTTGAGTCGTACAGCATTTTGTACATTTTGTTTCCGCCCACCGACAGGAAA
+ GGAGCACGCATGCCTCGAACATCCGACATCTTGACACCGCCGTACGCAGCAAGGATCTCACGCTGTCCGG
+ CAATTTCACGAGTCCACTTCTTCTGGGAGAACTGCTCGCCAAAGCTGTGACTGTAGATCAATGCCTTTAT
+ AGTTATTTCTATTGTTAGCAAGTGAGAACGCTATAGTCAATTTACTCGACTATTAGATACCCGGTGTTGA
+ GATAGTGGAAGTACAAACGGAACGTTTTGTAAAATCAAAAATTAAGTCAAGAAATCTTTCAAAGCGATGG
+ GCATGACTGTTTTCGGCTGTTTAAGAGTCTAAGAGTGGGCGTGTCCATCTTCTGAATAAATTCATGTTTA
+ GTCTTAGCTTTAGAGCTTTTATATTTATTAAGATTCGACGTTCATACGGACTATTAGAGAGACAGACGAG
+ CTAGTGGTAAACGGTCCCTTCCACATGTTACACTCTTTCCAAAGGACAGGTATATAAATAAGTGTTATTT
+ TTTGTAAACAAAGCGATTTGGGTTTATTCTGTGTGAGATTTGTTATGAGAGGTGATTGACTACATATGTA
+ AGTACCGTGATTCGGCGATACCTCTACTAGTTGACTTTATTGTGTATTTCATTGTCGGGTCAAAAACTTG
+ TTCCATCTACTTACGAAACTGTATGCGAAGCCATTTCATGTCCATCGGCGTAAAGATTCTGCACTTGACT
+ GTAGTCAGTCCACTCGTGGGAAACGTAAAAAGTGGCTGTGATGGGACAGCCGTTTGGATTGACGCGACCT
+ TTTTCAAAAAGATCCGTGTACAACTGCTTGTTTAGGTCATTAACGGAATCGTCAAAGGTCAAGAGAACGA
+ TCTGAGGGATGCTTTCAACAGGTAGCTCGCCTAACAATGTAGATGAAATGTGGGTGAAAAAAGTAAGAAA
+ ATCATAGCAGATGGATATAGAACGAGTAACCATTTTAGCCAAGAACAAGATACCGATGTGGACTGTGATC
+ AAGAGGCGCTTTAGGAGAATGAGACCCTCGAAAATGGCAACACGGTTTAACGCAACTTACGAAACGGTGT
+ GGGAGGCCATTTCATGCCCTTGCGAGTACAAATCCTGTACCATGACGTAGTCCGTCCACTCGTGTGATAG
+ GTAAAAAGTTCCGCGCCAAGAACAACCGTTGGGATTTTTCCGCGACTTATTATTAAAGAGTTCCTCGTAA
+ AGATCAATATTAATGGTATTGACGGCATCATCGAACGTCATAAGTACGAATTGCGGGGTCTCTGAGGCGT
+ TTAATCCGCCTACACATTGGTTTGCATTATTGTTATTATTTAGCATAAGGGCTATTGTTTCTGCACTAAA
+ ATCGTGATCTACCTAACTGGGCGTGTACTTACCAGGAATATCTCTTCCTCCGCAATAGCAGTCAGGCAAA
+ AGGCATACGTCCTTTCGGCATTTGGCTGCCGTTTTATCTGGCATAGGCTGTGGGTAAATAGGGTCAGGGC
+ GGGACGGTGGGTAACGGTATATATCCACAAACTCTTGAGCCTTTGATACAATTGTTCCCGATGGCTTAAG
+ TGTTGGCCGCGTTCGTCTTAAAAAATTTTACGTTATCTTACTGCGCAACAAAATATTAGACGATTCCTTA
+ CGGAGGATGAGTTCCGCGGTTGGGCGTGGATATCACGTCTCGATCCTGATTACTGTACATGGCACTGCCC
+ CGGTTCCTGTTGTTGTTTCTAGATGAGGTTTGTCGATATAGTTGTTTATGAAAAGGTTTGAGTTGGTAGG
+ GTCATAGCTTCTCTACTCAAATATAATTTAATTTAAATGGCATTTACTAATTTGTGCTGCACAAATACAC
+ AAGAGATACTAAGGAACGCAAGATTAACTGTTTGAATGGTATATGTTGGTTAGTAATCATTACAAACTTT
+ TAATTTTAACTTTTTATCACCTTCACCGACAAAAGCAACATAATATAATAGCCCAATTCATTAACTTTTT
+ TCTATAGTGAGAACCAAAAAGTTTTATAGCATACTAATGTGTTTCGTTTTAAACGACAATACAGACTGAG
+ AAAATACAAATAATTGTATTATTTATGCGTAAAGACTTCATGAGCAATCATTCACAATAAGTTGCACAAA
+ TAGTCTGATTTATTTATTGTTGAAGTTTTTAATCTAAGCAGTAGAGATTTATACTTAAAGACAATTGCGT
+ AGACTATCTAGAGGATTTACTATGGGGTCTAAATATTATTTTCTTGTAACAACACACAAGCGTGTACCAA
+ ATTTATGCTCGGTAAAATGTGCGAAAAATTTGATTTAGTTTTGTTTGCCTTTTATCGGTGTCGTATATGA
+ AAATGTTTCAATTAATTTGTTTATTCCGTTTTTTATATATGATCTATATATCCATTTTGCATACAAATTA
+ AAAATGTAAACTAAAAAATATGAATTTCTTTAATATTTAACTTATTGGTTATTGATGACATTTAAAAATT
+ TGGAAAACCAATTGACGTGAATATAGAATAAAAAAATTTTGTAGGGATATACTTAACTATCCACCACCGC
+ TAGGAATATAACGATAACCAGCGATCGGTTGACGGAATTTTATAATGACAACTTTCTACAATTTATTTAC
+ TAAAGTATTTGCAACATTTTAACCAGCAGTTAAATTGTAGTAAGAACTTGTGTGCTTTGCATAATGTCAC
+ CGAGTAATTTTCTGTAAAATAGAACACTACTTTGAATATTTACATATAAGTACATTAATCAAACACTGTT
+ CAATAGGTATTGGGTTTCAAGCAAAGAAAACTGTTGACAGGATGAAGTCAACAATCAACACCAACCAAAT
+ GGAAGAGTTACTATAAATATGTAATTAGAGGTGGGTAGATGGGGGTGGTATGAGAGACTAGAGAAAGCTT
+ GAAAACAGTATAATAAAAACAGTACAGTGTTGGGGCTTGGTTTGTTGTGTACAAAACGAAATTACGGTGA
+ TTCTAATAAAGGAATAAAGAGAGCAATAAGATAGTAGATCGACTGAACTTAGAAGCAAGATTGCTTGATA
+ CGGGTATCTATACCTTGAAGAGATTTCGTTGCATTTGGCGTTTAGTGTGCTATCGGAGCACTTCACAGAG
+ GCTGAGGCTGCGGGCCCATTATGGTTGATGCTGCTCTTTTGGAGTTGGTGATTTTTATTGTTGGTAGCGA
+ AGCCGATTTGAAACTTTTGGGTTTTACCCGCTGACACTGGTGGCTGATAGGTTGAGGTGCTAGGGCCTAG
+ GGCAGCGGCAGCAATCGACGACTTAATATCATTATTCACCCTCGAAGCGCGCGCAGTGTGCGGTGCAAAT
+ GAGGAGGGTGTAGCTGTACCGGTGGGAATAGTGGGGACAGTAGTTAGAGAAACTGGAGGGGTTTTGAGGG
+ TTCTAGGGGTACTAAAATCAGGAGTGCTTGACGTTGTTCTTTCTGTTAAAGTGGAATTAGCGGTCAAGAT
+ GTTAAGAGACGGTAAAACGGATACTCCCTTGATTCGGATTGGAAATAGTGTGGCAATAGGCGTGGTATCA
+ GGATGCAACGTAGTCGTGCTAGATTTTAAAGTGGTCGTTGCTGGCCGGTCGTTGGGCAAGTACAGTTTCT
+ TGATTTCACCGATAGCGGACCTTAATTCGGGGAGTGAATACTCATTAACGAATTGGGAATTGGCACTCTC
+ ATCGCTTTTGCTGTTGCTGTCACTGCCGGAAAGAAATTGCCTCAGTTGATCAAGGACGTTGGCGGATCTG
+ AACTTCTGTGACGACCCGTTAGGCGATGTTATGTAGCCGGAGTTTTGAAGACTATCTGCTAGAGTGTGCT
+ CCGCCGTTTGCTGTCGGTATTTGTTAGAGTAAAGGAACTTGACAGTTGGACGTTCTGTTATTGCCACCAC
+ GTGTTCGGTGGAGCTGTAATCTATTGCAGTTTCTTTTTCATTAATGCCATTTTGATAACTGTCCTCCAAA
+ GGCTTGCTTATTAACGCCTCGGCTCTTGGCTCGTCCGAAACGCTGGCTTCATTTTCGATTGCTTTATGTT
+ TAAGCGACTTGCTTAGTATATTTTGGGAGCCAAAGGCGAGATCTCTGGCGTGCAATGTGCCCTTTATTTC
+ CCTATACTTTTCATGTGGCATTGCTGTTGGCCCACCTAACAAAGACCTCTGATTGCCGATCACTTGTACT
+ CGTTGGGGCTTGGTTTTAGGCAGCGGAATGGGATCATATCCGCGGAGCAATCTAAGCTTGGGTGCATAAG
+ TCGTGGGCTCGTCCCCGCTGTCCCCGAGACTGTTTAAAGTGGCCGCCGTGTATCGAGAGCGCCCACGCGC
+ AGGCTTTGGGGACTGTGATATTTGGATGGCAGAGGAAGCGATTATGGCAGAAACGGTTGTTGAATCTTCA
+ GTCGACGTTATTCCTAGGGGAGGTGGTCTCATGGTAGTAGTTGTTGTAGTCGTGGTAGTGGTTCGCAGCA
+ TACTTGGGGCAGGACGCTGAGGACTGAATGTGCTTAGTATAGCGTCGCTGACACTAAAGTTGCGAGCGTT
+ TCCTGTCTCCATTGTGGCCAAAACATCTTTACTAGAGTTTCTAACAGACGCCATCATAAAAAGATTCTTT
+ CGTGATTTTGCCGTAGTCTGGAGGAACTCCGGAAAGGCAGGAGAATTTGTGTAGCGGGGTCTGGTTGTAG
+ TCCGTAGTTGGTGATGGTGGTGCTGGCGATCTTCATGAAGCAAGTTCTCAAGGCTTTTGAACGGTGAGAC
+ AAAATGCATAGCAGGGTTGGCTGTTACTCGATTTGGACTTTCCTTGAAATAATTGGAACGGGGCAAATAA
+ CCTGCCCTTGGTAGAAAATTCTGTTCTCGGCTGGGCTGCGCCGCAGATTTTGATGCTGTAATGGCCCTGG
+ TAGTGCTGCTAGACTCAGCTACATCTTTAGAAGTTGTAGGAGGAGATGTAGTTGTAGTAACGCTAGTAGA
+ TGTGATGAAAGTTGCGACTGTTGGTCTATGAAGTGCTTGTTGAATGATGGGCCTTCCACTACGCCAAATG
+ AGAAGTGGTGGAGCGTAAGTTGTAGGTTTGATGTCGACGAACTTCTGAAATAAGTCCGCCAGTGTTGTTG
+ AGCTAGTTGTGGTTGTGCTTGTGGAAAAACTTTTCGTCTTTGCGATCATTGGCTCCACATGCAAACTAAA
+ ACCTTTTGATCCACTTTGAAGACTATATTGTAGGGGCTTACTTGGCCTGGTTGTGCTTGTGCTTTCCATT
+ TCTTCCGTTGGTGCTCGCATTCCACCCTTTGTGGGAACTTTAAAACTTTGTGGAGGTACATCAGAATCTA
+ CGTACTTCTGAAAACGTTTGGGCTCTGGTTCTGTGTTCGGTGAGCTCGACTCAAACGAGTTGTCCTTGTC
+ TCGAAAAGGAATATCCTTGTTAACAAGATTATCTGGCACTTCATTCAGCCGAATGCCACTCGGGCTTGTA
+ CCATACGCTGCGGCATTAATAAAATCTAGGAACTTTGACGATGTGGTCGTTTCAAAGGAGCGACTCTTTG
+ GCGGATCAACCGTCTGATTAATTGTATGACTCTTGTCAAAGGCACTGTCAACGTTGTCCGGGCTGCTATT
+ ACTGGAGTTGTCCTTTACCAAGGGCCTTTGCGTGGTGGTGGGCGGGGGAATTAGGGAAATAATTTGACCG
+ GAAACTTGGTCAGGAACTGATTCCAAACTTGTGGACTGGTGGGGCGAGTTTGTAAGGTTTTGAGCTTGAG
+ GGTAACCGGTAAAATTTATCCTAGGTTGACTGCTTGGCACTACTCTTGCCAACGACTTAGCAACTTGTTG
+ TAGTTTCGATTGGAGAAAAGGATTTGAACTATAAGTAAGGTGATTAGGAAAAGGTGTGGAGCTGGTCGTG
+ GTCATGTAAGATGTACTGGAAGCTTTTGTGGTTGTTTTTGACTTGTCAGGAATATGTTGTTTATATGGCT
+ TATTTGCATGCGCTTTCGAGCTGTTGAAGAGACGTGTATTGGAATAAGTAATCACATAAGTGTTAGTAAC
+ TTATTTAAATACGTATAGAGTCGCCTATTTGCCTAGCCTTTTGGTTCTCAGATTTTTTAATTAATTTTGG
+ TTTTTGGTTATCGTTTTCGGTTGGGCTGTAATCTGAGACAACTGCATTTAACGGATAGAAGCATGCTCAT
+ GCGTACCTATATTTCGAATCACCTAAACGTTATCTTATGAATAGTCATGCAATATATGTGAGTAAATAAT
+ CATATTAGAAAGATAAACAAAAACAAAATTAAGTAACAAAAGTGTCTAAACAGTCAGCATAGCTTTTGAT
+ CCCTGTCACGACGCAAAAAAGTGTGTAACTTTGCTGACGCTGTATATATCATTACATTGCTATAAGGGTG
+ TAACTGTGTGATAGCCAAAATTTTAAGCTGCAAATGGTTTGTAAATATGATATATTACAAGCTTCATGAA
+ AATCGGTTTATGACTGATCCGCGATTACGTTGAAAGGCGACTGGCAGAGATACTTTTGTTCAGATGTTTT
+ TTCAGGTAGCGATTCCAATGAATAGGTAAAATACCTTGCAAGTTTTGTTGTTGTCGTTGGAGGAAATGTG
+ GATGTGGTTGTTATTGTTGAGGACTTTGTAAACGTAACAGCATGTGTTGTGGTGTTGGAACTCCTTGCAT
+ GGCTTCCGTTATGTGGCGGCGTCGATTTCGTTTTTTGCGATCGTGTTGGTGGAGTTCCGGTGGTCTTGTC
+ GGTATGGCCCACAACATTGGCAATTAGGTCAAAGTCTTCCGTACCGGTATGGGGCCTTGACTTGACTTCG
+ GTTAGTAAACGGTCCCTCTGGTCATAGTCTTCTATCGACCCATAGCCGTAGTCGCTAGACCCGCCCTTCG
+ GAGCATAGGCTGTGGTCAGCGTTTCGTAGTATGTGAGTACTTCCGGTTGAGATGCTGGCGTTGTTAGAGT
+ GAGTGTGCTCGAGTGGCTGGCTCGGGTATCCAGTTTTTGTATGGCCACATGTTCTGCCCTGATAGATAAA
+ TGTATTGTGGTTTGGTGTATACGTATTGGCTTGGTGGTTGTGTAAAAATTTTGATGCATGTGTAGTGAGA
+ ATATGAAGTTTTACACTTGTTAGGGTTCTAACTAGTTTTGCGGGATACTTCTTATTGCAGGAACTTTTCA
+ TGCTTGCAAGGCTGACTGTTTTTCTGGGATTGAGTTTTTTCGTGGATGATCTCTTTTAAAATGCTTTTTA
+ AATTAACGAATGCCGTGGCTTCAAAGCATTTAAATGGAATTACTTACCTTTGAGGAGTACGTGTTGGATG
+ ATCGTACGCATTATCCTGTTCAATCTAAAATTATGGGTAAACATAAAATTCGTAGTATTTAAATATATAT
+ ATAGTTTGTGAAAAGAAACGGTATTTAAAAGTTACAATATGAGAAATACTAATATAGATTTTTCTGTACC
+ TGGCTATTAATATCCTCATCGTAGTCTGTATTGTACGCTGGCTGGTTTTCGTAAGAGGGGGGCTTCGGAG
+ TGGCGGGAAGCTCTAAGGGGCGGTAGGTTGGGTGGGCCTGCTGTTGGCGCACTGCCGACTGATACTGCGG
+ CGTAGGTGTTTTCTGCTGCTCCTGTGACTGTTGCTGATGGTACTCTATATCCCTATATAAATCGATATCG
+ TCGTCGTAAACCGAATAATAGGATGTGTCATATGAATGTGTTGGGGCTTGTGCCTGCTGCTGATGTTGTT
+ CTTGTGGTTGCGCTTGTTGGAATGGTGTTGGTTGTGGCTGTTGTTGTTGGTTTTGCTGCTGTGGTTGGTA
+ GCTGCCCCCATGATTAAATGTAGATGCATTGTAGTAGTTACGATTGGGCTCTGACTGTTGCGGCGGGGCT
+ GCTGACGTGGGCTGTACAAATATATTAGCGGGTTGCGGTGTCCCTAGCGATGACGGTGAAGGCGACTCAA
+ CTCTGTTCAAGTTGTTGTTTTTGTTGTTGATGGTTTGTGAGAGTAGAGTTGTCGAATAAATAGCAAAAAT
+ TATATACATTGCCAAAAATTCAAAAAATGTTATAGGGTACATTAATGAGAGACATGTGGTTTTTATAAAT
+ AGGAAAGATAAAAGTAAAATAAGATTTTAAGAAAATTTCTACAAATTTTACAAAATAATAAGTACAAAAG
+ ATGGATGAAAAGATTGAAGCGATTAGCACAAGAAATTAGCTGGGGTTAGCGTTAAAATTATGGTTATAGT
+ TAAAGGAGCCCAGTCCAGAACATTTGTTTAGTCAACTGTACAGCTTGATAATTTCGTTACGTGAATTGCT
+ TAGTAGTGGGTCTTATCGTATACGTATAAACGGTGTTGCCGCCGAGTTGGGCGGAGCGGTGTAGAATATA
+ TGGTATATTTACATAGAGGAGCACTTGGTTTCTGTATTCACTAAATTCTTGTGTATCTGTGTAGCGGCAT
+ TATAGAATTCAACAATCAGAGATTTGTCTCGGCTCATATAGCTACCTGTGTCTTTCTGGACTTGAGCCGG
+ CATGTATTGAGTTTAGAGGAATGCCGCCCGGGTTGCTCTGCTTGCTTGAGTTTAAGACAACGGTATTGCT
+ TTCGGTATGATTATTTATTTCCTTTTGTTCTTGGACTGGTGACGTCGTATTCCATTTTTGTTGTCCTCGT
+ ATGCGTGGTCGGATAGTTGTATAACGCACTCGAGTTGACTGCTGTTCTGTACTGGAGGCGATAGGCCTTG
+ GATGGGAGGTTGGGCGCACACTGCGTGGAGTTGTGAGTATTTTGGTACTGGATTGTGGGGCGTTGGATTC
+ CGGGAGCTTGGGCAGCCGTTGCTTTAGTTCTTGGAAAATGTCACTAGGAAAGCTTATAAATGAGGGCACG
+ TCGGCCTCAGCAGCTGCTTGCTTCTCCTGGGTGAAGTTGGGAAACGGACGTCGGGTTGTTGTTGCCTCCA
+ GAAACCCCGTCTGGAAATTGGCTGGACCTTTCCCTGGCGACTCAGTATTGGGTCTTACTGTAGCCAAATG
+ TCGGCGGGGAGGGGCCATGGTCTCGGAGACTGGCATATAAGGAGGCATTTGAGACGGAGGCAATATGTCA
+ TCATCCTCTTCGTAATCCTCGTCATAATAGTCGACACTCTTGATGGTCGTGGTGGTTGGCATTCGTATTA
+ AAGTGGTTGATGTGTTGTAGACGGTACTTTGGCTAGAGTTCCGCGAGTTGAGTTGATTCTGTATGCCCTT
+ AATAAAATGTTCGTAGCCTTTCAGAATCCTCATTGTAGTCGGAGTGCTCTGCGTGGGGAGTGTCGGCTCA
+ GGTCTTATGCGTTTTTTGTACGCTGGTGTGTTCGGCGTGATGTCTACCTGGGGGGTCGTAGCTGTGCTGT
+ TCAAGGTGCTGGTACTCCCAGTTACGGGGCGACGATTAACCAGCGGATTGGGTAAATTTTTATTTCCGTT
+ ATCGTCAGTACTAAGATCTTTCAAATATTTGATCAACGGATTAACAGCCGGGTTGACACTGGCCAAATCG
+ CTTTCCTTAAGATTGGCCATGAACTCGTTGATGTTAAACTGAAAGTTTGTCAGTTTTGACTTAGGCGTTG
+ TAGTAAGCATATCCGCCAGCAGTGTTGCTGATGTGCTGACTGATTTAGTGAAAGTTTGGTAGGATTCTGG
+ AATGGTGCTGTTGATGGCGTAGCTAATGCCTTCGGGAAATAGAGCAAATGGGGCTTGCTGCAGACGATTA
+ GGTATTCTGTAGGTCAAATTTGGGGCAGAGACCACGTTAATACTCTGAGTCACATGCAGCGGCGTGACTG
+ GGGGCCGAACTTTAACTGCAGAATGATCAATCTGGTTTGGCGGAGCTGTGCTAAACACACCCTTCATCTT
+ CTGGTTAGCAACAATGTTGTACTGAAAGTAGTTGCTTTCCGTCGTGCTGTCATGTCCGTTAGAGGCAATA
+ CTATACTGGGATATCAACTTGCCGGGATAGTTGGGATTAAAGGAGGCTTGACCCGGTTTTTGGTTGTTGT
+ AGAATCCGCCCATTGTGCTGTATTGACCATTTGATGTAACCTGTTGTGAGAGCTTGGACGGGTCTACTGG
+ GGAGTAGTAAGTGGTGCTAATTGTGGGTACGGGTGTGACTGCTTGATTGGGTACCGGACTTATTGGCTGA
+ TTGTCCAGACGGAAGTACGCAAAGTTATCACTCTGGTGCTTGCGCTGTTCTTTTAGCTCCTTCAACTGTT
+ GTATCAGATAAGGGAGCAGGTCGCCAGCGTTAGAATGGTGCTGTTTGCTGTTGGGCGAACGAGGACTAGT
+ TTGAGCTGCACCGGCAGCTTCGTAGTAGCTACCTGCTATGGGACGAAAGTCATCCTCCAGCGGCGGGGGA
+ GGCAACGAAAGATTGTAGCCGGTGTAAGCCAATTTGTGCTTTTTCTGAGAGAATGGCCCAGCAGAAGCCA
+ ATTGTTGTTGCTGATGCACGTATGAGTGGTAGCCGGGTAGATGATTATAGTTAGGGTTGCCGTATGGCTG
+ TTGATTGTGGACAGGATTAGTATTGGGTGGTGTGAGGTATGGATTATAATTTCCAAAGCTGTATCCCGCT
+ TGCTGAGAAACCTGTGGAAGAGGGGGTGCGTCAATGGCGCGGTAGTTTTGTCCCGGCCACTTCAGTGATG
+ TATGTGAAATAGGTCGTAGCTGGCGTGGTCGTCTCTTCGACTCACCCGTGGCCACATCATCCTCGTCTTC
+ ATATCCTTCCATCAACTGGCTGTCTTCGCCAGGAATTTCTTTGTAGTCGAATTCCATTGCGTTCTCGCTC
+ TTTAGCTGACGTATTTTGGAAGAGTATTTACACATCCTACCAATTGCCGGCGCACCATCGTTTAAGCGTT
+ CTTGAGAACTGTATGAAATATTTGAAGTCTCAGTAGAAACAGAAAGCGCGGTAGGGCTAGTGCGCTCAAA
+ CACTACGCTTGAACAATTTGAGTCGTTGCGATTTTTTTCTTCTGAAACTTTCGTCGGCTGGGCACTAAGG
+ TCGCGGCGTTTGCGTCGCCTACTTTCATCAAGTCGGTTGTAGGACAGTTCGTGAGTATGGTCGTCCTGCA
+ GGCTTTCGCTGTTCGTGTACAGTGTTTTTTCCAAAAGCGTAAAGGTTGTCCGGGTTTAAGTCGGAGTGTA
+ GATGTGTCGGTGTCGGGTGGTGCAAAAAGATAGCGCAGTATGCGTTGTATGAGAGAAAAGAGCATGTAAC
+ ATAATGAGTTGCTTGGAATTTTGCTGGCATCAAAAAGTAGTGTCATCGATTAGAAAGCAACGATTGTGAG
+ ATCTGAGCTACTTGTGGCAGGAATAACAGCTTACCTATAGGCGGTTCCAAAAGCGTAAGATCCGATTTTT
+ CCAGTTTGAGGAATAGAATTAATACTAGCTTGGTGAATAATACCATCGCGATCGCGTTGAACTTGACTAA
+ CGGTACTGGGTTGGCCTCGATACACTCTCTGCTGACGGTCGGACTCCTCTTCTTCCACAGGCGGCAATGA
+ TTCCTGCGCATCAGCATACAGCTAAATTACATAAAATATTTACATTTTATTTCGGTTTTAAAAGTTCATT
+ TGTGTGAAAATTTTAAAATTAGAAATCACTAGATGGAAAGCTTACGTACCTACCAGGAAAGTGTGTGAAG
+ TCGACTACTATGTACTATATATACACGAAGAAACAAAAATCTGCTGTTCGATATTAAGGAGTAATACAAA
+ AATCGAAGGGTATCGTAAAAACTAACGAGAATGCATACCAACACTTAATAGTTTACGAGAAAAAGCGGCG
+ AAAGCGTAATATTTGAAATATTGAAATTGTGGTTATGGGTCTGTAAAAAGAGCGCATCGATTGACACCTG
+ AATCATATAATTATTCAAAAGATATTGTTCTAATTTTGATTTTTTTTTAAACATTCCCTCGCAAACATCG
+ ATTTTTTTTTGTTTTTTAATTTAATCACTGCAAGGGTATATAAACCTCGACTTGCTTAGTTCTTATATTA
+ TTTTTTTTTCAATTATATTATATGAATTCGGAGAATTGAAAGAATGATCCCCCAAAATAAATCCTCAGTT
+ TGTCTTCGAATTCATGTTCTTTTGAGTTACCTTTGCAATGTCCTCCTGGGAGTCGATCAGCGGTTTTGGT
+ TGACCACGCGACGTGATTACCGGGTTTGGTGACACTCGCAGCTCCGGTGGGGGAGGAGGTATATTCTGCA
+ CCTGCGCCTGTATTACCTGTGGTGGAGAACGATGGTACTGTGGCGGCACTGTGGCCGTCTTCTGTGTGCC
+ ACCCTGACTGCTGAAAGCGGCTCCAAAACGTACTCGGCTTGGCACGTGCTGTGCATGGGGTTCTCTTTGC
+ CTCTGGACCTGGCTTTGTGCAAGGTTGCGCTCGGAGGATGTGTCCGCCAACTCGCAGCCGACGTTTCGCG
+ GCCAGTCGCAGGTCTGCAGGTCGTGCGAGTACATCAAGCCGCCAGTGCAACTTTCAAGCAGCGCTCCTCC
+ AAAGACGCACACGTAGTATTGGGTGCAATCCGATGGGTGCGGATAGTATCCGAACTCCTCAGGGCAGTCG
+ AAGCTAGGGCCATTGGAAGTGTCGGTCTTGATGTTGGTCCCGAAGCTGCGGGAGCTGGTTACGCGCGAGG
+ TTCGTTTGTTTTGTGCCTCTGTGGGTGCTAGAAAAAAGATTGTATTTAAATGAGTGTTTGGTTTTTTGGG
+ AACACATTTTGGAATCACGAGAATCACGCAGGAATATAATGTCAATTGTTCACGTATTTTGACGATGTGG
+ AAAAATACAAGTTATTCCTTGTGTAAGAGTCCATGTTACTTTTTCCCTTTTCACGTAATCATACAAAATA
+ TGACATTAAAGTACATATGACCAATGGCTTTTTTTGGTTGATGGTGTTATTTCCTCAGTCGTTGTAAAAG
+ GCCTCTTACTTAGCTCAAGAATTTGGTACATTAAGTAGGTAAAACAAATTTATAGCGATGAAATAAATGG
+ ATCCTAAGGGACACAATATATGATTTTTGCGAGATAGTGTCAAGGCTTCAAGTAGGCATTTAGCTTTATT
+ TACAATTGAGTTACCACGCTCCAAAAAGTCATCAAGTATGCATCTCCCTCTAGACCTCTGCTCTGATGTG
+ AATACTTGCTACAGTCTGCTATATTGACGAATCCAATGATATATTAACATAAATATGTACGTTGGAGGTA
+ GATATAAAAATCCAATCACGTGCCAATGGTTACTGACCATGCAAGAGAGCTAGACCTGCCAACAGCATTT
+ GCTATTGTGCTCGTGGCGCTGTCGCTACCAATGCTAAGCAATCAGACAGTCTGCTCCACTGAACAATACC
+ ACTTTGTACGCTTCGTATTGTACTTCGAAGCCAGATCAAAAGCTATATCTTGAATCGAAGCAAGGCATGA
+ AAGCTCTGTTGTAACGCAGCTCGCAGTAATTCGAACACAATCTTGACTGGTTTTGCTTGGCATTTGTTGC
+ TTGTGTTCGCTTAATATTTATTACTTTATTGGTGTATCTAGGACTAATAATAGTCCTAATAATAACTTTG
+ TACTGGAAACTCTTACCTTCAGGTAATGGAGAAAGATAGCTCATGTGATCACAGTTTTCTCTTTACCGTA
+ CCGCGCACCGAGCAAGAAAGACAGAATCAAAAGCCTGACAATTCCGACCATTGTTCGGCTTACTCTTTTT
+ GTATGCTATGCTATATGCATATATACACGCGAACAACAAGCCATATACGTGGTTTGAAGATGAACTTGAC
+ TTTTATGTCAGTCGGAAGCAACACTTAAACATGGTACTAATGGCTCTTTCCCAAAGTACCGGCTCAAAAA
+ ACAAATTTAGATGAATAATAATTTTGCATATGATTGTTGCTTTGGAAATGCTGAGCTTTAAAAACCAATG
+ AAGCTCTCCATTATTTGTTTGTTAAAGAAATAAAAGCCAACTCTGCATGCTTCTATGTTTTTGTCCAGAA
+ AATACACAACCTTACATCGCGCGATAGCTTTCGTAGGTTTTACTTTTTCGTGCTCAAGGCGATAGTATAT
+ GTAAAACACAATTTTTTTTAATATTATACTGGGTGATGATACCCGGTGCGACTTAGATGTGTCACTGCTG
+ CCTGGCCCAAAATAGTACGAGAAATAAGATGGCTTGAAAAAGCGGCATTTCAACATCGCCTCTAAAGCCA
+ TTAAATTGGTAACCGCCAATAGCATGGCCAAATTTAGACAAATGGCGCAAATCATTGCACTAATTGCCAC
+ CTCGTTTGGCAGCGTCAAATGGATCTTATTTATGCCATCCTCAATGAGCTGTTAGTCAACACTGCAGTTG
+ GTAAAAGAGGTAGTTAGGTCAAATAACATTAAGCCTTTAAATAAATCTGTTCAATTACGTTACGTGGATA
+ AAGTTGGAAGTCTTTTCAATATTTATTTTATTTCTTTCACTTCTAATTACTTATAAGTTGGTTAATAATA
+ TTAGTTTAGGTCAAGATGAATGTTGAAACTTTAATAACGGTCTTTGTTATATTCAGTTATATAGTCAGGG
+ CCTGCTTGAGTGCCTTAATAAAATTTCCCTTTTTCGTGTTACGCGTTTGAACTTTTAATTACACGTAGCT
+ TGTTGTTAAAGACTTCCATTTCACTGGGTCCGGTTCAAAATTAAACGCGCGCCGAGCACACCCGCCAGAT
+ AAAAATATAAATTACTCAGTGCAAAAGCGATCAATTCAATTGCTTGTTGCATTCCGACATTACTTTGATA
+ ATTAAACATAACCCATATGACCACAAACACAATATTTTCCTTTGCAGGCATACGTCAATGTTAGTCCGTA
+ CTGATCAGCATTTTATTATTGTGTTTCCGGTATATAAATATCATTCATGCTTTTTCTTCTCGGGTCAAAC
+ ACATAAACCCAAACAAAAAGATATGGGTTCTCAAATGTAAAGAAATCATTTCGTGTTGTCAAAATAAACC
+ AATTTTGACTTTACATTGCAGTAAAATCTCTGATATAGGAGGCTTCAGTTGTCTTAGATAGTAAGAAATA
+ AAAGTGAATAGCAGCAGTGTGCCTAAAGAGAAACAAAACAGGAAATATCCACCTCTTTCTCTTGCCCCAT
+ GCCTCTTCTCCCGGGTACTTTTATTTTCGTAGCTGTGGGCAACATTCAAATACTAAGCGAAGCTCCGGCA
+ TGAAGTGCTTATGGACTGTTATGCAACTAGCCAATGGGCTTATGTTTCCACTCATACTCGAACAATCGAA
+ AATATACTTTCTACTGTATCTCAACAGTGGCTTAGTTTACCTCCCAACAATTTTTTGGGGGAGAATGCTT
+ CAGTTTTCAGTAAAAAGCTGTGTCGGCGGTTTTACGTATATACTACAAGCATAGCTAAGTTTATTTGTTT
+ CGAAGTGAAGAGAGAGCGGCCCGGTAGTAGGACACTTGTGTGGATAATTTGAATTATTGTCTACGTATTA
+ GAAACTGTCATTGTGAGTCTAGTTTTACCGCCTGACTTTGCCTATTGGTATTCAGTTAACTGCTTTAACT
+ AAGATAAGGAGAATTTAATCGCTTATTATACCTGCGGGTTCTAACCGCTTCTAAAAGAATGAATGCCGAA
+ AAGGGTGAGAATTCGCAACATACTGTGTTTTGGGCTGTTTTTTTTATAGACTTAGTCATATGCAACGGCC
+ ACCTGTACCATGTCAGAAAGCAGACACGAAAAAAAAAGACTTTGCTGGCACGCAGCATATTTGCAGTTGA
+ GTGCAACAAGCCGTCCAGTATGTGCACTCGTTATGACTGGCAATATGACTCTTGTGGCACACGTTATTAT
+ CAACTGGGCAACTTTTTAAAATGGTAATTGGCAGCTAACTTTCAAAATTTTTTCGATATATAGTGTAGTC
+ GTAAGAGCTTTCCGTTTTCCTCTAGACTGCTCTAAACTTCAGGTGTGTAAGATGGCTAATCGAACCAATG
+ GCTGTTCTAAGGATTCCAAAATTATTTCTGGCCATAGTTTGCATTTGAGTTGCCCGAAAGTGAATGCTGG
+ CCAAGCATTGGCGACAAAGACCTCAAGTAAACGGACCGAAAGTGGGTCAGACAGAGAATGTTGCATAACC
+ ATCAAATACACAACTCGCTGGTGAACGAGACATTCGTGCTTGCTCCACTGTGTGTGTAAGTATCTGAGAT
+ CTTTTTGCTAGAGGCCGTAGCTAGACCGACTGCAACGACAGCGACAACGCTACATTGTGGTACTAGCCTC
+ ACCACGCCCTCTTTAAATTTGATCACTTTCGCTTCGTGTAACTGCAACTACGATTTATGTGCTATGCAAT
+ GTCCGTCGTTCATGTGTCGCATTAGCAATAAGGCTACCATATCTTGTGTGCTCTACACTAGCTAGCCAAC
+ AACAATCCATACTGGAGACGGAACGGAGACTTCAAAATAAGTTTCCGAGCAGTGACTGTATCGAATCTAT
+ GTAGAGCACGGATTGGGTGCTACCCCAGACGGCAAAGCTGGAATTGCACCATAAATTGGAAACCGATTTT
+ GATGTTGTAAAACGCTTCGAGGGCGAAAAACTGCTACTGCATGGTAGTCGCATTAAGTGCTACATAACGG
+ CAGTGTAAAAAGTCTTAAATAATTATAAATTGGGTAATTCCACTAAAATCCGATTCGCAACTCCATTTGA
+ ATGATGACTATCTTGTTCCCCACAAGAAGCTAACCTCAACTCAGAACCCGTGCCTGTAAAGAGGTCATGG
+ CCTATTCAATGCATTCAGCAAAAAAAAGGAAGCTAAAATTATAAAAGGGTTACAACAAATTGAAAGTCGA
+ GTAACCATAAATTTTTGGCGAAACATCCAACCGAAAAGTAGTCAACACTGAAGAAGATTTACATCCTTTT
+ AAATTTATGTACATATATTTATACCTATGCGGCGTTGTTATGGCATTTGCAGTGCAGCGCTGCCGGTATA
+ TGAATGCATGCTCCAGCGGATAACGGTTCGTTTAACTTCTTCGCAGGTCAAGGTACCAAGTAGATATGTA
+ CATATGTATGTATGTATATCAGATTGGCTCAAAAACAGTGTTTATTGAGCAGCAACCAATTTACGACTGG
+ CATAGAGTCATACGGTCATAAGACCGTTGTGGCAATAACCATTTTCCTTTCTCTTTTAATTTAAATTAAT
+ TTGATAAGCACCAGGGCAACAGTAGACTGCAACAATGACCAGATCGGCCTGAACCACTAATCCAAGCCAC
+ AGACAGGTCGTTTACAGCGAAAATACTCGATGATGCCGGAAATATGTGCATAGTGTTGCCAGGCAGTCGT
+ CTAGTTTTTACATTGCTTGCTTAGTATTTACAAAAGTACCAGCAGTCAAATATTTTTATTAATATATCTA
+ CATATTAAATTTGACATTTTTGTAGATCGATTTGTCGCATCGATTATTTTTTTTTATTTTATTCTTTTTA
+ TTTTATTCTCAAGAACAACATCATATTGCTGAATCTGGTAAATTAGTTCTTATTATATTCTGAATTAGTT
+ AACACCTTGGTAATGCTTAACAGTCTGAACCTTGGCGAGCTTCTTGAACCCAAGGCAATCAGTTCAGTTT
+ CAACTTTTCAGATGGGACTTCGATTTCCGCTTATTGTTTCACACTTCCGCTTTTCACAAACAATTGAAAA
+ AAAAACCTTTATAGCTTATATGCATTTTTAGCTTTCAAACAATTGAAATGAGAGGATGATGCCAAATTTT
+ ACATTGCTCCAGCTGCCTTTGTGGGCTGCGCTCTTATTGTCACAGTGGCATTGGTGTGATGGTTCAAGCT
+ ACCAATGGCTTTCCGGTAGCCGAGATGCACTGAAAGTGAATAATTCCTCCTAATACATTTTTAAGCGCCA
+ TTACTTATTTGTAATTCAGTGCACCCGGAAAACACCAACTGCAGACACTCATAATATGGACATCGTCGTC
+ TGGACATTAAAATCGTCCGCATTAAACAAAATAAGTATGTTGAATTTCACAAACACAATACCTAATTGAA
+ TTCCGAGCGTATTTACTAGGGCAGAAGGCTGTTAAGAATTAGCCAGTATGTGTTAACCGTAAAATAAGAT
+ ATGAATATTGGGCTGTCGTAAAGCACATGTATTCTACTGCGATCCAATGGGATATATTTTCGCCAGGAAT
+ GTTGGTGGGTATCTTTTTGCAACCGTTAGCAATAATCTTTCTGAATGATAATACAGTTTGTTATTAACAT
+ TCCTGGACCGCAGTTCCCGGGTTTAAGTAATCGGGTAGAAATGAATTACAATATCAAATTCGCACGGTCG
+ CATACTCGGTCCGCAGCATACAGTTTGTACCTGGGAACTCCCCGTCTTTGGTCTAGGGCGTATATAGCAG
+ GCGCATTGTTTAGCAGCGGTGTTACTGATGGAAAACTCCATTTGCTTGTTTGAGAAATAAAATGGTTTGT
+ ATGCATTCAAAATTTAAATAAAAATGAACGCTATACGAACACGAAGTCCATCGTTGTGGCAAACAAACTT
+ AGTCAACAAATTATAGCAACAAAACCCAAGGATAGCATTTGCAATGATAGTATTCCTAAGCTGGTGACTT
+ GGGATTACAATCTAAAAGTGAACGTCGTGTCGGCTTATGTGTTGGTCTGGTCGAAAAAATTTTTTGGGTG
+ TGTCACAAAAGCTACAAAATTGTTGGGCTCAGTACAAAAGAACATAAGAAACCTTTAAACTTGTGCACTA
+ ACAACATATCGAAATTCGGATAACTTCAATGATTTGTAGCATTTAGATAATTTTGCATCGCCATAACTTT
+ TAAGTTACATTCTGTATTGCGATACATTTAAAACTATTTGTCTAGAACGTAAAGCCACAATTACATTACT
+ ACATCAGTGCTTAAAAGTCGGACCAGAAACTAATTCAGGGTCACTTAACGCCCTGGCGTGTCTGCCAGCT
+ GCTGCGGTCTATAAATGGCAGCTTCGCGACTGCTTGTTGCGCAAGAGAACTTAACAACCAACCGCCTATG
+ TGCAGCTTATGAATAAAAAGCTATAGCCATTATGGTTTCCATGTAGACCTGCGTCGGCGTCTGGTCTAGG
+ CTTAGCCAAACAAAACAATGAAAATGCGGCTTTTATAGACAACGCAAACAATTATAATAGCAAAAATGAA
+ CTATGTCCAATGGTGTATTGCTTATAAAATCAAATGGAGCTGAAAATAATTGAGTTCAGAAGATTGAAAA
+ AAAAAGAATTACATTATTTTTAGTATTTCTTTATTTATAAATCTGTCTTCTACTATTGTGATTAAAAAAA
+ AAAACTTAGAGGGAATATAGATTTTAATCCGATAACCGATTTACCTATGTATATCCGCTGTCAGTCCATC
+ CATTTCTACGCAAAGTGCGCTCTCAGTCTTAAAGATTTCCGCATAAAACTTTCTTTATATTGCAGGTAGC
+ TTATTAGTCGGAAAATAAGGTTCAATATTAGAAATCATAAATTCTTTTATTCGACAAATACCAGTTCCGT
+ TTATAGCAACCGTAAAACCTACAACTTTAATTGTATTTCTTCATGATTTTGCCAAATTTGCTGAGTCGAG
+ ACATAGCTATAATCTATTTTTTGCGTGGCTGTGGTGCAGCCAGTTCTAGCTCAACGTGTATGCTCCGATG
+ CTAAGTGAGAAGCTTGAGGGTGTGCCCGCTCTACCAAACTTAATATAACTGGCTTGTTGTTTACAATTAA
+ TGTGAACCAATTAAAACCAGGTCCGCACAATGTCGTTAAAATAGTTCACAGCCAGCTGCAGCTGCATTGG
+ AGTTTATAAGCAAGACAAAAGACCTGCGCAACATCTTGTCTAAATGCCATTTTTTGCTCACCTTTGCTAC
+ GCACCCTTGCTAGTTAATATGTGTATGTGTTTAATTTGGTAAACGGAAACATATCCACCATTCAGGTCGT
+ GATTATAAAGTTCTGGTTTCATGTTTTCTTTGATTGTTCGTGATTCTATCTATGTTTGGGTAGCTGGAAG
+ CAATACTTGGTTCTTTTTTGTGACGAAACGATGTGAAGGTTAGGTCTTCATTTAACAGCTAAATATGGTA
+ ATGAGTAAAGCACTTGTCTCAGCTTGCGCAGAGCTTGTGCAGCAGCTTATGCCAGGGAGTCTGAACTGTC
+ TCCATGTACTATAATTAAATTTATAAGTCCGACCAGTTAAGAGAAACCAAAAGAGAATTAAAGACGTGCC
+ ACGGATCTTCACATTGGTGATGTCATCAAAATGTGTTTGTGTTGTTATGTGTTTCGGCAACCTCCCGACA
+ GAGTCGCCACCTTGTCCTCTCTGTAGTTGAACTTGAACCGATGCTCCAAGCTTGGATGGTAAAAGAAATC
+ AGTAAAAGCTGCATCAATAGCAACAAATATGCACGAAAAACGAACACATATTGAAAAGCATTCGCATGGG
+ AGATGAGCAATCGAGTGGACGTGTTCACAGAAGTCGCGGATAAAACAAAAACGTAATTGTGATCCATCAC
+ AAACATTTGCGCAGATCGTGTGCTTATCTCACAAACAAAATCTATTTTTAGTCACTGCATAACGGTGACG
+ GCTTCGGTTCGCGAAACTTATCAGCAACTAGCAATTTCTAAGCTGTGTTGTTTTTGCCCCTCGCCCTGCG
+ CGCTGCGCAAGCGGGAGGTTGTTACAATTTACCTTACAAGTAAACCGGTAAATCTTATCGTGTTTAGTAA
+ ATATCAATTGCATTATACGGCATAAGTATAAAGACAATTGATATAATGGAGAATTCATTTGCTCAATCGC
+ GACCTAGCAATGGGTGCGATAAATTTGAGAAAATGAGGAAAGTAGCAGGTGTTGAGCCAGGAGAATTACG
+ CTCCCAACTCCGCGCCAGCTGTGCAGTTGTTTCCCCTAACCTGGAAGGTATGCCAACTCAATCTACGGTC
+ TCCAGCTTAATGGTGACAATCAGCAGCAACACCAATGCAAGTGTTACCTGCACTATTTCTAACGTACAGG
+ CCAACATGATCTGTACTCCTACATACACTGATTGCACAACCGTGACCACTAGCATTTGCCCAACTACGCC
+ TTATGACAATGGACTGCCGACACCTCTGTCATCACTGCCCAATAAGCCATCTAAAGCGAAATGCCCCTTT
+ CAAGCACATGATCGTACTGTCAACAGGAAACGAAAAGGCGTGTCTCAGCCCCCATTACCTATCCTCACCC
+ CTTCTCCAAGCCGTAAAACTAAAAGGCAGGCCACTATGCCACTCAATGAGGAGGCCTCTACCTCCACTGC
+ AGCAGCATTAAATAACAATCGCTTCGCGCTTTTGTCTGCTGAAACGGAGAATATGGAGCAAGACGTGTCG
+ GATGCTGATTCTGACATTGAAGACTCTGCTGCCCGAGATGGTGGTGGACAATCCGCTAAATATAGCAAAC
+ CCCCAGCCATATGCGTACCAAGTGTAAGTGATCCGGTCACCTTGGAACGGGCTCTTAATCTGAGTATTGG
+ CTCCTCAAACTACTACATCCGCACCTCTAGATTTGGTGTATCCAGAATCTATACAGCCAACCCTGATGCT
+ TTCCGCACCGCTGTAAAAGAACTAAATAAGTTAAATTGTCAATTCTGGCATCACCAACTTAAAGAAGAAA
+ AACCCTACAGAGTAGTGCTTAAAGGAATCCATGCTAATGTTCCTAGTTCGCAGATAGAACAAGCATTTAG
+ TGATCACGGCTATGAGGTCCTTAATATCTATTGCCCCAGAAAGTCTGACTGGAAGAACATTCAGGTAAAC
+ GAAGATGATAATGAAGCTACAAAAAACTTCAAAACTAGACAAAATTTGTTTTATATTAATCTTAAACAAG
+ GCCCGAATGTTAAAGAGTCTCTTAAGATAACTCGACTTGGCAGATACAGAGTCACTGTTGAGCGCGCTAC
+ ACGTAGAAAAGAACTGCTACAATGTCAAAGATGCCAAATTTTTGGACACTCTAAGAACTATTGCGCCCAG
+ GATCCTATTTGTGGTAAATGTAGTGGTCCCCATATGACCGGGTCCGCTTTGTGCATAAGTGACGTATGTC
+ TGTGTATAAATTGTGGTGGTGATCATGTCTCGACAGACAAAAGCTGCCCTGTCAGAGCAGAGAAAGCCAA
+ GAAGCTAAAACCAAGGTCCAGGCTACCGATGACTAATAATATTGCCACACTCAAACCTCCACAACGTTCT
+ TCAAGCGGTTACATACCAGCTGAGGCATTAAGAACCAACATCTCTTATGCTGATATTGCTCGACGCAACA
+ CGACTCAATCTAGGGCTCGTGCTACTGTGCAGGCTGAAGTTATACCAACGTCGGACAATAGCCTTAACAA
+ TAAATTTATGACGTTAGACAACTCCATTCGGGCCATCAATACGAGAATGGACGAACTATTTAAGCTTATA
+ CACGAAACTGTAGAGGCTAATAAAGCTTTCAGAGAACTGGTTCAGGTTCTAATTACACGTATTCCTAAAT
+ GACTCAACCAACCTTAAAAATCGGATTGTGGAACGCTCGCGGATTAACAAGGGGCTCTGAGGAGCTTCGG
+ ATATTCCTCAGCGATCACGATATAGACGTAATGCTTACCACGGAAACACACATGCGAGTTGGTCAGCGCA
+ TCTATCTCCCAGGGTATCTTATGTATCACGCCCACCACCCCAGTGGTACCAGTAGAGGTGGCTCTGCAGT
+ CATCATAAAATCTAGACTTTGTCACAGCCCTCTGACACCTATCTCTACTAATGACAGGCAGATAGCGAGA
+ GTGCACCTGCAAACATCGGTTGGGACCGTCACTGTAGCTGCTGTTTATCTACCTCCAGCAGAAAGATGGA
+ TAGTAGATGACTTCAAATCCATGTTTGCTGCGTTAGGCAACAAATTTATTGCTGGTGGTGATTACAATGC
+ CAAACATGCATGGTGGGGGAACCCAAGATCCTGTCCTAGAGGTAAAATGTTGCAAGAAGTCATTGCACAT
+ GGGCAATACCAAGTTCTGGCTACGGGCGAACCCACTTTCTACTCTTACAACCCTTTGTTAACACCATCAG
+ CCCTTGATTTTTTTATAACCTGTGGGTACGGCATGGGCAGGCTAGATGTACAAACTCTCCAGGAACTCTC
+ GTCGGACCATCTTCCTATTCTGGCTGTATTGCACGCTACGCCGTTAAAGAAACCACAACGCGTACGACTA
+ CTTGCCCATAATGCTGACATAAACATATTCAAAACCCATCTTGAACAGCTGAGTGAGGTAAATATGCAAA
+ TTCTGGAGGCGGTGGACATTGATAATGCCACAAGCCTTTTCATGAGCAAACTAAGTGAGGCTGCTCAGCT
+ TGCTGCACCGAGAAATCGGCATGAAGTAGAGGCCTCCAGACCACTTCAACTTCCTCCCAGTATATTGGCA
+ CTGCTCAGGCTAAAACGAAGAGTTCGAAAAGAATATGCTAGAACAGGTGATCCCCGCATGCAACAGATCC
+ ACAGTAGACTGGCCAACTGCCTGCATAAGGCCCTTGCTCGAAGAAAGCAGGCCCAAATAGATACCTTCTT
+ GGATAACTTGGGTGCTGACGCGAGCACAAATTACTCACTGTGGCGTATCACGAAACGGTTCAAAGCTCAG
+ CCCACCCCAAAATCAGCAATCAAAAATCCGTCTGGTGGCTGGTGTCGCACTAGCTTGGAAAAAACTGAAG
+ TGTTCGCTAACAACCTTGAGCAACGTTTTACACCCTATAACTATGCACCGGAAAGTCTCTGTCGTCAGGT
+ TGAAGAATACTTGGAATCGCCCTTTCAAATGAGCCTGCCTCCGAGTGCTGTCACACTGGAAGAAGTGAAG
+ AATTTAATAGCCAAGCTGCCACTTAAGAAAGCTCCTGGAGAAGATCTTCTTGATAATAGAACCATTAGAC
+ TTCTCCCAGATCAAGCATTGCAGTTCCTTGCCTTAATATTCAACAGCGTTCTTGATGTTGGCTACTTTCC
+ GAAAGCTTGGAAATCGGCGAGCATAATTATGATCCATAAGACTGGAAAAACACCGACAGACGTTGACTCG
+ TACAGGCCCATCAGCTTACTCCCATCTCTGGGTAAAATTATGGAGAGGCTGATCCTAAACAGGCTGCTCA
+ CATGCAAGGATGTTACCAAAGCGATTCCCAAATTTCAGTTTGGCTTCCGGTTGCAGCACGGTACTCCTGA
+ GCAACTACATAGAGTAGTGAACTTTGCTCTGGAAGCTATGGAAAACAAGGAGTATGCAGTAGGTGCCTTT
+ CTTGATATTCAACAGGCATTTGACAGAGTCTGGCACCCTGGGCTCCTGTACAAAGCGAAGAGGCTGTTCC
+ CGCCGCAGCTATATTTGGTTGTTAAAAGTTTCCTGGAAGAACGCACATTCCACGTCTCTGTTGATGGGTA
+ CAAATCATCAATCAAGCCAATTGCAGCTGGAGTTCCTCAAGGAAGCGTTCTTGGCCCAACCCTATACTCA
+ GTTTTTGCTTCGGACATGCCTACTCACACACCAGTCACAGAGGTAGACGAAGAAGATGTGCTCATAGCCA
+ CCTACGCTGACGATACTGCTGTGCTCACGAAAAGTAAAAGTATCCTGGCTGCCACTTCTGGTCTACAGGA
+ ATACCTGGATGCATTCCAGCAATGGGCTGAGAACTGGAATGTGCGCATCAACGCCGAGAAGTGTGCCAAT
+ GTGACGTTCGCCAACCGAACAGGTAGCTGTCCGGGTGTCAGTCTGAATGGGAGACTGATCAGACACCATC
+ AGGCTTATAAATACCTTGGTATTACCCTCGATAGGAAGCTCACCTTCAGCAGGCACATCACAAGTATTCA
+ GCAAGCGTTCAGGACCAAGGTTGCTCGGATGTCTTGGCTCATTGCACCACGCAACAAACTGTCGCTTGGC
+ TGCAAGGTCAATATTTACAAGTCCATATTGGCCCCCTGCCTGTTCTACGGCCTGCAGGTATACGGCATTG
+ CTGCGAAGAGTCACCTTAATAAGATCCGGATCTTACAGGCGAAGACCTTAAGAAGAATTTCGGGGGCTCC
+ TTGGTATATGAGAACAAGAGACATCGAACGCGACCTCAAGGTGCCCAAATTAGGAGACAAGCTCCAGAAC
+ ATCGCCCAAAAATATATGGAAAGGCTTAATGTACACCCCAACAGCCTAGCAAGGAAGCTAGGAACTGCAG
+ CTGTGGTCAATGCTGACCCTCGGACTAGAGTCAAAAGAAGACTCAAGCGACACCACCCTCATGACCTCCC
+ TAACCTGGTTTTGACCTAGAAAGTCTTAGTTTTAAAATTCATTAGAATAATCAAATAAATAATAATTACT
+ ATGTTATATCAACTATTATAATTCTCCCTATCATTTTTAGGATTAAAAATCTGTTAGTCTTAAGTAACCA
+ AGACACATTGTAAAATAAAATAATTTAAGCAGATCAAATTAAGTTGCCGCATGGGTAACAGTGCGTTGAT
+ CAAATAATAAAAACATCATCATATAATTTGATAGAAAAAAAAAAAAAAAAAAAAAAAAAATATTGAAAAG
+ CGAAAACAGGAGAAGCAATAAAGTGGCATTTTAACAGCATCTGGTGAATGGTTAGCGATGGTACTGTTAC
+ GAGGTATTAAATAGTAGTGGCCATGACACTGAGGAGGAATGTATCATTTGCTTAACTGCCAGAAACGCTT
+ TTAGAAGTTGCAGTTAAACAATATATATTGTTATTTTTATTTGTTTATAGGAAGCCTACTTGGATAAGAC
+ ACGAAAACCCTAATAGCCTAAAAATTCAATATAAGTGTTCCGATGTTTATATTTACTGCGTGTTGTGAGA
+ CAGTTGAGTCTGCGTTTGTTCGATTTTTGGCTGTTTGACTTAATTAACTGGTTTTAATGTCTAATTGGCA
+ ATATAAACAGTGAAGGCAACGATTATAAGCAAGAATCCAATACGTAAATGAAAATAAAAGAAACAAAATT
+ AAAATGAACCCCGAAAATATGGAGGAAATTACAAATGAATTTTAAGAGTTACAGGCATAAAATATATCAA
+ CAAATATTTAAGCTTACCGAACGCAGATAATAGTTGTAAGTCTGAGTCTGGGGCTTATAATTACGTATAG
+ GCTCCTCTCCTGATCGTTAAGACAAATGTTCCTCAGATGACGCATGTTTTCAGCAAGCGTTTACTTTGCT
+ TCATTTGTACACATCACCTGCCGCCTCTATTGGGAATTTTTGATGATCCGACATCAGTTCTTCTAGTTAT
+ CGTATTCTTAAATTATGGGATATTTCTATCCGGTTTTCTCGATTGATTCGATCCACCAGCTTAAAAACTT
+ AAACTCTCGATAAATTATGCGTATTTAATATTCGGTTTCTGTGTGTTTTTCGTTATGATCAGGTAAAAAA
+ AATGTAAGGCTTATTCGTTTTCATTAGTCACTAAAAAATGAGCAGGCACAACCTCCTGGGGTAGCAAATA
+ GGCTTGTAAACAGAAAATAGACTACATGAATAAAAATTCTTATAAAATGCAGCTTCAAATGTAGCCCACA
+ TCAGCCCAAACATCTCCTTGTTAGTTATTAAGTATAGAAAAAGTATATAAATTGGTTATCGGTGTCACAT
+ AAATAAATTATGCCTGTCGAGTTTACTGTAGAGCACCAGGACATAACGCTGTCATTTCAGACCCCAAAGA
+ AATATTGCTCGTATGCAATCAGACCAAAAACATCTCATAAAATACAAGGCAGGGCCGTACGCAACACATA
+ GTTTCCAATCCGCATCGCCTGTCGTGCATGGAAAAAAAATAGCTGGGAATGAAGTACATTGTTAGCAAGT
+ CCTACGCGCTGTCGCTTCGCTATTTATGCGATGCCTTTGGGCAAGGCTATAATAAATGTATGGCATTTTC
+ GTGTAAGTAACAATTGAGACATTGCTATGCACTGGCAGCCGGATGATCGCCTTACATTTCTGATAGATTC
+ TATAAACAAACTAATACATATTTAAAATTTAATTTTTATTATTTACCTATTGCTCGTAGAGTATAAGAAG
+ AAACTTGGGGATCTTGATTATCGCGTTCTCTCTTGTTCTTATTTATTAAATATTAAAATGATTATACAGA
+ AATATAATTTTTTATCCGGCCTATATTTTATAAACTCATATGGATTAGTATTTAAAAAGACTACAGTTTT
+ CCCACGCTAAATGGGGCTTACTGGACCACACCCTAAGCAACTGAGAGTGCAGCAACTCATAGGTGACGGC
+ AGCGTGACCATGCAAATTAGCCATTCGTGGCTTAAATGTCAACTTTTTATAAAACAATTGGAGCGGCCAC
+ TAGTAAGACAAGTGAAGCTAATTTAATTATTCCCTTAAGAATAAGGATTTGTGTTTGTATCGATTTCCCA
+ GCTACTGTGTGAATGGTAAATTGTGTTGCTCATAGAAAATATAATAATATAATATAATATAATATAATAT
+ ATAATAATATAATAATATAATTTATCTTTTGCTATTTTTAGTAAAAAATACTCCATCAAAACTGCACTGG
+ TCTGAGCTTTGTCCCTACTGCTGTACTAACCCACCCATAGTTAAATTTTACTAGAAATCAAATAACAAAC
+ TTTTCCAAATAACGTCATCAAACTATCAAATTTATATAAAACCTGTTCCTTTTTTTAAGAGGCTGCTAAG
+ TGACAATAAAAAATGTAATTGGTAGTGTGGCGAGTTCGCCAAAAGCAGTGCATTGAGCCGTGGTACCCGA
+ AAGTAAAATTGGTTAAAGAGACAAAATCAACACAAATAGTAAATACCTAGCATTATACCTTTATACCCTT
+ ACAATTATTCACATAATGCGCGGACGAATTAAAATGCACTGTTCTTATGGTATTCGAATACCCGACGGCA
+ GCCTGCTAAGTATTACGTTTAAAACCAAGCACTTAATGATGCTCTAACGAAACAGATGAGTGCGATTATG
+ CAATCACAGGGCACCGCTAATCGATAGGCTCACATAATCGTACCGTGCCGGCCAACATTTTGTCACTATG
+ AGGCCGACAACCGTTATTAAAGCGAGCTCACTAATACGTATTGGAGTCATATTGGGTTTGGTGAAAGTGA
+ AAGGTGAACAGCATACCATTTTGCGGTGCCGTAAAATATATTATAAATGAAAAAGTTGCGTATCCGAGTG
+ CTTAACAGAGGAGAGCAGCTGACCTGCTGCAGTTTGCCCTTGAGAGCCTTTAGCGTCAATTCCACTTAAA
+ TTTACCAAGCAGTGGTCTACGAAACAAACACAAAACACAACAACAAAAACGGAATCCCAACGGCAATCTC
+ GTCAAGGTCGATGCATTCAACATCTGCAAAATCCAGTTTATACCCACAAAGGAGACGAAAAAGCCTCGAC
+ TGACATAAGCAAACCGTGTGCCGGACCATCGATTGCCAAGCAAAACAATCACAATTAACTTCTGTAAAAA
+ AAAGAGCGAGCTAAGGAAATATTTGTGTTAGAAAATCCTTCAAGTATCAGTAAAATCTTCAATCTTAATA
+ AAAATTATATGGACATTGGAAGCTAGCTTCGACAAGCCGAATCATCTAAACCCTTCGAATAATCGAATAA
+ GAAAAATGTTATGATCAAAAAGGTTTATGCAGCAAATAGCATTAAAACTGTGAGATCAGTTTGCGTAGAA
+ ATAGACGAACGGACACGGCTATATAGAGCCGGCCGTTGATACTGCTCAATTAATGTGGTCGTAGATATAG
+ GATAGAAAGGCTATACAAAATAAAAGTTTACAGCGGCTTTTTGCCGTAAAAGAAAGTTACTTTGCCGTAA
+ CAAGATTGGTGTAAGAGGGTTAAGTGGAGCAGCTGCGTCGGGCCCCATTTAATTTCACGATACGGTGCAT
+ AGAGACGTCAAGAGCTCTATTTACATGTGCTACGGATATGGACGTCGTCGGCTTAACGCAATGTTTTAAT
+ AGATTGCCCATTTCGTAGCAAAAATAATTTTCAACTGTAATGCGTAAGCATTTCAAGGTGAGTAGCGCCG
+ TAAACAACAAGCTTGTAAGGGCAGGCGCAGAAGCTAAGAAAAGTTGGGTGTTGCCGTTTGGTAGTCTATT
+ GGTACTCCTCGTACTGTGCCGACAACAATTTCGACGTCCAATTCAACGCAAATTATCTGGAGCCTTGCGA
+ AATCCAGGGATTACCATTGCTGTGTGCAAATTTATTCAAGCTTGCCTCAGACTCGCTGGAATACTGCTTG
+ AAAGCGAAAGTGCACTGTGTGCATGCAAAACAAAGTTGCGCCATGCCAATGGTCGTACATGCTCGTATAA
+ AGTGTTCAGGTTACAGTCAAAGACCTAGCGAAGTAATTTAATGACGATCTTCCGCGTGCGCCAAAACTTT
+ CGCACGGTAAGCATTGACACTGCCTGCGGTAAAAAAGAGACGAAATGATTAGGTCGAGGCGTGACCACCA
+ TACTAATGGTTTAACTGGCATTGAAACTGAATTATGATTAAAACCCCTTTGTTATACTATTCATTAAACA
+ CGCGCTTAAACAAATGTTCTTGCAAATGTTCAACTTTCGCCATTGGCCTCGTCCGCCTCAAACCTTTTTC
+ TTTCAGCCATCGACATTCGCATTAAACCAGTAGTACATCAAATGTTTTAACACAAATTTCCTAGCAATTA
+ CGCATGAAAATATTTCCATGGCGGCATATCTAAGGTTTTACCCAAATATATATTTCTGTGGCTTAAAAAA
+ ACACCACTCAAAACACTGAGAAAGTTCATCAAAATGGAAAGTGTTGCCACTATGCCTAAACCAAGTCATG
+ CAAGTCTTCATACCCTTGCGGAGGGTACATTCACTTAAGTCAGAAATTTCAAAGCTGTGAAGGACACAAT
+ TGTGCCCATATATGGTATATATATTTCTTGCTAAGTATCAACGACCGAATCGGTATAGCAGATAGATTAT
+ AAATTGTTTAAAAGAGGACGATCGGACAGCCGGGCTTGGCTATTTCAAGTTCGCTGTTTTTACTAATATG
+ TTATGAATAAGATACATATATGCACTTTATAAGGCCACAAAGGTAATACAAAAAATCTATCTCAAAACAA
+ TTTAGCCGTCTAATGCTGTTATTATAATTTTAATAGTGTTAATCCTTACCACGTTATCTAAGCAATTTTC
+ GTAGTTCCCAATTTGTTTTCTCAAATTTTGCATATATATCATTCATAAAAAATGTCTGAACAATTAAGCA
+ AACTGTTTTAAAAATTATCAACAGTTATTATAGCCACAATTTGCTCGGTTACACCGATACACTCACTCAC
+ TTAGTGAACCTATTCAATCGAGTCAGCGAGCTGTATGCAATTAATATCTGTGTCATAAGCTGCTTGGTTG
+ GCTGCTGGCTGATAACTTACATAATTCCATTACCATTACCCAGCAGTATGGTGAGTAGACAGCCCAAGTG
+ ACCAATAGTTGGACACGGTAAGGCTTGTTATGGTCGAAATGCTTGATTATGTTATTGTTCGCTGGTAAAT
+ AGAGCAGTTGATCAGACCATGTATTTACCTCCATACATACCCTAATGTAAATACTCTTACTTTTTATATA
+ TCCTAACACATTTCGCAGTAAAATGTCTTAATATATATATATATATATATATATTAAAATAAATATACAT
+ TTTTGGACATATTAAGAAACTCGTTTAGCCGGAGCCGGAGTATCCACAATAGAGCTCAACACAAGTGGTT
+ AACAGCTGGTGGTTTGACTTCTTCTACGGTGATTGAATTTGACATTAGACTATTGCGAGCTCGTACATGG
+ CAGCCGGAACAGTGTTCAAAACAAGTTTGGCTTTATTTGCGGAACATAATATTTCTATCACGAAGTTTCG
+ AATATGATTGAGGAAAAGAAGAATCCATAGTACTGTAAAAACAATTCACTTAAAAATAAAACTTTTTCGG
+ ATCTACGTTTAAAAAAAGATTTCAGTTCATACATGAACTGAATACTTATCCATGGTTGTCTTAAAATCTG
+ GTTAAGTGCTAACTCTTCTAGGACTAGTGGGTAAAGTGTGTAAGCCCTTTGCTCTTTTAAGTTTTTGCCT
+ CCATTTGTATTTCTAGCAGAGTGTTCTTCACTGAAGTGGGCATTACTCACCTGTTTTAAAAAGCAGTAGG
+ CACAATCCCAGCAGGCACAGAATGTTTATTCGACTTGTTGAATACTTCATATTGCAGGTATGGCGTGTCG
+ TCGTAACTGTAACTGTAAATTTTCTTGATGTGGTTGGTTCAGTTTCGTTTTGGGGTTAGTTCACAGAATT
+ TAAAATACCATAGGCAAGCTCGGATAAAAATAGTGGTTGGAAGCGCGGGAAGTGGGGAGCAGCAGCAGCC
+ ACCGTACCGATGACGGAGGCAGTTACCGTTGAGAAAACCTCTGTTTTGTTGAAAACAATTGCTAAATAAC
+ TAAGAAGGCAGTGTCGCAATTTTTCAATTTAGATTTTTTGAGCCTTGTGTTACAGTTTTCTTAATGGTGT
+ GTCTGGCTTATGCCGCGACTGCGGCTTTGTGGCTGTGCCTTCACTTGGTTAGGACATGTTTGTATTGTTG
+ TAAGCAGATTTAGTTTCTGCCCCTATTATTCGAGCTTTCGTTTGGCTTTAACCAACGCGACGATGCATAG
+ CTAACACACACGTTTACAGATTACAACACTTAGTTTTCCTCCATTGCTTTTGGCAAGCGATTTTTAGTTA
+ GGTTTTTTAGTTTCTTTCACGTGAGACTGCAATGACCGCTGTTCGTTTTGTAGTTACCATGGAAAAGATT
+ GCTAGACAAAAATGCAAAGAGATCAAATCGAAGATCGGTGTTTGATTTAGATTTCCCGTACGGTATCGCG
+ GGCACCTCCATATTGGAAAACTCTGTATGAACTAGTCTGTAGCGCGTAGAGGAAAATGCGAAACAAAATA
+ AAACAAAACCTGCACGTTTTTATTTTGTTTGTCGAAGCTTGTATATATATTTAGCGTAAACTTTCTTTTT
+ AACGCAAAGTTAGCTTACCACCGACACACACGCTTGAGCTCTTCGACTAAACTGCAAAATGCAGTTAAAA
+ CTGCTTTCTACAAAATGTTAAATTTTTGGCTGGTTGCAATGTCCAGTCAGAGGTGGACTTTATTTCGACG
+ CGTTTACGAAATAAATTAGCAATCGAAAGCCCAAAAATTGATTGTGGCTTATTGCAAACAGTTTAGACCG
+ CCTGACAAGTTCGGGTGACCCTCGAGCGTCTCTGCTTACCGTGCGCTTAAGCGAACCACACGTCCTAATC
+ GAAACAACTATACAGCGCGACTGTGCGGACGAGTGTCTTGAGACTCTGGGCAAGCGCAGCCAGCCAACCA
+ AGTTTCGAAGTCTGGCTTTTGGGCCAAGCTTGGTCTGCGCCACGCTTGGCCCCGACTGTTACTTTACATT
+ AACAGACTGTTCAAGTTGTTGCTGCACCCGCGCGGAGTCGTTTGTATCTCTTAAGCTTTTGAAAGTAAGA
+ GTAAAGTTAACGCTTGCGCCATTGCAGCTTTGCTACGTTTTACAAGTTATACAAGTTATCAGAAAAATGT
+ AGTCCAGACCCATATTCTTAGTGAATTTCAACATTTTACTGAGAATTTCATCCAAAGCTCCCCATCAGTT
+ TCAAGCTATCTACAAGCGGGGAGCGGGCTTTGTTTATTGTTTTCTGAAACTACAACAATATCCACCCTCT
+ AGCCAACGAAGGCTGGGAAACTATTTACCAAGGCGATTGTGAAATGTTGTTACCTTTTTCGTTACATTTT
+ CGTTTAGCAGCAGGTTTCTGGATCGCTCGATAGTGGATTACGGTGCTTAAATTAAAGAATGCTTACTACT
+ TCAACATGGGCTTGGACTTGAATCCATGTCAAGCATGGGATCGAAGGAAGACCACTCAATCACTTTTAGA
+ ATTAATACCACCCAGCTGAATTGCCCTTGATAAATTCGATTTATATGCCCAACATATAGCTTTACTCTAA
+ AGTCTAAAGTAAAGTGGCCAATTTCGAACCATAGAATTGAAAGTAAAACCGAGTTGAAAACATGGCAACG
+ ACCAAGAACTAGGCCAAAGCAGCCAACCAAAGCCAAGCAAAAGCTGTAAAACAACAGCTGAAGTAAAGGG
+ GTTCTGGTGAACGGCGATGGCTGATGGTTTGAGCAAGGCATGCGAATTAATCTAATTCTTTATTTATTAA
+ TTTATTTTTGCTGGATTGTGTTTCACACGATTTTTTCTGTGAATGGAGGGCGAGGTGTTTTGTTGCATTG
+ AATATTTTTGACTTTGTTTAGGAAATTATTTAATTATTTCCGTTACTATATTAAAAAGTGTGTAACGAAG
+ TGTATCTTGAACTAAACGTTTCGGACCATATAAAATATACAAATACTTTATCAAGACCATTGGCAGAGTC
+ GATCAGGCTTGTCCGTCCGTATTAACGTCGAGTTCTCAGGAACTATTAAAGCTAGAAGGTTGAGATTCAG
+ CATACATATTCTAGTGACATGGACGCAGCGCAAGTTTGTTGTCCCATGTTGCCACACCCACTGTAACGAC
+ CTCAAGCAACCCGAAACTGCTACGCCCACATTTTTGAAAAATTGTTGCATATTTTTTTGTATATTTTCAT
+ CAGTCTTGTAAATTTATATTCATTTGCCAAATCCATTTTTTCCACGCCCACTCTTACGCCCACAGACCGC
+ CCATAGCTATCGTTATACTAAGAACACTTTGGCGGCGTTCCTTCTAATGCCCACAAACCCCCAAAAGCTG
+ CCACGCGCACACTTTTAAAAAGTTTTTGAGATTTTTTTTTATTTTATTATAACCCTTGTAAATTTCTATC
+ GGTATACCAAGAACACTTTGGCCACGTTTGGTAAAACAGGCGATTTGGCAAACTCATTAATGAACCGTAA
+ TAACTCCGTTTCCTGAAACAAATATTTCTTCTGTTATGTATATGAAACCTGTCAAAATATGGTCAATAGT
+ TAGCACGCATTAAGATATCGCAAGTTGATTCAGACAGAAAAAGCTCAACGGAAAATGATTGTCAAATTGT
+ TGGCCCTCAAAACTCGCCTATAATGTTTTCGATAAAGTGGTTACCCGACAAGTAAACCCGCACTTTGCTT
+ ACACATGCAATTCGAATCGGTCAGAGCCTTCAGTTTATGGTATACTTGAAATATTGGAGCATTGTGCTTA
+ ACTCTTGAATAATAAATGGAAGACAAAAATACAATAGTTCCGTTAATTGAAAAAGTCATTGCCGTTAAAC
+ ACTTAATTAAATCATATAGTTTTACGAAATGTTGAAGCATTAAATTTAATCAATGAAGTGAGTGACAAAT
+ CAAAAATGTCAAAAATTGTAGTGAGAGAAAAATTGTAAACACTGTGGATACATCATAGTTAATAGTATTA
+ TTTTCAAACGCAGCTCTCTTGGTGACTTCTGGTGTATGGCAATCTTTGTCTTAGGTGTTTGGGACATGCC
+ ATACTACATTAATGCCCTTGTTAATACAATTCCACATCGGCTACTTGTGGTCAAATTTATTTCAGCCTCT
+ AACTCAATGATAAGCAAATTTCGTTCGATTGTCATGAAATTCCTTCGCGCACAAACTTTTTTGTGCCTTA
+ AGCCAAGCATTTTGAAAGTATTTTGACTTTAATGGGTCCACTTTTGGACAGCGCATGCAGTTGCCTTTCT
+ AATGACAATAAATAAAATTAATTATGTTTCAGTTATAACAAAAATGGACAAGTATGCAGTCACACCTACG
+ AATCAAAATAGTTGGATAAACTTTTATCAACGATTTGTTAAGCTAAACGCCAAATATATTTTGTCTTTAC
+ TTTAATATCATATCAGACATTGAACAAATATCAATAAGAGTCAATGCTTTTAGTTAGGAATTGAAAAAAC
+ TATATACAGAATTTTCAGATTGTTAAATAGTTTAACATAACTTCTTATTTTATTTTCTTGCTCTTTCGTC
+ TTTAGAAACAACACTAGAAGTCTTTCTCATTGCAAACAAAAGTACAAGTAATAGCGTGGTGACCTTCCCG
+ TTCACCAACGTTTGGGGTAGGAACTGAAGAGAAGGGGAGTGGCCTTTAAGCAATCTAATTGTACAAATCA
+ AGCGCAGCGCAAATGGTGGCGAATAGAACAGCCGTCAAGCTGCTATTACCGGAACCACTGGCCACGCCTT
+ AGTTGGAAGCAAGTCGTAGTTATAGTTAGCAGCGGAGACTTACCTAACTAATCTGTTACATACATTTTAA
+ GAAACATACTTTTCGCAGGTTTTTAAATCTCCCAACAACAGACCCTAAGAACGTGATATGTTTTGGTGTT
+ GATACTCGTTTAATGATTGATTATTTTTCTATTGCTAATTGATTTAAGGGAAATAGTTGCAAAAAGTCAT
+ GAGATATTCGATACCTATTTAAAATTGAGTTTGAGTTAGTTTTCAAAGCAGCCGATTTGTACGAAGCCGG
+ TTTTGTGGCTTTATTAATAATATTGTCACACTTGTAGCTCAAAGTTAAGAAACAGCGAATAGCATTGTAA
+ GTTGAATAAACCGGATTTGAAACTGTAGCAGTACTTCACAACACCTTGCAGCCGCAGCGGTGCTACCTTT
+ ATAATTTCAGCAAGCAAAAGCTTATTACCCCAAGGCCGTTTTGTCAACGGGAAACTAGCAGACCTCTTAT
+ TGCCTAAGCTTGGGAGGATTGAGTTTTGCCGAGGCAGTTGCAATGCGGAAGAGATGTGTATAACTGGTAC
+ TTGGCAGAACATCCTTCAATATGCAGTGGCACTTACTTCCTCCTATAGGCAAGGTCTCGAATAAATATCG
+ TTACATGGCTCCGTTACCCTCTCCTGTACGTACAGTGGTCCAACCAGTTCAAGATCGTGAACTACCTAAA
+ CTTGATGGGTTGTTTTGAAGCATGGGCAGAAGAAAGTCATCCGGGTTAAGGGTGCCTCTGGCCAATTTGA
+ TTTGCTTTCCAAATACACACAATACGAATGCTGCCTTGACTACCAATGTATTACAAAAGCGTGTAGTCGG
+ TTATATCGACTATCTGCATCTGCATTAGCCGAGCAAGCTGTTTATTACACCGCAGTCAACTCTGCCCACC
+ TACGATTAAATTTTTGCTCTGCATTCTGAAAACCATATGTTGAACTTTGTTTCATTTGGTACTGAGTAAT
+ ACATTTAAGACATTTGAAATCAATCTCAATTGGTTTTTTTAACCTGTATCTTTATGATCGAGATGTCAAA
+ AATTCGATTAGTATTCTTTGTCTCTTGTCGGGACGCTGTGCGTTTCACTACATTTAACGTTGAAACTGAT
+ GTATGTATGTAACATTTTCCGAACCTTACCCGGGTCAATAAGAATGCAACCAGACCCACCAGTCCAATAC
+ GTTGGTGTGCAATATTTGTAGCGAATTTGTGAAAATAACGACAGCCCTTGCAAAAGTCAGTAAACGATCC
+ ACAACATACCTTGGAAAGCCAGATTAGACCAACAGGCATCAAAAGCTGATGGCTCGCTTACTGATTTTTA
+ ATCGGGCCAGACACAAACATGAATTGTTCTCGTGCTGGGTATAATTTTTTTGTGGACAAAAATAAGGTAC
+ TCAGAAATACAAGTTTAACATTGTAATATTATTTTATTTATTTTTTAAATAGCCAACAGGCTGTTTACCT
+ GGTTATTAAGTGAAATACCAACATTTCGCGTTTTTTAAAACAGAAAGGAGTGCCATCCTCCGCCCCACCC
+ AATCAGCCCCATTTGGGGGCCAATTTAAATATTTGTGATCCTATCAAAAAGCGAGCAATTGTTTTGAGCT
+ AATTTTTAAATTGATGATGCATTATAACAATCCAAAATTGACTTACTAAAGGTGCGGCCCCTCTTGGGCC
+ ATTCCTTTTTCAAATTTAATCAAAATTTCAAGCGGAGCGTTGGCAGCTACCGGCCAATGCAAATTTTTTG
+ CACAATGCTAAATGTATCTGCACCCAACATTCAGGTCTAGCATTCAATGGACTACAGAGTTGTTTCACTC
+ ATCGAGTTGTTGGGAGTTCAGCGCTCGGCTCTACAAGTAGAAGGCTAAAAGTCAAAATGTACATGCTATG
+ ACTTCACGCAGACCATGCTAACGTTTTTTTTTTTTTTGCTGTATGAACCAATTGTTGGTTATAAAGAATG
+ AAGTCAATCAGCAAAGAGGCCAAGAAAATATTTTTAGTAAAAGAAGGTATTTGAGAAGGCATAATATGAC
+ TTTAAAAAGTAAACAAAGTAAATCTTCCCTCTAAAAGTAAAGTAAAATCCCCCCTCCCTCTCCGTATTAC
+ TGTTACGGATTCTTAACAAGAAGTATTTTTTCTTGAACTATTAAAAGGTGACTGATGACTCAAGCTATTT
+ TGTATGGAGTAAGTCCTAACATACTCAAATTTCGGATTTGTTTGATTACTACTGTTCAAAATGCACTACG
+ TGCTAAGGTGGCGAGGCACTACTGGCTACTTTGTTCGCGCAGTAAATTGTCGCTATCCAACAAGCTGACA
+ ATTTACAAACAGATATTAGCACCAAACTGGAAGTATGGGTGCCAAATCTGGGTCTTGGCATGCGACAGCC
+ AAATAAAAAGGATCCAGGCTATTCAAAATAAGGTAGCAAGACTCATCACCGGCTGCGAGTGGTTTGTGCG
+ AAACACCACCCTGCACAGAGACCTGAAACTCGCAACGGTATTTGACGAGATAAACCAGCACTCGAGCAGG
+ TACCATGACAGGCTGGAGCGCCACAGAAATCGGCTGGCCAGCGCTCTTAACAGATCTCGCCCACCAAGGA
+ GGCTCAACAGAAGGCAACCGAGGGATCTCATTTCCCGATCTCCTTTGACAAGGGTCAGCAGAAGCTGACG
+ CTTATCAAAAAACCTATTTATTATATGTGTTTGTTATGTACTGTATTATAACTGTATAAACTAGAAAAAG
+ CTAACTATAGTTAGCCGGCGCGCCCAAATGGGCAGAAATAATAGAAAAGAAGGACACAAAGGGGCTCCAA
+ GATTTCCCCGTATGCCTTAAAAAATAAATTTAATTATAAGAAAAAAAAATGCACTGAATCTGTCAGCCTA
+ AAAGTATGCTTCATTTTCGCCCAAACTACATTTTCTATATGTATAAAAAAAATACATATTATATACATAA
+ ATATAAGACTAAAAAGGCCCCACCGACAGGACCTATTATTTAGAACGCTGTTGTAACAACTATCTTGATT
+ GTTAATATAGGAACATGACAAATATTTACCCTTGTAAATATGTAAAAATTCGTTAACGTTGAATCAATAC
+ AATAGTATTATTAATTTCCCTCCTCAAATATATAATTGTTTAAGATGCCTGAAGGTAGCAGTACAATAAT
+ TTAACTACGTGTATCCAAACTTAAAATAATATGTAAAATACATAAATTGGTAAATAACAAGAAAAAAATG
+ TTGCCGATCAAATGCGCTCGTAAATTTTAAAATACCTGATGAGATGTAATTCGGGCAATTTGTACACATT
+ CGTTGCACACCATTTTGCATTGATGTCTATCTGCCAACGATAATAAAAAATACATTAAAAATGTACGTTA
+ AGCAAGCTTTCACACAACGGAAAGGTGTTTAGGTAAGAATTGGGTACCAGGGCGCACATATCCTTGATTT
+ TTTTCATCTAAGGATAAGAAGAAATGATATAATCTGGCCCGTCCCGACTTATAAACTACCTAAGACTTTT
+ GAAAAACTTTCGTGCAGATCTGTATGCAGCTTTAAACTGAGGGACTGACGACGGACGGCGATGAACACTG
+ AGTTTGATACTGATCAAGAATATATGTATGTATATACTTTAATGTCTCCCACACTGCGCATCAAGGTTTT
+ TACTGGAATCAATATACTCTCTGCAAGGGTATATTCCTATACACTTAAATGACTTAAATGTACAATTGTA
+ TGTACATATTTATGTTAATGTAAATAGTCGTGTGGCTGCTTCATGAAATAAATGCGATAGTTCGGAGTAT
+ TTTCCAAACCTTTTGCATACCTTTTGGCGAACGGATGCATTTAAGCCCAAGGAATATTCATATTCGTACA
+ TATGTATGTCTATAGGAAAGCAATTTGTATAAATGTGCTAAAAGCATTGCACAGCCATATTAACGTATTT
+ ATTAATGTTGATTTTAGAGTAAAAGTTACCCCAAGATATTGATTCTTATGTATAGATTTAAAATAACAAA
+ TCATCACCCATATTTCTGACTGTTGTTATTTAAGATATGTGTAAATATGTACACACATATATAAATGCAT
+ ATATAAACATGACTAGGAACTCGCCTAAAAATCCAAATTCTGCACACTTTAGGCTTGAAGAAAATTCAAA
+ AAGTTTGCCTACTTATTTGTTTTACGTCAAAATGAAGAGACTGTGTTTTCCAAGTCCAGTACGTCCACAT
+ CGCACTTATTGCTAATACGAAAGCTTGATTTTAAATTTTTTCTTATGCCCACATTTTGGCGTAAATGCAC
+ GAATACATAGACATAGTGAATCACAAAATCTCAGGAAAATAGCTAAAATGGCAAAAGAAAGATCAGAAGC
+ ATAAGCTCTAAGGCACGCAAACAGAGAACAACCAACACTATCAAAATGAATGACAACTAGTTTTAGTTCA
+ AGGAGAGCGCTTCATGCGAGGAATCAACGTAAATAAAGGCACCAACAGTTGATAAGTGAGCGAGTCGTCT
+ TTTACTTTACGAGCGGCAAATTAATACATAATATGTATGCACGTATGTATTTTAATAAGGGAAGTAATAG
+ CTTTTGAATATGCAATCGCCTTCAACGGTATTTAGATACACCTTAAATACCCGGTCGCAAGAAAAAACTG
+ GTGGAAAGAAAAACCAGCCGACTACATTTACGCCATTGAGGCCACATGGATAGAGCGGAAAACTGGCTGT
+ GCGCCATGAAACAGACGGACACCAAGCCCGCACACATATACACCAGCGCTCGAAAAATAGAAACAAAAGT
+ CGTGTAAGTGTTTAATACAAGCAACAGTCAGGGAGCACGCACACCATCACCGGCGGTGCAAACAACGTAG
+ GAGAGGCGAGAGCAAAGAAAGAGTACTGTAAGCCATCAGCGCGAAACTGTGTGTGTACGGAAATGCATTA
+ GTATGTGTGAGTGGTGAGTGTAATGGCAAACGGCAGCAACATTTATTTCGCTCAGTTTTATTTCGTTTTT
+ TCGTCGCAACGCAAGTGCTGGTGAAATCGTTGTGGCAGAAGTCTATTTTAAGTGAATAAATCTTTTATTG
+ TGCTCATGTTCGTAATTCCAAAACGTTCGTCGAGACTAAAAGACTTCTGCAAAGCTTTCGAGAAAAGAAT
+ AAATGGAAAAATACTATTTTCCACAAAAACATAGCATAGCAATTGTGAACAGCGTAAAACGAGGAAAGCA
+ AAGATCTGCTTCTGTTTCTCACTCTCTCGGACTTGCGCTCTCCGCTTTCAATGATCAATACATTTACAGT
+ TTGTTATTATTTGTTTTTCATTTTGCCTTTTGTTTTGCACGCTCTCAGTAACCGCGCGACGACTTTCTCA
+ AATTGCAAGTGTAAAAAATTCATGAAAACGAAGTAGTGGGCAAGGCGAACTGCATTGCAAATGGTAGTGT
+ GTGTGTCTAAATTTGGTGTTAACAAGAGTAAGCCTATTACACCGAACCCCTGGGATTTTTAAAAAATTTT
+ TCTGCATTTTGTCATCAGCATGTTGGGCTTGACGCTTTGAGATAGGAAATAAAAGGCGCATTCAAATTCG
+ TAACATGGATGCTCAGTTTGAGCACTTGTGCCGCATTTGCGCTGCCAACACGAAAAGCAAGACGAATTCC
+ GTGGTTGAAAGTGTGTTTATTTTTAAAACACAGGGACTGAAGGATAAAATATCTCGACACCTTTATCTAA
+ ATGTAAGTAAATAAAAAGGAACAGCCTGTTTGGCGCTGCATCAAATTTAATCCTAGATCTGAATAAGTAT
+ CAAAACAAGACCTCCGCGTACTTGCTAAGACTCGACATTTAAAAAACGTATTTCTTTTTAGGTAGCTGAA
+ GAAGATCCTCTGCCAAAAGTGCTCTGCAAATCTTGTTACCGCCAAGTAGAGGCCACGGCGTCGCTTTCAA
+ ATATAGCAAAACATACTCAGCTCGTGTTTCGGGACTTTCTCCTTAGTACACTGGTAATCGATTATATACC
+ ACTTATATATAATCAGCAAGCTTACAACTTATTAAATCTTCCAGCCTAAGAATGCGAGGGAAGCGGCTGC
+ TGCACAACTGAGCGTTCCAGCAACCCAAATCCCACACCGACACGACGAAGTCCAAGCGGAAATCGATGAA
+ TTTCGCCCCATTTTGCTGACCCACGTGCCGGAGTCCGGAAACACCGCTTCCAAGCCCCAACCAGCCAATT
+ GCCTGGAGCTGGCCCCAAAAACCGGCGAAAACTACTTGGCTGCATCTTCCTCATCCTCTTCTCTGAGCAA
+ ACCCGCTGGATCAGTAAAGAGCTATCTTAACACTGGGAGACGCAACAGCGTTTTTACAGACACTAGGTAT
+ GGATCGGCCCCACTGTCTATCGCTCAACGAACTATGCAGTGTCTGCCTTCTTTGGTGCCCCTAAACACAG
+ AGTCATTGGGTAGCAACGCAATGAGAAAGAGCCCAGACACAAAACTATCGCCGAAAGGAGTAATAAACTT
+ CATCCAGACTCATGGGCGCATCACGGGCAATATACCTGAAGTCCAAGCAGAGGACAATACCGGAAACATC
+ AACGTGACAGATAGCAGAAACACAGTTACAGCTTCCGTTCTTATTTCTTCAAACGTTAGCAATCCAGGAA
+ CGAAATCTCAGGACAGTAATTTGTTTCTGCAGAAAAGTAGAAATCTTAAAAACACATTAAACAACATTAA
+ AGCCATGCGTACCGGACAGGTATCACTGCTTAAGGGTGCGCAAAATCGAAACCCTATTGAAGATGTTAGA
+ CCACTGGTCACAACTACACTGGTACCCCAATATGGTGGTGAACCTTCCGTGGAGGAAGCACTGCCAGAGC
+ ACATGATCTTTGCGGCGCCAAAAAAGAAAAGGGAGGATGAAGAACAATTTCTTCAAACGGCTCTGCCACA
+ GCTAAAGAAAACTGTGCCAAGTCAATCTAAGACAAAGTCCACAAAACTCGATTTAACTATATCGGTTGAT
+ TCGCATGTTTCACCCCCGTCAACGTCAATTTCTAATGTTAAAAGCCTCACTGATGCAATATTCCTGGGAA
+ GCGTTATTAGGGATCCAGACTTGTTGATGCTTATTCTCAAGGCTCTAAAATGGCCGGTGACAGCAGAAAA
+ CTGTGATGAGCAAATGTCCCGCTTAAAAAGTTCAAAGTTCGCTGTTATAATGTCAGACACAAACCTTCTT
+ CAAGACACAGATCTCACACAACTTTTAGGTCCATATTTGGCCCCAATGCTGCCTGTGGTTCAGCAACAAG
+ ATCAGCATCCACTTTCCTCAGCTATCGGGTCTGCTTCTTCAAACCATTCATCGCAGGCGACTAAAGATGT
+ ACTTAAGCTGGCTGACTTATCTAGTGCAATGCCTTATAAACTTCCACCAGAAACGTCGGTTCAATTAGTG
+ CCTTCCAGTCCCACGGAACAGGAACCGCAGCCTGTGCGTCACAAAAAGGCGGTTAGCGTGCCAACTGTCA
+ AACGCCATCAACGAAAGATGCGTGCCCTTGATTTACCTGCTGTTGACAAGACGCGCCGCATAATTTCGTT
+ ATCGACTTCAAAGGCAGCTTATGTCAGCAACGAACTGTCGAATATCAATTCTGTGCTTTTTTCGCAGTTC
+ GAATCAAATCCGGCCGACGCTATTAATGAAGCGCTTATCTCACTCCTTAAGCAGCAACAACAAGAAACAA
+ AAGACCAGCGAAAAACTCGTCAGAGTTGTATTGGCTCTGACAGTGCAGTTAATTTAGAAGACATTGTACT
+ GATCGATCCCCAACCGCCTCTTGCAGTCGATCCGCATAATGTGAAGTACCTTGAGGATGACTACGTCTCT
+ CCGCAGTCCCAGCCCGGATCCCAATACAATTTTAAAAGGCGCAAAACAGACATTCGGTCATCAGAGCCGT
+ CTGAAGTCGTTGTGCTCGATAACAGCGGATCCCCAAATGAAAAGAATTCAAAAGAAGTATTTCCAAGTAC
+ GAAACAGACTTTATCCAGAGAAACAAAGAAAAGTGCGGTAACTGTTAGAAAAGAATCTTTGGGTCAGCTA
+ AAGCAGGCACCCACAAGTACCGTCCCGGAAGACATTTGCGATCCTAAAGCCAGAGCCATTAATGCGAAAG
+ AAAATCCCGAAGTGTGTGAACCAGTCCCGGACAATGGAGGTAGTGACGATATTGATGATAGCAAAGCAGG
+ CTCGGTATCCGTTCGGAAGTCGGAAGTCAAAGCTGCGCTTGGACAAAAGCTTTTGGAGGCTATTGGACTT
+ TCTCAGTTGGGAGCCGATGCAGCGCCTGAAAACTCCCGCGACACTCTTAGAAGTGCGTTAAAGCGCTCTA
+ TAAAACAGGCCCAGGAGCAACAGCTTCAGCTGAAGCGAGGCAATCATGAAGAACCTGTGAAGCAACTTGC
+ CGATTCCACAACCAAGCTAAGTGCAGCAGAATCGGCAGATGAGCATAAAAAAGCAATTGCCGAGCGGGAG
+ CTGGCCCTGCTGAATCGTGGATTTAAAGCAGGAGAAGAAAACACGATTTCCCTAAAAGAGTGAGTTGTAG
+ ATTTATTGATACGGACTTTATTTAAAATGTTTACCGTATTTTTTAGTGATAAGTGGGAGCGAACTGATGT
+ TAGTTCTTCATCATCAAGAAACCGCCGAGGACGTAAATCAAAGATTGATTCCAACGTCGAGGATTTTGGC
+ GATGAAGAAAAAAAAGACTCTAGATGGGATGAAGACGATGACTTGCCGTTAAAGGCAGATACGGAAAAAC
+ CTTCAGAACGGAACAGCACCAACGCCCGACCGACCCGTACTAGCAAAACGTTATCAAAGTATTATAAAGG
+ ACCAACTTCTAAATCACATCATAGCATGGGTACGCGCTCGACACGACAGCGCTGAGATATGCTTTATATC
+ CTTCATATAAAATATGTGGTTTTATTTTGGAAAATATTAAATACCTATTTTACGTCCCTCTAAGATGCAC
+ ATGTAATTGTGTACAATGTATACTCCCATTTAAAAACTAGTATAGTTGTATTAACTTTATTAAAAGCAAT
+ GGCTGGAGTCTACACACGAAAATAAGTCAAGAATAGTACAACTATTTAAAGAATAACACGATTTGGTTGA
+ AAAAATTTCCTTACGTATGTAAATCGATTAATTATTCAGCGCTTAAGTTTTCTTTTGGGTTAAGTTTTGA
+ ACATATAATGTACCTTCTGGTGTATGTTAACATAAAATCCAGAATATGCCTTTAGACAGCAGAACGGAAG
+ ATATTTATTTGGTTTACAGTCTTGAATCTAAGCTGTATTTTTGTAGTTTTAATTAAACTTTTGTTTTTAA
+ TAATAACGGTACCGAAAAATAATTTTAAATAATGTAAATAAATAATGATGCTGAAAATTTAACAATTGCA
+ ACGTCTTTTCTAAACATCATCTTAATTGATAGTTCACAAACTTATTTAAGTTCAAAAGCAGAAAGAATGT
+ AAGCTTCGACAGGTCATTTCGATCATTAATAACAATTTGATATACACCACTTTTGTATATGTTTCGGTAA
+ TGATAAAATCGGTTGTGATATATCTGCTTTAGAAACAGCAGGAAAATGAATGAAAACAGCTAATAGGCAA
+ TTGCCTTAAAAACTTGCACATACGAATGTAAATATGTATGTACATATGTACATCAATCTCTTTTTACAAA
+ GCACACAGCGCGAGGTCTAATGGCTGATTCAGACAATGATAATGTGCAAAACAAAATATCAGTTTGAAAA
+ GCTTCGCGACGTGTGGCGGTTGTTGAAATCGAGCAAGTCAAAATATGTACACATGTAGGTTTATGTGAAC
+ GCCCCAGTGATTCTAAGAATGAAGAACATATACTTGTTCAATAAAATATTGTTTTTATTTAATTATTAGC
+ ATCAAACTTTTAACGTTAAAAAAGGTCTTCTTAGCGATTGGTAACATATTATTTTTCAGCTATCTAATGA
+ ACAATAGCAACGTTTTCAACTGTTCCGAGATCAATTTATTTCCATCATACAAATGACTTGCTGCTGTGGA
+ AAGCAAAAACGAAGCCAGGATGAAACCTATCAGAGGTTTAAAAATGAGGATGTAAGTTTGTCGATACTAA
+ TTGCTTTGCATCGTCAACTTTATGGTACATTAATAGCCAAAAAGAACTACCACCGCTATCGAATACGACA
+ GACAACGCCTGTACTAATACATATGAATGAAGAATATACATACTAGAAAAGTTTCTTAATGTAGATACAT
+ ATGTATAGGCGCACCTACGCATGACTAAATTTGTATGTGTAGACAAACAATGTTATCAGAATGCAAAAGC
+ TACATATCTCGGGGTTGATAAAAAGTATTGAGCTATAGGTGGCCTCGGTCAGGCCGGCATAAAATCAAAT
+ TCCAAACAGTCCGCTCACAAACCGCTGCTAAAGGCACACGTATTTTGGCTTTCAGATGCATACATACATA
+ CATGTGTATGTATATATGTATTCAGCCAAAAAAAATCTCGTACATTAAAGCGCGCTGAATTGCACCAAAA
+ GAGCGAGAGAGCGTATAAGCTCCGTGCTCAAAACCGCATTTGCATCGGGTAAAATCGGTAACCCCATCTT
+ TGCATAGTCAGTATGACGGCAATAATACTCCTGGCTTGCCACTCGGTTCGCGAACTCGTCGATCTGTCAG
+ ATGCTCTGTGGCAGAACACTTTTAATATCGAACGAAGTTTAAACTATTATCGCATCAAGCGCCGTTTGGA
+ ACTGTTTCGATTTCATTGCCGCGAGCTTTGGTTGCGTCAGGTGTCAAAAACATCCGATCCAATGCATCGG
+ AAGGCAGGCATAGATTTTGCAGCCATTGAGGCGGGTGCAGACTGTGTCCTAAATATGGATGCCTTTGACG
+ ATACGACAACGGAACTACACAAGAGGTTTTTACAGGCGGAGGGCACAAGACCCTTTCCTTCGGATTGCAT
+ CAGCGGCATCGAGGTGGTGGATGGAAATGAATTTAAAGTGCGTAATCGGGATACTATAGCGCAAATACTG
+ AGTGGTTTAGTGATAGTGCTTAAAGTGTAAACATGTGTTTGTACGCATCACGTACAAATGTTTTTCTCTT
+ TTTTCGTCTTTGTTTTGACATTTAGCGTACTCCGCAGTAATTCCCCTATTCGCGTTGTGGGGGAGCTTTT
+ AATAGCTGTTCGCACAGTCGCGGTCGGACAGGGTGGTTTCTTTAGCGCTGACACCAATTTAAAAAAACTC
+ CACACTGACGCCAATATACACAATGGCGCCACTGTTGTTTTAATTAAGTTCAGGCACTTCACTATGTAGT
+ TTAAATGAGTTGTGTATAATGGCGCCACTGCGATTTTAAAGCAGGATTGGTGTCGCCAGTGCAATGTGTT
+ TTTAAAGCTTTTGTGTATCAAAGCGATAGTTTTCCAAAAGCTGTTTATAGAACTCGTTGATCTGTCAGAT
+ GTTCTGTGGCAGAATACCTACAAAATCGAGCGAAGTTTAACTGTTTGGATTTTATTGCCGCGAGCGTCAG
+ CCCTCAAGGCATCGGAAGGCACACATTGATTTTGCAGCTATTGAGGCGAGTGTATACTGTGACCGAAATA
+ TGGATGCCTTGGACGGTACGACAATGGAACTGCACAACAGTTTTCTACAGGTGGAGAGCACAACACACTT
+ TCCTTTGGATTGCATCAGCGACATCGAGGTGGTGGATGGAAATGAATTAAAAGTGCGTAATCGGATAAAT
+ TGAGCGCAATTGCTGTGGCTTAGCGGTTGTGCTTATATACGTACATGCGTGCGTTTGTCACATCATGTAC
+ AATTGCTCTTCTCTTTTTCATCTTTGTCTTGGCTTTTAGCGTACTCCGCAGTAATTCCCCCATTCGCGTG
+ CTGGGGGAGCTCGAAACAACTGTTTGACATAGTCGTGGTCTGACAAGGTGGGTGGCTTTAGCACTTAGTC
+ AAGTCTGAACCCTAGCCACTCTTCATAATTATTTAAAGCGATAAGCTCTCAACACAAGTCAATTCAGGAG
+ CTTACTCGCCATTTATTTGCACATCTGTTAAGGGTGTATACATACATACATATATCGTCGTTTTTATATG
+ TCGAGTTCAAAGAGCTTTTGGCGTTGTCATAGCGGCGTAGCTTCAATTCTCTTCAAGCGTGTAACTCGCG
+ AAAAGGGAGACAATAATAACAGCTAAATATCTGGCAACCAAACCATTTTGTTAAATAACATTAAAATCCT
+ TTGAGCTCCTGAAGGCTGAAAAGAACGTTTTAGGGCAGAATATATTCATCAACAGCGAATTCTAAGGAAC
+ TAAAAGTATATTATTTACATGCGCAGTATTTAAGTTACAGTGACTTTTCGATTTTCAATGTGCGGTAGCG
+ AGCAAGTACGATGTTGATTCATTCCTTAATGTCTAAAAACAAATACATTTCGATAAGCGATTCATAAAGA
+ GTTCTGTGGTTAAAAAAGTACATCCCTTGAATTAGACGAATATTTAATTTTTTAGTTCTGGCTATTCAGA
+ TTTCCAAATCAGAACGTAAAATGTGTCTTAGGGTTTTGTATGAAAAAATGATGTGCTGTTGTCCCAAGCT
+ GAAAAAGGGAGGTTTGAATGAGGTAAGCAAGCATTGAACATATTGACGGAAGAATTTATAACTAAAAATG
+ TACAAAAGAGTAAAATGATAGCTTACATCTGTAAGCAACTAGTATTTTGATTGTCCTTTGGAAATGACTT
+ ATAGTCTTATCGTTTGTGCAAACGATAAACAAATTAAGTTAATCTTAAATTTTCTTTATATATGGAATGG
+ CTGACAAGGCTACTTTCCAATTTGGCTATATTTTAATCCGAACACTGCCTTTTACGATAAACCTTGAACT
+ GGAGGGGTGAAAGACTGTTTTAAGAGTAATTAAAAGTTTTTAAAAGTTCTGCTTATTAAATTCCCATTCT
+ AGGCCTCATTTTACGAATATGCAGATGCTGTGCCAAAATATTTTAACGACCAAATAGGGAAATTGAGCGA
+ AGGGATAAGTTTCACGGTGACTGGGAATCTCTCTGTAAACTGCGAGAGGTATGTTAAGTGGCCAAGTTTA
+ CGTGATTAATTTTTAAACTGTTCCTCGTCCTTTTTAGGTTTTCCATCAATCTGGTTTATAACAATGACTC
+ TCGAGATGTGGCGCTCCACATTAATCCACGGTTGCCACAAAACTATATTGTCCGCAACACCAAAGTACAG
+ GACATTTGGGGAAACGAGGAAGTGTCCTCGGCATTGCCGTTTCTACTAAGTCGAGGCGAGGAGTTTTCCA
+ TTCAAGTGCTAGTTACTGAGGCATGCTATATGATATCGGTAAACGGACAACACTTTGCAGCGTACACTCA
+ TCGAATCCCTTATAGGGATGTTCGCATTCTGGAAGTGAAGGGAGATGTAAGTAACGTGGAAATGAAGCGA
+ ACTTTGGTCTTAAAATATCCTGAGCGATTACCCCAGTCAGAGGCTAATAACATTGAGCTTCACATAGATG
+ ATGGGATTAATGAAATTGATGCCAGCGTTGAGGAGACTGTTAAAATACCTCATGAGTGGTGCATTATTAG
+ CGCCCCGAACACACAGTCGGACAGTTCGCCTAAGCGTAACAATAGTTCGAATGATCTTGGCCTTACTTTG
+ CCTTATTATGGAGCATTGCCACCAAATTCGTTGGTCGATGGTCGATGCTTGAAGATTGAAGGGAGAGTGC
+ GATTACTTCCCCACTCGTTTTATATAAACCTGCAACAGGGGCAGGACATATGGCCACATCCAGTAATTGC
+ ATTCCACTTAAACCCACGTTTTTCGAAAGCAAGCAGCGGCGCTATTGGAAAGGCGGTGGTGTGTAGGAAT
+ GCCTGGCTTAATGGAGCTTGGGCACAAGAAGAGCGTTCGGAGTTTGACACAAACTTTCGCCCTGGTCGGT
+ CTTTTTGTTTAGCCATTGTTTGTACCAAAACATCCTTTGAGGTGTATGTCAATCGGCAGTTTATGACTGA
+ TTTTAAATATAAGGTTAGCCCTGAGGTGGTGGACACTGTCTACATACAAGGAGATGTTAAACTTTGGAAT
+ GTAACGCTGGAAAAAAATCAGATGATTAAAGGCAAAAATATGCGAGTCTATCAGAATCCGTGGTTCTTTA
+ GTGAGTAGTAGCTGTTCATGTTTTTATTTTTTAGTAGTTTAGCGACAATAAAAAAGTGATACGCTCGTGT
+ TTCATTATACAATATTTTTGTTAATAAATAAAATTATGGTAACGTCATCCGATTTTTATTATTCTTCCCT
+ ACACATGTGTATTTATATAATTGAACGCATAGTCGCTATATGGGTATTTATTGAGTAAAAAATAGCTTTC
+ AATGTTTCTGGTAATGTCGTTTTCTTTTTTAATGTCAAACTCTGGGTATTTATTCAAATGTTATAAATAT
+ TTTAATCTCCCTTGTATAACAACAATTTTGAAGTTTCTTTCCCTACTACTGCCGTATAAAATGGAGAGCA
+ AGTGTATGAGCGTGTATCCTGGAGCGTGCACTGTAGCTCTAAGGCGAGTTATGGATGCGATGTCGTTGTT
+ CTATGAAAAGCGTTCAGAAGCCCATCGACGCAAACATTTTAAAGTGATCCAATGTCCAAGGCCAGGACTT
+ TGTTTCGTCTTCCACGGAATGATCCTAATGGCATGTGAGCATTTTGTTATTGATTTTCTCACCAAGCAGG
+ GAAGTGAAATATGCGAGGAGTGCGATGTCCTACTGCAAATAGGATCACGACTTCCTCAAAATTATATAAC
+ GCGTAATTCTCGTCTTAAGGGAAAATGGGGACCCGAGGAAAATTCTTCATATTTAACCTTCCAGCTGAAC
+ CGGGGAAAGTCTTTTTGGATGCAAATATTGCTTACTGAGGAGTGCTTCTTTATTTCTGTCAACGGCTATC
+ ATTTTGCGAAATATTTTCACCGTATGCCTTATCGGTGGTTGGAAGCTGTGGATGTACTCGGAGATGTCTC
+ CGACATCGTTATCGATACATACTATGTTTCCGAGTATCCTATACGCCTAACACACTCATTGCCTCGACCC
+ ATTCCACATTCAAACAAACTTCCCCGAGATGGAGAGAACGTGGAAACTGAATGGATGGTTTTATCTTCTC
+ TGGCAAAGATGTCATCTAAAAAGTTCCTCTACCAGCCGAGCCTCCCTCTTCCTTTCTATGGAAAGCTGTT
+ AAAAGAAAACTTCCTCATTGAAGGAAGTTCACTACGAATAGAAGGTCGTGTCCGATTGATGCCCCAAAGA
+ TTCAGTATAGCGTTTCAGAAAGGACAGGAAATTTGGCCGCAACCCACAGTGTCATTCTATTTCAGCCCAT
+ GTTTCTTGCGTAGTAGACATGACAAAATCGGCACGGCTATTATTACACGACGTGCCTATTTAAACGGCGA
+ TTGGGTGAACTGCACAGTGTCTCGCTTAAATACAAGTCTAAGGCCAGGAGGCGCCTTTGTCATAGTAATT
+ GCTTGCAGAGACAGCTATTACGAACTGTTTGTAAACAACAGGTCCTTGTTTCATTTTAAGTATCAAATGA
+ GGCCAGAGTGCGTCGACATTGTGAATATTCGTGGAGATATCAAGCTTTGGGAAGTAGCAATCCAAGGCAA
+ CACTACTTACAAAAAACCAAAAGGTAAAGATATTAAACTTGCCAAATTAATATTTCAACTTACAGTTCTT
+ ATTTATTAAAGTTCGATCTGCTATGGAACGAGCAATAAGTGCCTGGAAGCGAGCTGAAATCCCCCAACTT
+ CAAATATAATTCAATCAGACTTGAAAATCAATCATTCCGTGAAAAGCAAATTACATGAATTAATAAATCA
+ ATGACGTCCAAATAATTTTGATTGCGCCTGCACCACATATATACGGATCTTATAAGAACTTTGCAATTAA
+ AATATTTATGCGCACTGATCCTAGGGCACCGCAGAGCTCCGCTCATAAATGTCAATGCGCTCTAGACGTC
+ AAGCGGTTGTCTGCCCATAAGTGGGCCGGATAGCAAAAGGAGACTCAGCTTCTTTCAGCGAGTCCGCAAA
+ CTAAGGCCGCCTTAAAGGCATCGGAAAATGATTATTAAAAATGATAATCGATTAAGGACGCAGTATGGCC
+ GAGCTGCTCGAGTCGCCAGTGGGAAGGCTGTCCTGAATTGACGTATATGTCTACATGTGTTTCCAAAGAC
+ AGTTGACATTTTTTTTTCACGGCCAGCAAAAACAGTAGCAAAAGAGCCATGCCGAAAACGTCCAGCCTTC
+ AAATATTTCCCAAGGCTCGGCCAAGGAAGTAGAAAAGCATCTGCAAAGTAAAAAATATTATTTATGATTC
+ CAGTCTGTTCGTGTCAAGAATGCTTTGGACCATTTTGCTAATGAAGTAGAATAGTGATGTTAAATCGCGA
+ AGGGAACATTGTCATGCTTTGTTTCGTAATTCTTAAAATCATTCTAGGCTTTACGTTAATTTACAGTAAT
+ TATTATGAAAATTACTCTATAGGTATTGAATAAGGAAATATTAAGATCTTTATAATGTATCATTTCCGAT
+ CTAAGAAGGAATATGCATAGTTAAAAAGTTTAAATGCTGGCTGCATAATGCATTATGGTCACAACCAACC
+ CTAGATGAAATTAATCAAATACCCGATTGTTGGGTATGCTCCTTCTGTGGTCTATACTATATTGGCTACT
+ TAGGTCGTTTTCCACTTGTTTAGTCGATTATGTTCATTTTACACTTCAAAAATCAGAAAATGCGACTATA
+ TGGTTTTTAGTTTGAGGCATTTGCGCAGTTGTGTTGACTGATACCTTTTTTTTTTGATGCAACCATTTTT
+ CTCACTGGCAGTAGTCGTGGAACCATGGGCGTGTTTAAACATTTTTGTTAAATTGAAAAATTTCTGACCA
+ AACCAGATCAATCAAATATCACAAATTTGGGCAGGCCGGCAATACTCAACTGAAAAGTAAATGGTAACAA
+ ATGCATTCGCACCAATTTACAACATGACGTTGTCCTCATCGGACTTACCGATTAGCCAGCCAGACGCAAA
+ ATGAGTAGGCTTATCAATATTCCGAATGTGTTCTCATGTCACACAGAACACTGTGCAATCAATGGCTCCG
+ CAGTGCGGTAGCTCTGGTACATTCTAAATTAAACCTCAATTGAGGTTTTGTCCTCTGTTCCTCCTTAGTC
+ CCCTTAGTGTTCCTGTGCCCAAAGGTTTGCCACAGCAGCTGCCACTGCCAATTGTTTGAAATGGTCAACG
+ GAATGCAACCCGTTTCTCATTCGTCGTAAGCATCCAGCGAAACCGAGTTCTTGAGCCTGGTGCCTTTCAT
+ GCCGAATTGCAAGCCAAAAACAAAGTTATCGAAAAATTACTCCGCGGATATTTATATGGCTCTCCGCCGC
+ GTTTTTTTTGCTCTCCATTGTTTTTATTATATTGTGGATGTAATAATCCAAGGATTAGCACTTACTGATC
+ GGACGTATCAATTTGAATTCGGTCTGTTAAATCCAATTGCAAGCCAAAACAAACATAGTTGGTATTTTAT
+ TCCGGATTTCAAAGTACGCCTCAAGATTGAAGTATTCAAAACAAAAAGCGTTTTTCACATTATATACATA
+ AATCCATATATTAGATGTACAAATGTTTTTTCTGTATTTCTGGACGTTATAACCTTTTTAACTTATTTTT
+ ATACTTCTTTTTCGTTGCTCCGTGAATTAAATAGATGCAGGGTATTTTCTCAAAACGAGGTTAAACGGCT
+ CGTTTCTCCTTTATATATTCGCTGGATATATACCGGCATGTTTAAATGTGTGCACCTCCAAGTAAGGGAC
+ CAGTGATCAGACTGGAGCACCGGCTCTCGAATTCCCAGAATATCGCCCGAGATCAATCTTACACTCGTTA
+ GATTGCATATTTTCATATGGTAGTTGGACACATCGTTCTTTCGCATCCATTTTCGGTTTTGCTGTTGCGA
+ TGCCATACACTAGAAGCCGGCGGCGTCAACGTCTGCTTCTGCTACTTTCAGTTTCATAAAAGCAGTCAAT
+ AACGCCTTGAAGGGCAACCATTTAAGAGATTTGATTGTCTTCAGATAGTCAGCAACTATGATTGGTTTTA
+ ACATATATGTTATATATGTACACATATACATGTATGTATATAAGTTCTATAGTTAATAAATCTCGTACAC
+ ATAAATTTAACATAAATGTCCTGCACCAAGTTGTGTCTATGTCGAAAAGCTCACAAAGATTCTTCTTTTA
+ AGGTGATACATTTGCTAAGGGCCAGCCAGGCAAGTGCGAGTGGGATTCTGAGTTGGTCCAGCAGGGCATA
+ TTGCGTAGAAGTATGGACTTAATGGTGGCGCCATTTCATTGCGCATGTCCATGTCTTGGATTACTGGGAT
+ GGTATGGATTTGGCAATTGCAATGAAATGGAAATGGACACAGATGGTTTCAGTTGAAATATGTAAATGCG
+ TAAATATGTTAGCGGGGGATGAGTCATTTGACGTGTTAACCGGCCTTAAAAGTGATATAAAATAAAAAAG
+ GAAATACATAATGTTGTAATCCGTTTTCAATATTGCATCAGTTGTTTACGCAGCCATGATTAACTTAATA
+ ATTAAAGAAAGTTTAATAAGCTATTTACTTCGTTCTTGAGAATTTAGGTTCGTTCAGACTGAATGTGTGC
+ ATATGAGTCAAATTGAAAGATTTCTTTTTTATAATATTTTACGCGGCAATCGCTAGACAACCATTTGGCA
+ CGCAATAAAGACAGTCTGTCCCATTCGTCGCCTAATAGCTTTCTTTCCTTTTCCTTCACTTTAGCTAGGT
+ CAGCTATTGGACTGTCACGAGCCCACCAGTCGTCTGGTTTTATTTTGAAATTGTCAATTGCGCCTTGCAA
+ TCTAGGCGCCAACTAATGGTGTGCTTGTAGGCCTTGACGTACACATACACAAGCTCCTAACAAGTTTTTT
+ TCCACCTTACCTCCTTGTATAGCGAAAAGTGTTCTGCTCTTCTATCCCTACACCCAGCTACATAAAAATA
+ TCTATTGCTGTGTCTCAACCCAATGATTTCATATTCTGTGGATGCACAACTATTGTAAAAAGCGCAGTAT
+ CAAGTATATTGCAAAATGTGTTACCAAAGGGCTAAGGAACAACTTTAAAATTGCTTTGCTGGAGAAAATC
+ CTAAAACGGAGATATTTAGCATCTATTTTTAGCCCTCGTCTATAACGAGTTGAACATTTTTGGTTAATTA
+ TCAATGTAGTCCAAGCAGCATTGATCGTGCTAATTTGTACGCATATTAAATGAGAAGATCACGCTAGCTA
+ GCTCAGCATGTGATGCCAAGACAGTACTTAGTTTATTGGCTCACCCTCGCACCAACACCTTGTGAGGCAC
+ ACGCGCAACTGGCAACTGCCCCGAAATAGACGTTGCCACACCTGTGACAGGTGCGACAATATTTGTCGTC
+ TGCTATAACTTAAAGCTGCAACTACAATTGTTTGTGGTATTTTTAGACGACTTTAAAGTCAATATTTGCG
+ CAACAATTTTTCAGTTTGCTTCGACTTAAATAACATCTCGTCACGACATGTGATGCACCGGTTTACTATA
+ GTTTATATTTTTTAACTTATTTACACAAATGCTAATTTGTAACATTGCTACTAGAAGTCATTTTTATATG
+ AGCAGATGTTCATTTTTTTAAATATTATTGGGATACCAGGAGAATGAAAATTTTAAAACACAGCATGTGG
+ CTGGGATTGTCTTTAAATTCGATGTTAAAGCAAGAAAAATTAATATTAATTTGTACAGGGCCTTCGCACA
+ TTTCCCCAAATTCATTGAAAAATCCAGCATTTTACGGAGTAACGTTGTTGTTTTTTTCTTAACAAATTAC
+ GGATACCATAGGCCTAGCAATCTCTATTTTGTGTGTGCAATTAATGGGAAAATTTTCTTAAATTTGTTTT
+ ATTAATATTTTATTAGGAAAGTGGAGGTACTTTAATATAGATGTGTAAGTTGCAGGTCTAGTTCCCACCT
+ GCTCTTTGTTGAATAACGCCAATGCTCAAGTCATTATATATGTACTGATCGGAAATTGCTGTTTTTAACC
+ TGTTTTCTATAGGATTCTTAGCTGATGTAATTTGTTCTGGATATTGCACTGGGTCAACTAGATGCAGTTA
+ CTTTGTTAATAATATGCATAGTTAATAGTGTTGAGTTCTTTCAGAGTACGTCATGAGTTCTAATGCACTG
+ TCAACTTACTGTGATATTGGTAAACTTTGTGCCTGCTAGATAAGCTGACAAATATATTTCCGAACCTGAT
+ AAGGGGACTAAGTTTTGCCAAAACTCGTTACGATAACGTGGATGCGTTCAGGTGTACTTAAATCGATAGC
+ GTGCCGTTCTTTGCGCACCTGTTGAGTTTTTAATATCACGAAATAGCTTGTTGCAAACGATAAGATTGTT
+ TAACGTACAGACATAAAATAACCCTTAAAGCCGTCATTTCTATATGGTTTCCTTTAGTGCGCTTGCACCC
+ AGATGACTAATATTTTAACCGCGACCACCTGAAATCCCAACTCTATATAAAAATACATTCTCTTTATAGT
+ AAGTTTTGTGTATTTCCTGATTCTATGGCACGTACACTTATGAATGTATACATGGGTACAAATATATCAA
+ TGTATACAAAACAATGAGATTACAATTGAAGAGGAAACGTCTACAGTTACTTACATAAACTGAAATTTGT
+ TAAATTCTTTATTTAATTTCGTAACTACGGATTTTTAATTACTACTGATTATCTCTGTTGTATGCAATTC
+ GTAAAAGAAGAATTGATCTTATTATAGAGGTACATGTAAAAAAATATACATTTTCATATTCAGTCCTAAG
+ GTAACTAAAGTTGATGGTGAAATTACAACATTTTGGCAAAGCTTCTTTTAAAAACTTGTAAATTGATATA
+ AAAATCCTGTTTGAAACAAGAAACTGAAACTTTTTTAGGTAAATATATAGTTTACATTATTGTCATTTAC
+ ATAGGTTTTAAGGATGCCGATTATTGTCTTTTTATACACTCGTACATAGATGGCGTTGACTTTTTGTACT
+ GACTAAAATGTTTCTGTAGGTAGAGATTAAATTATGATCACATCGCTAGTATTTATTCATAACAATGTCA
+ ATATCAAATACAAATTGTATGCAGGCATACTTAAAAATTTTTTTTTTAAACTCATGAAGTCTGTATATCT
+ AACAAAGCCTTGAAAACTTTTAAAGCTATTAGGCCACTTCTGGCAAAGAATCAAAGCATGTGGATAGGAA
+ TGCTGTATGCAGATTAATCTAAGCTTAAGCACAAATATTTAAAAAAATAGCAGAAATCAGTCGCATTTAA
+ AGTCTAAAAAAGTAAGTTATCCACGAAACTGGACAGATTACTCGTCTTTCTTTCGTTTCACTTTTCCCTC
+ CGTTTGGATGGTTGATGTTACAGCTTCTAAGCACGTGGCAATGGACGGTACGGATTGATCGGCGCTGTAA
+ TCCTCGCCAGCCATTCTACTTAAGGTTAGTATATAGGAACACGCTACCCGAAGAACGGAGAGTTTGGAAA
+ GTTTTTGAGTGCTGGCATAGGCTGGAACAGCTTGGCGGAGCGTTTCGTAGGCGGCGGATATGGTGTGTAC
+ ACGGGTCCGTTCACGTGCGTTCGCCTCAATGCGGCGCTCCCTAGTCATATTCTTGTAATTGCGTTGATGT
+ TGATGAGGTCGCGAAATTGGTGCCAATCCCGTCTTGTTCAGATCCTCATCGCTAAGACTAGCTTCTAAAA
+ AGGAAGATGACGTTGATTCTTTTTGCGTCCTTTCCTTCAACGTTTTTTTGGCGGATGGCTGTTTTCCAAT
+ TAGCAATGCGGAAAAGGCCTCTATTTTAGGCCCCGCTTGGTCGACACATTGCTTTTTGGTCGTTACTAAT
+ GCGAGTGGTTCCAGCTGTTCTGGGTGGGCAGCAAGCGATCTGTGAAGAGTCGTAACTCCCGGATGGCGAA
+ CATATATATGTGCCGGATTAGGCATTATTTCATGCTGCAGGCGCAACGTGGAAGGTATGCAACTGTTGGG
+ CGGTGGAGAGTCTATGGCTGGTGGCGTTAGGACAACTGCCGAATCGGCGGAAGATGTGTATCGTATGCGT
+ TTCTTTAGCGGACCAGTTGCATTCATACTCGCACTGGACGGAGGACCAGGCATGGATTTAGAGTTGGGAG
+ TCGTCAAACCTACGACTTTGAAGGGTTCCGAACTCTTGCGTTTGTTGCGGACAAGGGCTATTGGCTTGGA
+ GTCCGCCGAGTCTGTTCCTTTTGGTCTGATGTCGGGACTGCCACTGCGCGCGTGCTCGACGACCAAGTCG
+ TCTCCGCCTTCGCTTTCCGAACTGGCGGAACAAAAACCCGCATCACGGTCGTTGGAATTGGGTGAATCTA
+ AAAATACCAAAAAATTTAAGAGTTAGTTATCTTCTATCTGTGACGTATTACGCCGAACCGGTTACTAATG
+ TTTGGCATTTCGTATTCGTAAATTTAAAAAAACCCCCGTTTTCGCGGAACAGGCCAGCAAGCCGAATAGG
+ GCTGCGACTGCCTTTGTGTGACACCCCTTCGACTTTTCAAAATTCAATAAATCCCAAATCTTTAGTTACT
+ ATTTTTTATTACCATCTGATCGAAACTAATTGGATGACGTAGTTTTGACGTATTTTCTTATCTATAATAT
+ GTTCTTCCACCCTATGAAATCTATTTAATACATTCAAATCGGAGGTTACATGAGAAGAAAGTCCATTATA
+ TAAAGTGAAATTATGCATTGATCACGAAAACAAAACAGGTTTCTTAATTTACCACTGACCTCCACAAGTA
+ TTGAAGTGCCGAAACGCAGCTTACTTGTTAAAAGTAATTTATTTCAAGTCTGGCGAATAAAGCCAGTTCA
+ AGTTCAGCATGAAGCAGCCACTGCATCAGAAGCCAACAACCCGGTTAGCAATTTAAAAAAAAATCACAAT
+ GCATATAAACGAGCATACATACATGGATCGAATTTGTTTGCGATTTCAACTTTGGTTGTGCCAGCAAAGT
+ ATAAAGGTATAGAATCTGCTAGGATATTTATAAGTATTCCGGTATTTAAGCAAAAAAAAACTTTGTCTTC
+ AACAGCTAATTTTTTTTGTAATCAATTATTGTGTTATCAGCCTATCCATTATATATATGTATATGTTTGT
+ CAGCAATCATACATACAATAATTACTTGTTATTAATTTTAAATTAATTACTTAAGCTAAGTTGGCTAAGA
+ ATGAGTAAATTTATTCCCTGTTTGTTTGAACCGGTGCGGACACACATTTACGGAAGGTAAGCTTTTTGCA
+ TGTTTATTCAACTATTTATAAGCACAATATTCTGCTATCTTTTCTAATTTTAGGCAGATAAACAACGAAA
+ CGAAATTCAAAGCAACTGACTGACATTGCGGCCACGAAATCAGGCTGTACAAATAACATCAGTTTTATAG
+ CCCTAACTCTATCCCATGTCTTGCGTGGTTTATATACCGCATTTTAATTTATATTTAGACAAATGTTTAC
+ TTTTAAGCCACCGTCCTCGCAGGCGTCGTCTAGTTTAAAACACCTGTGCCAAACGGAAACATTTTTAAAG
+ CTTGCCAAGTTTTTAAAAAATAAATTTCTACCAATTTATATTTAAGTTGTCCGTATCAGACACTTAAAGT
+ TACATCTAACGACCAAAGGGCAATACCTGCACATTTTATTTTATTTTTAGTATACACGGAAGAAGGTATT
+ ATTCTCGATTGTTTATATTAAGAATATTTTAAGATGTTTTTTGTACGCCCAAATTAGTTTATTTTTTATG
+ GATCTGATCCGTCTTTAGGTGCCAAGTACAAAATAGCAAGTTTTGCTCAGAAATTGACAACGGTTTTCCC
+ GTTATTGGCCTTTTTTTCTAAGAATGAATGCCCTCCTGCGAAAATCAGCTAAAACCTACTTAAAAACGGC
+ AGACATTAACTGTCAGAGGCATAAGAAAATCCCATATTCACGCCAAAAGTCAACGAAAGGTTATCATCAT
+ AGGCGGCTTTTGGCTGGCGGTCGGTCCACTGGGAAGCGTTCCCTGTGTGGGAAGCCTCGTCTTATCATAA
+ CAAGTGCATATACTCATACGTACATAAATGTAAATATGTTATAGCGACTATATGAAATATATTGTAGTAA
+ AATGACGCATCACTTTTATGAATGAATCGTAAGAACACATCCAGATCATGCAGTACTTTGACACACTTGG
+ TAAGGACATTTTTACGTTGGTTATAAAACGAACCCAATATCATTCGGCTTTCCTGTTACTACATTGCGTT
+ ATGTAGTAAAATAATATAAGTGGAATTTTTATAAACTCATAGTGATCAATTTAAATTAAAGACACCTTAT
+ TCTATCCAAACCAATGGCCATCTAGACTAATCATTTCGAAACGTTGCTGATTAAGACTAGCATTTTAAAT
+ AAATGATCACAGAAACAAAAAATAAAATCGATTTTATGAAATGCTGACGTAAACAGTACCAACAATATGG
+ AAGGAGTTAACGTCTGTCCTCGAACATTATAACAATCAGCAGGCGGTGGTGAAAAGGGACACACAATGCA
+ GAGTCCAACTGTCGCTCCAGCTTCACAAACAGACAAATTGCCAATATGTCTGGCGACATCGTCGTCCCAA
+ ATTCGCCATTGCGGGCAAAGTGCTTGGCCGACATATGCAACACAAGACGAAAGTTGGAGTACGCTGGCGA
+ CACATAGTTGGCTTTATTTACGTATCTGTCTGCATCTTAATTGCCATCCTCACAAGTCTGCTGCTAATAT
+ GATTCTGCTGCAACGTGTTAGTTGGTGGGGCTTTCTGGGTGCACACGGCAGCACCCCCTATTAACAATGT
+ TGGTCGTCAATTATCTTCAGTGTCTATTGCATAGCCTTGGGCCATAGCCTCCTTGCCTTAATGATTGTAT
+ TCGTTCTTTTTGGGTTTCGATTACAAAAATGAATATACAGCTATTTGACAAATTATTGTCGACAAATATT
+ TTGCGGGAAATGATTATAATCATCCGACTGCAAGACATAAAAAACCTATGTATGTAGGTGTGTATATTTA
+ TGTAAGTATTTGCAGGTGCCGCACAATTCGCAGGCAACAGGTGCAGTGTCCTTTGCTCGTGCAAAAGGTA
+ AATACCCACCTTTCATAATAATTGCTGATAATTCCGATGCGCTTAGTTGCATGTAAAGTTTTTCTGTGTT
+ GGTATTCGCCATAGCCGCGAAGGACATTCAAGAACTTTAAAAGTAGCGCGTATCCGAAAACGGTATTTGA
+ ATAGTTTTGTGGGCTTATATTTTATTTATTCACAATTACGGGCTTTATGTTAACATAAACCTATTGAAAT
+ GTCACGTATTGTTTAAAGGCACTTTTTTAATTTGTGGTTTGGTTAAGCCGTATGTGAGCTTTGGCACTAT
+ CTTCAACTTATTAGAACTTTTTATTTTCACGATTTCTCGTAAAATCTTCTGACCGGAGCACGACTGTTCA
+ CAACGAAAGTATCTGACGGATTGAAAATATCTTGCGGATTGAAATGGCCTGCGCCAGGGACCGGCTGGCT
+ TCATGCTAAAAGCAGCACGCGGTCGAACTGCGTTTGGTTATCAGTGTTGACCATTCAGTTTTTTTAGAGT
+ CCGTTGTCCTAATGTGTGTATGGCTTGAAAAAAATTGCGCCCTTAGCCAGAAAATATATTTCTTCCATAA
+ GTAAATTATATGCTTAATAAGAAATAAAGTATTTATCTTTACAAGAAATATATAAATACTTTAAAGCAAA
+ ATTTTGAACAGCTAAGTTTGCTAGGCCTCTGAACTTATTGGCACCAGAAATATTAGGCAGAAAGACCTGC
+ CAGCACTGTGGTACGAACCGCTGGATCGGTTCGCTGTCGAACATGTTTGACTACCACATTATTAGTTTTA
+ TGAATGAAAATATTCGCTCGCTTGAGATTTGCGACTAGAAAAAATTTGTATTCAACTTATTGATTGCAAG
+ TATTACTTTTCTGCGGCCTTACTTATGTTTCAATGACAAAATGTCTTTTGACTTTTTGTAAACTTATCGG
+ GATGAATATACATTCAATATTTTGGACAGAAAAAGATCTTAAATGCCATTGAATTAGGTAAGATTAATTA
+ ATTTCGGCTGCTCTCCATTTTGCAAAGTTTGACTTATAAGGCTGTTAAAGCCTCTATCATAATCAGGACT
+ TTATTAAAACAGTTTATTCTTCTTGCAACATTGCTGCTGGACACAACGCATATACCAGCGTCAATTTCAT
+ TTGTGCATACGTGATAAAATATGTATTAGTATGTATTTCATCTGCGGATGGCACTGGCGAAGAAAGTAAA
+ AGCAACGGTCTTAATAATGTCAACATTTAATTTTAGTATTGCACAAGCTGTTCGATTTTTAGGCATAGAA
+ TGGTCAGTTTCTTAGATAGTTTACAAATATTTTATTTGATACGTATGTATTTTTTTAAACAGAACTCGTC
+ ATAATTTTGTAAGTTGGATTATCATGGCTTCTTTTATATTTATGTATGTATATATGTATATGCTTGTATT
+ TGGAAATTTATTTAAGTCAGGATGAATACCTCCTTACGTTTTGGATAAAAAAAAGATCAGTTCTAGGAAA
+ AAGTTTAAATTTGCTGATCATTCTTTCGAACGCCGCACAACAAAAAACTTGCCGCTGGAATGAATGCAAG
+ AGCCAGTTCCCTAATATCATTAGGGTTCTTTTCGTCTTTTTGTCTGATATCCTTAGCAGATGTACACTGG
+ GCACGAGTTTGAGTCTGTCGCGCGAAATGCTTTTTGAATGATGACTTTCGTTTTTTTAGAGACTTGTTCT
+ GCTTTTAAAGTATGCGATTGGGCTGCGGCCTAACCTGTTTTCTTCGATTGGACAGACCCCAGACTTCACA
+ ATCTCCAGTGTAGCAACCTGAGCAGTCCTCCGCTACCGCCGTTTAGGTCGCGATCAAGCCTTTGTCAAGC
+ TGGAAGTTCAAGGATAAGAATGCTGGACTTCCAAAAATGGTTCGTGTACGTGTCGGCGAAATTTGATCTG
+ TTCCTTTAAAAGTAAACCATTTTTTCCGTACGCCCCAGCTAGAATTACTTCGGAATCATTTGCAAAGATT
+ TTTTTTAAAATTAGGTAAAGTTGCGGTTACTGATTTGGCTTCTGTATGAGGACGGGCTCTAAGTACATGA
+ AGTCAGTTTGGCTTCTACATATGTAGATATGTGCTTTTCACCAAAGATCAAGTCAGAAGAAGTATTTTGC
+ GGACAACATGGTGTTGACGAACATGCACAAATCGAGTTACACTGATTTGGCTTCTGAAAAAGAACTTACC
+ GAAATAAAAATAGCAATATATATTTAATTAAAATGGATATCGATTCGATACCTGAAAACACATATGCATT
+ TGTACATGCGCACATACACATATAGGTATTTCTACCTGTCATTCTCGGCATGGAGCTACAAGAGCAGGAT
+ AATGGAACGTCTCAATCACTAATTGCTTTTAGTCTGCGTGGACTAATATCTGGTCCTTGCCAATAGTTTG
+ AACAAACGCCTGGGATATTGGAAATTTCTTGAAAAACTAGCGAAGTCAGGTAGTGGTGACTTCTGAGAAT
+ ATTCATGCTCAATGCCTACCTTCTGCGGAACATAATGTAATATTTGTTGCGTATTTCAGCTTTTGAGAAG
+ CTCATCGAAATCAAATAACCTTTTATCTATTAGCCATTTAGCATAATTAGAAGGCTTTGTTACTCGATCA
+ AAATCATTATCAAAAATTAGTTGAAAGTGATATCGTCTCAATTCAAATTCCTTTCATATAGTAAACATAA
+ CGTTGCCGTAATAAGCACATGTCCCTCCATGTGACGTCACGTTCCTTCTTGTTACGTTTAGTAGTGGAAC
+ CAACCGGCCTTGGCACGTGGTTATGGAAATTGCGTAACTCACTTCTACCGATACACTCGTTACTCAATGA
+ CCCAAGTTAGTGAGCTTAATAATAATTCAACAAGGAGAACGCTATAGCCGATTTCCTTCCCTCTATCAGA
+ TATCTCAGAAACTAAGATAGGGAAAGTGCGAGGGGCACATATGTATGTATATTTTTCTAAATGGTCGGGG
+ TGCAATTTTTTGCAGTTGACGTGAACAGACAGAAGGACATGGCCGGAAGGACATGGTCTCAGATAGAGAA
+ TCGGATCAAATATCAATTAAATAATAGATCTAAAAATATTCTGAAAAGCGTTTGGTGAAAGGATTTCCAA
+ CAGTAGCCTACTTAAATAAAATAAAAACAAATATTTACGAAAATATGTTCAGATCCGAATTTGTAACACA
+ TGGAATTCTCTGCTTGCTGTAAGTGCCAGCACATGTGTTTTCTTTGAGAAGAGGCGTTTTTATTTTCTGG
+ GCCTTTTGACCTTTGCCGGCGTCACCCAGTTTGCAGATTTTCATTGAATCGGCGCCGTCGGCGACTAATG
+ GCACATATGCTGACCAGAAGGATAGGAAAAACAGACATCCTTAAATTCAAGATGTGTGAAACTTGCATAC
+ AGTGATGTGAATGGCGACAATATGTCTTTTAATTTGCGTGGGAATATGTTTAGAACATGTTTGTATGTGC
+ AGATATCTGTCTTAAAGCAAGAGTATTGTAACTATGTCCAGTGCAATATAAAAAGCTCAGTTTTCGTAGA
+ TTACACCTTATTCTTTTAAAACGTGACAGCCGCAAGCGAAACTATACAGCAGCATCAATAACATGCGTGC
+ CAGAAATCATACCCATGATATAAAATTAGACGCTAAGAAGTACGTTATTAATGTCAAAATCTAAAAAATC
+ AGGACTGACTGCCAGACACAACTCAGACAAACCGGAGAATGCAGGACTTTGCACGCAAGAAAGAAGATAA
+ AAGAAGAAGAATATTAATGAGTCCAGACATCTCCACCACAGCAATTCCCACGCTTCTTGAACGTAAAACA
+ CCCGCAAGCTCATCTGCAAAAATGTAAGCAAAAGCATTGACCGTATCTCTGCAATGATTGCCACCGTTTG
+ CCTCAAGCCCCCAAAATCCGAATACTGTACAGGAGAATTCACACAGAGGCAATAAGGCAAGGCAGCATCA
+ CAAAATTGTTAATATGGACCTCGATACGGCAACAGCAGAAAATTGTTAATATGAAAGTCGAGATCGCTTT
+ GAGCATAAGTTGCCAATGGGCAGCAGTCCCGAAACAAGGCAATGGAATGGGTTACTTAATAGAATGTCTT
+ AGCATGTGGGTATGTCATGCACCTCAAAAGTGTCTATTTATATCCGCTTGTGCATGCGCTTTGAGTTTGT
+ TAGCACCCTTACCACTCTTGAATTTGTCGTCTATATCGCTCATGCTGAGCTCCGCGTATATATTGAAGTA
+ TCGCGTTTTGACCGTGTTGAATACTTAAAACGAAATATGATGAGCTTAGCATATATGTATGATTGTAAGG
+ CATTTGCTATTTTAACTTTTTTTAATATCGGCAACTCCAATGCACGTGCAAGGCAACATTTTGACATTTT
+ ACGGATTGGAGGTACCTGTCTTCGATTTTGCCCTTGCACGCACTAACTGTTGTTGCCCATTTGCAAGTGG
+ GTATTGTTAAATATCCTTGTCATAAAACTGTTTTGTTCACTTGTCTTTTGTCATATAGAAAACTTCATTG
+ TTGCAGTCAACACACAAAGGAGTAGACAGAAGACGATTTGGTTAATTTTTGGGTGGCGCCAGACGCACAG
+ CTGGTTGCCGTGGCCTCGGCTGTGCGATTGCAGTGTCATAAACGTAATGTAAATAAGTATAGCAGCCAAC
+ GGCACAGGTCCATTGCCATCGGTGGTGTATGGTTTCTGACCGACCGACCAGATGCATGCCGTGGTCGAGC
+ CTTGACGTTGACACGCACGAGCGTAGCCAGAAGCATTTGACCAGGAGGAGACACACTCGCGCTTATAGCT
+ CCCTATCACTACGCCCATGCTGACACATGGCATGCTATACAGTGCGATGGTCACGGGCTATTGGTCACTC
+ ATTTGCCAATGTTGGCGTATTCGCAACTTCTACTTGACCACTGCGAAGTAACTGGTTTGAATTCTTCATT
+ TGCGTGCCGAAGCATCTGTTCCTCTGTCTATGCGTTCGAATAACCATGAGCATCCTAAATCGTATTATTT
+ GTATTTGTGCTCAATTTAAATGTCTTTCTGGCTAACACCGTTTGTAATTCGATTGGAGTTCTTGTAGGCC
+ TTCTTATTTAGCGAATCTTGGTTAATTTGTTTTAAATTTCATTAAGACAGTATTTTCGATATTTCCCGCA
+ TAAACTCGGCACGAATACCTGCATCTTCATTCTTGGCTCTGTCTGTATTTTTAGTGGTCCGTATAAGGCG
+ CAGACCAACTGCCACTACTACTGATGATGTGCTGGCGGTCATCGCCTGTTGATTGTTTTCGTCCTGCCTA
+ AACTAATAACTGCATCGTGCGGTTGGGCTTCTCAGGTGCTTTTCGAGTTGATCATTGAGTGGGGCCAAGT
+ AAAAGCAGCAGGTAAAACGACCCTGACGATTGGATGTAAATTTCAACAAAAATTAAGAGGACAAATTATT
+ GACGAGGATGTTGCTGATACATATATGCACATACATACATACAGTTAGAGATCGTGCAAAGTAGTCGTTC
+ GCATCAATGGTCTTCATCACGGTTCTGGTCTTTTGGAATTTAACATTTTTAAGGGCGTTTTGCCTTATTG
+ CACACAATTTAACGTCTATAGAAACAAGTACACACATTTATCCTAACAAATGTATCACACTGTCTGGATC
+ GCTAAAAATAATCAATAACTACACACCTCAAAAGGTGCTAGACAGTTAATTTATACGGTTTCATTCGTAT
+ ATGTATACTAAAAATAGTACAAAGCGTTGAATATAAATAGTTACTTATAATTAAATTAACACATTTCTGC
+ AATGTGTACTCTGCAGGTTGAATTTTAAATTTAACTTGGCCTTTTATGCTCTTAACATACATATGTGCTT
+ CCAAAAAACCCGTTGAGCTTTACTAAGATCGAATTTGTATAGCCACCAAACGAACGTAGGGCGTAATAAG
+ GTTGTACCTTATTTTAGCGTTTTACAAGATAATACCACTCTGCACATGAAGAAACTTGGCGCCAGCCATG
+ AAAAATATGTAGACAATTAGAATAGCATTTTGGCGCTGCTCTGCGGTCCGATTCATTAAGATGTTCGGGG
+ ACGTATTTATAAAATACTTATATATGTACATACATACAAAGTGTGTATATAAGTGAGTGGCGATCTCGGC
+ GTGAGGCTCTATACAACATCTTGTCAGAATGTCATTAATTGTACTTTGTACCCGGCGGCTGATTCTTTTT
+ GGCAACGTTTGTATGGCGATGGTGGCATCTGTCGCTCAAGTGTCTTTAGTTTCTGGCACAAAAGTTCAAA
+ ACGAAAGAGCGGTGGCGTCCCAGACGGCGTCGCCTGTGGGGACATAACTTTGTGATGCAGCTGCACATGG
+ TTCTATGTATTGTATTTTATCATTTGTTTGTTTTTAAAATAATTTTAAGTCTTTATAAATTAATTGATCA
+ TCTCAACGAATGAGATTAAGGTGGCATAATACGATGCATACGTTGATACGCCCGTATCCCATATTTATGT
+ AAAGGCTCTAAATGCCCCAAGACGTTAACGGTCAATAAGGCGCAACCCTGGGGTAAAATTGACATAAACA
+ AATCTGGCGGCAACGCAGCTGGCCATTATGGGAAAAGCACTTCTGTGTTGGAGCGTATATGTATATTAGG
+ ATGGAAATAATTGCACACAGTTCGTCATAATTTGTCGTTGAAACAGATGAGGTCAGAAACGAAGAGCACT
+ ACACTTCAGAAAAATGTTATTCGTTTTTGGAATAAAAGTATTTTCAACACAACAACTAGTATAAAGAACA
+ TGACCTAATACGTATGATATCTTATATTAGAGAATAATGTTTCCTATAAATTAAAAACAAGCGTATATAA
+ AATCTCAACTCTCATATGTGGATTAATAGCTCATTATAGTTTTTTTTTTGTTTTGGTAATTGTTTTTAAG
+ CTTTCAAGTTTGTTCAGTGCATGAGAATTTATTGTAAAAATGGATAAAACGAAAGTACTATGCAGTTAAA
+ GAATTCATTAACAACTTCGCCACTACCATTTATATAAATAATGGGTAAATTTATTCAGTCAAATTAATTA
+ TTTTTTTGTGCTCTTAACTTTAATGGTTTTATATTTAAAAGTATTGGTCTGAACTTTTGGTTGGCCCAAA
+ GTAAACCTTTGTTAGGCTGATCAGCAAATAGGCCAATCAAAAGCTATTTAACGTCATCTCTTTCTCTTAT
+ TTTACCGCCGTCAAATTCTAAACAGCCTCCCACTGACATCAAGCCCATTCCATGCATGTGGTATGCAACT
+ CGTAAAAACATAGCGCATCCTAAGGCGGTCGGAATGCGGGGGCTTGCTGTTAATCTAAAAAAAAACTCGC
+ CAAACTCACTGCAGCTGTTGCTCGTGGGTGAAAGTGAAAACTTGTGGCACATGTTCGGCCGGAAGCTAAA
+ GAAAATCAAAATAAACCACCATATGGATGATAAGTTTTAATAAAGTACGTTTTTCATAATAATTGTCTGT
+ TAGATAAATACTATGAAAAAATGTACTTCGTGTACTTAATCTAATTCAATATTTGATAAAGACTATGAAA
+ AAATGTTAAAAAAAAGCTAAAGAAAATCAAAATAAACCACCATATGGATGATAAGTTTTAATAAAGTACG
+ ATTTTAATAATAATTGTGTGTTAGATAAATACTATGAAAAAATGTACTTCGTGTACTTAATCTAATTCAA
+ TATTTGATAAAGACTATGAAAAAATGCAATCATATTAGAATCGGAACCAGTTCATCTATACGGGCCTCCA
+ GCTCATCTCTGGTATGTTAAGATTAATCGATGAGTACGGTTATCGACGGCGCTGCAAGTAAACCAATATA
+ AAGTCAGGGTTTATTTGTCATAAAATAAATAAGAAAAGAATTGGACCACTTTAGCATACGAATTTCCCAA
+ AATGTCGAGTGCCCAGCGCTCGTTTGTGCAAAAAGTTTCCAAGTAAGTTTTTCACTAAAGGAAATAGTTT
+ ATTTTAAACAAAGAAACGCCCTTAATGCTTGTATACATATGTACATATATCAATTTGTAAATCCCTAGGC
+ AGTCGGCTGCGGATGTACGAAAAAATGTTTCTGGTTGCCATCTATCAAAGGCAATGGACCCATCATTGTG
+ TGGTTCTTCGGTAAGAGCACTATTGTTTAAAATATACAATTTTTCTGTTAAGGATTCCATTTTTTCAATA
+ GATCTCCCCGACAGAGCCCCTTGATTACGAAGAATTTCTATCCCAGCATATGAACATCATCAACCGGGAT
+ CCCTTGAAACATATATTGGACTTTCCTCAAGGGGATGTAACTGTTAAAATCATTCCCCGAAAAATCAGAA
+ CTGTTGATCACGTTGTTCCCAATGAGAATTTGTATGTATGCACCTAACTTATACAACAGCTACATAGCTA
+ CAGTCTCTTTTAGGTCTGATTTGCCCCATCACGTACAAGAATGTGTTAACTGCTATACGCGCCCATGGAA
+ GGTGGTTGAATATGCACAGCGGCACCTTTCCAGTTCTTGCTATATCCGCGAGCGTATCGACCGCGGAACC
+ ATAAGTCCCTCTGCGTACCAGCAGGAATTCGAGATCGACAAGGATTTTTCGTCATTTGAAGAGGCGTTCG
+ CTTATAAAAGCGAGAGCTGCACTCCAAGTTCTCGACAATCCATTGCAAGTTTGGCTTCAGTAAGCTCTTG
+ TACGGACACTTTGACCCCGCGTGGTTCTTGGGCTAGCTTTGATCTTCGACGTTCGGTTAATGACCCACTA
+ ATACCCAATTTGCTTGACAATGTACCTCCGGAGCATATTGATCAATCCAATGAAGCACGCCGGCAGCAAG
+ ATCGACAAATGGCTCTTTTCTCACTGTATCCGGAATCTGAAGCGGAGGAAAACATTGAACGCCGCCTGCT
+ CGCAGAGATTCCAGTTGAACATATGGGTCATCGCATTCAGGTTAACTGCCTACAGCTTCGGCTTGAGCTG
+ GAAGTGGAGCCAATTTTTGCATCGATGGCTATTTATGATGCTAAGGAACGGCAAAAAATTTCTGAAAATT
+ TCTATTTTGACATGAACGCAGATAGTCTTAAACGCATGTTGTCAAGTCATGTACAGTGCGCCGACATAAG
+ TACCCAGAGCCACTCAGCCATATTCGAAATTTCATATCCGAGTAACGATTTATTTCTCGTGATTCGTCTG
+ GAAAAAGTTTTGCAGGGTGACATAAACAATTCCGTCGAGCCGTATCTCAAAGAAGACAAAGATAAATACC
+ GAGAGAAAGTAAAATCCAACGCTGTGGACTACTGTGAACGACTAGGCAAATACCGAATGCCGTTTGCATG
+ GACAGGAATCTACCTAACAAATGTTTTTAATGGCGATAACTTTGAAAGCAAAGACGCTGGCGCCGCGGAA
+ CGGGATTCCTTTGGAAATGCTTGTGGCAGCAGCTTGGGCACAGCGCCAAGCTCCAATAGCTTAGATCGAA
+ AATCTTCCACAAGTAGCTTTGATCAACTAAGGCGAAAAGCTAACGATATGAGCGGAACACTTACACGACG
+ TGGTTCGCTTGAACGGAAGGAAAAGCACCGATCCTGGTCCCCAGATGATTTTGCAAACGTTGTAGAAAAC
+ TTTCGTCCTATCACTATAACAGTACCAAGCTTCTTTAAACAAGAGGCAGATAAAATGAAAGACGAGGATT
+ TGTACAAAATTTTACCAGAGTTAAAACGACCGAGCTCAGTTATGAAGAAGTACAAATGCATACCTGGTTC
+ TATTAAATTAGAAATATCACCTTGCGTCGAGGAAGCCAAGAATGCATTAACGCCAGAGTTAGCACCTATA
+ AACCCTCAAAGTGCAGATAATGTGCGCCCAGTTAAGGAAATCTTAGAATTTCCGCAATCGGCGATTTACA
+ ATCCACATTATAGCTATCGCAATCTCCTATTTGTGTCACCAAAGGAGCTAAATTTTTCTTCGCGTGCAGG
+ TTCTGCTCGAAACATTGCCGTTCGCGTTCAACTAATGGCTGGAGAAACGCCAAAAGATGCGGTCAATGCC
+ ATCTACGGCAAGTCGTCTTGTCCCAAATTTTCTACTGAAGCATTTACAGCTGTCAATTATCATAACAAAT
+ GCCCATCATTCTACGATGAAATAAAAATTGCGCTGCCTGCATCAATAAAGCAGCATCACCATTTATTGTT
+ CACCATTTACCATGTTTCATGTCAAAAGAAACCACAGGACTTGCAGCCGTCAGTAGAGACTCCTATCGGC
+ TACACATGGTTGCCCTTACTGGAAGATGGAAAACTTAAGTTTGGGGAATTTAATCTTCCTGTTATGGTAG
+ AATCACCGCCGGAAAATTACTCATTTATACCACCGAATGTTCACCTGCCTGGAATTAAATGGCTGGACAA
+ TCACAGAGCCGTGTTTTCTATTAATGTAGAAGCAGTCACCGCAATTCATACTTTGGATTCTTTCCTCGAT
+ CGATTCTTCTTAATTTGCGAATATCTAGACACTCGAAATATACCTTCCCATATTGGCGAGAATAATATAG
+ AAACAGAATTAAAGAAATGCTTGCTGGATATCGAATATGCAAATCGTGAGCCATTAGTGAGGCATCTACC
+ ATTAGTCTTGGATAAGCTTATCGAATTGTTAGTTGTCACCCACAAAGTTGGTGGACAAGCAATGTCTCTG
+ GGATCTACGGTTTTCGAAGTTCTTTGTTTGGTATCATCTTTGTTATCAATACTTAACGACGATCAATATG
+ ACCAATACGGTCGGCAAAGTTTGCTATCAACATATGTGCACTTTCAATGTAAAATTCCGCACCCCTTTCA
+ AAGCAAACAGCGACTAACATGCAGTCGCAGCACAACAGAAGACTTGCAATTAAGCGAATCGTACACCATA
+ TATGATAATGTTTTAGCAAGTGGCCGAAGCTTGGATCGCAAAGGTAAAATACATATTTTGTAAAGGCTTT
+ AAATATAACCTTTTTCCTTTCAGAGCTGTCCATAGATGTCCTTCACTCGATGGCTGCACGGGATGTCCAA
+ GTGCGGCTGCTTCACGAAGAATTAGCCTTGCATTGGGTTGTTGCAAGTGGAAAGGCAGCTGACTTAGCCA
+ TGTCAAATTCGTGGTTTTTATTTGAGCTTATTGTCAAATCTATGATTGAACATTTGCATTGTTCAAATAC
+ TTTAAATGGTCCCCGCAAACATCGATTTCCACATCAGTTTAATGATGATCTATCCACCCTGGTGCACTTA
+ GTTACAACAAAAGTGGTCGGCTACCACAGCAACGAACCTAAATTAGCGCAGTCATTAAATGCAAGTTTAG
+ GCTTTTTTATATTTGACATACTAAGCATCATGGATCGGGGATTTGTTTTCGGCCTCATCAAAACGTACAC
+ AAAGGTTCTGATTTCTAAAAATGCTTCAATACCGGATCTAATGAACTATAAAATAGACTTTTTGAGAATT
+ GTGTGTAGTCATGAGCATTTTGTAGCCTTAAACTTGCCGTTTGGTACTTCATACACAATGGTAACAGCGC
+ CATGCAGCCCCACGCCAAGCACAACGTCGAGCAACAGCCAAACTTCTTGCGTAAGTAAAAAAACAATACA
+ CTTTAATTTTTACTTATTTGTGGCTTCTTTTAAAAGGGATCACTAGAGAGAGCCCTTCACGCCGACCTTA
+ GTCAAGAATTCCTCCAGCAACATTTTCTAGTCGGACTTGTTCTGAGCGACTTAGCAGCAGTAATGGAGGT
+ GCCAAACCCCCAATTACATGGAAAAGCAATAAGGTGTATTCGCAACCTGATGACATCTCACGATTTGGAC
+ GCGCGGTATAGCGAAACTGATGCACGTGCAAGGGTGGCTGCTTTATATATACCGCTACTTTCTATAGTGA
+ TGGATTGCATTCCTCAGTTGCATCAGCACGGCCTTGAGCAGGATCGTCTGCAGCAAATCGGTCAACTTGA
+ AGACTATCAAGGGCCACATCAAACTATTACAGCATCAACCATAAATCCGGAAGTGGCATTTGCGATATCG
+ GGAAGTCGTCCCTACTCCTACTTGAATGAACAAGTTAAAAACAAATTGCCCCTCAGCTCGGAGAATACCC
+ GCCATTTATTGGTGTGTTTTCTGTGGGTGCTAAAAAACTTGGAGCGCAACGTTTTATATCGCTGGCTTAT
+ GGATTTAAGTCCGCATAGAGTGCACCAAATGCTTCAAGGTGTTAACGTTTGCTTGAAAACTTTCGAGTAC
+ ACAGGACAAAAAAACGTGGCCACCCTTAAACGAACGAATACACAAAGTTTTAGGAAAACTGGATCTACTG
+ ATGTTAAGGAAAAGCTGGAAGAATGTATTAGAGGCACAAATTCAGCACGTTATGATTTAATAAATCGTCG
+ AAAAGATCGTAATTCAACAGAAAAATTCCGATGGAGGAAAGACCAGATGCCATATCGCTCTCAATATGCG
+ GATGCTGTGGGAAAAAGTGAGCATGAACTTGAATTAAGTCATTTCATCGAAGGCTCTTTGGCAACTGAAG
+ TTGCACTTGTACTTCTCGATACCCTTGAAATAATTGTTCATGCTGCTGCCAACCTTTATCACAATCTTCT
+ TGGAACTGTGCTAAAGGTGCTTCTTCATTCTTTGTCCCGGAATCAATCTGTTTTGGCCCTGCAAAACTTG
+ TTTGCCTCCCAACGCGCGTTAATCTTTAAATTTCCAAACTTATTATTTGATGACGAGACCGATATATGTG
+ CGGATTTGTGTCTAATTTTACTGAAACATTGTGGGTCCCTATTGCCAGGAATACGATCACAGGCAGCTGC
+ ATCACTATATTTACTAATGAGACAAAATTTTGAAATTGGAAATGTAAGTTTTATTTTATTGTTTAGGTTT
+ ATTTAACTAAATTAATGGTCACTTATTCGTATAGAACTTTGCCCGAGTTAAGATGCAAGTGACGATGTCT
+ TTAAGCTCCCTAGTTGGAACAAGTTCGGTCTTTAGTGAGCAATCCTTACGCCGTGCGCTTAAAACCGTCC
+ TGGTTTATGCTGAATCCGACTCCGACCTGCAGGATACTTCTTTTCCTGAACAAGTACAAGATTTGCTTTT
+ TAATCTGCATATGATCCTGTCAGATACTGTTAAAATGAAGGAGTATCAGGAAGACCCAGAAATGTTGCTT
+ GACCTCATGAATCGTATTGCCAAGGGATACCAAAATAACCCTGATCTACGACTGACTTGGTTGGAAAATA
+ TGGCTAAAAAACACCGCGAGCGAGCAAATCACACGGAAGCAGCCATGTGTTATGTACATGCTGCTTCTTT
+ AGTTTCTGAATATCTTAGCATGTTGGAGTCACAAAAACATTTGCCTGTTGGAGCTGTAAGTTTTCAACGA
+ ATTTCTCCCAACACACTAATGGAGTCGGCCGTATCGGATGATGTGCTAAGTCCCGGCGAAGATGGTATCT
+ GCCTAGGAAATCATTTCACTGAAACTGGGTTGAAGGCCTTGCTGGAAGAAGCCTCCAATTCTTTTCAAGT
+ TGCTGGCATGTATGAAGCAATGAACGAAGTGTACAAAATTCTAATACCCATATGCGAGGCTAACAGAGAT
+ TTTCAAAAGCTAAGCAAAGTTCATGGCAAATTGCAGGAGGCATTTAATCGAATATCCCAACTACAGGTAA
+ CAATATTGTGTAAATTTTACCAACGGAAAATATATACATATTTATAAACAGGGTAAGAGAGTTTTTGGAA
+ CATACTTTCGTGTTGGCTTCTATGGCGGAAAATTTGGGGACTTGGATCAGCAGGAATTCATTTATAAAGA
+ GCCAACATTGACGAAGTTGCCCGAAATATTTAGTCGGCTTCAGGTATATATTGCAAATTGGAAAAAATAG
+ AACTAATCAATTTTGTTTCAACATACGTTAGAACTTTTACACTGAACGATTCGGACCGGACTCTGTGCAT
+ ATCATTAAAGATTCCAATACCGTTGATATTAATAGCTTGGATCCCGATAAGGCTTACATTCAAATTACTT
+ ATGTTGAACCCTACTTTGAAACATATGAAATGCGTCATCGTGAGACATACTTTGAGCGGAATTTCAATAT
+ AAGTATGATATGAATTAAACAGATAATTTAAATCGAAATTTAAAATTATAATTTTAACATTTTTGGTTTA
+ TGCAGAACGTTTTATATATGCCACGCCTTTTACTAAAAATGGAAAGGCACATGGCGAACTAAATGAGCAG
+ TGTAAACGGAAAACGATTTTGACCACGGCGAATCACTTTCCATACGTAAAAACTCGCATTATGGTAATTA
+ GCCGACAGCAAATAGTCCTGGAACCGATTGAAGTGGCAATTGAAGTAAGTTATGTTGTAAAATCCCAAAA
+ GTTAATAAAATTAAACGTTATTGCCTAGGATATTCAAAAAAAAACATTGGAATTGGCAGCTGCCACGAAT
+ CAAGAGCCAGCAGACCCCAAAATATTGCAAATGGTACTGCAGGGATGTATTGGAACCACTGTTAACCAAG
+ GACCGATGGAAATGGCGAGTGTGTTCCTTTCCAATTTATCCGACGGAACAACTGTACCGACAAAACACCA
+ AAACAAACTTCGGTTGTGCTTTCGCGAGTTTTCAAAGCGTTGTGCTGATGCTTTGAAAAAGAATCGCAAT
+ CTAATACTTTCAGATCAAAAAGATTACCAACGAGAACTGGAACGTAACAACGATCGGTTCATTGAACGAT
+ TGACTCCCTTTATTACTCTTACATCAGTTCAGAATCATGGCGTTGTCAAGTAAGTTTTTATTGTTATACA
+ GTGAAAAGGAAAGTTACATTGTGTATACATATGTATTAAAATTCTCATGTCTTTCTTATTTTGTTCCTCA
+ ACGGAGTGCTCTAAATAATAGACATAAGATGCTTAATTAGATATTTATAGAATCCAGCCTAATATAGATA
+ TTACTTTACTATATGACTATATTAAAAACCACCAGTGCAAAAAGTAAACATTAACTTATATAATTTTTTA
+ TTTCTTTTCTAAATACATCCAATAGGGCCAACGCGTACAACAACAAAAGTACTCCTTTGAAATGGTAACT
+ TCTTGCACACGACTTAGTCTGCAATCAAATTATCATACTTTTGGTCTTTCATGTCTAGCGTATCGGATTA
+ TTTTAAGTAAATCTTACATTTTAAATTATCGATCTCTATAATTGCTAATGTAATAGCATAACTTTTTTAT
+ GCATCTAATAGATTAAGCAAAATATTAAAAAGCGAAAAAAATAAAGTTTACACTTTTTTACTTTTACGAA
+ AATAGTTAAAGCAACATGTTTCAAGCTACAAGGAGGTGCAGTTAAAGTGAGTGAAACAAATCGTATCCTA
+ CAGCAACAAAATTTAATTGTCGATTACCAGAAAAGGGAAGTATTCGAAAATGATAATCCTCGAATTTCGC
+ ATGGGTCGTTAACGGTTGTTAGATTGACTAAGAGTGAGCTCCGTGAGGCAATGGTATCGAACGCGACCTA
+ TCGGTATTCGCGAAACTTTCGAGTATACTATCGATGTTTTTATTTATCGATAGTGTCGGCTTTAATTACA
+ CGTAAACTCAGATAGTTTGCCGGTTAAAAAGACAATAAATAAATAAAAATGAGAATCAAGTATTGTTGGC
+ TCGCAACGCTAGTATTCATAGCCGCTGCTTCGGCGTCATATTCTCCCGAAAAGCCTGTTCCGCCGCCCTG
+ CAGGGCATGTACCCAGCTTGTTAGCTCTTTCAGGGCAGGACTCGAAAGGACAAAACGCGGACACGCGGGC
+ GGGGACACGGCATGGGAGGAGGAAAAGTTGCGTTCGTACAAGAACAGCGAGGTACGGCTAGTGGAGATCC
+ AGGAGAAGCTATGTTCGGAAGGAGAAGTGATAAACAAGGATCACTGCCACAACCTGGCTAACGAGCACGA
+ GGCGCTTCTCGAGGACTGGTTTATCCACAAACAAACAGAGAGTCCCGACCTGCAGTCATGGCTTTGCATC
+ GATCAGCTAACAGTCTGCTGTCCGCTGAACACCTACGGACCAGACTGCCTGACCTGCACCGAGTGCAATG
+ GAAATGGTAAGTAATGATAACCAAGTATTACAGGCCACAACTTACATAAGTGTGTCAACTTAAGATTGCC
+ GTCTTCGTTAATTTTACCCACATGACAAATTTCAGGAAAATGCAAAGGAGACGGAACTAGAAAGGGTAAC
+ GGAAAGTGCAAATGTGATCCCGGCTATGCGGGTCCAAACTGCAACGAATGTGGACCGGAGCACTACGAAT
+ CATTCCGTGACGAAAAGAAATTGCTGTGTACACAGTGCCATGCGGCCTGTGGGGAAGGAGGCTGCACGGG
+ AGGTGGTCCCAAGAGCTGCCGCAAGTGTAAGAAGGGCTGGAGCATGGACTCGGAGGCAGGATGTGTCGAC
+ ATTAATGAGTGCTTGGAGCAACAGCGTCCAAACCCTTGCCGACCACAGCAGTTCTGCGTGAACAATGAGG
+ GCTCCTTTAGTTGCCTGGAGTGTGATCGATCTTGCGATGGATGCGATGGTGATGGCCCTGACATGTGCAG
+ GAAGTGTGCGGATGGCTATGAGTTGAAGGAAGGAAAGTGTCATGGTAAGTAAGACAGAAATTTAATAAAT
+ TTGCTTTTAAGCAACGCATTGTCCACTGTATGTATTGCGCCTCCGATCATTTAAGATATTTCTGCGGAGC
+ AACGCAGCAACTACGTAAGCTTTACGCGAATGCTCACCTACTTCGGAATGTGCGTGGCCACCTGTGTCAT
+ CTTCCAGAGCTCTACTCATATTGCCTGGGGTTGCATTGTTGGGGCGGCAGTGGCAGGGTACATTGCTGTT
+ TCCGAGTACTGGATCAACTCGGAGGCAGGAGGCGGCCACCAACCCGAAATAGATACAAAACAGTTGGAGG
+ AACTAATAATGAAGTCTTTATAAGTCAAAAGACATGTCAACATTGCTTTCCTTTTATGATATACACGAGC
+ GTTTTGAAAAGCATAATCTTTTAACATTCCCCCAAGACATCTAACGATTTTTGTACTTCGTTTGCAGTCC
+ GCAGTGATTCAAACTCCACGGTGCTCGGTGAAGAGTCCACGCACGAAGAATTGTAAAAGTAACCAAAAAC
+ GCACACCTTTTGTAGCCAATTTTACTTTAATAGGTAATATTATCAATTGATATGTAATTATAAATTAGAA
+ TTTCAAAAAGCAGGGCATGACCATATTTTTTTACACGTACCACACTTAGATATTTATTTGGTTTCAAAAA
+ TGTATAAAATCACAAATACAGCATATATTCGTATGAATAAATATTTTTAACTAAAATTACTGACGTAGTG
+ TGCTTTTGTGACGTCCAAATTTTCATTTTGAAGACCATCTGTCGTGTGCAATGTAATACTGCTTTAAGCG
+ GATTAATAAAGGAGCTACAGTGATACGAATGAATCATTGCATTTGGATCTTACAAAATGAAAATTTGTAA
+ ACAAAAAATATACACAAGATAACAACCATCACCGCGCTATATAAATAAAAACTCTAAAAATATTAACTAG
+ AGGAACTTAAGCATTACATACGATCGTTCCCTTTGGCTTCTAAAGTTATCCAACACAGTCCGAAACGGAT
+ ACAGAGCTCCCCCCACAACAGCCATTTAATCCCTACGACCGTGTCAAATGAATTTGACTTGTGCTGGCCG
+ CTAGTCCTATCTCTTCGTCCGATTCATCTGAATCCAATGGACTCACTCGAATGGCTTGGTACCACTTGTT
+ AGTCAGGTCGGCCATCTGTGACTTGCACTCGTGCAATTCCTGACTATTGAACCGACGTGTAAAAAACGGA
+ ATAAAGTACTTGCGATCCATGCGCCCAAAACGATCGCGCGCTTGAGTAAAGGTGACGTCCTCTTCCTCGG
+ TGAGTTCAGACAAGTGTTCAGAGTCGATTGCCTGGCCCCATTCGCGAGTTTTCGATAGGGAAATAGATTT
+ TGAACGCTTCCTACCGCTGCCGTTGCGTCGACCTCCCTCCTCAGCGGCATTCCTTCCAGAGCCGCGTGCC
+ CGCCGTTTTTTTCCTGGCTTAAGGTACTTTAGCAGAGGCATTGTGGAGCCCCCCAGCACTAGCGTGGTAA
+ ATAGCACAATGATTAATCTGAAATTTTAATTCTTCAATGACTGAGCATTATTTTACAATCCGGAATATGC
+ TTACGTTGTTGTTATGATGACGTGTCGTTTCTCCTGGCTGTCAAGATTCAAGTGCAAAGATAGCGCGTAG
+ GAAATCGCTCCGCGTAGGCCAGAAAACCACATAATGAACTGCATCTTGTTATTGATCTTATGCTCGCGAA
+ ATTTGTTGACCAAGAACGCGAGCGGAAAAATATTGCAGGCGCGGCCAATTAAGCAAAGCACAATGGCCCA
+ TATAACAAAAGATAGTTCAACTTGGTGTTTAAAAGAAAAGATTGCTAATCCCAGATAAGCAAACACGCAG
+ GTCTCAGCAATGAAAGCTAGTGTCCTCATCGTCTGCTGCATGGTAATTTGGGTAACCTACGATTAAAAAA
+ GTTTTAATAATATATAAAATAGGGATATCATATGACTTACAGTGGATAGGTTGAAATGCGTGTAGTGGGA
+ CATGACGATTCCGCAAAATAGTATAGCCATAATACCTATAGTTGAAAAAAATGTTTAGCTTTTAGAGTCA
+ TAGTCAACAACATTGATATACCGCTTAAGTGTATTCCCTCTGCCAAGACGTAAGGTGCGTAAGTAAACAT
+ TAGCATCATCGCGAACTCGAGGGATGGATGCTTTCGTAAATCGATGTGCTTCAGAAGAAGAGCCGAAATT
+ AGTGCAAATATGACTCCAATGCCCGCCGAAGCAAAGAACATCGCGCAAAAGGTCTTCAACGCGCTGAACA
+ TGGCTTCTCCAGTGCTGGCCTCAGCATTGACGTTAGCGGATTGGGTTATGGATGCAGTCAGCACAATAGA
+ TATGGCGTCGTTGAGGATGCTTTCGCCGAATACCAACATGTTGAGTATGGGGTCTACGTCAAGAGCATGG
+ AAAATTGCCACTGTTGCCACAGGATCAACAGCAGAGATGAGAGAACCGAAGGCAAAGGATTCCGAAAAGC
+ TTAGGCTAAAATTTAGGATAAATTATTGAATGAAATTGACAATTTATTTTAAACTTGCCGAAATGCCACC
+ TCCCCCAGGCCCAGCAGGTAAATCCCCGCCCCGATGACTAGTGCAGAAATTGTTGTACCGAATATGGCAA
+ AGACCAGTATGGATCCGATGTTCTGAAAGAAGTTTCCCTTGTGCAGATTGTAACCGGACTCGAATATAAT
+ GGGCGGCAGGAGCACCAGAAAGAAGCCCATGGGCGAGAAGACCTCTTCACGTTTCCAACTGCCATTCTGC
+ CCAGACATAACGTTCAGCGAAAGGCCAATAAAGGCGCCCAGAAAGACTACCACAATGCTTTCTGGCAGGT
+ ACTGGAACCCGGTCTGGAGCATAGAGTGGATAAGCAGGATGCCCAACATGATAACGCAGATGACGAAAAA
+ CAGTGAGAGTGAGGAGTTGTGCTCCTGCTCGACAGCATGGGAATCGATTAGAGGCGGATCTGTGACCAAT
+ GTGGATGCGTTTCCCCTTTTCGTGGTGCTTGCATTACCAGATGCAGAAATCGAGGGCGTGACATTTCCAA
+ GCGGACTGTTGACGAAGACATCCGAAACGGTGTGGATAGAGCTACTATTATCTGTAGTGGTGGTGTTGCT
+ TGATGTTTTGCTTTGGGGCACCTCCTGTCCACTGATGCTTTCCGGACCCGCGTGCACCAACAGTAAGAGT
+ GCAGCTGCACTATAAGCTACCCAAACCCTCATTTTTGCCGACAAAACGTGACGTGGTCGCTATTAACGCT
+ CGCATTTAACTTTTCACTATTTGTTCAATTTGTTTTTTCACAAACATCTGTTTATCGCCCTATCTGACGT
+ ATATCGGGGAGAGTTGCCGTATCATTTTGGCTTATTGGCGCGTGCCTTTCATATATTCAAAAGAAAATTG
+ TGCACTTAATTGCGTGCAGTATATTTTACCATATAATGAATTTATTTAAATAATTGGCTTTTGCCCAGTC
+ ATTGTAGCTGATAGCTCTTGTGAAGTGTCTTGAAAATTGAGCATTTTAAGTTTAAATATTTTTGTCTACG
+ TATTGAGAACGTTTCTTACGGCAAAAAGAAAATTATATATGTATTAGAAAAGTGAAATAATAAAAAACCT
+ TGTTATTGGCAAAGTGATAAATTGTTTAGTTAAGGCTATTACAATAACTGACGATAAATCAGTAAAATAA
+ ATGCATTGCCACAATCTACAGTTCGCAAGCACCCACCATTTGTGCTCAAGAATAATGTGCCCTGCGCATC
+ TGTTCGTTCAGGCACACGCGATCTTCTTAGGCCCCGTGGGGTCACACCTTATTTGAAAGATAATGGGGCT
+ TGTTGTTTTCGGTTATATTCAGTGGGTATTAGAATTTTAAAAAATGTACATGCAAAAACTGATTACCAGG
+ CTCCTTGATCTTGGCAGACCTTGTTTGTCTTCTTGGCTGTGGCATGACGTAAGCACTTTTTCAAAAGCAC
+ AAATTGTTCGAATAGTATGAGAACCCTAATTGACGACTTTCCTTGACAAGATAGTGTCGAACGATCCATC
+ TCCAAAAGGGCAGTCACTCCATGTTAGGGAAAAGCTAGGGTTTCAACAGATACAGACATTCGTTTAAAAA
+ TTCGCTTCGAATTGCGCTTCGTGTAGCGATTGTCTATATCATCGAATATGTATATGTCAATTGCTGTACA
+ TAAGAGAAGCCGAGAGAGCAATGCTAAACAGATTTTAAAAATTAGGTATATAGGTGGCTGCCGTGGTAGC
+ ACATAGTTTTGTTCTGATAAGCTCTTATTTCTTGCCGACTCATCTTCTCAAATGCTGTCTACAAAAATTT
+ ATAAATATTATTCGTCTGTAAAAATCATCCGCAGTTGAACGCAGGTTGAGCAGGAAGCTAGTCGAGACTA
+ TAATCCATATCTTGTCTGATCCTTTGTTCAAAACCACAGTGAGTATAAAATAAAGGATCTGGATCTAGAT
+ TCACTACAGTTCACTCCGGAGCGGGGTGGCAACGCTGGGCGGCGGAACAGCTGCTTAAAACCCAAAAACG
+ TGGAGATACTGAAGAAGTAAAATCATTTGAGAGTACCGAGAACGCTAGGAAAGTTTCCCTAAAGAGCGCC
+ CAAATAAGTCTCAAAATAATAATCGAGTCAGCCGAAGAGAACCGCCTCCTCCGTTTGCGACGATAAGCAA
+ AAGCCCGCTCTCTCGTTGGAGGTATAAATTCTGAATGGCATTAAAAAGTTGCGCTCTTTTTCTTCAGAAC
+ CGTCGCTAAGATAGGACGTGTGTTGGCTGCGCCGCTGATTTGGTTGCCGTCGCTGAACCAGTATAACTCA
+ GAATCAGTGTGTATAATTTGTTGAACTAATAGCTAGAACGTCGAACACGCATTTTAAACAGCTAGCAGCA
+ CCGAGCCCTCACCTAGCGACTAGTTTAGCTTTGAACCCGCTCAACGTGCGTCTCATGTATGTAGCGACGA
+ TTGTGGCAAACGCGCAGCATAAAAACATAAAAGAAGGGCGATTATATAAAAAAAACTATAACGAAAAGTG
+ TGCGAATACCGGAAAATCCCAACAGCCTCGAGGCGGCCTATAGCTTAGATTCGCGAATGCGAAAATAGAT
+ GTGTTTTGCAAGAGTTCGGAAAATCAATTTCGTTAAGCGTTTTTTAACAACCGCTAATGTGGCCTCTCTT
+ TCTCTCTGTTCCCCCAGCTCCACCAACAATTTAGCCGACCGGAACTCGGGTTATAGCACTGCTCCCCCAT
+ TGCCCCTTCAAACTTCGAGTTACATATTACAAACTACCCATCAACATGCCGCAAAAGACAAACGGACATA
+ GCGCCAACGGATGCAACGGCAGCAATGGCAACTCATATGACATGGAAGACGGAGCTACATTCCTGTTCAC
+ TTCCGAGTCCGTTGGCGAGGGTCATCCAGGTGAGTGCTTCATTGCATCTGCGGCGCCTCCTATTGCATCA
+ TACCGATAGTGTCAGTGTAAAAAAAGAAACAATCTCAAATGCCCCTTCGGGCGTGGTGAGAGATGTTGCC
+ TGTCAGTTCTCATAACCTGACCAAACTGATTCTCTAGCGTCTGAGGCCCTTCTGTCTGAAGTCCCTTTCC
+ CTGTATACCCAGTTCCACACCTCCACCGTCTACTCACTTCTGCTTACCGCCTGAACTCTAACAAAATGGC
+ GACGAAATTATGTCCATACCTTTGTTGATTTCTACCCAATTTGCACGACTTGAACAGAGGCTGAGAACGG
+ GAAGAAGAGCTAGTAAAACGTGCCTCTGTTGCATCGCCCGGTGACCAAGCCGGAAAGCTGGGACCACGGA
+ GAACAGCTGGCTTCTCTTGAAATCCCCGCACAACAGCGGGCTAAACCTTGTGCTTGGATGGGCAGACGCA
+ ATTAATAGACTGGTTCTTTATCGTTTGCGGCTCTCACATATGTATGTATGTGTGTACAGAGAGACTACGT
+ CATGCGCACCATGTGCTTGTGGCTCATGGGAGATGCGAAATTCAAGTATTCTCTACGTTGTTCTACGTTG
+ TCCACGCACTTGTTCATTTGATCGCAGATGGCGATCAAAACAACGGCCAACACAAACATACCTTACATTT
+ TTCTAGACCGCTGTCAAAGCTTATTTTTTTCACCGAAATTGCCAACCACGTGTTTTGCTCGAGCTCGATC
+ TTTTCGCCCCTCCCAGAGTTTGTTTATATCAGCAGTGGCGACCAGTATAGTAGTGTGTTTGACAACAGCT
+ GTTGATAAGCCGAGCGACCTTTTATACTACGCATTGATTACTTTTACTATTCTATACTATTTTATTTTAT
+ AATGCTAATTAAGTCGGCTTGGCAAGCTAGCCCTAGACAATCTAGCCCTATACAATCGTGATGATAAGCG
+ CCGAGTGCCATTCAGAAGAATACACCCCAAATGGTTGACATTAATATCGCCTGTCTTTTTGTAATAAATG
+ AGTGACGGACTTGTTAGAATAGATAATTAGACTAGCCGGAAATTGGAAACCCTGAAACCCATTTCAGAGT
+ AGCTACTTTAAACCCTTGACCTAACTAGTTTCCTCGCAATCATTATCCCAGCCGAAATCGATACCATGCG
+ CCATTTCTATGAGTCAACAGTTTTGGTAATTTATGTTGCTATTGCTGACGCATGTTCGAGTTCAATAACG
+ CCTTTACTACGAAAAGTAGCCGAATGTTGACGGACTCCAATTACGCGCCAAGTTTTGAGGCAAGCGCGAG
+ CAACCCGACTGGTATCAGATGAATCCGACTCCCAGGATTTCATGGACGATTCGGCTTCAAATGTCATCAT
+ TTTGTGTTTGGACAACACTACGGTCGCCTTATGCTCTTGTTCTGGGAATTGAATTTCGCTGTCAATAGCA
+ GACAGATTAAATGAAACCGCATGGCCCAGCAAATTTTGATCCGTCGCACTGAATAACATTTTGGCCCGTT
+ CCTCCTTCCACTCCCCGACAAAAATGCTTTCCCCTCCTTCTTCGCCCACCTCTGGCTTACCTCTTGCTTA
+ CCTTATTTTTTTTAGACAAAATGTGCGACCAAATCAGCGACGCTATCTTGGATGCCCATCTGAAGCAGGA
+ TCCAAACGCGAAGGTGGCGTGTGGTAAGTGTTATGAAACCTGGAGTACATGACTGCTCTGACCCAAAATC
+ AGATTTATATTAAATTCGGCCAATGAAGGTGCGCTGACCAACAATAAATAATCTCATTCATAGAATTAAT
+ CAAGAATCACCGTGAGTGCCATTCTTTTTGAAGTTGACTTATTCGATAGCGCCAACATAAAAAAACAAGG
+ TCAAACCACCGGCAAATCTGTTTTTGGATTACCTGAAAAAGTTGCCGAAATTTCTTTTAACACATTCCAT
+ AATATTTAATACAGAAACCGTCGCCAAGACGGGCATGATTCTGCTGTGCGGCGAGATCACGTCTAAGGCT
+ GTGGTCGACTACCAGAAGGTTGTTCGTGAGACAGTGCAGCACATTGGTTATGATGACTCCTCCAAGGGTA
+ AGTGTCTATTAGGTACATAAACAATTTGTGGGCGGGTATTACAATTCGTTCCCTACGTCGGTCCTACGAA
+ CAATACTGTCAACTCAATATTAAATAACAATAAAATCAAATAAAAATCAAAAAGGTTTCGATTGGAAGAC
+ ACTTAACCTGCTTGTAGCCATCGAGCAACAGTCGCCCAACATTGCCAACGGCGTTCATATCAACCGCGAA
+ GAAGAAGACGTCGGCGCTGGTGACCAGGTACAGCAAAGCTTTCCGTTCTTCTACTACCGCCTAGCACTAA
+ GTGATGCGGAGTGTGTGCGTTCGTTCGTTTCGTTTCATTTGTTAAGTGTTTCCCTTAATTCGTATCTTTC
+ CCACATTAACTTGGCTTGCTCACAGGCCAACAAGAGTTTCGCCTTTGTCATTAAAAGCTGATGAGCAATA
+ GGAATACTATTACTATAACTATTTTTTCTTAAGCCCCAAAAAAAATCAAATTGACTTGTTTCCCACAGCT
+ ACGAACCATTTGGTCGAAGACAACTTAACAATTTCACCTCAAGCAAATATATAACGACTGAAATACATAA
+ CATATCACACATTTGGATTACACTGCGGGCGTTCTCTAACCACATAAATTGCATTCAACCAAATCCATTG
+ AAAGATTTATGTAATCATTAAAATTCCGCTAGTTACCGTTTTATGGAAGCAAGAGAAGTCTTGCATGCGG
+ CTTGTCTGACCTATGGAAGAAGGCTTAAAGTTTTCCCAGACTTTGGTATATAGAAAAAACACCAAGAGAG
+ TGCTTATGAAGATTGTAGAAAATACATTTTTTTGTAAACCGTTTTTATATATATAATTATAATCTAAAAT
+ AATAGGGTGTTTAAAATCATATTATGAACATTACTTACAGACATTTTCCTGTGTATGTGCACCATTGCTG
+ CGCTTCTCTCTTTTATCTTTCTTTTCGTTTCATATTAAACCAATCTCGATACAATCCAATACCAAACTTT
+ AAACGATATTGTGCACTTCGCAATCGCGCTTCGAAATTCACAAAAGGTTTCGATTTCAAAACGTGCAATG
+ TGCTGTTGGCATTGGACCAACAATCGCCTGAGATCGCTGCGGGAGTGCATGTCAACCGTGCCGAGGAAGA
+ GATCGGTGCCGGAGATCAGGTGTGATTTAGAAGCAGTAAAGAAGTAGCAGTCTCGGCAGGCCGGGATCGA
+ AGGCCCTTTCCGAAGAGCAACGCATCTTTTTAATTTTTATTGATAGCAATTTAGTTGCGACTAAAATATT
+ CATGGTGGTAGGGCGTTTATAAGCTCTTTGGAAGGGGTGTTGTCGCCACTTCTATAATTTCTGTTTATCG
+ TTTCCTTTATATATTTTCGTAACTAATTGAAGTAGTGTATGACGACTTTATTGCTATTTAATTTTAAATT
+ CATCTGTTTGCCACTATATCATAATAGCGCTGCAATATTGCTCCAACCGACCTACCAACCATATGATCGT
+ CTTTTTTGTTAATTGAAGCTGCCAAATCCATATCATTTAACTTTTGACTTTTCAGTCGATACCATAATTA
+ GAATAGCAGACACAAAACTAAGGCACACTACTGCATATATATACATCACTAACATAATTTTGTAAACAAC
+ TTTTTGACTCCTAAGTAGCAACAATTAATTCATACCCGAATCTATCACCCATGCTTGATTTACCCTTTCC
+ TAACCCAAATGTGTTTTATTTATCTAACGCTACTGATTCTTTTTGGTTTTGGTTACTTTTAAGTGAATAA
+ TTAATGATTAATTAATTAGTGATAGAGATTATTAATGAAGCGAAATAAACTTTTTGCAGGGTATCATGTT
+ TGGATATGCCACCGACGAAACCGAGGAATGTATGCCCCTAACCGTCGTTTTGGCTCACAAACTAAACGAA
+ AAGATTGCTGAGCTGCGTCGCTCAGATGTGTTCTGGTGGGCTCGCCCCGATTCCAAAACACAAGTAACCT
+ GCGAGTACCTCTTCAATCAGGGATCAGCAGTTCCCAAGCGTGTCCACACTATTGTAGTGTCCATGCAGCA
+ TTCTGAAAAGATATCGTTAGAAACCCTGCGCTCGGAAGTAATGGAGAAAGTTGTTAAAGTAGTCATTCCC
+ GCCAAATACATTGATGCCAACACCATTGTCCACATCAATCCTTGTGGGCTTTTTGTAATCGGTGGACCAA
+ TGGGTGACGCTGGGCTTACAGGAAGAAAAATCATTGTAGATACTTACGGAGGCTGGGGCGCCCACGGCGG
+ CGGTGCATTCTCTGGCAAGGACTTCACCAAGGTTGACAGATCAGCTGCATATGCAGCACGCTGGGTGGCC
+ AAATCACTGGTTAAGGCCGGTCTCTGCAAGCGCTGCCTTGTCCAAGTGTCCTACGCCATAGGTCTTGCTG
+ AGCCTCTCTCCATAACTGTGTTCGACTACGGAACTTCTCACAAGTCACAAAAAGAACTTCTGGATATCAT
+ CCGTCGAAACTTTGACCTCAGGCCCGGCAAGATTGTCAAGTAAGTGTCAAACTCTAGATGCTAAAAAATA
+ TTTCATAACAATTGTCTATATTTTTGTTTTAAGGGACCTAAACCTGCGCCAGCCGATATACCAGCGAACA
+ AGCACTTATGGACACTTCGGTCGCGCGGGCTTCTCGTGGGAGGAGGCCAAGCCTCTGGAGATTGACAACT
+ GACTAGACGCTGAAGCGTTGCAACCGCAGTCACCATATGCTAAAAGGTCGAAGCTATCCTTATATTCATC
+ AGCGTCAAAATTAACAGATACCCAAGCACCAACGTAATTTTTAGTGTCGTTTTTAAAGCCTAAAGTCAGA
+ GGAGAAGGCGGCATAGGCTTGCCAACTCTTATGGGCTTTCTTCTCTAACTTATGCTGTGCTCTTCGCTAT
+ ATAATTTAAACCATTCTGATGTGTGTAGTCTTCTCACACGGAACTAGTTTTAGTCGTCTTAATACCCGCA
+ TATATACCTAATAGAGAGCTCCAAAAGAATTGATGAGCTTTAGTTATGCATATACATAGTATAGTGTCGG
+ TCAGTTCAGTAAAAATTAAAGCAGTAGTTAGTACCTCCTTCAATTATCATGCAACTTAATTATGTTGGTG
+ TCTATGGAAATTGTATAAAACAATTAAATCCGTTGCCTAGAAATTATGCAACATTCTCATGTCCCCATTG
+ TAAACTTATTTTTGTCTCTTTTAACATTTCTATTTGTTGTATGCGTTGTATATGTTAAACCTAAAGTTTT
+ AAACAACTCGATTGTATGTACATTACACTCTGTCTTTGTATTTTCTGTAACCAACCATAAGATAATGTAT
+ TTTCCTTTACAAAAATATATTAAAGATAAATATGAAAAGTATAATTTTACCGGTATGCGCAGAATGAAGA
+ CTTTAATCGTACAAACAACAGAATTTGCAATGTCTTTACAACCAAATAAAGTCATCATAACCCTGGTTTT
+ TCACAAAAACATAATGAGACAGCGCCCATAAAAAATTACAAATATTTGTGTACAAGAAACCCAATTTTCT
+ TTAAAAGAAATCATTTTTCATATGAATATTGCAATAAATTTCATGACAGTTTATTTTTAGTTATTGTATT
+ GTTTCGCCTACTATATGGGATATTTGCAACAATATTAATATTTATTTTTCTGAAATTCGGTAATTTATAG
+ AAATGTGTAAAGATTTTAGTAATTCAAAATTTGAATTTAACAGTCTTATCCAGACGCCAAGATCCAGGGA
+ ATGCAATCGATATATCGATATGTCACAATCAACAGTTATTCGCGCAGCCATTGTGATTAATTCTTTAACG
+ GTTTGCGTATTGGTTTTTGCGCAGAGCTAAGCAATGTAAATTCACAAATCTGACGGAGTTCCCAGCTGCC
+ GGACTTAGTGTAGTGAAATTAATAGTAGAAGTAGTTTTATTAGTGTCCCAAGTGTTATTCTCAGCGGTCT
+ TGCAAAAACAACAGGTCACTCCTGTGCGCTATTTAACCAACGCAATTGATCTGCATGTCGAAGATTTGTA
+ CGCGATCGCAGGCAAGAGAGGCTGGTAAAGATTCCGTTGTTTAAATTAATTCCCATGATTGCATTTAGTA
+ TGACGCCCTATAAGCTGTACCAACAGCGCGGAATGCTGCATTCGTTAAAAGGTAAATGATTGAAATTGTT
+ TGTTTCTTTAAATATATTTATATGCATATGTTTGTGTGAATGTGAGCTTGCGAGCTACATATTTATATAC
+ GTACATATGTACATATGTACCAATCAAAGTCGCAAAAATTGGTGTTTAAAATTTTGATTGCAAAAGGTTA
+ CGATCTTCATATCATTTTTAAGCATGCGTTTTGGTTACCGTCAGATTCAGGATACAGTTAAGATAACATA
+ CAAACTGTATATGTATGTACATAAATGACATACACATGTAGGTTTTAAGTCGCGCAAGTACAGTTTCAGT
+ ATACAGTTATAATAACATTAGAACTGTATACATATGTACAATAATGACATGTAAACATGAAAACGAACAT
+ ACATACGTTAAAAGGAATTGTATCTCGGACACATTTTATTTTGTTTGAATTACATTTGGAGCCGTACAAT
+ CTTATTTATGTAGGTAATACAATTTTCCTTGATAGTTGTTATATCTGTTGTCAAGCTGATGTCCTATAAG
+ AGAGCCTTTACTGTCACACTGGTCCAAGCTGGTAGGAGAATCATCCCATTCAAATTCATCCATATTTGTG
+ TCCTCATCGCTTTTCGAATCTTCATTATCCAGGGAGGGAATGAAGAATTTTGAGCTTTATGTTTTGAAAT
+ GCTATTTCGAGTTTTTTGGTCATGAATGTGACTCTTTGATTGAGCAAAACCACTCTAAATGAATCATTTT
+ GTTTAGCAGCCACCATCATGTTGGTATTGAAAGATGGGGACCACATAGCCATGACCTTGTCTTCTTAGAT
+ CGTTGGCACAACGTACTTGATTGTGGAACTCGCAGAGCGTGGCAAATGTCATATTGCGGCCATTGCGGAG
+ AATGCAGACAGGCCGGTAGTACCGGGGACAGCTGCGCTCGCACGGATCCTCATCCCGGTCCAAGCCGGCG
+ GCAGTAGCCCTGCCATCATCCTCTTCATATTCATTATCGTTTGAATTCTCATCACCGTCGAAATTTTGAT
+ CATAATCTAGAGCTGTGTAGTAGTTATAGCTTCCCAAGTCTCTGTTGCTGTGATGGTCTTGCCAGCTCCA
+ TTCCTCCACAATGGTGTGCTCCGTTTGCACCTGTACTGCGAATGACAGGTGGAGCATGGCCAAAACAAGT
+ GCTATGAATGCGTAAAACATACTGCTTTGGCTCCTATCGATCAACTGTATTCACGGCAGTCCAGTTTCCT
+ TGCCTCTTAAATAGACAACTGTGCGCCAATCCACAGCGACGGCAGTTGTTCAAATAATTTCCATAATTAA
+ CTTTGTCGGTTTTTATTGTGACGGCTCATATCACAATTGATAGAGCTACCAAATAATTTGAATACTTTAA
+ AGTGAATCAAGGGAACAGGCGAAGTCATACTTTGCCGTTCTGACTTAAAATTAGTCTAAAGGCAGATAGA
+ GTTTGGTAACGAACGGCGCAGATCTTTAACTCAATCCTAAATTCTAATCTTGGGCAAGACTTGATTCTAA
+ CTCTTATGCAATTTGAAGCATATCTACATCTATATATTTTTATACCCGTGACTCGTAGAGTAAAAGGGTG
+ TGCTACATTCGTTGAAAAGTATGTAAGAGGCAGAAGGAAACGTTTCCGACTGTATAAAGTATACATATTC
+ TTGATCAGGATCAATAACCGAGTCGATCTAGACATGTCCGTTTGAACGTCGAGGAACTATAAAAGCTAGA
+ ACGTTGAGATTCAGCACACAGATTCTAGAGACAGATATTTGTTGACCTTTGTTACCACGCCCACTCAAAA
+ ATTTTACACAATTTTAAAAAATGTGTTGAAATTTTTTCATTTTTGATTAGTCTTGTAAAAATCGATAGAT
+ CGATTTTCTAAAAAACTTTTTGCAACTCCCTAAAACCGCCCAAAACAGCCACACCCAGAAAAATTATGAA
+ ATTTCGCGTCCGCATTTACACTAGCTGAGTAAGGGGTATCTGATATTCGGGGAACTCGACTATAGTATTC
+ TCTCTTGTTTATATTTAATATTTCCATGATATACATATAAACTTACGCCATCGCATAAAAAAGTAAACCC
+ ACTAATATTTTTTACATATTTGGTGAAAACAATTTTATGCGTACTTAATAATTTATTCGTAGTGTTTCTT
+ CTGCCTTGTTAACAATATGATCGAATTATAGTAATTTATTGTTCCCTTGATTATATTTGTATTCTTGATC
+ ATAAACTTTTATTCAGAATCCAATATCACTTTGATAGTTTATTAATATTATTGAAGCCCATAAATAATAT
+ GGGAGGTTAAGACTGTCCCCTGAAATACCGCTTAAAATAATTTTTCTAGCACCGAGGTCAAACCGCCCAT
+ GTTGTTAATGTTAGTAATTGTACGAAGTAAAGTTAAAATATTTCGTTAACAGCTGTATGACATATGCAAA
+ AATGGGGCTGACCTCGGAGTGTTTCAGTCGCAGTCTAATCATAAAGTATGCTGCTACGGTGAACAGCAAA
+ TAAAAACTCATCAAGCAAGATAGAGACCACAAATAGTGCATGTTTTCGAATCCTAAAAAGGCTAACAAAA
+ CTTTCGACTTTTTAAATGAGCAAAAGATTTCCGTGTCTTCGCAAATTGTGTCGGCGCGTCCGTAGTCGTA
+ CAAGGATGCGACTAGGCCTTCCATACTATGGCGAAGGTAGCTAAGATGCATGAGAAACCTCATAAGAGGG
+ GATATGTATGTTCCTCCGCCATACCCAATGCCGTAAATGGAAAGCAGGATCAGCGGCACGGCGAGAACTG
+ GCCCCATGAACATTGCATTCTAAAGTATAAGTGAACTAATCAGGATATATTAAAAATAAATGTGCGCCAA
+ ATCGCTTACCACTAAGCTCAGTCTACTGGAGATCAACAAGCCAAAACTGTCGGAAGTTAGGGCCGTTACG
+ AAAGCTATTGTAAATAGCATGGCAAAGCGGAACCATTCAAGTGGTTGGCTGGACATTAAGTACACAATGG
+ ATAGATAAATAACGGCCAAAATAAACATAGATGGTAGCTTTGAGGTAACCATTGCTGCGTAGTAGGAGCT
+ CAGACGGTACCACTGGTTGTTGTACTCCCTTTTTAACAGATTGATTTCCGTGGGAACTTAAATGTAGGTA
+ TTTATTATTAAGAATTACTGCTTGAGGTTAAAATATAGTACTTACAATATAAGAGCACAGGCATCATAGG
+ AAGGTAGAGGTATGCTATCACAATGGTGAACATGAAACCGAAGTTAAAAAGCGCTTTAGAGGCCGAGGTT
+ CCCATACCAAAGTAGAGCGAACCCACCAGTAAAGCAAGAACGATGTTCATGTAGAACTTAAGCTTGATGT
+ ACGACTACGGAAAAAATAAAATTACATTGCCTTTCTACGTCGTTTTCTAAGTGCACTCACCTTATCTCTC
+ CACATTTGGATTAGCATACGCACAAGCAATAGCTTGTACTGTAGCCACCAGCTACATTTGGCCTCCAAAA
+ GTTTTGGGCTAATCTCTTCGTCAAACTGATCCCTTTCGTAAAACGACGATGCCCCCGATGTGGTGTCGGT
+ TTTGGTTGTTGTTGTTTCACCTTCCACTGCTGGAGGACTCCATCGCGCAACTTTGCCGTTGCCCACGGCT
+ TCTACCATTGGCTCGTGATAGGACCCGCCATACTCAAGGCAAGCAACTTCGATAATGAAGTCAGCCGGGT
+ TGTAGGTTATTGGACAACAAAGCCCAAAGTTCTTCAAGAAAGGTACAATGTTGGACCCCTTTCCTTGGTA
+ GACGCACTGGCCTTCGGCTAGAACGTAGACTGCATCGAGCATCTCGAAGATCTTGGCAGATGGCGTATGG
+ ATGGAGCAGATCACAGTGCGCCCCCCGGCGGCCAAAACTTTGAGTAGGGCAATGCATTGTGAACTCGATA
+ AATCGTCTAAACCACTGTTGAGTTGGTGGTAACATTAGTTCTTCGACTTCAATATTTATCTTATACTCAC
+ GTTGTAGGTTCATCTAGAAAGATGACAGGTGGGTTGTTGACCAGCTCAAGGGCAATGCATAAACGCTTTC
+ GCTCACCCCCAGATAGCTTTTGAGCCATGGTGTTTAGGGTGTCTTTTAGGCGCAACATTCCCAAAATTTC
+ GTCAATCTGCTCAAATGTTAAGATAAATACACGACAAAGTGCATGATTTAAAATCAATCTTACCACTTCT
+ AGCTTTTGTTTTAAATTTAGTTCTTTTCCCAACTTCAAGTTTGCCGCCAAAATCATCATTTCTAGTACGG
+ TAAACTGTGAGTCCAGGACATCAGTCTATGAATTACACCAATATTTATGGGAACGCAATTCAGTAATCCA
+ CTTTTACCTGCATTATATATCGAGACATTTTGCGAAAGACTCGCATATCTCGCGGACTGTTGTTTACCAA
+ AATCTCGCCGGATTCGCACACGGCGCTATCGGTAAATATTAAAGGAGTATTATAAGGGGGTCGTTTGTGT
+ TATATCTTACCCAAAGCCCGCCAGCAGGTTTAGCAGTGTGGTTTTACCAGCGCCTGAAGGCCCTATAATC
+ GCAGTAAGTTCGTGAGAGTGAAACATTCCATTGACTCTCCGCAAAATCGTCTTTGTTTTTGAAGCTGTGG
+ GGTGTGATGACCATATTAAAAAGAATAATTTTAATGTTTCATTGTAAGGGAAGATGTCGGCATTAATTTA
+ TTGTCGTTAATGTGGAATTAGACGGAAATTGCTATTTAATATGTGCATGTTCAGCATTAGAAATCAAGCG
+ AGCTGTGGAAGCAGTAATTACTTCGAAAATGTGCAATTACCATTCTTAATACCCCATTATCAATCACGAA
+ TATATTCATTATCAATTACTCAACCGTAATAGACATAAGCTGATTTGATACACTCACCATTGGTCTGGTC
+ GGGAACCACATAACATAGTTCCGAAAACTGCAAATTTACCGCTGGCCAGGATGGCAAATACTTGAGGCCG
+ AGGACTGTTTGAAAGTCCTCAGATTGATCGGGCTCGAGGCTATCGGCGTTAATGTCGCTGCTATATTGAA
+ GGGAGCTGATTTGGGAGGTTGTACTGCCTTTTACGCTGCTGGCAGTTTCCATTTTAATATTTCTAGACTT
+ CGTTGTTGTTTTGAATCGATGTCATTGCTCCTTGAGAAGGAAAATGGTGATTTTTTGATAAGAAATTCAA
+ TAATTTCACTTCGCACTAAAATCGCTTATAAGAATTGATCTGTTTACCGTTCACATAATGCTTTGCTTTT
+ AAAGATAACCTTTTAAGGTGCTCGTTCGAAATCTGGAATCCTCGTTTTAAGGCGCAGTTTTATTTGCACT
+ ATACACTAGAAATTAATTGGTTAACAGTACAAGAGAAGGCAGTACGTTTTTTTGGCTTAAACCAGTTTGA
+ TAAACTCATCATCAACTCATGTGTCGTTTGCTTGCTACCTCAATTCAAGTTAATTAAAAGCGGTAATTTG
+ CATTTCTAAAAATTACTTACGCGTATCTGGGACCACGGAAAGCGCCCTCCCTTCGTTCTGGAAACAAATT
+ CCGAACTGACCGAAGAACTTTTTAAATTAATTTCATTTACCCTACGAAATGCGCGATCGTAGTCTCTGAG
+ CGCAGCCCGAAAACAAACTCAGATTTTCAATTGATGGAAAGCAGTACACAGTACATGCACGACTGACAGC
+ CTGCTCGAGTTCTGACCGAATGACTAGTCGTCTGACTTCAACGACGGCCCGGAGATCTGACGGTCCGGGT
+ ATATGCCGACCCAGTCAGGGAATGGGGGAAGAGCAAGTGGCATGGCGAGCTGCTGAGTAAAGGCAATACA
+ AACCGAAACTGGGCAGTCGATTTGCAATTATTCCGATGCAGCTTCAACACTACAGAACTTTCTGAGAAAT
+ TCGTGCGTTATCAGCGAGTGGGTGAACCCATAGCGGAAGTTTGGATCGGCACTAGATTTAAGGCGGTCGG
+ GCGGACAGTACGGATGCGCAATCTTTACGTTATTATTCACTCTTTATCTTCTTTTTACTTTGACTGATTG
+ CGGGTCTCATGTTTTGGCAACCGAACCGCTTTATCTGTTGAAAGCGTCAGTCTATGAATACAAATTTAAT
+ TGTGAGTCGGCCTCACCATTGGCGCCACTTTTTGATACCGTTTAAATCAGTTTCGTTTAGCGTCTTGCGA
+ ATGCCGTATTATGCTGCTCATAGCAAGACGTTTTTTCTTGCTTGTCTAGGGTATACAATATGCGACTCGC
+ CGGCAAATCATTTTGGCCGGTGCTGTGAGTAATGGTGCATGTAAAATGTACTGAAGCGAGAATATTGAAC
+ TGTGATACATGCATCAAGAGTCCAACGAATTAATTTCACGTACATGTATATAAAAGATTAGGTATGTAAA
+ TAAATCCTTATGTTTTTAAATAATACAAAACTTTTCAACCAAAGGTCTCTGATAACAACTGTCTTGGCTG
+ ACCCAGAAATCGATTCAATAATTGTCTTTGCTCGTGTCACCCAGAAGCGGGGTAAATAATAGTCAAAAAC
+ TTCTTTCGTGCTTGTGTGCAGTGCTGCAAGCACTGTCGCAGTTGTTTTCGACTTCGAGTTCAACGAACGC
+ GTTAGATACAGCCGGCGTACACTACTATTTGCAGCTGCGTAAATGCACCACTCACTGGCTCTGACGCTGG
+ CGCTGCAGCGGGTGTATCGGTAGAGCGATAGGGGGCACTTACTCCACTTTCTTTTTGTAGTTGCTGCTGT
+ CGCTGGCTTTTTTCACTCTTTCTCATGGCGGCAACCACGCCACAGCAGCGAAGAAGCGTCGTCTTGTTGC
+ ACCGACGACCGAATATGTACTAAATGCGAGTGCAGGAAGACTGCGGCAGTGACTGCTACTGCAAATGCTA
+ GATTTACAGAGGCGAAGTCTAGTGCCCGGGCCGAATTCTTCTGCCCTTCAGAAGTCTAGAGGCTGGCTTC
+ AGCTATAAAAGATCAAAAACTTGTTTTGCAGCCCATTGAATCCGATTCGAAGGATATGGCCAGTCTATTT
+ ATACCGATTCCACTCACTCACCACTCACAAATAAAAAAGAAAGAGAGACCAGGCTTTAGCTTCAGTCAAG
+ TCCTTACCTTAATTATAGTAGCTTAAAATTTTGAGTACGATTTCCAATTAGGATTTTGTTAAGGATCGAA
+ ATATTATAAGTGACATTCCTTTAAAATTGAATACCAAACACTATTTCTGAATGAAATTAAAGCAGGCACA
+ TTTATAGGAAGGGGTCCCCATAATTTCGAACAATTTAAGGCATGTCATTTGCAAAATTTTAAACTCCTAG
+ CAATAGTGTGAACAAAACAGCGGGATGTTTATGTTTTCATATCTGGGATCCCACTTGGAAATTTACAGCA
+ TTCGTATCCCATGTGGTGAATGCTACAATGCTAAAACCTTTTTCAAATTAAGAAAATAAGATATTTTTGC
+ GACGGTGGTTTATGTGTATGTAAGTAAATGCTTGATTGCTTGAATAGACGCCCCAGAAAAACGTTGTCGT
+ CCACTGCAAGCGATTCGAATTTAAACGGCCGACTCGCACGACTTGATTTCGTTTTCCGGCAGATGGCGCT
+ CCAAGAGCTTTTAAGTAGATAATGCCGTTGATCACAAAAAATAATGGGTATCATAATCTCAAATTGTCTA
+ ATTTCAACTTTTTAGGTAGACATCTTTATTTGCCCCAAGAACACGTAGTTTGTACAGTATATATTCAAAA
+ ATGTTTATTCTAAACCTGTAATAAGAAAATATTACAAAAAATTCCAAAGGGTCTTAAAGTACCTTGAATA
+ AAAATATTAATGTATATAGACACAAAACATGTTCGTTTTTAATTTAAAGTCATTCAAAAATCCTTCGGTA
+ AATACAATTGGAAATGTTATTCAGTTATTTTTATTTAGAAAATTGGTTTCACGTTCAATAACTTATTTCA
+ TTATACGATTCACTTATATCAATGATGTGCTCCAACAGTGGTTTGAATTGGTTTTACTACATATGCGGCT
+ GGAATCAAGCTGATTTAAGATAAGAAACCTCCTTGCGTTTGTATCACTTAAAAGAAGAATTTCGCGACTA
+ AAAACTAGACAAAAAGAAATTTGTAAAAGATTAATGATTAAGAACAAAACCCAAGACGCTTTTTTGAAAA
+ CTACAATATAAAGTACGTACATAGAAAGCTATTAAATCCAAAACAACATTTAAAATTATGTAATATGCTT
+ ATCGCACAGTCTTCAGCTTCCAGCGCAAGAACAGGTATGCCGAGATGCGCAGCACCACGAAGATCACAAT
+ TAGGGCCACAATGTCGAGTGTAAAGTTAGCGTTAACCATGTCCAGTTCCTCCAGCGTGGTAATAGGTGAT
+ TTAAAATGGCAGTAAGTCTGGAAGCACCTAAGTTTCTCCCGTCCGTAACCGTAGGTGGCCAGAGCTGTGC
+ CCTCGAATCCATATCGTATGTACGACAAATATGTGATCCACCTTAAGTATACTGGTATAGCGTCAAAGGA
+ GACAAAGAAGCCGGAGAACAGAAGGAAGGGCACGGACATCACTGGGGCCAGGAAGACACCGTTCTGAACA
+ TTCATTGCAGCGCCTACCACCAGACCCACGGACTGAGCAACGAAAGAAATGAGAAGGCAGGCCGACAAGA
+ ACATGGAAAAGCGGAATAGCTCCCAAGGTTGTGAAGTGAAATAATACACGATCGACACGTAGATAACGCA
+ GAAAATAGCCTAAAAGAAACAATTATTTTGTATTAGTAACATTCGCTCTACTCAACAGCTGAGTGCAACT
+ CACTTGAAACGGTAAATCAGCAACTGATATAGCCAAATAGTAGGACTTTAGCGAGTACCAGCGATTAAAG
+ TTTTCTTTCAACAAAACGGGCATCTCAAGCGGGACTAGAACACACAAAATAATATATTAACTACAGAGAA
+ AGGAATATCAAACTGGTTTCCTTACATGATAGGATCGTAATAGTCATAGATGTATACATGAGGAAAAGCA
+ TGTTAAAGAATAGGAATCCCAGGTTGCTCAAAACTTTTGCTCCATCATTGCCAATGTCATAGTAGAGTGC
+ CCCAATCAAAAATCCAACTAACAGATGGGCAAATAAACGCAGATACATAAGAGTCTATAATAAAGAGAAG
+ CAATGTTTACTAAAATCCTGAAAAGCACCATTATAAGTTTTCTTACCCAATCCCGGTAACTGAAGAGTAA
+ AGTTCGCTTAAGAACCACCCAGAACTGGTGAAACTGCGATGTTGGATATCGCTCTGGTGATGTTATCTCC
+ TCCGTAAGCAAGGCAGTGGTGCAGTTTACGGACTTCTCCACATCGATCATGGCATCTCCCCTTTCATTGG
+ TAGTGACCAAGGCAGAGCTAACGTTGCCCTCCTTCACAATATCATTGACCATGCCGTTGAGCAAACCGTT
+ GTTCAAGGTCAAATTGTCCTCGTACTTGCGACCGCTGACACTTGAAGCGTCGTTCTTATCGAGAATAGCC
+ TTCAGGTTTTGCACCTTTACCAAATCGTTGCGAGCCTTGAGGCCGGCATAGTCTGCTGATGAACGAACGT
+ CCCGCTTGCCGTTGTCAATAGCATCGACCAGTTTGCGCGTATGATCTCCGTGCTCCCCGCAGGACACCTC
+ AATCACGTAGCTTGCCGGATTGTGGTAACTGGGGCACTCCAGGTTTAGCGTAGACAAGAAGGGCACCAGT
+ TGCTTTGTACTGCCTTGATAAACGCACTGTCCATCTGCGAGAGTGTACAGCTGGTCGAACATCTCGAAGA
+ GACGAGCGGACGGTTGATGGATGGTGCATATGACTGTGCGTCCGCCAGCAGCTAGCATTTTTAGCAGATG
+ AATGCACTGAAAACAGGTAGAGCTGTCCAGGCCGGATGTGGGTTCGTCAAAGAACATTATGGGAGGATTG
+ CTGACCAGTTCAAGGGCAATCGAGAGCCGCTTTTTCTGACCGCCGGACAAATTTCGAGTCATCGTATATC
+ GGTGCTCGCTCAGGCTGAGAGTAAGCAAAATGTCATCGATCTGGAAGAGGGTGTTAAGCAGGTTATTAGC
+ ACGTTTAAGATAAAACCCAATACACAAGACTGTCGAATCAAATTGTCTACTGGATTGGCTACTTATGATT
+ AATCTTTAAAGTTATCAAATTCTTCCTCTCGGGCTTTTTTAATTTTTTCAACTTGCCATTGAATGCTTCT
+ CGGGCTTCGAAAACTTCTTGCTGAGCTTCAGATTCGTTGCCACAGTCATTGCTTCCTGGACGGTAAGGTT
+ TCCGTGAAGCTGATTGTCCTGCATGATGTAGGCAGAAAGCTTGCGAAATGCGCTTAGGTTGCGCTCGGCA
+ CCGTTCATCGTAACGCTGCCTTCGATGCTCGAAGTTCTGCAAGTGCAATAGATTAGTAATTTGGTAATTT
+ GGATTTTAGAACCGAGGGCTATTGTAAGTATGAGTATCATCTAAATTACATTCCTGTACCATAGTCTAAA
+ AAGGCCCAACCTTTTTTTTTTGTGCGTCTACTAGACCTATTATCACTGGGCAAAGCCAATTTCGAGTAAT
+ CTAGCGTGTATTTTATTGTGCATATCTACGTTTGTGTGTATGCGGACCTTTATTTGATATACTAAGCATA
+ CATGTGCACGCGATCGGGCAACCTAAGTCCGAAGTCCAGCAAAGTAGTAGCTGATTCTCCCTCAAATATT
+ CAAACCAATAAAACTTGGCGACATTGCTAAATGTGTGTGAGGAAATAGCAAAGCAGTCGATTACACACAA
+ GTACACTTGTATCTATGTATCATAGATTTCCTGCTCGTATCGATTCAGGGTGATCGGTTGACCACTCCTG
+ GTAACAAAATTTAATGCATGAAAGGGTAATGAAACGGTTTATGATTATTATGCAATAGAGCAAAATTTAA
+ GGTTTACAATAAATAAATAAAGATTGAGCTGTAGAAGGAAAGTCTTTGCGCTTAGAATAGGTACATATGT
+ AAGTGTGTATCCCACATAAAATACAGAAATACGAAGAACGCAAGGCGAGAATAGGTCGGCTGTTTAAGCA
+ CCAAAAGCGGCAGAGTGGTTATCAAGTCGCAATTATTTCTGATGATAATACAGGGCTGAATATAAACATT
+ TTCGAACTCGTTTCGCCGTATTCTCGTGCGCTGGCGCAAGGTCAGATTCAGTGTCGGAATCAGCAGCTAC
+ TTGACGTGAATGCAAATAATCAGGCCCTGCGAAACCTACTTGTAGCCAGACAAAATGTTGAGCAGCGTAC
+ TCTTGCCAGCACCCGATGGTCCCATTATGGCGGTGAGTTCTCCAGACCGGAGGCGTCCACTGACGCCCTT
+ CAGAATGGTCTTGGCATCTGTAATAAAAACACACAAAATTAGTGTTTGGGCCAATCTCTTGTTGGGACTA
+ AAAATAGTTCGCGTTTTGATATGTCTTACGTCAATATCTAAGTGCCGCCGCAGCTATCAAGAAAGATATT
+ GATTGCATTGGCTTTTGGACGAGCAAGTGTAGAGCCGATAGGTAAACAAAATCTGCAAAGTCTGACAATC
+ GAAACACATAGCACGGTCAATGGCCCCATCACGTTTTTCTTCGTCCACCTCCATATATAGTATGACTTAT
+ GCTATTATCGACAGAATTCCAACAGTTGTCAAACAACCGCGTCCATTACTCAAATTTTATTAAACATCCA
+ ACATCAACAACGGACAACTAATAAACAAAGCGGCTAAAATTCGTAAAAAGCCAATTGCACTTTAGTAACG
+ CTTGTTTAAAAATAGTTTGACTTATTCTGACGTATATTCGCAGATGCTGCCTAAATGGAACTGTTCAGAT
+ GCGGAAGTGCCTTATAATCATGGCATACCTTTAAAGTTTAAACCAATAGTTTTGTACAGCAAGCCATCTG
+ CTCTACGGAAAATGCTAATATACCCGTTTTCATGGGGGCACGCTCTTCGACTGCCGGCTCTTAATCAAAA
+ GATGTATTTACTATTGAATCGACTTTGGACACAAAAGCGAGCTATGACTGGTTATAGAGCTTCTGTAAAG
+ TGACTATTACGAAATAATTCATTTTATGTTTGTCATAACTCCGATTAGTAAAGTACCGTGACCCGCTCAG
+ AAGTGAAACTCAAATTTATTAAGCTCATGCAGGGACTGTAAATGTTTTATTCGGCGACTTACTTAATACG
+ TAGACTTTAAAAGCTGGTAATGAATTCCAGCTGCCAGGCAGCGACTAGCAAGTCGTAACCACTAGGTACG
+ CAATGTCTCTCATTGAACTTACTTGCTTGCCAATTGATGTAATAGCACCAAAAGTGGGGTCACGCTTGAA
+ AAACTATAGTCCAGCGCTAAGGCCAAATCGTAGCTTTGATGTTTATGACCGGATTGGACAACAAGTGGAA
+ CCATTCAGGGCTCCTAAGAAAAGGTTACGCCAAACTTGCAACAAGGGCACAGAAAGTCGCTTTCAGAATT
+ TATTTATATCTGTTTTAATATAGCAGCCGAAAACGTTAGCAGGCACTTACTTCATTAATTGTGTTTACTT
+ TAAGTGGCATAGTTAGCCAAAATCAGCGCAATTTCCATCTGTTGCCTCACTTCCATCTTATATTGTATAC
+ ATTATTTTGGCACATAACTTAGCACACCCCAGAAGGCGGCGTGCCATCTGCAAATCTTTCGGCTAGGTGG
+ GGCACGCTCACAGGGCAGTGTAAATAAATCTGTGTATATTCGCTTATTCTGAACGACTTAATTGAGTCGG
+ ATGGCCGACCTTTGAGGTGTGCAAAGTTCAGGCTGCTGCCTTCTCCAATTAGTTTTGCACTTGGCTGGCC
+ TTGGGCTTAAAAACAGGCTTTGACAGTCCCTCAATCTTAGACGGGATTCACGGACTATGTCCGCCGTGAG
+ GCCAGCCATCCAATGCGACAACGAGGGGAGTGGGTTTCATGAATGAGCTTTTATAAATATAAGAATAAAG
+ CAGTTGTGCACGTTCGCATACCAAACTAATGGAATATTATCGCTCGGCCATCATTACTTATTCTGAACGG
+ CCCCACCGGGGCACTGCATATTACCACAAATGTGTTTTCACCACCACACCCGACTAAAGCTAGCTATTGG
+ CAGTGACTAAATCCTAATCGCTCTGCTAACACAGAAAGCACATACCGCCGCCATCAGTCTTGACTTCCTC
+ AACTATAACATACCCGCTACTCAATTTCATAATCCTTTTTTTTTTGGCGGATCAGGGGCAGTCTACGAGG
+ AAAGGGTATAAAAACAATACCTCTCCCTCTGGCACGTCATCACAAATTGTTTTCCATAAAAGCAGTAGAT
+ CCAAAAAAAAACCCCATTGTGCTCCACCCATGCTTTAAAGTAGATACACTGCTACGTGAGAAAAGTGCGA
+ GTACATGGCTCCTCGCCTTTTAGATGCTATGGCATCGAACCAAGTTGTTGACTGTCCCAATAGCGAAATA
+ GCTTGTGTGGGCAGTTACTCCGCGGCTACTGGCTGATGATTTTGATGTATTTAGCAGTGCTTATCGCGGT
+ GAAACCTAGTGAACTTTGGCCAGAGCCGCCCTTGTGAAACTGGGAAATGAATTTGACGAAGAGACGACGG
+ GTTACATATCTACTCAGCCACAACCCGAAGTTCTCCGTTGCTCACAGTCTGAGTGTTGATACTGCGTTAC
+ AGCTGCTAAAAGAACAAAGAAACCAGAAACCAACACAATGCGAAGCGCAGCTAAAGCAAACAAGTAAAAC
+ CCGCTAAAGCCAGGGAAGTGCGTAATAGCGACAGAGTACTCCGGAGAACTAGCTCAATAACACATGTGCG
+ GAGTACTACTAGCCAGGACCGGAAACAAAAGCTCTAGGGTGAGGTGAGAGCAGGCGCGGGAGGTTCAAGA
+ TCCCGCTCTCGTGCTGCCGAGGAGTGCAGCTTGATATAGAGAGAGGTACTAGACAGTGGAAGTACTTACT
+ GCTCCGGTTCCCCTCCTTGACGCGGTACGTCAGGTTGTGAAAGGCCAGGTCCACCGCTGGTCGCTTGGGG
+ AGGTGCTGGAGCGTCTTTGGCTGGGCGGGTACTATTTGAGCTTTCAACTGACCCGCTCCGGCTGTGCCCA
+ GTCTGTTGTCGTTCAACAGATTTGCATTATCGTTCTTAGTCATCTTGTCAATCAATCAACCAGGGGTTAA
+ AAAGCAAAATGCAACCACTGTGTTGTGTGTGTATTCTTTGTAAACTTTAGCACTGACAGCAATACTGCAG
+ CCCCTGCTGCCCTTCGTTCCCGTTTGGTTTTTCGTTCGCGTTCTCGATTCGATTCCACCACCGTCTGGTC
+ CGGTGAGAGAAATTTTCCACCCGTCTGCTCGAAACGGTACTGCCGCTTCTCAAATATTAGGACTTCACTC
+ GCTCGCGCCGCGATCGCAACTGAAATAAGCAATTGCGGCAGTGGAACAAAGGCAGAAATTTAGGCAACCG
+ CTGACAGAGAGTGCCATCGCATACTCTCACAGCCCCAATGCTTTACGTCTGTGGTTAGAGTGGGACGACA
+ ATAGAAGCACTACTTCTGGTGGGGATTCTAGTGCGATTGAGAGGCACTGCGGGTTGGCTCTCTCTCAAAA
+ GCCAGCGCATTCTTCTACTAAGTCTTGAATGAATTTGGGAAAAGCCTATAATCTGTGAATATTCCTCGAT
+ CGGCGGACCCATGTATCTCGAAATAAAATACCACTAACTAATTTCGAGGAAAGTCTTTACCTTGAGGAAG
+ GTCTTTGATTCCCAGTCTTGTACTTTGATTGGTTTATCAGCCTTTTATAGTAGTTAGTCCTGGAAGCTAA
+ GGTTCTGGCCATTGGTTTATTCAATCTAAGTTAAAAGTTCACGGCCTCGCTCATGACTCATGAGTTATTG
+ GAGGGGCTTATCTATGGGTGTCAATCTACAGCTGATAGGAGTTTTCAATGAGCCGATAAGGGGTTGTACT
+ TTGTCATTTCGTGTTTTACGTAAAAATAAGTTAATCGGTGCCGTAATTCGTTTAAAGGAGCTCTAGTACG
+ CTTTTTAATGGTTTGCTTACGCGACATTTTACCTACATTTTGCTTTTCCCTACATTTAATGTGGCATGAG
+ GTCATTTGTGGCTATGGCGTGGGACGACCTTACAACTTTGCCCCAGAAACAGTTTTGTGGTATATCTGAA
+ CGCAACAGTTAGATGTAGACATTGCTGTAAGGCTCCTTGTTGGCATGCTTTTACGATGCTCCGGTCTATA
+ TTTTGCCCAATCTAATTGGGATTTACGGATTGCACTGGGAGTGCTAATAACGTTTAGTTAAACCGGTTAT
+ TGTATATATTGGGGCAAGTAAAAACGTAATGAATTGACCAACAAAAGGTATTTTCCCAGTACAAACCGCA
+ ATTTGAGATATTATTCCTAGTTCGGTTTCTGGGTTCAAATCAGCATACAGCACTAAAGTTATGCAGTCGC
+ CTTAAGATATGAAAGAATAATGTATTTCCACTGGCAATTTCCCGATGACTATTGGCTTGGAAATTTTTTA
+ AAGCTTGTGGCTAATCAAGTCACGGAGATGTCAACAATTGGCAGGAATTGCAAACCGGTTGTTCTACACT
+ TGTTGATTTCGTTTTATAAACGGGGGGTGTGGTATATTAGATGTGCCAACTAAATGTGATGCATTTTGCT
+ TGAGACCCGCCTGATTCGGCTACTTACAGATTATTATTTTCCAAAAACTGCTTCCAACTATACTGGTTCA
+ TGGTGCCGTAACTCAACAGCTACTGAAACCATCGCTTTGAAGCAACAAGTTGCCTTCGCGAAAGCTAAGT
+ CGCAGGCAATAACGAATAGGCAGTCGAAACCCAAACCGAATATAAGAATTAGCGATTTTGTATTTGGTTG
+ TTGCACATCGGGTGTAAAAATATGTACACTCTGCTGGAGGGAAACTTTCGTAGTTTCTTGCGAAAACTGA
+ AGCCGGCCAACTAGTGGAAACGATGCCACGTAACTGGAAAAGCGTAGACGGCTATATGGGAATTACTCGG
+ GTCTATGGTGAAAAGTGGCACTCACACATTGGCACATAAAAGTTTCCTCTGTTTTCCTTGTTTTCTTTGT
+ TATGCCCACCTGAAGCTCTCCCAATATGAGCCGTCCAAAAAAGCTTGCTTTCCCGCCAGAAACAGAGTTT
+ TAGCTTTATTTTAACATTAATCCTATCTGAAATATACTCATCCGTTCTTCAGTACTTTCCTCTAAGTTAC
+ GAGGCAACCAACAAATAATTGGAAGACATATCTGTGGTCTCGGCTTTTGTGCGACAACATGCCATTATGT
+ AGGAGGGAGTGGGCCAATATGCGTGGCTTGATGAACGACGGCCTAGGACTAAGTATAATCTGTAACAAAT
+ AAATATTGAATATCCTCCACACAGGATATTTAGATCAGAATTTACATAGCATTTAAATTTCAACGTTTTA
+ CATACTCAGCCTAAAAGTTGGCTACACTGTGTACTTATACTGCTATTTTAGTTATAGTTTTAGTTAGATA
+ TATTTTTAATATTCAGAACGTCGTATGCGAGACCCAAGCCAGGAATAGGAACATTTAGTACCGAATTTAC
+ ATATTATAAACAAATCATTATTGCTTCATTTAAGGCTCTATTAATGCGGTCCACCACAGAGTTTATCAAA
+ TGCCAAACACGAATAGACACAGCTGATACGGTGCTCCTTGCATTCGCTATATTTAATTGTATATAGTGAA
+ CTTTGTACCAGGCGTGTATTCAAAACAATCAGCCAAAGAGCAAAATGGTGGAGGTTTTTACGAAGAGATT
+ ACGAGAAATGAGAGAGTGTTGTAATAAGTAGTACTGCTGAAATGCATCTGCATACTGCGTAACCTATCAT
+ AGTTTCTGAAATGAATTTATCAAAAATGTAGAACTTAATTTGTGGGTTCTAAAGTGGGCCATGCACATAA
+ ATGGTGCAGGTGTTCTACGATGAGAATTACTAAAAACTTTTGTTTTTCATTTGGCGCTAATGCAAGCTAC
+ AAGTGCTCGAAATGCATAAATGAGCTTATAGCGTGTGCTCAGTAACGGGGCTTTTGGCTACCCGACTAGC
+ CTCGAAACATAAACATTATGGGTCGCATTGCAGGTCTCTCTGGCTAGTGGCTGCGGAGCGGGTGCTCATA
+ TACCGCCAGTTTTGAATGCTCTCTGGGAGGCCTTTGTCTGTGCGTCGGCGTCGCAAACGAGATAAAGAAA
+ AACCCGAGGCGCGCGACGAAACAACGAAAAAAGTGAATGCTGTCGCGCTAACTGTGCTCACAAGACTTCC
+ AAACATCGAATTGGTCGGGTGTCCCCAACAGTCGCTCCGCAGCCCCTGACAGAAACAGAAACGAAAACCG
+ AAAGTACCGCAATCCAAAATTACCAAAAGACCTGTCCAACCAGCGACTGTTTAACCAATCATATAACTGT
+ AAAGTGGAAAAACGAGCAGAGCACGGTAAGTTGTGCGGAAGACTGCGTCTTCACTGGAAAAGTACCCCTT
+ TTTTAACTACCTCGGAAAATCAAGTGCAAGGAAAATAATTACATAAAAATTCATGAGAAAAGCAGAGTGA
+ GCCAGCATGCCACCAGCCCTTGCCCTTCCTGCGCACGTCCTCACATTCGCCAGCAATACATAACTAACCG
+ TGTCCTTTTGTCCTTCTCGCCGACTCCAATCCAAGAACCAAGATGGCACTACGCGTGGCAGGACTCTTCC
+ TGAAGAAGGAGCTGGTGGCTCCCGCAACACAGCAGCTGCGTCTGCTGCGTACTGGCAATACCACCCGCTC
+ CCAGTTCTTGGCCAACTCCCCCAACACGGCTCTAGACAAGAGCATTCTGCAGAGGTACCGCAACCTGGAA
+ ACGCCGGCCAATCGAGTGCAGGCTACTTACTTATGGATCGACGGTACCGGCGAGAACATTCGCCTCAAGG
+ ATCGCGTTTTGGACAAAGTACCCAGCTCCGTGGAGGACTTGCCGGATTGGCAGTACGACGGCAGTTCCAC
+ CTACCAGGCCCATGGCGAGAACTCGGACACCACGCTCAAGCCACGCGCCATATATCGCGATCCCTTTAAG
+ CCGGGAAAGAACGACGTAATTGTCCTGTGCGACACCTACAGCGCCGACGGCAAGCCGACGGCGTCCAACA
+ AGCGTGCCGCGTTCCAGGCAGCCATTGACCTAATTAGCGATCAGGAGCCCTGGTTCGGCATTGAGCAAGA
+ ATACACTTTATTAGACGTGGACGGACGTCCCTTCGGCTGGCCGGAGAACGGTTTCCCAGCCCCACAAGGT
+ CCTTACTACTGCGGCGTGGGAGCTGACCGTGTGTACGCTCGCGATCTTGTGGAGGCCCACGTCGTGGCCT
+ GCCTGTATGCTGGGATCGACTTCGCCGGCACCAATGCCGAGGTAATGCCCGCGCAGTGGGAGTTCCAAAT
+ TGGTCCAGCCGGGATTAAGGCATGTGACGATTTATGGGTGTCGCGATATATTTTGCAGCGCATAGCTGAG
+ GAGTATGGCGTAGTGGTCACCTTTGACCCCAAACCGATGGAGGGTCAGTGGAACGGAGCCGGCGCGCATA
+ CCAACTTTTCCACAAAGGAGATGCGTGCTGATGGCGGAATCAAGGCCATCGAGGAAGCTATCGAGAAGCT
+ GAGCAAGCGCCACGAGCGGCACATCAAGGCATACGACCCCAAGGAAGGCAAAGACAATGAACGGCGCCTC
+ GTGGGACGTCTTGAGACTTCTAGCATCGATAAGTTTTCTTGGGGCGTGGCCAACCGGGCCGTAAGTGTGC
+ GAGTGCCGCGTGGCGTTGCGACGGCCGGCAAAGGATACCTCGAAGACCGGCGGCCAAGCTCCAACTGTGA
+ TCCCTACGCCGTGTGCAACGCCATTGTTCGCACCTGCCTGCTCAACGAGTAGGCTGTGAGCGGTGCAACA
+ GATGTTTAATTTTTTGTACATTATGTTTTATGGAACTGTGAAGCGTATCCGATCATTTGGTTATATTTAC
+ ATTGAACTGAAGCAAAATTTAGTTTGCTTGTGCAAAAAAGACAGGAGACCGAGGCACGAAAAGCGTGCGC
+ TTAGAATTTAAGAACGTGGGTGGGTGGCAAGAAGAACTAAGCTAAAGCGAAATTTCCTTAAAGCGATGGG
+ GCCTCATGAATACTTTGCCATATATCTCACAAACTACGTATATCTATCATTGCTTTAATCTAAATAATAA
+ AAAACATTGTACTCTACGTTAATTTTTTGTACCTTTTAGATCAAACAAACATTTTGGGATCCGACGTTGA
+ ATTCGGTCAACGCCATTTTTTGCCCTTAACTTCTTGAACGCACTTTTTTAATAACTCCTAAGAGTTTCTA
+ AATGTAAATTTAAGAAGGAAATATCACTGAAATCGGACGATATGCATATTAATCATTCATATCCATGAGC
+ ACGAATACACATATATGTGAAATATGTTTATAAAAACCAATTGTTGATTAGAAGTTGTTAAAAATAAAAT
+ ACTAAGAAATTAATTTATGTATATATATTGGTACATATGTATCTCACTTTACGGATCTGTCGCTTCACTT
+ TGTTCGGTAGCATTTTACATCATTTTACTATATGCTGTTATAATATAAATGTCTAAATACTAGCACTAGC
+ AAAATTAAAAATTCCATTGAGATACATAAATACATTTTGAGTAAAAGCAGAACTGCGTACAAAGCAAAAC
+ ACATTACTACAGACTATTTTATTTTCTCTTTTCTGGCGAGCTTTTGAACAACTGTTGTTGCAATGACTGT
+ GAAAATCAAAGTTTTAAAATATAGAACAGCTTGCTTGTAAATAAGAGTGACATGAGGGCACAAAAACTAG
+ CTAAGGCAAGACCTTGTTTTTAATGGAAAGTTTTCCACCACAAACAGCTGCCTGACACTGAAAGTATTCA
+ AAGACTAAATCTTAGGGTTTCCGTTCAGAATATGTGTGTTTTTCGCTCAACTGACACACACCCTCGTATA
+ TATGTACATATATGTATGTTTGTATGCTTGGATGAAAGATATGGCTGCGAAGGAGACAATGCTTCCATAT
+ ACTCGTATATTCCCAATGGCAATATACTGCGTCCAGCTGATAGGGCAGGGGTACTGCACTCTGGGATGGC
+ AGGCAATTGCATTTCCCTGCAATCTTATATTGATTGAGTATAACCGCGAACTCAATCGCTTCAAAGGGGG
+ GCTATTAAGTGTGGTTATTATACTTAAACTTACAAAATAAATCTTAAATTTGAATTAAATTAAAATAGCA
+ GATACTGCAGTACTACTAAACTGATATTTAATATACATACATATGTATGTATCTAGTATGTCTTCGAGCA
+ TCTAAAATTGAGTGTGCTTTTTTTACTGCACTTTGCATGTCCGTTCTCGCAATTGTTGACATTCTGAGGT
+ GCAGTTAGCGGTGTTTGTTTGGCTCTGCTGGGAGCGGATTACGGATTACGGGGTATGCAAATGTAATAAG
+ GTTAAGAGGGAGAGATAAGGCCATCCAGTTTATACAAAACAGTGTTAAATACACAGAGATAGTTCGACCA
+ AGCCAGCCAGCCGAAAGAGGCACGGAATCATCCGTAGTCAGACCATCTATAGCTTCGTTAACTCATCTTT
+ AAATGTTCGAACGCATTCCTGTGCCCAATTCCAATTCGACTATCTAATATACCCGTTTTCCATTGCAGCA
+ TTTGTGGGCACAATGTAGATACTATAATATATTTTAAAATCACATAAACAATCGAATCAAGGCACTAGCC
+ TGTTATGGCCACAGAACTCAATAGTTCCGCACCGTCGCCCAAAAACCAGATTATTAATTAATTGAAGCAG
+ GTTCATTGGTATGCATGAAACACGTTCAAAGATGTCAACATCATACAATGCAGGCCTGAGGAGATCCAGT
+ TATGCTGCCTGAGACCAGGCGATTTGCATAAAACGGAATGATAAGCTGGACACCTGATTTCGAAACTATT
+ GATAACAAAATGATATTGATATATCACTGAATCAAGTGATCAAAATAATATATTTTTGCTCTAGATAAAT
+ GTAGGCAACGATCGACTGGATAGAAATATAAGCTTCACTTACTCTCCTCACCTTCCTATAAAATCTTCAG
+ TTCGTCAGTTCACTCGGTTAAAGTCCAAGCAAACTGATAAGACAGTAAGGCCACGAAGTTAATCTTCCGG
+ CTGCAAAAGCCTGTCCAGCGTTTACCATTATCTTTTGTACCGTGCCTTTTACTTCTGACTCGGTCAGAAA
+ AATACCTCCGCCTGGGTAGGGTTATCAAAGGGCAATAAATCATACTGGCTGCGGTTGCGAAAATAAAATA
+ ATGTTGAACCATAATTGATCAAATCAATTCCATATAAAGAGATGAAATAATTTTACCCAGACCCCTGCGA
+ ATTTTATTTAAATTACCTTAAAGTTGGGCACGATTGTGGAGCGTGATTCCTGAACGGCCTGTCACAGTAA
+ ACTCATCTACTGATCGACTCTTGTCTGGCCAATTGCAAATTACCATTTTCAGAGCCTTTAACTGGGTCAA
+ GACATTCGCTCGCCTTGCAATGGGAGTGGTCGGAAAAAGCACTGATAACAGCGGATTTACGGACTCAATG
+ CAGTACGTAATGTGACAAGCGGCAATAAACGGGTAACAAAACAGAGCGAATCTGTTGTGGAGCTGCTGGT
+ GAAATAATCGTTGCTGGGGGTGCTGTTTATTTTTATGTGATGTTTCTTTTGGAGCGCACCAACTGCTTGT
+ TGAGATTATGTTTTATAGCGCTACTTTCAGTCCGCGCAATCGTAAATGATTGCTCGATCAAAATATGTGG
+ TCGCACTCTGGAGAATTATAAAACCTGTCAGGTACAAGCAGATACATAATATATATAATATAATCCTATA
+ ATTCTATGTCCTGTGACCGATGTCCAGCAATTAATCGGTCACGTAGCGTCATTTTGGAATGAAAAGAAAA
+ AGAAAAGATTTGCGGCCGCAAATAGTTTACTACGCAACCGATTTTTCCATTTTATCTATGGCGGGTGTCG
+ ATACGGTGGGGTTCTTGCGCAAACACAGGCAGCCAACAAGTGCTGTCTTTTATCTGGCCTATTTATCTAA
+ TTTCCCACTGCTCACGCCATTCGCAATGTTGTGGTCGTGATGAGCGCCTATATTTAATTTGCAGAGCATA
+ TAGATGTCTGGAACTGAATCACCCAACAGCAGGGTCGGACTGCGTGTTCTGTCTTAGTTTTCCAAAGAGC
+ CCAAAGATCTTCCTCCCCCCATTTTATGCCGCTTTTTTTTTTTAGAACACCTCCACTTTACTTTCTCTGC
+ CACCACACGCGATTCCCAATATTTGCGTCATGGGCCCACACGCGTCTACCAAGTGATCTGCGATCTGTTC
+ CGTGCGTTTTGGCGCATCGCATCAGACAAAGTTCAATCCCCCGATTCTTGGGGTAATCACCGTAGCCAAA
+ CCGATGACGGGCATATGGTCAGGCAAAGGTCGTCTTCTGTGGCACACATTCATGCGCATTACTTTAATTT
+ CATTTTATTGTTAATTGGTTTGTGTCAGAACGGCGATTATGTTTCTAAGTTATCAGTAAAGCGTCCCGCT
+ TTTAGTTGATAATGAGATTAGGATCCATTAGCAATATTCAGTCTGAATGGATGAGAGTCGCAGAGATAAT
+ ATATGTATTAAAAAAAACTTTGTTTTGAGAAAGTCGTTTGATAAGAGCTTTTCGATAAGCCGGCAGAATT
+ TTACTGGGCGTTGTTTACCCAGACCTCATTGGACTTAAATGATAAAATTAACTGTACATATGTATGTGTT
+ TTCTTTGCATATTATCCAGACAATTTAAGAGAACGTATTTTCTGTTTACATAAAAATATATAACATTACG
+ GGGCAACTGCTTGTTTCATGCCGTGCAGGCAATTCGAGTTCGTTCAACCGATGTCCATCTCCCTACACCC
+ ATTTTATTGGTCATTAGCGAGTCCGAAATTACATATTTGGGAAGACCTAGTAAAACCTTGTCAACACAAA
+ TTCCCCATTTAGGCCGGGCCTGTTTTAACAGATAATTAACAATAATTAATTTGGAAAACTTAATTTAAGG
+ AAAAAGTTATTACAAGTAATTTCCCTTTAACAATTGCATAACAATTTTGAAAGGGATGTAAAGTGCAATG
+ CAATAATTTAATATTTTAATAATATCATAAGCACACATTTTAGTTGTAATATATGTGTTACATTATTATT
+ TATGTTACATTTATTACAACAGTGTAGTTCCTACTTTGTAAGTTTATTAAACTTATGAAGCAGATATTTA
+ ATTGAATTCCAATAATTAACCCAAAGAGATTTAACTATTATTGCACGTATTCTTAGACTCCAAAAAATTA
+ CAAAATGCAAAAGGAAAAAGCTATATAGATATATAAATATATATATATATATATATGCATCTCTTGTTTG
+ TAACGTACATTATGTTATAGCTGATGACTTCGGTGAACAGTGCAAAGGCTGCGCCTTTTACTTTTCCATC
+ TGTAAAAAAAACTTGTGCCTGAAGTTAATATACCTTCTGCAAGGGTAAATATAAATGCCCGTTAGTATGC
+ CACAAAACAAACACCTGTTGGTAAAGTATACTACACTGATATGTAGAATTCTCGTATTTTTTTGATCACT
+ TTAACAGTTTGTGGAAATTATATTCAGAGGTATAAAGTGTAAAGTATATATATTATTGATCAACAGCTGA
+ GTCGATGTCCGTCTGTACGTTTCTGCATAAAATATTCTCATAGTGCTATCTTCCAGAAGATATTCCAAAT
+ GTCTTCTCTCTATTGCAGGTTGAACACAAGCCGTATCAGACTACTTTATCTGATATATAGCTGCCATAGA
+ AATAGTAGGAAAAATAATAAATTTGTATTATTACTGCAAAACGTTGAATTTTTTCTTGTTCGATTTACTT
+ GTGCTGATTTATTTCGGTCGATCTTTATTCATTGGATCCACAGTACTTTTTCACAACCTTTCCAGTCATG
+ AAGTAGGTGGACAGCGCCCTTAGTCTGCGGCCACGTGAAAGTTCTTCAAACAAGCCGCCACTCACGGAGA
+ ACGTTTGTTTCGGTTGGTAGAGAAGGCTCAGAAGTGGGTTTTTGGGGCTTACGCGCATGTTGATCATGAC
+ GTATGTGCCTTTGACCAGAGGACAGCTCAGCGTGTAGTTACTTTGCTTGAGCATGTTGTCCTTGGCTGGC
+ TTAAAAAGCGGTACGGAATTGAAGACATTCTGCAGGTCGCACAGTTTGGTGGAGGCGTTGTATATGGTGC
+ GAGGCTTACCCCGACCGGAGTGCTGAAGTATGAGGATGCGAGACACCGGTGAGGCAATCTCCTCGTTAAT
+ GGTGGTTACTGAGCCGATGCCAGTCTGATTCGAGAAGGTCATGTTCACAACAAACCGAGGTCGGTCATCC
+ GTCCAATTGGCATACGTGAAGGTCACATAATAACAGCTCTATTCGGTTATTCAATATTAGTTTGAGACAT
+ CCGGAGACCTTTCTTGAATACAGACCTCCTTGCTCCTGATCTCACTGAGCTTCAGCAGAACCACACAAGT
+ CGAGATGCTGAGAATCGTTACCCAGGTAGCGCTCATGATTCCCAAAACTGACTACTACTGTATTCACGTT
+ TATTTTCTAAACCAGCTGAGATAATAATAAAATAATTAGGGTTCCCCATCAAATTGCCATTAGTCAATTA
+ CAAATCTCGTTTTCGTATCAATTTATTGCCCTAGTACAATATGTCAAACTTTTCGGCCAAGTTCAGAATT
+ TGGCTTAATTTGCGGCTAATACGCTCCGATCCCGTATTCTTCAGCACGTCCGTAAGCTTGGGGCGTTCCT
+ CAGCCTCTGAATCGCCGATGAGCGCGCTGTCAGCCAATATAAAGCGCGTCATAAAGATTGCGTGGGGAAC
+ TTGTATGTACGCCACCCTCTTCACTTCCAGCCGGAACCTGCGAAAATCCGACCTATTCGTACTCAGTTAT
+ ATATTGATCATTTATCTTACTCTTTAAAAGTGTGAACCTCCAATTTAGCTCCCACACGTCGCAGACAACG
+ CTCAAAAGCCTCATAGTAGGCCTCTAACATGTGTTCGAACTCTACCTCCAAGATAGCCGTATCAACGCTT
+ GATAGCAAAAACGAGATTATGTCATGCACCACTGAATCGTACTGTGCCGTCTGAAAGTCGATAATTTTCA
+ GCTCGACGGGTGTTCCAGTGGGCCCTAAAGATTTCAAAGAATAGTACTTGTTTCTTATATTTTAGAAATT
+ TTGTTATGCTAACAATTCCAAAGAAATAATTAGTTTTCCGCTCTTTTTATGTAAAATCGTATTATTGAAT
+ GTTATTACGTGCTAGGGCGATCATTTGTGCTAGTGATACTAACCGTAACGAAACATTATATTATTTATCC
+ AGAAGTCACAGTGTATAATGCTGGTAAAAGGCCCATCGGGTCTATCTGGGGCGGCTGCTAAGAATTCAAA
+ AAACTGGTCCGACAACTCTTTCATTCGGGCTACAAGTCTGGAGTCGTTGTTGGTGGCTCGACGAATGTCC
+ TCCAGAGTCTCTGCCTTCATTACCGACTTCCACTCGGGCGCTTCAGCATGCCAATCGAACTTTTTAAAGA
+ ACGGACGGACCTGTTCCCGGAACACCTCTGGTCTGAGGATCCGCAGAGCTAGAGACAGGGCGTGGAACTC
+ GGCCATATATTTAAGTGCTAGCAACGTGTGGGCCAGATCGAAAGCTTTTAGCCTCTGGCCGGAGACGTAG
+ CCACTGCTACGCAAATTTTCCAGCACCAACACGGCATTTTGATCTACCTTTGATGAGTTGGATTCGAGGG
+ ATTCGCGACAGCCATAGAAGCGAGGGAATCCTTTAAATTGGCTCTCGTCAGGGACGCCAGCTTCATCTTG
+ AAGGGTGGCCAGAGCAGGGGCCAAAATCTTGTAAACAGCGTTCTCAGTGAGGCATGTCTGCTCAGGCTGG
+ AAAAACTGCCAGTACTTGGGGTCGATCGGAGGCACTTTAGCCACCAGCTGCTCTTCAAACGACTCACCAT
+ TGGATTTCTGCAGCCGGGCATGAATTGCCAGGAGAACGCTTCCGTAGTTATCGCCCGGTTTCGTCAGACT
+ GCTTGTGTGATAATTAAGGAGGCGGGACCCTGAAACGTGGGGTTCAACCACTTCACTAAGAGCTCGAATT
+ TCGGGCAGCTTGTCCACACCCATGTTCTTCAGCTTGCGAAAGATTGTGCTCCAACTGAAGACTATAATCT
+ TCCGGAAAGACTAAAATGAATTCTTTCAGTGGGCACACAAACAAGGCGCTAATTCGATGCCTGATAACAA
+ ACACGTGTAAATAACGAGAATGTGATAAAGGTGACCAGCTTTATGGTGAAATTTTTATTTCGTGACTGGC
+ AAAAATAGATCAGTAAAATATATTAAACTTTTTCCCTAGTCGCAAGATAGCCTCAAATTTTGTCACAATA
+ GTTTTTGCACCCGTGTTCTTTGTGAGCACCGAGAAATCCACGTCTTTATAGTCTTTAGGAATCGTACTGT
+ TATCAGCCAGTATAACCTTCATCATAAAGATCGCGTGAGGCAACTGCACGTGTGCAGTTTGCTGTACCTC
+ TTCGAGAAACCTGCAACAAATTCGATGAAAAAAGTCATCCCATTGGCTGCGGAAACTCGTCTTACAATTC
+ GTATGTGTAGTTGCTGGTGTCCACATTCACGCTGCGCAAGGTCTGAATGAAGGCGTTGTAATAAATGGTC
+ AGGAAATTGTAGAAATTGTCCTCGAGAACATTTACGTCCACACTTGAGAACAGCACAAAGATGATATCAT
+ GCACCAATGATCCGTACTGCGCGATTTGAAAGTCAACAATTTTCACCTTGAGTGGAGTGCCTTCCTCACC
+ TGACAAAATTCTTAAAGTATTAATATAGCCTGTTTTGCTTTAAGAACTAACCCCTCATACCGTATTTTAG
+ CATCATATTGTTGATCCACAGGTCTCCGTGCACGAGGGTAGTGAATGGGCCGTCGTCCACATCGTTGCTA
+ GCTTGAAAAGCCTGGAAAATGTCCAGCAGCTCCTTGACGCGATTTACGTCCCGTTCGTCGCTAGTCACCA
+ ACTTTATGTCCTTTAAAATTTCCTTGTTCATTATTTCCGTCTCGGCCTGATCAATATTAGAGTTCATATC
+ GAACTTCTTGAAGTATGGCCGCACATACTCCTCGTACACCTGCGGTTTTTTCAGGCGCAGGGCGATAGGC
+ AGGGCATGGTATTGGGCCAAATAGTGCAGAATAAGCACAGTTTCTGCGAGATTGTACGGCCGGTGTCTGT
+ TACCAGGTCGATAGCCGCGCGTAGTGACGTTCTCTTGGACCAGAACGGCATCCCGATCCACTTTTGTAGC
+ GCGGTTGTCCAGTGATACGCGGGAGCCGTAGTATCGCGGAAAGCCGTCAAAAATTTGGGCGGGCAGAATG
+ CCTGACTCCAGCTGCAACTTATCCAGCTCCGGCGACAGATACTGGTACACCGCGTTCTCCGTAATGCAAG
+ TCCGCTCGGGTTGGAAGATCTGCCAGTAAAGGTCGTTGGTGAGGGGCGGCAACTTGGCTATCAGCGGCAA
+ ATCCCGAATACCACCGTCTGCACTGCGGATTTTCGCTTGGACAGATAACATAATGCTGCCATAGTTGTCC
+ CCGGGCTTGGTTAGGTAGCTAGTGGAGTACGAGTCCAGCGTACACCCTTCTGGCAAGTGAGGCTCGATCA
+ CCTGTGGCAAGTTCTTGATTTTCGGAACTTCTCCCATTTCTGGAGCGGATTGTACTGCTACACGCGTAAA
+ AGGCGACTGAATAGGTTCGACGACGATTCCGCGTAAACGTGCTTTTCTACCCTGAGCTGTGCACAATTTG
+ AAAGGTATTTAAATCCACAAGCGTAGTGCTCTTTTCTATGTGGTGGTCTAGTTTATTTGTCAAATTGCGA
+ CGCTACGCGAAATATTAGCTCAAGTGGCATTGATAACGCTCATAGAACGTACTCAGTACTCACTCGATGA
+ GCTTGAAAGCTTCTCTTCTTTAAACAATGTCCCGATCATCTTTTCCCACTTCCATTTTATTTGTACGAAA
+ AATTGTAGTGTTCAAATTGCCAATTAAAAGTTTAAGGTTTTTCAGCCCAAACAGTTTAAGCCCAAACATT
+ CAATAATGTTGATGAATGAAGGGTACACTTGGGTCGGTCCGTCGCGAATTCTCACCTCTCAATTGAATTT
+ GTGGCGTTGTGTTTGTGCTTGTATCCAGAGTCCCCTGAGTAAATATTCGGTTTGATTTATATCGCCGAGT
+ TGATAGATGAAGTGTGCGAAGGTAGCACTACAAGGGAAGCTCAATAAAAAGAGGCGGCATCGACAACAAT
+ CGAGAACATCAGCCGGCGGGACGAATAATTAAAATGTCTTTGTTATCAGCAATGCTTATGCACCGCGGAA
+ GCAAAGTTATATTTCACCTCATTACGGGAAAGTTTAAAGACTCGAAACTCCCCACTAGGAACTAGTTCTT
+ AATAACCGAAGATTTTAAAGACTATAAACTCCCCACTAGGATCTAGTTCTTAGGTAGTTCGCGCTAGTAA
+ CTAGTTCTTAAACAGCTCACACATTACCGATGTTATCTTCTGCCATCACTACGTCCGATTTGTTGTGTGT
+ TTACTTGTCGAAGATAAATGGACTTGCAGTTACTAATGCAGCAAATGTATAGTGGTGCGTCGGTCATGAC
+ GATTTCGGAAACGAACATAGATGGTTACAGATACGGTATTCCATCTGGCCAGCACCAAGAGCAGCCAATT
+ TACCCTTTCCTGCCCAATGAAAACGGTGACCAGTTGGTTGGGCAACTGGAGGACGACGACGATGAGGAGG
+ AGGACGAGGAGCAACGGACTCTGTTCTGCGGGAATCTCGACGAGCGCGTGACGGAGGAGATCCTTTACGA
+ GGTGTTCCTGCAAGCTGGCCCCATCGAAGGAGTGCGGATACCGACCGATAACAATGGGCGTCCCCGGAAT
+ TTCGGGTTTGTCACATACCAACGCCTGTGTGCGGTGCCTTTTGCCCTAGACTTGTACCAGGGCCTTGAAC
+ TGTTCCAAAAGAAAGTCACCATCAAGCAGCAGGGCGGCAAGCAGCTACCTGCCTACAACCAAAGTCGTCT
+ GCGCAATCAGTTCATGATGGAGGCTCTACCGCAGCCATCGCCACTGCGTCACGCCCGACACAGTTTGCAT
+ AACGGCAAGCCGTACGATCGCAATCCTTTTGGACACAACGCCGATCAACGGCGCCGGAGCGACAGCTCCG
+ TAATGGAACGCAACCGGCTAAAACCACAGCAACACCACCAGCACATGCAGGGAGGCAGCAGAAGATCGGA
+ CCAACGCTCCAACAACAAACGCAGATTGCTTTAAGATTTCACCACATTTTCGTCTTTATGTATACCCTAG
+ TCCTTCAGTTACTCAAAACCAAAATCAAAAGTTACCGTCTTTAATCGTTTAATGAGCTGGATATCTGCAG
+ AAAATTATGTATCAAATGAAGCAGTTTACTCTGTGGTGTATTGTGTTTTATTAGTGTACTGTATAATTAT
+ TCTTAATACTTGACTCTAATTTATTAGCGAACACCCTAATCCTGTAAGCTTCCAGTGGCTTTGGATACTA
+ AACCTATGCTGTACAGATCTTGATCTGCCATAGTCAACGTGTGATGCTCCTAAGAGTCTTTTCAACATTT
+ CTGTAGGTGCGTGGTGGTATCACCTCCAAAAGCAGCCGCTGATAATTATGATTTTCGGATAAAGCCCGGA
+ ACAAGGACTTTGCGTAGCTGCGGGTCTCTAGACTGCCTTCGAGAAGAAGATTCGCTCCAACCACAAAAAA
+ CTTGTCGCGGCTCTCGCGGCCCATTGCATAGATCCGGTCACTGCCCAGACGCTCAACTAGTCTGAAGAGC
+ AGCTTTGCTGATGTCGTGCGCACCAAGGCATTTTGATGTTGAGCTCCTTTTGTCGCAAGAATGTTTAGAA
+ TCTTCTGCGGCTGAGCATGGTCCACCATCGACTCCAGGGCTCGATTGGCGTCAGCACGGAGAAACCTATT
+ CGTGTCGGCGGTGCGGTGCAGGAGGGCACATACCAAGTCGTCACATTCCTGCTGAAGGCTGGTGGACTTC
+ AGCGAGAACAGCTCCGCAGCTGCTTGGCAGGAAGCTCGAGCTACTTGGGAGCGCAGATTTCGGACTGAGC
+ GGGTGAGCTGGATGCAGGTCATGTGCATCTGATTGTCCAATGTCTCGGCATGGTAGCGAATCAAACGTAC
+ CATGCTTTTCAAGCCGGACACGTTTACTTCCCAGTTGCTGGAGTCCAACTGGTCAAAAGTTTTAAGCAAA
+ GCCTCACGGGGCCTATCAAATCGAACCATATTCTGCGGGAAGAGCTCTGCCTGCGACATTTTGATGGGCT
+ GCTTTGAAGGTGAGATTCGCCGTTGTGCCCGCAGGAAGTACGATGTTTTGGACTTGTGTTTAAGCGGCGT
+ GTGTTGAGCTTTTGCAGGGACACTAGTATTTCCAATTTGAGAACCAGTTTGTGAAGTGTTTTCCGCAGTG
+ CTTGTGCTTGTGTCCATAGATCCCTGCTTTGAAGCCGGTCGCGTCCCATAAAGAGAGTCCAGGGAAACGC
+ TACGTGAATGGATCACTATTTCGTCGTGTGTCGGAACCAACTTTGGACCAAAAGTATGATTTTCAAGTTT
+ TGTAGCTTTTACCGGTGTTGCTAGCTCCTCCTGCAAGGGGACTTCCTCCTCGCCCTTCGCTGGGGATGAC
+ TCCAGCTCGTTCTCCACTTCTTCAACTACGACGAAACTGTTGCTGCTCTCAATGTCCTCCTCGATTAGCA
+ GCGATTTTACTGACTGAGCCCTCGAAAGTTGCGGGGTAGTTTCCTCCAGCTGAGTTTTGATGCTCTCCGT
+ TTTGCTGTGAAGGCTATTTAGGCTTCCATTAAGCTTGAGCAGCTCCTCATGGGCAGTAGGTTCTGATTCC
+ GTCTGCACCTTAATGGCATCTACCACCAATTCCCCGAACGCTTCGTTGGGATTGTGCTCCCTGTTCAGCA
+ CTTCCACCTTGCAATCGTTCCAAAGGCCAGTGGATGAGAATGGTCGCTTCCCCATCTCGTTTTGGCTTAT
+ GCTCGACTTCGCCGAGGCTGTTGACTTTTGCGAATAGCTAGTAGAACTTGCGGAAATGGGGGAGCCATTC
+ GTCATACCGTTAACTTCTGTTTCGGTATCCCTGTTTGGGCAAAAAGAAAAGAATAAATGGCTAGTACAAT
+ TGGATTTACGTTATAACGACTCACAACTCTACATATTGAGCCAAAACTTTTTCTTTTTCACTATCTTCCG
+ GCTGCTGAAACACGGGGAAAGAGTGCTTATCATCGGCGAGCTGGGTTTCTGTATCAATTTGCATCGATTT
+ TCTGGACTCCAGAGCCGTGTCAGTGCAGCAGAAGCCGCAGAACGAACGGTGTCCAGAAAAAGCCCCACGT
+ AATGTGGAGTGTACCTCCGAAACCCTGGGGCAGATGCAGTCTCTGACCGTGTGGAATAGAGTACATGTTC
+ TACGCAATAGATCAGATGGCTGTTCGCCACAGGAAAACGCATTCAGCATTTTTTTGCGCTAGCCAATGAA
+ TAATTATCCAGGCGATTTTCTACTGGAAACAACACATACTCGAACTAACCCTATCCGCAATAGGCGTCCG
+ CTTAAAACAACGCGACTTTGCTGACTGTTTGCAATGCCCGTCGCCAGTCCTTTTGGTCATTTCAAATGAA
+ TTTCCATACCGGGAATCCACAACAAAACCAAAGTTGCAAACGAATACAGGACATTGCGTTTTCCAAGCAA
+ GCACACGAACACTACCCCAGTGGTCAGAACGCCTAGCCACCCACAGGCTGTCAAGTCAGCCACGGAAAGG
+ TCTAGTGCTCACCAGGAACAAAGTTCTAAGCCAACTGGCCATAGGTCCTACGACATTTGCTAAAGCTTCT
+ CGACTTCTAGGCAAGGACCTTCTTGCCATCTTCGGGCGCCTTCGTTTCGGAAAGTCCCGAAGTCTATAAA
+ ACAACAAGTTGCCATTTCCCGAGAGAGCTTCAAATGTATGTAAAACATCTTGGATAGCCAAAATGTTACT
+ GTCCAAAAAGCAGTTACCCTTATTGGCAAACTTTTCTATAGTTGAGACCAGTCCGAATTAAACTGGTCTT
+ GGTAATCCATACCTGTTTAACTAGTCGGGCATTTAATTTACCCAGGAAAGAATTGTAGAAAACCGCCGAA
+ GAAAATAATTTTCTGCCCCTTGAATCGTTTCTAGCATTTCGTATCGAGTTGCCAGTGGTCACTTGAAGGT
+ TCGTCGCTACTGACGTTGCCCAATGTCACCCGCCACATACTTAGATTTCACCAACGCGGTTTCCACTGCG
+ CATTTAAATTATTTAGGTTAAAGAACTCGACTCCTTTAATGCCACAGTTTTGTCAGCAGGGTGCGTGTAT
+ TGGCCAGAGAAACAACCAAATTCGCTAAAGTGAATTGTCCCCATAACTTTCACCCTGCCTTATGCTCAAA
+ TATCTGTGTGGATTTGAGTAGGGTGTTTCAAAATTTAGGTTAACACTCGCACCCAGCGAGGGGTAAATCA
+ TTGTGGCGACTGAATAAATGGGTTTCCTATTTGCCGGCCCCCGAATAAAATATATAGACGAATCTTACAC
+ TGACTTGATGACGTCGGCGCATTTGCTGTCCAGTGATTCCATGTGGTCTGTGGAAATACCGGATTTTCTC
+ CTCTGAGATTCGTTAAATTTGTTATTTTCGATGCCTATAATAACGAAATATATCAAACGTTGGCAGAACG
+ AGCAGAGAAGTGATACTAACTTTGACCAGGTGGTTCGTCCCCCAGCTTTGTGAAAGAATCCTTGTGCTGG
+ AACTTCTTGCGGATCATCTGCTGGGACTTTGGGATCGAGTAACTGACCTTCGGGTAGTTCGGTCTCTCCA
+ CGGAATGGGACTTAGAGCCTCGCTGCATGCTGCGCATAAAATTGTTGACAAAGTCTGCATGCTGGTTCAT
+ GGTGGGAAATCTGTGAGTAGTGTTTTATTAAGCTGCTCTGACGTTGGTGGGTGACAATGCAAACCTGGAG
+ TTTGGTCCGGCAAGTCGACCGCCCGTGCGGGAAGTGAGCTGTATAAAGCTGTCTGTGGCGCTACCACTGC
+ TGCAGGTAGTGGTGGTGCTGTCGGTACTTCGGCCGTCCATGGAAGTATCAGAGCACGCCTTGGCCAAAAA
+ GCGACGTTCAATAAAGGATTGACTTCCTGCGTTCGCAATGGTTAGTGTTATTGAATATATTGAATAAATT
+ CAGAAGAGACCTACCACCGTTAGTCTTAGCGCCAAAACTTAATCTTTGCGAAAAGTCCTAGGGAGAAGTT
+ ATTTTAGTTCTATTAAAAATAACAAAAGGTATTGGACTAACATTAATTGGGCTAGCCATGTCCAACGTTT
+ CCGGGGGGGAATGGAAGGAATGGCGATGCACGCTCTCGTTGACCTGCCTGAAACTGCGGATATGCATTTT
+ ATTGAAGTGCTTTTGTCAGTTCTAAAGGTTGGGGCGAATTTTTAATCTTAATTCTATACTTATAACGCCT
+ TTCTAACGTAACAATGCTATTTTGCGATATGAGGCTTATGTGGATAAGAATACCTCTAAGTAAACCTTGT
+ TTCGTACCTGGGGAATGGATCATTCTTGTTTTTTGCTTCCGCTCCCCCAAGTACATTGCGCTGGCTGCTT
+ GCAGCCCGCATGCGTCGCCTCTTAATTGTATTGGGAGAGGCAGAGCCCTCACCCTGATGGATCCAGTCTA
+ CATCAGCTCCAAATCGCCTGGCTCCAGGTGGATCAGTCTGGTTGAAAACGAAGAGCACGCCGCTGTCGGG
+ AGTAACGATGGGCAGTTGTAAACGCGATAGCCGCACACTTGTCGCCTCCAACACCATTGGCCCAAGCTCT
+ ACGCCGTCCGTTGTCTCCGACACAATGGTTAAAACCTCTTTGATGGACGAGATATCGGCAAGAACTGCTA
+ GAACCTCCAGAGCCGCCTGCCGCACCCGTCGTTTTCGGTTAAGAAGGGAGTAGACGGCCTGAGTCGTCAA
+ CAGGCTGATGTCGAAGCAGGTTCCCGGGAAGGTCATCAGCGCAAAAATTGACATTTGAAGAGCGTGGTCC
+ CGGAACTGCGGTACATGAAGATTCAATAATTGGGATCGTGCAATGCAGAATAACAAACCTTTGAACTCTT
+ TGCATGGAGGAATTCTGGTGAGGTCAGCTTAGCAACTATGGTTCCCGCGGGAAGGCGCTGCATCAGAGCC
+ TTGCATACCCGGTTTGCTCCAGCGTTGCCCTGGCGACAGAGTCCCGACAAAATCTGTGGTGTGCGCTCCT
+ CCAAGTTGTCCAATGGTAGGCGCGAGATTAGGTTAACCAGTAGCTCTCGCTTAAGATCGGAGACCTCAAA
+ GTGACGCTCCGATGAGAGGAGGGTTCGAAGCAGACTATCCAGATACGGTTGGACCAAGGCCAAATTGCTC
+ GAAGAGCTTAAGGCAAGCTCCAGTTGGCCTATGCCCATTAGACGATTGCGCCAATCCTAGAATAAGTAAA
+ ACAAAGAAGTGAATAATCGGTAAGTACATTTTGGCGTGCCTAGTGTTTTATGGCCCATTTGTGCTAATTT
+ AGCAAATTCGAAAATTAATGCCGCAGAAATTAGATACAAGAACTGTGTGTGCATGACATGTAACAACGTC
+ TACTGAAAGTGTCAAAAACGTCATTTGATGAACTTTATTTTGTCAAAAATATGTGTACTTATAAACATGC
+ TAACCGGCTCGATCTTGTACTAACTCATTGTGCGCTTCTTAAATAGAAACAAATTAATAGATTATTTTTC
+ ACACGATCGCAGGGCAAGTGATTCTGATCACCTCTTAGATTCTTTTTTACTCTACAAGTGACGGGTATAC
+ TTATAGTTATGAAATTGTCCATGCAAGAAAAAGGTCCAAAGGCTAGCGGTCAATAGCGACGTACAATCCT
+ GCTTCTATTTAGAACGCGCTGTGATTTTCGTTAATGTTATTTATATTTTTGTGCTTGAAATGACCCAGTT
+ GCAGACACGCTCTGCTCCCCCACCCTTTTCCCTAGGGCCAGCGTCTTCATCAAACACCGTACTGTAATGG
+ TAGTCTTACTACTTTTTCGTCGCATACAAGCTGCAAGCTGGGAGCCAGTTATTGTTGGTCTTCTTGCTTT
+ GAGCCTGGTTCTGGTACTATGAAAATCGCGTGCACTTAAATGATTGACCAGCCAGCAACGGCAATGGCGA
+ GGAACCCTTGGTGTTCGGCCGCAGCTCCCTTAGCGAAGCAATCCATCCCAATTCAACGCCCAGTCTGCAC
+ AACATGCAACTGCCACCGGAATCCTAAAGTTTTTGTGCACCACTCAAAAAGTTGGTCCTGATAAGAGGTA
+ CATCTGAGGCAGCAATTGCCAACCCTGAGTATAGCAAAATAACGAATTATTTTTCTGACGCACTTTTTTT
+ TTTTAGCAATTTTTCCGTTTATAAGTTTTTTTTTTAAATCGTCCATTCTTTTTTGCCGTTACTGTGAATT
+ ATTTCCTTTAACTAAACATGGGAAACTGGGAACTCGGCAAAACCGAGAATGTAGATGTCATGTTTATAAT
+ ATATAATTTATATTATATTACACAATGACTATTAAAATTTTCAGTTGAATCTTGCCAAGAAAAAAATGTT
+ TGGCAGTGTGCATGCGAACTTCAACTAGTATCTAAGAACTGACGCAAATGGTCCACTGATCCTAACTGTA
+ GTGTGCCCACTTTTGTAGACGTTAAAATTTACAATCAGTTACAAGAATAGTATGTAAAAAGCACAACTGG
+ TTTGATTATCCGTCAAGGAAATGACAAAAACAAAAGCATATTCATGTACACTTTGAATAACTTTTGAAGG
+ GATTTGTGCAAGTTCTTCGACGTGTAACTACGTGTAATACTCGTAGTTAACTCCTTCCCTTTATGTTCTA
+ AGTACGTGAGCGTAGAAAAATTAATAGGTCATTGGTACAGTAGCCCGAGAGAAGCCGGTCCCTACTCTAT
+ AGTCACCAATATGAGTGCCGGCTAGGGGAGAGTGCTCGCTTATCGCTGAAATTTTCATTAGTAAGGAGCG
+ ATATAATAGCACCCGTTATAGCAATACCTACTGGGGGAGTGATGCGTGTCTCGTCCGCAATAAAGCAGGG
+ CGGCTGCCATTATGAAGGCAGAATTATGAACGCATATGAAATTGTACATATCCTACTGACCCAGTTAGAG
+ CCCAAAGCGCCTGCGACCCGGAACCCGCGTTGGCGTAGCGTGTGAAGTGATTTCATTGCTTTATTTTTGG
+ TCGCACAAAGTAGACCATGCTGGAGACTTGATTAGAGGGGTGCAATTACACGAGGATTGCTAAATGTCGG
+ CCACTAATTTTAATGCAATTATTTGGACTTAGTCATAACGCTTTAGGAACATACCCCAGATCGCAACTCC
+ AAGAGCGTCTTTAAGTTCACAATGTCCAGATCCTCCCACGATTTCGGCGTGGCCGGTGACACAGGAGACA
+ TCGTAGAGGCGGATCTTGTTCGACTAATAAGCGGCTGTGTTGGTGAGGAAGAGGGATTCCCTGTTGCATG
+ AAGGGCTTTTCCATCCCCATTCCCATCCATGTCTTCTGAGCGTCGCTGAGAACGCGGAGACGGATCGCGC
+ TGCAGATTGTGCAGAACCTCGATTTGCTTGTGCGGCACTTTTGGGCTGATGTTGTTGCTTCCCGTCGGAC
+ TAGTGCTGCGGCTGCGAAACCCGGGAGAGCTAGGTGATGGCGACAGCCGTGCTTTGTTTTCCTGCCGATT
+ GCGGGGACTGTTCGATGACGGCTCACTCTGCGCATTGCTCTGATGCCGGTGAGGCTGCGAGCATAATGAT
+ CGGTCTTGAGGCAATGGCTTGGTATTGTCGAAAGGGATCTCCAGCACGAGTGCCGTGGTCCTCTTGTCAT
+ TGACGGGTCTAGAAAGGGTAGACTTCTCGTCTGATGAGACCAGGTCGGAGATCGCTGCATCTTCCGAAGA
+ CGAAACAGTAATACTCTGATTGGTCTGGGTAGGGCTTCGAGAATTGTTTGTAGAGGAGGCTGCGTCGCTA
+ TCAGGAGTTCGCATCTTAACGATCTCACCTCCGAAGGTTACTCGCTTTAATCCCCGAGAGGGAGTACCCG
+ GCTCGGAAACACTACCCGCCTTGATGTGCGGCTCATCCAATTCTGAATCACTTATAACTTTCACAATCCC
+ CGCCCCTATATTAGGCTCTTGGTGGGTGCTGCCACTGGACGAAAGGGGGTGGCAAATTAAATCCGTCCCA
+ TCTTCTTCATTAGAGAAAATCCTTGTTGGGCTATCAGACTCTTCGGTCTCGGTATCCGCCTCCAGAATCC
+ GCATAGTCACTGTATCATCGTTGATCTTGATTTCTGTTTCCATAATGATCTTTCCCATGTCCAAGCAGTT
+ TGACTGTATTTGGAGCGTGGTGTCCAGGTTCTGTACAGCATTGCCGTTTCTCCATCCTTGCTCACGTGGT
+ AAGGCGCGCCAGGCGCCAGCTTTTACTTCGCCCCCTGTTTTCGATTTTCCAGACACCCCGTAAACCTGAG
+ ACAGTTGGTAGTACCTAGACAGCGTATCTCCACGACCCACGTTGCCCATAATTTCTTCGAACTCGTGAAC
+ GCCCAAAAGCTCCCTGATCTTGCTTAAGACTTTTACGGTGATTTCTTGCTGCACCACTTGATCCATGTGT
+ GCGACCACTCGCTCCACGGTGCTATGCACAATGCGGTGTCTCTGCGCCGTATGCATTATTGATTGCAGAA
+ GGGCAGGCACGGACAGCAAAACGCCGCAGCTAAGGCGACCCATGTGCTCCGAATCCGCTGGCACCTGCTT
+ CGTCAGGCCTGCGTCTAAAATTCCCAGCATAACCGTCTCCGGAATTGCAGTTTCGGCGAGATAGACTCGC
+ AAGCAATCGAGAGCTCCTTTGCGCACGGTGGGGGCTTGGTGACCAAGGTTCTCGACCAGCAGACCAATAA
+ GCTGCTCCCGCTCCATATGGCCATCGGCCTCGTCTTGCATCACCACCAGGACGTCAACGAGGACTCGCAG
+ AGCGTGCTGCCTCACCTGCCACTCTGGGTCCTGCAGGCGCTCATGGAACTCCGCGTACATGGCGCTAGGG
+ AAAATTGTTTCCGGAAGGCGGCGGGTGCGCAGTATGTGTTCCCACAGCGGCGTTAGCTGCACTGCACCGA
+ TAGGAGCTTCCGCTCGGCGCTGAATTTTCATTATAGCTGGTAGTGGAGCACCCGCGCCGACTGCTGACTG
+ GTTGTTATTACTGTCCTTGACTTCACAGTCGACGGCACCACTCACATATGTGACACTCTCACTGTCCTCG
+ CTGTAATAATGCACTGCCGGACTTTCCGTGGTCGACTTAGGGGGCAAATGATTTCTGGCACTATCCAAAA
+ CGCGCCGGAAAAACATACTGGGCCGCTCTTTTTAAATTCAATTATCTAACCAACTGACTCCCGATTGCGC
+ ACACGGGCTCATGTTTTAATTGTCACGCACGCTTGCATCCGGTTGCAAATGGCCTGGCTACTATGCTCGG
+ TCACTTTCAAATTTTATCCACTCCACTTGACTTGACCATAACAAACCAGAGCAACTCGCTAGCAACGAAT
+ GCCGAATTTGTCCGCTTACTTTATACTTTTGTAGCCAATATTGGAACCTGCCTATGGTGAGAGCACGCAA
+ CTTGACTCCAAATTACATTAACTGCGCATGTCCGCTTTGTCCTCTGGCTCGCTGTCTAACTCTGTTACCA
+ ATATTTTGGGGATCGAGATTCAAAGTCACGGAATAATACTGGACAAGTTTGAATAGACCGAAAAAAAGGC
+ TAGGGTTATACCCCGTAATCTGGGTTTTGATGATTTTGAACTAAACATATAATGAACTTAGTAATCAAAA
+ TTCATCCACATATGTTGTTGTTTATTCTCTGCATTTTTGCAATTTAAGTGTTAAGCATTTAACATTTAAA
+ TGGATTTGTACCTAACAATAATATCGCTATTCCTTGTGTTTCGAGTTATCTACTTCATGTGGCCAATCTA
+ AATCGATTCCCACCACATCTAGAGCTTGAATATCCATGGGTTTGCCTATAATAGAGGACAATGATGGCGT
+ GGTCCTACCAAATTCGCCATGAACTAACTCTTTTATGTAAGTCCCCGCTTGAGTGACAATATCGATGATC
+ AAGGCTTTTGGATTTCCACGATGCACCTTGGCGGTGACACTGTAAATTGTTCTGGGACGCGTGTGCAATG
+ GACGACGATGAAGAACTCGTATGGGGGTCTTTTGTTGTATGTTAAAGCTTGCTGATATTTGCAGTTGTTC
+ CAGAATCTTTACTGATACTGGTTCTTGCAGGGCACAAAGAGCGCGATAGAATTTCTTTTTCTGCTCTTCT
+ CCCGTCTTTATGTGGGTTAATTCTTCTCTGGGCACGACTTGGAGGTGATGTATAGACACCATACCAGACG
+ CATCCACAGCCCGTTCCATCGCAAAGGCTTCATCTTTAGTTAGGCAACTCCTTTTGGCATTTGGAATTTC
+ TAGAACAAAAGGCCTTCCTTTCCCCAGGCATCGGACGTCCACATCTTCTCTGCCACTCGACATGAAGGTG
+ ATTTTGCCCAGCTTCTCTGTAAAGTGGGGACCGACATGCCTAATTATAATTTCCTCGATACTGTCCTCCA
+ TGAGCCTTTGGCCATTCAAAATCCAGGGAGTATGTGAAAGTTCCCTGCTCAGCTTTCGATATCTGCCAGC
+ TACACAAATCAATGGTCCCTGCAGGTCTATGGAAGTAAGTTTTATAGATTCCTCTACGTTAGAGCAGGGT
+ ATCTGAAAATATTTCTCATAGGTTTCCGCCTTAACTTTGGAGGGTTGATACTGTTTCTCTAGTAAACCTC
+ GCGAAATTTCAATGCGCTTTTGATGCGAGGCCTTGGCGGGAAAGGCTTCTTTGTTTAATTTGACCAGTTT
+ TTCCACCTCTTCGCCTTCCAGACTGTGCGTGAGGTCTATATTGATCATCAGACCGTTGGCATCGTAAACC
+ TTGGCCAGCTTTTCACAGATTATAGGGTGTAGGATCAGCTTGACAGCCTCTTTTATAGGCACGTCTGGGG
+ GATTGTTTTCGTCTATAGATGGTCCAAATCTTCTTCGCAAGGCAAACCACATGGCCAGCTGTCTCAACTG
+ AAGCGACATCGGTAGACAAATCGCCAGAACGATTTTCTGGCAATCGTATTTCGCGAAATCCGATGCCAAA
+ ATGCTGCTGAGCAGCTCATTCTGAAAGTCTTTGGAGAATAAACCCAGGCACGTTGAACACACGCCCAGAC
+ GGGCCCTTTTAGATGGTTGACTCCCTTCGGATATAACAAGCTCTTCGTTTTCCACATTTTCATTTAGTTT
+ TACATCCAACTGGGCATTTAAACGGACAAGTTAGACATCAATTAGTTGTCAACAAATTCAAATTAAACCG
+ TTCTTACCTTTTGCAAAGTCTCATTGATGTTTCTATACTCCGCGCCTCTGGCCTTCAGGTAACGCAGCTG
+ GCAAATTTCGCACACCCCGCACGACCTTAAATATTCCACCAAATCCTGGTTTTTCATAGCTTCTCGTGTA
+ ATTAAAATTATAAACAAAACGTGGAAGCGGTTCGCGCGCTAACCAACACTATCAGCTGTCGAATCTCGAA
+ AAAAACGATACCCGATATCAGAAATCGATGACAGTCTTGTTTTTGTGCTGGAATTAAGGCAATATAAGAC
+ AATTCCTTGGGTATTGCCAACAATTTAAGGTGTGTGATCAGGATATACTCTACTTAACGTTGTAGAGAAT
+ ACATTGAAATTCTTGGGGGCCAGAGACTGCTAACGGCTTGAAGGCTTAAACCCCTTGTTTATTGTTACGT
+ CACAGTGTGTGTGCTTCGCTCCACAGACAAAATGTCGCTTACCCCCTTTCTACGCCTGCCCTTAACCGAT
+ CTGACCGGGTGCCTAATTAACCACCAGACCTACGACAAGTGCGGAAAATTCGAGATGAAAATGATGGAGT
+ GCTTCGAGGCCTATGGCCTGGAGCGTGGAAAACGGGAGTGCGCCGACCTGATCTCCGACTTTCAGGAGTG
+ CGTCGGCATGCAGAAGCAACTGATGCGCTTCCATGTGAGTTTTTCCGTAGCTTCATATCCCTAACGATCT
+ GTAATTTTGTCTAAAATGCTAAAAATTCCTCTTTCAGGCAATGCGAAACGAACGCTACAAGCAGTGGCTC
+ AAGGGGGAGCGTAAGGGACAAGAATTTTTTGCGGATCCCCCACGCGTTGATGCCTACTAGACGGAGACCC
+ GTTTTTCTTGGTTAGTTTCACATTGTAAAACTGCAAATTGTGTAAAAATAAAATGAGAAACAATTCTGGT
+ AAAATGTTTTTCAGTATTTTTGCCAGAGTTGCCGACTTTCACTTCCTTTGTTCTCACTGAAAGTAGCCAC
+ ATCTATTCAGAAATATCTGAATTAATCGCTAACAGCCATGTCGGTAATATTATATTTCGAACTCTGGTCA
+ CACAGCCATACAGCTTGAGCGGAAGAAAAAAAATTATAAGGCTTCTGTTTTTACAAACAAAATCTTAATT
+ ATGGGTACCAAAAGACCCAATAATAGCGTAATTTTGGCCCAAGAGGCAAAGCGTAGCAAAAATGATCTGA
+ TGGCCTACACAAACAGGGACAAAGCGCTCCTTGAATCGGTAAGCGTGCTAGCAAGAAGAAGCACTAAGTA
+ AATTTTGATAAACTTTGAATATGCTTTTACTATAATTTTTAGGGAGTGAGGCGTACCTCAAACCTGCAGG
+ CGCCCATAATGCAATTAGAAGGACATGAGGGAGAGATTTTCACAGCGGAATTCCATCCCGAGGGGGAGTT
+ ATTGCTTTCTTCTGGGTTCGATAGGCAAATCTGTGAGTAAAATTTGGAATAAATGTGTGATAAAGTCGTA
+ TGAATACCAAGCTATCTATGCATTCATACAATAGTGCCGTGTATGAGAGCCTATATCGTCACATTTTTGG
+ GCGCAAATGAATTTGTAGTTCTTGAACATCTTTGATTATAGAAATAGCATGTAAAACAATTAATATGGAT
+ TTCAGACATCTGGCAAGTGTACGAAGACTGCGAGAATGTGATGGCCATGTCGGGACACAGCGGTGCTGTT
+ ATGGAAGCTCACTTTACGCCGGATGGATCGCACATTTTTACCTGCTCCACTGATAAAACTCTGGCCTTTT
+ GGGACATAGCCACGGGCCAGCGGCAACGGCGGTTCAAGGGGCATGGCAACTTCGTGAACAGCGTTCAGGG
+ CTCGCGTAGGGGTCAACAGCTCCTCTGCTCGGGAAGCGATGATCGCACCATAAAAATCTGGGACGCCAGG
+ AAAAAACACGCGGCACACACTTTGGAATCCCCTTTTCAAGTCACAGCTGTTTGTTTTGGTGACACTGGAG
+ AACAAGTAATTAGCGGCGGGATCGACAACGAAGTCAAAATCTGGGACATTCGAAAACAGGCTGTCTTGCA
+ CCATCTGCGAGGGCATTCGGATACGATTACCGGAATGTCCTTGTCCCCCGAAGGAGACTTTATCTTGACA
+ AATGCCATGGATAACACCTTGAGGGTGTGGGACGTGAGACCTTATGCACCCGGGGAAAGATGTGTGAAGG
+ TATTCCAAGGCCATCAGCACAATTTTGAGAAGAATCTGCTGAGATGCGCTTGGTCGCCGGGAAGCGATAA
+ AATAACATCGGGTTCCGCCGATCGGCATGTCTATATTTGGGATGTAAATACAAGGAGAATTCTTTACAAG
+ CTGCCCGGACACAATGGCAGTGTCAATGCCGTGGATTTCAGCCCAAAAGAACCCCTGATTCTATCTGGAT
+ CCAGCGATAAGACTTTGTATCTGGGAGAGATCGATGAATGACCAATTTTGAATAGTAAGAGCGAAAGCGA
+ TTATTGAAACCCACGTTACTTCTTAGATTAGTTTGTTGTGCACAAATTATCTGAATTCGCTAGGTGGAAG
+ TCAATAAAGTATAAAATGTGTAGACGAAATATGCATTACACTCCAGTTTTGTCTTTATATACAATTACTA
+ TTACAATTTCAACGTGCAGAACTGGCCTTTCTTCGAATACCTGAAAATGATGATGAAATTATAGTAAGAA
+ CGCATTTTAAATAAGCCCTACGAATAAATATCTATACAGTTGATATCGTACAGTTGGGAGGCGCGTGGTA
+ TCACAAATAAGTTTTATTTTAGATTTATCAATGAGTTAATAAGTTACTTTTATTGCTGCGGTGGTGGAGC
+ TCATTTTCCAGATTTCCCCTCCTTCATACAGGCAGTACACTTGTTGAAGCGGAAACGGTGTTCTTGAAGA
+ GTTGTCCGAAGAACTTGAGCCCCGTAGCTCCCCCAGGGACAGTGCCCAGGACCATAAAGAGCAATGCAAT
+ TATTTGCGCCACTGCAAAAAGGACTGTAAATGCGGTGCTTTTGGCCACCAAGGCGCAGTATAAGGTTAAA
+ ATCAAACAGGAACTATATGAAAGCGAGGTGAGCAGTCTTGGTTTGGAAAACATTTGCTTTAAAAAGGATC
+ CAAATCCGGAGAGAAAGCAAAAGCTCAAAATGAAAAAGAGGCTGCCAAGGGTGTAGAGCAAGGCAAACTT
+ TCTGGCCTTCAATATTAGGAAGGGAATGTAGAACGTGGAAAGGGTCATGCACAATGCGCCCATTCCTAAA
+ CAGGCCACGAAGCCCACGATTCGCTGCAGGCGAGACTAGAAAAGTTCAATTTTAAATTAGCACATTCTGA
+ ACACACCAGAGATTGATAAACCCACCAATTTTGGAAAACATGAGTCGCTATCTTTCAGAAAACTATTTGC
+ TTCTGGGTCGGAGCTGGAGAAAAATGGAACTTTCAGCTGTGGCAACTTGACGTTGAAACTTGGTTTCTTC
+ TGATCACTCTGCAGTAGCAAGTATTCATCCAGGTCCGATTTTAAATTACTCATACTTCTTTTATATTTAT
+ TTATTTGTCGTGTAAGCAAAACAAAACAAGCTGCTAGCCGCGATAACGATAACCAACACAGCTAGAGCTG
+ ACTCCTTGGCTATACTATCTACTATACTTTTCCGGTGTAAAGCTATGTTATGTTGGTCTTTGATATTTGT
+ GGTTTTCATAAGTTAAACGAGAAATAAAGCTAGAGAGCATGATAATGATTCTGGTGATGATTAAGTTTCA
+ GGACAACAAAGTCCACTTATAAAATAAATATAAGTTAACACCTGCGCTTAACATAGTTCTGTTGAAAAAC
+ TGATGTTAATGGTTTGGGTGCTGGACAAAATAAATGTTTAGTATATTTTTGGTATTAACTTAGGGTGTGT
+ GTATTTTCATAGGACACTGCTGCGACCACATTGTGTCGGTCACACAAGAGCATCACTAACGGTCACATTG
+ TTTTGAAAATTTTTGGAGTGAACGGACCGCGCGCGTCGTTTGCAGCGAGCTAAAAAAAAAGCAGTACAAC
+ AACAACGGCGGCGAGCGATTAAACAAAACGCCGCCAAAACACACACAGCGAAAATAAATTGTTATTATCT
+ GAAAAGGCAAGTGCCACCACCCCTTCCCCATTCTGAGTGTGTTTGTGTGAGCAGCGGCTGCTATATATCT
+ GAGTGTGTGTGTGCGCGAGTGGTTTTGTGTGCGAAAATGCATTAATTCACCAATACGAAAGCAGATGCAG
+ CAACAACATCAGCATCATCAGCGAGAGGAATATTGCAAGCGTTAATCGAAATACAGTAAAATACAAGAAA
+ AAACAGGCAAAAGTAAATTGATCAACGAGAAAAGCCTACTGAATGATAAAAATTAAATTTTTTTATTGTT
+ TTCCATTTAAATTTGTGATGCCTTTTGCCGAATAAAAAGTCACCTCATAACCCAGAGTGAATAAATTACA
+ TGGAAAAATAACGTAAAATACACCGAGTGTTAAATAAAATCAAATCGGTACATTTGGACTCGGTTCGGTT
+ ATTTCGGTTCGACACGCAGAAAAGGCAAAACTCAACGGTCGCGTCGATACCATTTTTGGAAATTATCGAA
+ AGAGCATAGCAAAACCTTTGCCTCGAAATATAACGTGTACAATGCGTCAGTTTCGAATAAAGTCCAAACC
+ GAGTTCACAATAATTTAATTTACTGAGGCAGCGAAAAAGGATTCTTCCATGATCGGCCAAGGAAAGCAGC
+ TCCAATGGTGTAAGTCTTGAATAAATATGATTTGTAGCAAATTATAATAAAAGCATATTTATTATATTTT
+ TAGAACTAAGCACGTATTTTTGGGTTTCTAAAAAAGAGTTTATAGAATTTTGTTCATGGAAAGATAGCTA
+ GTGTTATAATTCAAAGAAGTATATCGTATAAATAACGTATTCATTATCTGTATTTCAGCTCTCAACGCAA
+ ATGGTAAGAATGGATCACTCGATTGAAAATCCACATAAATGGAGCAAATAATCCATTCACGGAAATAATG
+ TGATAACCCAATAAAAGCCCATGTATTTTGAAATTTGGGTATGTGTTTAAATAAGTGCATAACTAAATGT
+ CCAATAAAAGAAAAATTAGCACAATGAAATGTCTAATTAAAGGAAAATATGCCCGTACCAAAAAACGTCA
+ TAATTTATCAACTAAAATACCATATAAACAAACAATCCAAATAAAAGTGGTTTCAGAATTTTCTAATATA
+ GTAAGATATATAGTGTTTTTGTAAGATATATTTATAATTTTTTTAGCAAGGAGCACAATACTTTTAATAA
+ GCATTAGCTGATTTCGGACAAAAGTCAGGTTAGACATGTCGTTCGAAATCGTCCATTACTCCCAGAAAAT
+ ATTCTGTACAGAGCAAAACTTTCTTCCTCTTCTTCGGGCGGTCTAAAGCAGTTGGTAGAACACCAGTACA
+ AAGAAAATTGGCACAACAAAAAAGTGAGCTCTGCGGTAGTGACGCCGGCAGAGGCAGTGACCGAGGCAGA
+ GGCTTTTTGCTGCCGACGGCGGGCAGCAATTAACTCGAAAGCAAAGAATTTCATCAGAAATTCAAAGCAC
+ ACATACATACTAAAACGGATGACGTGCAACGTCGGCAGAAGCAGCGGCAGTGAGAGACGTTGGAAATTTG
+ TAGCGAAAAATCCAGGCTGACAGCTCCCCCAACGTTCGAAAAAGTAACATGGCGACTATATATAACCCGT
+ ATATATAAATATAAATACTGCGTGTGTGCGCGGACTCCAAACTACAAAAACGAACAACGCAAGGGAGCAA
+ TGGGTACGGGGCAGCCATTGTTGCGGGCGTCAGAGCGAGACAACAGGAGAGAAATTGTCGTGTCGTTTGA
+ AAAATCGATTCAGCTGCTGTGTGAGCGAGATGAAGCGATGTAGTACAGCGTCTTTATTTTTTTTTATTTT
+ TTTTTTTTCTTAACCCGTTTTGTGTGCGTGCGCACAGGGCATCCCGTTAGTGTGTGAGATTGGGGAGAGG
+ AAAACTACAAAGTTAGCGCTCTCTTTCTGGTAAATGCTGTTGGTGTGTGGTCACGTAGCCACAACACGAA
+ AAGCAGATACTACTAAACACATACTAAAACTGGTTTTCTCTTTGCTGCTGCTGACAATATTCATGAGTTC
+ TAGTTGAATCGCCTGTCTTTAATGGGTTTTTTCCTCCTTTGGAGGGAATGAAGATTTCAAGAGATGTACA
+ ACAAAATGGCAAACTAAAAAACTAAACTATTCCAAGCATTTGGAGAAATTTCGGAATAATCTTCGTCTAT
+ CCTGGCTGCCCAATTAGCGAATTAGGTGGGATTTTCGTGTAGGGGTCCCTATAGTAGAGGCTTTTTGCGA
+ GCCGCACCCCACCAGTTCTACAAATCGACTGAAATCGCGTAGCACTGCGAACCCAAGTTTGGATGAGCAG
+ CGCGGCAACAGCGACGTCGCAGCAAAGAAACTTTCACGGCACCGTTGGAGCTTATTCCGTGCATCAGAGC
+ GAGATACAAATAGGGCACTCAATAATATAGCTGTTCGCTCACGAACACCAACAAGGAAATTGACAGATGT
+ ATGGGTGATTTCCTGCTGCGCCCCAAAAGAAAATACGTAGGAGATTTAGAGCTACAAAACTACACGAATT
+ ATGGAAGAACGTGCAATAACAAAGCAAAAGAAGCGCACCACATGACCACATAGCCATTTATAAATACACA
+ GCGAGTTTCTCGTTTTCCATGTACGAGAGAAAAGTACCAGCTATAAATTCTTTATGTACACGAGTATATG
+ GCACGCACACACAAACCCAAACACCCTATGTACTTTGTGCGCTGAAGCAGCAACAACAGCTGGCTATCTC
+ GCTCTAGCAACCACGTCAGACGGCAAACGTCAATTATAAGCAAACAAAGCGACGTTGCCTCATTTCACGA
+ AAGCCGCAGCGAGGCAGAGCGAGAGCAAGCGAAATGGCGCTTCGCGGCAACGTTGCCAAACTTCAGCGTC
+ GACTGCGTGTTGTTCTTGTAGTTTCCATGCTTCTTTAGTGCATGGAATTTTAACATGCTGTACCACCAAC
+ CCTCTTTACGGGGGATGGGGGATTATAATAACGCGCTGCTGACGTCGCTGCTCGCATTTTCCACCTTCTC
+ GCATTCGTATTGTTGCAAAGGAAATGGCCCTATACAAGAAGTTTATCTTTGAATATACATACATACATAT
+ GTATATTTAGTACATGCCGTATTCCGTGCTTAAATTGAGGCAAAAGGAGGAGAACATATCTTGGGTCCAT
+ TGAAATTTCAATAAATTTAAATTGCTCTAGTTGAATTAAATTAAAAGCGTATTTTTAGTTGGTAAATTAA
+ GGCAAATTGGCATTAGTGGAAAAAAAAATTGTGTAATAAAGTAAATCGCTTTAAGAAAAAGTCAAATATT
+ GTAATCACAATGAAAAAGCTTCTATATAAAGTGCACGTGCAGTGTAAAATAAAAATTAGTGTCCGCTGGA
+ TCTAACCCACATATTCCCTCTATCTTTTATTATCCCCATTTCGTTATATAGTGTTAAAAATGTGCAAGTG
+ AAGCGGAAATCTTACCAAAGAAAATAAAATAAAAATATCCATAAAAGTTCTTAAATCAAACAAGCCGAGT
+ ATCTTAACAATCCTCACACTGGAATATATAAAAAGAGTGCATAATGTTTAATGGGAAGGAGGGCGCCCAT
+ TTAAAATGATGCCCCTCCATTCGCGGCATACGACGCAATGCTCCTCCTAAATAGAAGAAGATTCTGCTGC
+ GAATGTTCCGTTGTCGAAACATGGTACGCGACAATAGCCGTAACATTTGTTTTGGAAAATTAGCCGAAAC
+ TACTACGACACAACAACAACAACAGCAACAACAGTTCGTTGTGGATAGCAGCACCATTATAAATAACAAC
+ AACAATAACAACAATAATAATAATAATCAAAAATTGAAAAGGTAAGCCTTATTTAAAGAATGTGCATAAG
+ ATATATTTAATATAATAAATAATATGATATACATGTATATACTTACTGAACTATCTATTCATCGAATTTT
+ TATATAGCTAAATTAATAGTTTTAACGACACTTCAAACACCGAGACCAGCACTCTCGAAAGTATTGGCGG
+ GTGCATTTGGGCGCAAATATAAAACCGAAAAAAGCAAGCTCCAAATTGTTAAACATATAAATACATATAT
+ GTAAATAATGTCTCTTAGAAAATGTCAGCGTAGGCCACTAACAGCTACCTGTGTTAGCGACTGTCCACGC
+ GAGCTAGCTCTTATCATTACGTTGGGATATAAAAAAGTCTGTGTGATATGAATTTTTAAGCTGGCTGCGT
+ CAGAACGCTATTCTCTTACCCCTTCCTCGAACGAACCTCCAACCCAGGCAATGCGTGAAGCACAAATGCA
+ AATGGCTGGCCATGCCCGAAAAATAGTGCGTATCTTTTTACCTTGGCTTTTCTATCTTAGTATCTAACCT
+ GAGTGGGTTTCACCTGGCAGGGTTGTGTGTGAGTGACTAACGAGTACACATAAGAGGTAATGCGAGTCAG
+ GAACTGATATTAGTAGGAAGTAATGGGAATACGGTATATGGGAATGGTGCTGCTGCTGCTCTGATGATAT
+ CCCACAGATCCCTACGTTTTTTTTACCTTTAGTTGTGCATTTATGTTTCGGATTTGCATAAGTCTGTCTC
+ GAGATTCAATAAACCTTTTAAGATTGTCACAAATTTGTTTGTCTTTTAAATGAACTGAAAGTTGGGTGAT
+ GAATTGAAAGTATTTGAGGGAAGACAGACTGTCCCCCAGGTATACAGGTATAAAATGCCTCCTTTTTATT
+ ATTGCGTAATACTTTTTCATAATAACTTTTGTGATTTGTTTATGTGATGTTCGGCCCAAACTAAAGAACT
+ TTTCTGAGCAACTTGTTCTTTTCTGCCGGTTTTAGGTTGCTTTTTTTGTGTTTTTCTTTTATTAGTTAAA
+ CGGGTTTTACGGTCCCCTATTAAATTTAAATTTTCGTTCAGTGCAAAAGAAAAATGACTTAATTGCTTCA
+ TTAGCCACAGCAAAAATTAATTTGGTTTCCTTTAAAACAAAGACCAGACCAACACATTTTGTATTTGCTT
+ CTTTTCAGGGCGGCTGCTGATGCATTAAGCCCGCATCAAGGAAAGACGACAACAGAGGGCAAAGCTCCAT
+ TTAATAGTTTTGCGGTAATTGCCAACAGAAATCGTGGAATCGTCGCGGGTTGAAAACAGTAATTGTTTTT
+ TGACATTGACAATGAACCCTGTGGCCTAAGTAAATAAGTGAGGCACCAGCAAACACATGAAACACTGATA
+ AACAGCAAAAAATAAAATTATATTTTCAGCTGCAACCCTAAATTACGCACTTTTCTATCTACTCTTTTTC
+ GAATTTGTTTCTTGAGTACTTGACACTGAGCAAAATTTCATTGGTAGCTGGCAAATATTAAAAAGAGAAG
+ CAGAAGAAGAATATTAAAAGAAGAAGACTTAAACTTTTTTTAAGACGTTGAAGATTTTTGTTGATTTTGA
+ AATTTAGTATTCGTTCTTCCTTGGCTGTTCACCTCGTCCATGTAACCCCATCAACGTGAACTAATATTAC
+ TTTATTAAATTGAATTTCGTGCTCGGCTTTTTAGCACGCTATGGGCAGAAAGCAAAAACAAAAATAATAA
+ TGATCTACATACGATTTTATGTAGACGAAATTGTATGTATTGCTTTATAATGTTTTTGACTTGTTTCAAT
+ GTCATGTTACAATTACAATTGTTGCTCTCGTTAGATTGGCTTTCTTTATTGTTATTTATTTTATTGTTGT
+ GCTACATGAGAAAATATTTAGTTTGCGTTGCCCGCCTTTTGTTCTTGATGGCATTGAGATTTCTCCTCTC
+ TCAAAGTCAAAAATATAGATTAGATAGAGACTAAAAAGAGACCAGAGTAGTAAAAATCTAAGGAACGACT
+ TCTTAAAGTTATAGTTTATTAGAGATACAGCATTTGGAACCCAATTATCGTATATTTATAGCAAGTTAGC
+ TGTCTACTATTCCAAATAATTACCATACTTTGAACTATCGTACTTTATTATTATTCAAAAGTTTAGTCAT
+ TGATTGTGGTCCGATTAGGTAGTTTTTTTAATCTACAGAAGATCCGTACGGGGTCTATGATTACTCATCC
+ CATTCATCCAACGACGACAGGAACTGAACCAGCAGTATATGAATTCAAAATATTGCTCTCGAACGTTCAC
+ TAGCGTAAGAAATAATTTCGCGAGTATATAGTGATTATTATGTTGGTTCCAGCCAGTTGTGCAATAACAA
+ ATGCATTTTCTTATAGTTGATTTTCGTTGCTATTGTTTTACATATTTATGCCGGGCACTGCACATTTCAT
+ TGTTTTTTGAGCAGTGTCGTAATACCAAACGACAAAAACAAAAATAGCAAAAAATTGAAAAAGAGTCATG
+ CAATGCGAGGATTGAGATATCACAAGGGAACGTGACGAAGTCGTTCGAAAGAGGCAGGGGTCTAGAGGCG
+ GGAAGGCGTGAGACGGCGAAGCATTTGTATGGGAAATTAGAAATTTCCCAAATTATTTCGCACATGAGAT
+ GAGCTAAACTCTGGAGCAGAAGCCAGAGAAGTGGAGATGAGGCAAAATCTCCGGATCCGTGAAACAGTCT
+ CTACAGTGCGCAACGTTGCCAAACTTCTCGTTGACAAAAGGTGCTAAAGAACCGGACAGACACAAAAGAT
+ TATCGTCAAGGGGCGATTGTATGAGATTGTTTGGCCCTGTGTTCGTGAGACCGAGCGTCGAGGCACAGAG
+ CCAGCACAAAGAATGCACAGCAACAATCGATTATATTCCGAAAGAGCTGACGGAGGGGCTTAAAAATATT
+ GATTTTTATACAGAAGTTGTCCAAAATATACATAAATGTTACCCATCATAAATTGGTTGGAATCACAAAT
+ ATCATTCTCTGTCTCGGAAGTAGTTGATTATATTAATTCAGCGAACTATATATACAGTTCCAGGAATTGC
+ GATTTGGGAAAATCATAGCATAGCAAAATAAACTTGTGGTCGCATCTGTAAAAACAGCCATACGTGATAT
+ CGAGTAAGGAAATTGGAGAAGGATGATGAAGACGGCTCGGATTCTCTTGGGCTTGGTTTTGGTGTTCTTC
+ TACCTGTTTAATAATAACCAGTTGGGGCCTGGACTTGGGTTGGACTATGGTTGATGATGATGACGAGGGG
+ GCTGGTGGACGAAGCTAACCGGTTTTTCGACTTTCTGAGGCCTATCATAAAGGCCCGATCAGGTGCATAC
+ ATAATAACACTGCTGGCCGCATGAAAATTAAGCGACATTGTTGCAGCAATTTTCATCGTTAGGCGAGAGA
+ ACGCCGCGCCACAAAGGCACAGATACACACCATGTACGCAAACTATGGCTACGCGGCTACAAAGCTGCAG
+ AGAAAACAAAAAGGAAAAAACAAAAAAAGCAATACACTGAAGTTTGGCAACGTTGTCTGTTGGTGGGGTT
+ TGCAATTTCGCATCTACAGATACAATAATACCCCAGAGCCAGCTGTAGACGCTCGCTGTGCTTGTTTTTC
+ TTGTTTTTTCTATACACACACACTCTCTGCTTGTTTTCAATTAGAGTCGAAAAAAAGAAAGAAAAAATAC
+ AAGCAGCATTTGCTGCTGTTTTTCTTGTTGTTCGACGAGTATCTTGCAAATATACCGCACGTTGTGTAAA
+ CATCAGTCTCTGACTCTGCTGCAGTCGACGTCGACGCCGCAGTATGTGTGCGAGCGAGCCAGTTTTTGTT
+ TGTGTGTGGTGTAGTTTTGTAAATGTATCTGAGTATGGATTTTTGTATCTTTGCTTTTGTGGTCGCTGCC
+ TTTGTAGGTTTTCCTCTTCTTGTTATTGTCGCCGTCTTATGCCTCCTCTGCTGCCTTTATAACAGCGACT
+ ACTTTATTTTTATGCTGACATTTTTGCGGCACTTAAAATTTGCTCTCTCTCCGTTCATTCTCCTTTTGGC
+ TCTCTCGCTTTTGTCGTTTAATTGCAAATGAGTCATGCACACACAGATATTCGCACACTTGTACAATTCA
+ AAGTCCATGTCTGATTAGCAAAAAAATACGTTTTTAATCAATTGGACAAGAAAGAGAGGAAATGTCCTCT
+ CAGCTTCCTCCCGCATCTTTGATAAATAAATAAATCGATTTCTATCTTTTACTTTTTTGCTGGTAGATTT
+ CACCCGAGCAAATACCAAAATCCCATTTTTTTAATTTATTTTTTGCCATATGGGAGGGTTCTCAACTGCA
+ ATTGCAATGATTGACAATAATTTCTGTATTTATAATGAAAATTACTTCGATTTTTTCCACTTATCGCCTT
+ TACAGCGGCGACCATAACTTCTGGACTGCGTTTCGTCGTTTTTCCCTGTTAGCTTATTAAACGGTGTAAA
+ TAAAAATATAATAATGTTAATTAACAATGAATATAAATAAATAAACCCACAAGAATTGCAAGTTGACCAT
+ TTAGAACAATAACAACAATAACAAGTTGACCGCAAACAATATTTTATATTAACAATGCACTTTACTTAAC
+ TTTACATATTTCTATTACTAGCGTGTTAAAAATTCCTGCAATTTTAGAGTGAAATATTGGAAATTGATAG
+ ACCACCAAATATTGAAAATGAAGAAGTAAAATCAAAATCAATCAATCAATCAAATAATAACTGTAACATT
+ AAAAGTTAGAAGGGGAGACACAGACACCACAAGTCCAACCGGAGTGTTCTGCTGTAATTTATGTAGTACT
+ GCTCTGCTAATTGATTTTGATTAGTTGGCGAGAGGGCGTTACAACTCTTATGACTTGTCTTGTTTTATTT
+ GGCCAATGAGAGGTCAGTCTTTCATTGCATTTCGGAAGTAGAAATATATATGAGAGGTCATTGTCTTCCT
+ TCGTAATATGTTACTTACACACTAAATTTCTACTTACATTTCTAAATTTGTTGAAGAGTATGCAACAGGT
+ AGAAAGAAGGGTTTCCAACTGTACACGTGAATATTTTTCATCTTTATTCAACTATATAACATTTTAAACT
+ AAATAATTTAGAAAATTTACTTTACTCGTTGGTTTGTATTTTGCTCTCTTATCTTGCCAAATGTAAATTG
+ ACTCGCTACTTTTACAGTGGCCTTTCGCTTTCAGCCTCATTCATAAGCTAACACTCATTCCGTATAAATA
+ TACATACATATGTCTGCCGAATCCCTCCACATATCTGTCTGACTGTGGCTAGCACAAAGAAAAAGCTGAG
+ CTACTTGCAAAGATAATGGGAAAAACTGTCCAGAAAAATGCGAGAGATACAACCATATGTACATGAACTC
+ TTGAATGGTTGTTCTGCGACTATCTGCGGCGTGCAAACTTCATGGTTCGATGACAAAGCTTTTTCTGTTC
+ TCAATATTCCATTTTCTATTTTATGTTACTTCTTGCTCCCGCCAAGCGGTCTTCGGACCTTGAGCTTTGT
+ TCGCTCTTTGTTTTGCAAATTCTGGAATCACCGAGAGGAAAATGAAGCTAAACTTGTTCTGCTCAGGAAG
+ CATTCAAAGAACCCCTTTAGCTTGCGCCTGTTTATTATCCAGCACCAAAGAAACTTTGACATTCAAAATA
+ AAATACACCCAACGTAATATCGGAGCAGTGGAATATGTGGATGAAAGTAGAAGGGAATGAGTGGTGGAGA
+ GGGAAATGAGAACAACAAGCAGCTGTGCAATATGCGAAGGCAAAAAGAATGCTCGAATGCAAATATACAA
+ CGCTGGCAAAATACATTTCCCCCTTTTTTCTGGAACTGAATTCTATAAATGAAACCATGTGTTGTTACTG
+ GTTTCTATATTTCTACCCTTTTTTGGATCTATATCGTTTGATTTGTGCTGGGTTGTGCAGGTCTTGTTTT
+ ATCCCATAAAGTTTCACATTTGCTTTTTTGTACACATACAATATTACATATATTTTGTGCCTTGGAATCA
+ ATTTGAATTATACATATGTATATAATAAATTAAGCCTGAGGCACATTATATTAAATATGTTAATATATCT
+ AAACAATAAAATAATATTGCAATTTTTCCAACATTAATTCACATAAAATCAAGCATATTAGCAATCGGCT
+ TGTTTCGATCATTTATTACTTTTATAATAACCATATGGTCTAAGTCGCCCAAAAGAATACATCGAACGTA
+ GATCGGACTGTAATTTTTAATGTCTCCCTCGCAGTCTAATAGTCAAGGGACTCGGCTATAGCGTGCTCTC
+ CTGTTGCTTATATTTTGAATGCAAGTGATTAAAGTACAAATGAGTCCTACATGAATTTTCTAGATTTTAA
+ AGTCTGTGGACATCATACAATCGCCTAAGCACCGAATTGTGTTTCTCCATCGAACAACTTTAAATTTACC
+ TATACTGATGGAAGAGGACCGACAAACGAAGAACACCCACTTCAGCTTGCAGCTGTTGAAGCAGAGTGAA
+ ACCCGTTTGGATGTTTGCACTAGTTGCAACTAGTTTTCATTATTTTTATTGCTATTGCAGCTGGCGTATC
+ TTTGTGTTTTTGTCTCGGGCTGAAGAATGAGACCAACTTGCCGTCTGAAACTGAGTTCGCGAACTGTCAA
+ CGTTCGCTTCTTCTGCGAGATTTCTGCGTTGCTCTTCTGAGTTTCTCAGAGCTTTTCCTGTGTTTTTTCG
+ ATATTAAACTGCAGCTGTCAGTCAAAGTGGTTGCAACTGCCTTTAAATGTCTCTACATTGTCGTTGTTGT
+ GGCTTTGGCCGCTGCAAATGGGGTCGAGTTATTGTGTTTTTCTCTGTCTAACAGTGCAAATTCTTCAGGC
+ TGCTGTACATATATTAAATACTATCGGTTTAGATATCCCTTACTTTGACTTTTATCTGCCGTTATAAACA
+ ATAAGTGCGTGTGTGTATCTCTATCTTTAAACGACGATAGTAAACATTCTTAACGACTAACTTTTGATTT
+ TATTCGTATAATAAACATCTTTAGGATTTTGCTGAAGTATAACTATCCAAATACCAAATACAGTGCGGCG
+ GTATGTGTGTCATCCTGATAAAGCAGTAAATAAAACCACCTTAGTTACATAGGAAACATTTTATTTAACT
+ CCTCACACGTTCAGATAGTTAAATATGAATTAATTTCGTGGAGGCTTAAGTATATCTTATCACAGAACTT
+ AGAAAGATCATTTCAAACATTTTAATTTATAAATTACATGTTTTTTGTTGTGTCCTTTGTCCTTTTGTCA
+ ATTATTTAGTTAACGATGACGTAACATTAATTTCAAAAATAGTTAGAATACACAAAATTTGAATTAATTT
+ CAACAGCTAGTAAAGTAATATTTTGAGAGTTGCATTGTAATACTTAGGCGGTTTATCGTATTTTATCTAT
+ TTTTCAATTAAGTGTTAACAAAGAACTTATCATATCATATTAAATGTCCGAGTCGCACTTTTTATCAGCT
+ CATAAAAGCTTACGCGTTTATATAGGCCTGTACATACTTTATATATGATGAACAACTGCGTTTCCCTCCG
+ ACGATTAGATAAGGGTCCTGCTGATAAGAAATTTAAACATGTGAGTAACGTACTACGTTAACTGTAGGCG
+ AGTTCGTCGCAGAGTGGGGAAAAGCATTTCTGTATGTGTTTACATAAGGAACGTTAACAGTTTGTTCTAA
+ TAATAATAGTCTAATAGTCTAATAATAATAGTCTGTTTAAAAGAATCCATTAGTCATTTGGCTAATATGA
+ TGCATGTTTCGAGCTCTAAATCTTTTGCAAGGATTTGGTTATCTAGCGACATGGTTTCAGAACTTAAGTG
+ ATTGATAAGGGGGAATGAAACATTAAGGTTGGCTAGTGGCCTTTTACTAAGGCTGATTAGCAAATTGCAT
+ ACTTCGAATGAAGTAATAACAAAATGACAAAATTTTAACAGTTTGACGTTAACTTATTCTTTGAATTTAT
+ GAGGATGAATTAGTTAAAAGCAACCTTTAATCCCAACTGGGTTACTTTTAGTTATCTCGATCTTAATAAA
+ TCATTTCAACTCTTTGGGGATTTTTTTTTTATTATAATTTGATATTCTGGTTGTCCATTCTTTTTCTTCG
+ GTTCTAAGTCGTGCCAAGCACCGGATTTGCATTGTTAATTTGAGCATCTAAACTTATAAATTTACACAAT
+ AATTAAAAAATGTAAATACCAGTGAGCATCAAATAGTAATTGCCTACACATTGCACAAAGGCTAGAAAAT
+ GATAATAATAGTAGCTTTCACAAGCCGATGTTCTTATATTTCACGATTGCTGCCAACTTAATAAAAAATT
+ TTCGAAAGAAATTTCGGAATTCATTTGACAAGTAGCATAACAAGAAAAATTAATCTGCACAATTTTATTT
+ TTATATCTGTTTATAAAAGGATCAATCAGAATGGCAAGCAATCTTTAATATAAATAACCATAAATATACA
+ CGTGAAATATATCTAGTAAATACTTATCTATATACTGGATTTTAAGACACACGACAAGGCAAATGCAAAA
+ CACTTTTAAGCTGAGTTCTTTCGTCATGGTATCCATGAACGGCCAGTACATACGTGTATATTTATATAGC
+ GAATCACAAATATGTATATACGACTATATACATTTCGAGGAGCCACAAAAGACCAAGGCAAACACAGGCG
+ GAAAGAATGACAGAAGAACAGACTGAGGAAATCTCCATATAAACATACCGCCACCGTATATACCATACGT
+ GTATACCTTCAGCTCTGACTGTTACCTACCAACAACAACGAATGTACCTGTTGTGCGTTGAAAAAAAAAC
+ CAAGGAGACAGACAGAAAAATATAAAGAAACCAGCAGTAAGTTTAAATGTTATTCAAGTTACCTTTGAGA
+ CTTGAAACCGGTTAGCGGCTCACGTAGGTGCTGCCAACTCACAAAACAAAAACAGAAAACATAATGTTAG
+ TCTCGTCGTGATGCCAGCGGAAAAGAAAAAAGAAGAAAAGAGCATATCAGACCAGAATAATTATCCAATA
+ CAGGCAAATGAAAAATTATTCTGGCATAAATCAATATTTTGTTTATATCTTTTTGATCGATGTAAAATAA
+ TGCTCTTTTAATTATTTATTTATTTTAAGCTTGGTTTTAATTTGGTGCAGATTAAACATTGGAATAGTAA
+ TTTGGTAGTTTCGGTTTAATTATTTTTCCTTGCTTCAATATATGCGCCATATAGTTTAGTCTCGAAAAAA
+ GGGGTACCAACTGACTTCTCTTCAGTTATTGCTCGCTGCTCCTGGTTGGCTATTTAAACCAGTTTATGTT
+ GTTAGTGTTGTTACGCGTTTTCATACATTGCAAGGAAAATTTTTTTTTTTTTTTTTTACAAATTTTGTGA
+ GGTGTTTGTCTAAAGTAATATTTTTATATCCTAAGTAATATGTATATATCTTATATTCTTAATCCCGATC
+ GATTTTGCCAAGACCGGCCGTAAACGACGCCCAAATTTAGTTGTATGATGTTTTTAGAGTACTCTTGTTG
+ CTCTTACAATTTTTTTTTTAACATAAATAACTATTATGATATTTTGTATACACCTTACTCGTTAAGTAAA
+ TGGGTCTACCACATTCTGGGAAGCGTTACAGGCAATATTAAGTGTATAAATTTCTTATATTTATATTTGC
+ TTGATCAGCATCATTAGGTGAATCGGTCTGAGCATGTCTACCTGTCCGTCCGTATGCATGCAGTAATCTC
+ GGCTGAGTAACGGGAATCTGATAGTCAAGGAACTTTTTTCTTTAATACTACCTTCCCACACAGATCGTAC
+ TCCTAAATCTTTTATGATTTTAGAGCACTTGAACGCTAGATTTCATTTCTTAATTTTTTTTTGTGCCGTT
+ TCCTTTGGAAACACGATTAAAATTCAAAATACTGAACTCTGGCAAACCCATTTGCATAACCAGTTTTCTT
+ AACTCACGAGATCGAGGATGAGCAGACAGATTTCGTATCGTCTGTTCTGACCTGTGATTTTTTGAGTTGG
+ CCCACCTGCTGCATTTTCATTGATTTAAGGAGGTTGGTCCTTAGCAGCAGAAGCAGTGGCCATAATGTGA
+ CTTATGTGCATTATTTTGTTTGACTTCCGTTTGGACTTATGTAATTCATATTAAACCAAAATTGCTATCG
+ GAAAAATTACCACCTTGTATCTGCAGCTGTGGCTGGACCGAAATTCGTAATGGTATCTGTATCTCATCGA
+ GTTCTCAATTTTCTGAGGGTTCGTGATCTACCACACGCCTTTCACTCACACGAGTGAACGCACAGTTTTT
+ TTTAGGTGTATATCCATGGGAAGGTCCTTTAATACCGGGACTAATTTTTTCTTGGTGCCAACTATTCTTC
+ TATTTTAGTTATATAAAGTCAAATTCTTTTATGTACTCCATGATTTCAGCGTATATTTTTGGTGTTACCT
+ TATGCAATTTGCACGCGTGAGTTGTTTTGAAGTCGCGTGCAGCCCCAACCTATAGTACATTTCTTCGTTT
+ TTTCTTTTTATGCCGTGTGCATAAAGTATATTGGTGAAATTGGGTTTGATTTTAAGTTTCACCACCCACG
+ TTCTAGATTGGGTTTGTTGGCCCCTCATACTAAATTACACATATCAAAAATCCGGCAAAAGCTTTTTATT
+ TCTACTGCCATGGCTGAAACATTCGTTCTTCTGCTCTCAATTATGTTTAGCTGTCGCGGCTGCGACGACA
+ AATAGACAAAGCCCGGGAGAACGCTATAGTCCAGTAGTGCAAATGGTCAAGAAAACTCAAAATAAATAAA
+ AAATAATTCCTGGGATCTCGACGTTTATACCGACGAACAAGACTCTCAATTCTGAAGGAAGACCCTTTAA
+ GGCCGATTTACCGTTTCAAATAGCCGGCCAATACTCCCCAAATTCCCAAATCATAATGTTGGAAAAATCC
+ AATAGGTCGGATCGTCTTTTTTTACCACAAAATTGTGCGTACAAGATTTTTATATAATTTTCACTATATG
+ TACATTCTCTCCCCACTAATTTTAATTTCTCTTTTAATTCGCTTAATTTTAGCCAAATATTGCCTACAGT
+ TTGTAATTTTTGCTTCGTTTGTCATTCCTGTGCCATGTGAAACGTTTCACGGACCCCTGATGATGATTAT
+ AAACATTGTTTCATTTTCGCTACTTTAATCAATTTGCACTTGAAATTTTGGACACGACTTCTTTTAAAAA
+ AAATAATCTAGAGTCTTTAGTAAAGACCCTTTACAGCTTGGAGTAAAACGTTCCCAGGTGTATATTTGCG
+ TTTATGTACTACATATGTATGTACCAATAGACAAACAATAATACATATTTGTATGTGCATTTATAATATC
+ TCCCGCTTACTTTTTGTGTTTTTCTATGTATCTCTTTTGTCTGCTCGGCATTTGGCGGCTGACTCTCCAA
+ TGTCAGCAAGAGATCAATAAACTTTTGGCAAATAACAAGAAACGAAAAAATACGAGAAAAGAAAACAAAT
+ TAAAGCGCATAAAAAACAGATTACAGCGAAAAGAAATAAATAGCAGCCAAAGTTTCGACACATAAAGCGT
+ GAAATGGGAAGGGGGTTTGGGGTGTAAAATCTACTTTTTATATAATCACAAACAATACAAAATTCAAGAC
+ TTATTGTGTATACAATACATAACGGTCTATTTTCCTTCTACCCTGCTGCTTTTTTTTGGCATCTCAGTTT
+ CTCTCCTGATATTTTTGGCGAACGGAGCGTCAGCGTCAGTGTCATTAAAGTTTTTTGTGTATGCCAGAGG
+ CCACAACAGAAATAAATATGCCATAATATGCACGCACCATTTTAAATCTTTAACAATTTTTCCGGAAAAT
+ ATGAAAACAAAATTACAACCAATTAGATGTCTATATTATGAATACTTATTTAATATTATTCACAAAGGTA
+ CGAATTTATACATAGTTGTTCTTAAATTAAAGACATATACAAAGGTAGAAATCATCACTGATTGTTTGTT
+ GAATAACACAAATTCGCAAAATTGAATAGTTTCTTGCATTGACATCAATTTAATAGACATTTTTTGCTTA
+ CGGTATTTATTGTGCGTTTTGTTTTAGCTGTCTCGACCTTTTAATGGTTTTCAGGCTATTATTCGATTTA
+ GTAATGTATTTTTTTTTCGGTGTGTGAGTTTTCCCTCTCTTCTCTTGTCCCTAAAAATAGTAACAAGCAA
+ ATACAAATAATGTATTTATTTTTACCTTTTGGCTTTACAATTTTTGGCTCGTCCTAAACAATTTGAACTT
+ TTGTACTTTTGGCAAATGGAGACAGACTGTTTTGGTTGAGAAATGTACAAAAATCGAGAAAACTTATGGG
+ AAACTTTAAGAAAATTTAGCAATAAAATTTTTTTTAATATGGCAATGTTTTAATTTTATTTTCATTTTTT
+ TTATTTATAGGTGCGTATCCTTAAAGCGACACTGCCTGCCTCAAGTCCTGGATTATTGAGGCAGCCATTG
+ AGTGACGACAGTAATGTTGATAGTAATGTAAGTTTACATGTCAGTGAAGTATTTCGTTTATATATTGAAA
+ ATCTACCGTTCAATTAAATGGCTAAAATGTATTTAAGTTACTTAAGTGTTACATGTTTCTATCTTCCTCC
+ TTGCAAGAAACTCACCCATAAAAATAATAAGTATCATTGGCAAAGGGTACTTCTTATCAGCTTCGTGCAA
+ CGTATCGTAATATGCCGCATCACCCTTTTCTTTCGCTTAAGCACTTGCCGTTTCGTTTACCCTCGAAAGA
+ ATTTTATAATTGAGCTCAATTCCTGCTCACCTGTATTTTTTGATGCGTGCTGATTGCACTTGACTTAAAC
+ AACTGATGACAGCTGAAAAATACCTTTCGGAAGTCTGTGAATCGATAGCATTTTAAATATCACTCGGTGT
+ TGTGTGACCCACTTAGCGATTATAATAGATTTTCGAAAACCGGTCATAACCAGGAAATGAAATACAAACA
+ TGCTGTTAGACCAAGCCCAAAAAGAGACCCACTCTCTAAAATGACAATAAATCCGAACAAATAATATCGA
+ ATTCGGTACACAGATATGTATACGCCGGCTTAAATATATTAGCAAATAATGATAGAGGCTAACAAAAATT
+ AATAGAGATGTTCAAGGTTTTTTTTTTTTTTGACTCGACGACTCATCTTGAAGTCGTATTCGTGGCTAAA
+ CACGAGGCAAAGGAAAACAGCTATGCTTGAGAACTAAAAAGAAGAGGACAACGAAATGTTTTCCAATTGG
+ GCAAATATACATAGTTTATTTTTGCCACTTAAAGATTATGCAAATCGTCAAATGAATAATATGAAAACAG
+ AAAGAAGTAACAATACTTGTTACATACATATGTACTTTTCAACAAATCTAGAATATTCTTTTTTTTTAAT
+ CTACGCATTTTGAGAATTGTGCATTTAAAGTGTCTTAAGTTAGAGTTTAATTATTTATTTATTTATTTAT
+ TATGATAGATAGAATAGTTTACAAAACTAGACTAACTTAAATAAAATAGCATTAGCTACGGGGCTTACAG
+ CTATATTTATTTACAATGTTTTTATATCTTGGAGTTTAATTATCATTGCATAAAAATAGAGAATGGGTAT
+ ATGGTTTCTCCAAGGTAGATTTTTACACCTAGTTGCCTTTTATAGATTAACGCAATATAATGTATGTAAC
+ TGAGAAATGCATTTGTAATCAATCGAGTTTATTCAACAGTAAAATTAAAAGATGGTTTATACAACTAATT
+ CAAGCAGGCAGTAGCTTAAGTAAACGTTATATTACATGTGCACAAACTGAAATGCGGCTAAGTTTAAAAA
+ AGCTTGACAATCAACACAGCAATATATTTTAAAATTTGAAGACTAAATTCAACATTCAATGCATCAAAAA
+ GGATATTTGAAAAAAAATTATAATAATTAATTTAATTCTCTAACATGGACATGTGAGTAAACCAGTTATA
+ TTGGTTTACTGTGTATCTGTGACGTTACATAAAGTTGTACACACGCCCCTATTTGCAGGATTCAGATTTC
+ GATTTATTTATTATTTGTTTAATCTTTTCAATTACAATAACCATGTGTGTATGAGAAAAATGCAATTAAA
+ ATAATAATTTTAATGATGACTCGCCCTTGTATTCTGCGAGTATTGTTGGCTTTGGTTTTTTGAGGTCTTC
+ TTCACTTATTTTGGCAGCATTACCGACTAATTTAGATTTCCAAGTTATCTATCAAAAATGTGAACCTTGC
+ ATCAGAAACAATTTGCCGAGTTCTTTATTAAAAGAAATTGCTTTTCCAGGATTCCTTTGCCAAACCCATC
+ GTTGTGGAATAAAGACAAATTCAGGCTCTCGTGACTATGGTGAAGAGGTTCTGGATCTTTATCCCACCCC
+ AATCTTCCCCTTTAATTTATCGCCCTGCCATTATAAGGATGCCATGGCTATGGTAGCCGCATTCGAATAC
+ TTTGGGTGTGTCCTAAAATCCTTTTCGATGCATTGAAATAAATTGCAGTAAACATTAAATAAAAGAAGTG
+ AATGGAAAGAAATTACCAAAACCAAGAAAACTCCAGCTATAATCAATCTTTATGTGTGTGGAAATGCTTC
+ CTGGCCCTCGGATATGGGTAGCTGGAAAAGATAAGGAACGATTTCTTTTTTCCCCAGAAAAATATATGTA
+ TTGCTTACTAAATTTTAGTTGTAGACGTAGGAGAGACAGATAGAAGGAGGTGCATACAATTAAATTTTAC
+ ACACTGATGAATAAATCCACCGCACAATATCATTTTTATATTTTTTAGTGTATGTATTACTTATATAACC
+ AGAACGCCTGCAAGTTTAGATACAGAACACACATACAGCCACGTCAATTGCAACTGTGCATTTCCCTGGA
+ AAATATTGATCGGAAAATCAATTTTAATTAAATTGTCAGCCCCCCAAAGGAGGTGATTATGTATCCCATT
+ CGCAATGTGCGTTTGTATCCGTATCTGTGGATGTGTATTTTCATCTCCCTGCATGTAATTGCATTGCACT
+ GTCGCCTGTTTTCACTTGAATGGTTTTAGCAAACAAAGTTTGCGATTTTGTCTCCATTGGACTCCATTTT
+ CGCCAAATCGAATTAATTTAAATGCAGCCAAACAAGTTAAGATTAACCAGAATAAATGGTGGCAGTAAAT
+ ACCGAATTCTGCCAGTGCTGGGGAAACTCGAATCCTTGGTTTCATTTGAATGAAGGGTTATCAAAAGTCG
+ CAGTTAAGTTAATTCAAGTGATGTTGATGTGTCTATATCCGTACGCGCAGAGTAAAAGGGTATAATAGAT
+ TCGTTGAAAAATATAAAACAGCGCTTAATAGCGTTTTCGACCCTCAAAGGCTTAAGGTTTGTTAATTAGG
+ ATCAATAGCCGAGTCGATCTAGCCATATCCGTCCGTATGTCTGCCTGTACGAACGAGATCTCGGGAACAA
+ TAAAAACGAGAACATTTTATTAAGCATGCAGCTTTCAGAAATTTGCCACTTTTACCCCCGCAAACCCTTC
+ TCTCAAGCTTAGTAACGGGTATCTGATAGTCGAGAAAGCTTTTTCTCTTGTTTTCATAAAAATAAGAGTG
+ CTTATATTAGTTTACTCAATTCGTATATATGTGATGCCACTTTGCATCGCATGCCTAGGATCTGACGAAG
+ ATATTAACACAACGACTACCACATCTTACTCTTCTGGGTTTCGTTTTACAACGCAAGATATATTTAAATC
+ CGTGTTAGATTTTCCTGGTCGTTATAGTGACTAACTTTTGCTTGTTATTATAGACCAGAATTCCTTAAGA
+ TAACATCTTTTCCATACTGCAATTTAGCTTTTTGTTACCATTTCATTAGAAGCGGCATGATAAGAAACCC
+ CAACGCATGTGGAAAAACAAAGTGCACTGGAAGTTCCTCTTGCCGGCATAGGCTCTGGAGGTTGTGTGAC
+ GCCGAGAAAAATGACAGTCTGGCTACAGAAAGGGCGCGGCAGAGCTGCTTCCTGTAAAACTCATCATGTC
+ GTCGCCAGTGTCTTTAAAAGTGCTTTCATTTTCCATTTCCACGACCTCGTTTTCAAGCAATCCTAGCCTC
+ TAAGTTAGGAAGACGGTTATTTTTTCTAGCTTCTGATCTGACATTTTTTTTACTTGAATCTTTCAGTGAT
+ TTTATTGTGGCAATTTACCCTGTTGTTGTTTATAGGGCCCTGCGGCTGTGGGTGGCTGCCAGGATATGAA
+ AGATAACCAATGTCCTGGCCTTTTATATATATGTGCATATATGCCAAGCATGTAACGCAGTCCGTAGCAT
+ TTTCTGTCCAGATTATGTACTGGAATTCAGAGAGCGCAAGCGCAATACGATGGTAAATTCTCTGCCCTTT
+ TTCGGATTTCCCCTAGCTTTCTCTCCCAGCTTAGGCACTCGCCTTGCATAAGTTTCATTCAATGGTTTGA
+ ACCGGCCTGGGAGGGAAGATAATCTGTGCTCCTAGCCCTGCTTGTTGTTGCTATATGTAACCCCTACCTT
+ TTTGCCACCCGCTTTTTTGCCGCTTCCGGTTGCGTCACTTTGGCTCGGGTAAGCAGAGCCGCGAATTTTT
+ TCAGAACATCCCCTGGTTTTCCTCGCCTTTCTTTGTTTGTCGCATACCTTGGACACACATCACACCAATT
+ CACTAGCATGTTACTACTTTAATTGAGGTCGCCAGTTGGAATAACTAATAATTTAATTTTGTGTCTAAAT
+ TAATATAAACAACAATATTAATATATTAATAGGATATCCCGTTTTCTTAGTTCCGAAGTTAGTTTAAAAT
+ ATTGTAGTTCTACTATTTAGATAAATCCAAGCTAATATGTTTTAAAATCAATAATGGTTATTATACCCGT
+ TACTCGTGGAGTAAAAGGCTATAATAGATTAGCTGAGAAGTATGTAATAGGCAAAAGGAATCGTCTGTCC
+ GTATGAACGTCGAGATCTCAGGAACTAAAAAAGCTAGAAGGTTGAGATTAAGCGTACAGAATCTAAAGAC
+ AAAGACGCAGCGAAAGTTTGTTGACCCATGCTGCCACGCCCATATGTTTTTATATTATCTCATATTTTCC
+ TTAGTTTTGTAAATTTCTATCGATTTGCCAATTTATTATTTTTTCAGTCATTTTTTAATTCTATGTGGGA
+ TTTTGTCTTGACCATTGCATTTTGTATTCATGAGCGCTCAGTTGGTGATCACCCCTTTTGTGACCTACAT
+ GGGGCTATACGAAATATTTTAAATATACTAATAATGAGAAATTGTCCTATAATCTGAAATTATTTTGGGT
+ GGGGCTCTCCTGTCACTTCCGTGTTAATGTTTATCTTATTCCTTTAGCAGAATGTCGTGTTTACATCCTG
+ CGCGTCCTGTCATTCCCGCGTCCTTCAACTTTTGCATGCAGGGGTGCACTCTATGCAGCAATGCTTCTGT
+ AACCTCTTCATCCCGATCTTCCTAATCCTACTGCCAATTCCGTGATATTGATAAATTTCACGCCCTAAGG
+ GGAGACGCGTTTAGTGAATGTTCTCCCGTTCAAATTACTTTGACTGCAGTCAGTTGGGAAATGGGTGGGC
+ AACGTCGTCCGGCTATGATTGAAAATAAGACTTAAAAAGGGTTACACAAATTTCAACTCCATGAACACGG
+ TAGTGTGAATGTGTATGGAATGCGGGAAAACCCGGCAGGCTAAGTACATACGGGGCTTCTTTTTAGCTTC
+ TCCTTCTCTTATGTTCTAGGGAAGCCAAATATACACATAAATAACCTCAAACAAGGACGTTCGGTGAGAA
+ ACTTTTGCCAGGACAATGACTGGGAGACTGTGGGCTGAGGATCCAACCAACCAATTGTGTGCTAAAAATA
+ AACACAATAAATGTATTTGTGAGAGCCTTTTTAATGCAGATATGTTCTTGATAGCTTACCATCGCTGGGC
+ TTTTGACATAAAGGATTCATGCAAATTTTAATATAGTCTTTAGCTGTTTGGTTTGTATTTGAACGTTTCG
+ TTTAAAGTATCAAAATTCGTATAAAACCTAAACCCAAAACCACCGCTATTTAGGTTTGTTTCTCTTCACC
+ GGCTAATCAGCCATTTACTGCGCAGTCATCTTGGTCGTGTATTACATAAGCGCTCCCGCAACCACAGTAG
+ CGCTGGAAGCATGGCAGTAATGCAATTTACAGACGCCCAAAAATGTCCACCCACCTTCGAGGTTGTTGTT
+ GTTCAATGCGTGGTTTTGGGCGACGGCGCTTCTTCGACTGGCCGCAAGCTCCCCCCTCCCCTTTTCTCCT
+ GGGCGCAACAAATGTTGCGCAGTAATGTTGTTATTACTGGCGATGTTGTTGTTCTCGGTGTCGTTGTTTT
+ GGTTGGTGTGGCCCTGCAATTCCTTGAACCGGGCGCTCTTTTAGCTGAATTGATTTTTCTGATGGCCTCA
+ ACTGCGCATGCCGGACAATCATTCTCCCCTACTCATCATAGCCCCTGTTTCGCCTCCAAACTGCGTTTTC
+ GATAAACATATGAACATTTTCGTAAGGTAAATATCTTTTTGGAACATCCTTTAACGTATCTCAAAATGTA
+ AGTTACTTCATACTTGTATAAAAATTTACCATAAATTTATGAAAGACTGTACCGCACTTCAGTGGCAACC
+ GCCTGAGTTAGGCCCCGAGCTATGTGCACCACAGCCACTTTGTCTGGCACGTCCTCCTGCTGCAGTCGAA
+ TTCTCTGCCTCTGGCGCTGCTCGCCAACTTATGTGACCTGAGCAGAGGGCTGGAAAATGCTGCATTCAGC
+ TCCACCACCACCATGCCTGTGCATATACTCAGTACATATGTATAAACATATGTAAACAGTTTCTTCTTGG
+ TGCATGATGCGTTTGGCCATATTCTAAGTGCTGTTCCTTAAAGCGCCTAATGCGGCTTTAAAAAATATTC
+ ATTCCAGCAGCTTCTGAGGGCTTGAGACATCAATCTAAATAAGATGGCTTCAATTCATCAGCTTGTTCAT
+ TGTATACTGTAGAAATATGAGCTAGTCTGGGTAAATAATGATTACGATTATAAAGCTATCTGCTCTTTCC
+ CAAAGAATTTCTCTTTCTTCTTTATAAGTCAGAAAGTTTATGACAATATTAAATCCTTATTGAAAATTAA
+ TAAAAATCCCATAACCATTGTAATTATAAAAAAAAACTGTATTATAAGTACAAGAATAGCTTGAGGAATA
+ TTAGTGTGTTATTGAAGTAATTAAAAAAAAAAAAGAAAAGAAAAGTCTACTATATCCCGAGTTTCCGATA
+ TATAAGAAAAAACGTCACATCTTTTGTAAAAGTCATCAAACCTAGTACTAATTAAGAATAAGCTGCTATT
+ TAGCACTATGTTATATTTTTAGTAGGAAACTTAATCTTTTATATTTGGAGATATGGTGAGCCTGAAAACG
+ ATGTACAACTGAAACCCATTGTCCTTTTTATGGAATAAATTGAGCCTTCTGCGCCTTAATTTATATGGGG
+ GTTGGTTTTTGCGTCTTGAATTGAATGTCATTGTTACTCGAAACTTCAGGTAAAACATTTAAATTTTTAC
+ CTGGTATCTTCCGAATCTTATTCGGTTTAGTATGAGAGAAAATGTTTTCTTATCATTGTGAAAAATATAA
+ ATGTAGCTTACATCAGATAGACAAATAAATATTTCGGTAATTATCTGGTCAGATAACTACAACTTGTTGT
+ TTTAAAGCGTTTGCCCTTTCGTAACCCAAAATTTGGCAGAGTTAATTTGTTGACATAGTTAAACATATAA
+ ATAAATACAACTAAACGTATGAAAAAATACTCAATTATTAAAAAATAAAAAAATACACATAATGGCTCTG
+ GATGTAAACTCAGAAAATAGACACAATTTTTACATGGTTACGTTAAGGGGTACGTTACGTCAAAGAGTTG
+ TTTACGTTACGGTAGTACCAGACAGTCTGGCAGCACTACACGCGAATATCGGCACAAAATGAAATCGGGG
+ TGGTCAGTGAGCGAAATGCGCCGAGCGAACGAACTGTTTATTAAATGAAGAGCAAATCGCAAGGACAAAT
+ AACGTAAGGCAAGCCTTTAACCGTGTAAGAGTGACGGAATAATAAAATATTTAACACTAAAAACCGGTTG
+ GCTATTAAATATAGCAGCAAAGAAAAACGTGGCTCTCCCGGCTTTTTTGCTTCTGTGTTTGTGCTTCTTC
+ GTAGCAGCTTTCGTGTGTGCAAACGCATCAGTGTGTGAGATATTTGTTTGTATGTGTAGCCGCGTAAACA
+ GACGCAGACAAATAAAGGAAGAAGTTGGCGGATTGAGCCGCACGTCAGTTTATTTGGCGCTCGTTTATTT
+ ATTTGGCCAAGTGAAATTTTTCGTAGTGCCGATTTATCAATAGTACGAAGAAATCGGGAACGGATAAGCG
+ AACAAAAAACGATAGATTTGGTACATTACTGTTTCCCGATGTTAGCACTAAATGTTGGGGCTCCCGTTTC
+ TGGGGATGATAAATTAAACCGGGATTACCTATGTAGCAAAGCTTACAACGACGATTTTCCCAGCGAGAAC
+ CGGTAAATAATATGCGAAGGTGGGTTACTATTCTGGCAAGCATCATGAACATTGGTAATGCGATGAACAT
+ ACATTCGTAGTTAAAAAAAAAAAAACAAAACAATGTGGTGGCAACCCTAGTTCAATATATACATATGTAT
+ GTATGTACTATATGTATATGCGTATATGTTTTTACCTAGATAATAAAAAAAAAAGTGTTACAAACATATA
+ AAGAAAAAGCAGTAAAAGCTAAATTAATTATGCGTATTATTCTATGTCATAAAATGAAAACGTATTTTTG
+ CCCCTTATTTGTGCGCTATAACAAATACATACATTTTAATGTGTTTCTGAAATTTGATGAATTGTTCTAC
+ ACTATTTTAGGTCTACAGAGGAACCACCGACAAACAGCTTCGAACGGAATTATTACGACCGCACCACCAG
+ CCGTTTAGTCACGCAGTATCAAGCGAACAACTCAACTTCCTTGGCCAATTCAAACTCCAGTCCCTCGTCC
+ GTGAGCGCCTCCGCGTCAGTCTTCGCTACGGCGGCAGGAGGGTCTTCCGAGAGATCACGCAACCGAGATC
+ GCCCGTACAGGAATGGTTCTGCCAGCGTTCAAGGCGGCGGCATCAACAGCAGCAACACGACGACGACGAC
+ AGCAGCCTGCACAGCTGGAGGATCTGGATCGGGAGCAATTGGAACTGGGACTGGGGGTTTGGTAGGCTCA
+ GGTCCTGGGGGAGTACCGCAGGCGCTAGGCGACCGCAGCAGCACCCAGAATATCCACCAGAACCATCAGA
+ GCGCGCGGGTGGCTCCACCACAGTCATGGTACGAAGCCGCCACTGCTGCAACGACGGCCCAATTGAAAAG
+ TTCTGGTGGCAGTGGCAATGCCGGCGCCTCAGCAGCCGTGGGCTTCACAATGAGCAGCTCACCGATCAAC
+ CATCATCCGCACCAGCATCCGCATCTTCAGAATCCTCAACACCCGCACTACACCAGCAGTCCAGTGGTAG
+ GAGCCGGATCTTGTCCCTCCGCCGCTCAAGGACAGCCACAGATTCAGTCGCAATCGCAGACCACGGCCGT
+ GCATCGAAGCGTGGCCTATGCGGGAAGTGCTGCGGATGACTTACTGAACACCGCCACCTCACGAAATATG
+ CTTCTGCACAGCAGCAAACTCAATAAGCTACTTAAGGGGGCAGGAGCAACGGGAAGCGGAGGAGAACGCT
+ CTGGTTCGGAATCACCAGGAAGAGCTGGAGGAGCTACTCCTTTGACTACGACAAGTACAATCACAAACAA
+ TAGTTTTAGTAGTAATAGTTTAAATAATACAATAACCACGGCGACTCCAACAATGCCCACGATAGCTTCT
+ GGAGCAGCAGGATCGGTGGGGTTAGGATCTGGAGCAGAAGCGGGAGTATGTTCCAATTCCGGTACAGCCA
+ GCGGTGACATTCTAAATGTGGCCGCTGTTTTGGCCGCCGCCGTGGACAATGGGGTGCCAACGCATCCGAT
+ CCGGACACGACACAACCTGCACGGACGCAGCACCACCTCCTCCAGTCGCTCGCACTCGCGCTCACCGAGT
+ AGCTACAGCAGTTCGCACAGCTCCTCCTCCTCATCGCACTCCTCATCCCACTCGCACGCGTCCAGTCCCG
+ TCCAGTCTTCGGGCAATTGTGCGATGGCAGAGGGGCGCAGCAGTCGCACCGTTAATTCTGTCACAGTAAC
+ CAGTAAGTTGCGATCATACAAAATTATATTAGAAATATGTCGTATTAAATGTCTTTCGTTTACTCCCGCA
+ GGCAACTCTTCAAATCCCAGTGGCACAGCTGTTACCGTCAGCAGTGCAGGCGTCGGAGGGGGATGTGGGT
+ CCAGTTCATCTTCAAGCAGTAGCTCTAGTTCCAGCGGATCCTCCTGTCTGACGGCCAATCCCGTCGTGCA
+ TTCCGAAGACAACCGGCCGCTAGCGATACGAGTCCGCAACCTGCCTGCCCGTTCCTCGGACACATCCCTC
+ AAGGATGGTCTATTTCATGAGTACAAAAAGCACGGCAAGGTTACGTGGGTTAAGGTTGTGGGACAAAATT
+ CTGAACGCTATGCTTTGGTTTGCTTTAAAAAGCCAGATGACGTTGAAAAAGCGTTGGAGGTCTCTCATGA
+ CAAACACTTCTTCGGCTGCAAAATTGAAGTGGAACCGTACCAGGGTTATGATGTCGAGGACAACGAGTTT
+ CGACCCTACGAAGCCGAGCTGGATGAGTATCATCCCAAGTCGACAAGGACACTCTTTATCGGGAACCTTG
+ AGAAGGACATTACAGCCGGCGAACTGCGTAGTCATTTTGAAGCATTTGGCGAGATTATTGAGATCGATAT
+ CAAGAAGCAGGGCCTGAATGCCTATGCATTCTGTCAGTATTCAGACATTGTCTCGGTGGTAAAGGCAATG
+ CGCAAAATGGACGGTGAGCACTTGGGCAGCAACAGGATAAAATTGGGCTTTGGAAAATCCATGCCCACCA
+ ATTGCGTCTGGATCGATGGTGTGGACGAAAAAGTCTCCGAGTCGTTTCTTCAGTCGCAGTTTACACGGTT
+ TGGTGCAGTTACTAAAGTGAGCATCGACAGAAACAGGCAGTTAGCTTTGGTTTTGTATGACCAGGTACAA
+ AACGCCCAAGCCGCGGTAAAGGATATGCGTGGAACGATCTTACGGAGAAAAAAGCTTCAAGTGGATTTTG
+ CATCTAGAGAGTGCCAGGACGCATTTTACGATAAACAAGAGAAACAGCAACAACAAAGTTCGGGTAAATG
+ CAATATTTTGCAAATTTTATTAAATACAACACCTTTCTTATTAATGCAATACTCTCATCTAGGTTCTAAC
+ CCGCGCTTTAGTCGCTATGAGTCAAGCGCCTCTTCTTTGCAATCTCGATCTCGTGCATCTTCCTTTAGCC
+ GCCATCAAAACAACTCTAACGATGACTGCTCTCCCATTAACACGCCAGGAGGAGCAAGCAGTGGAATCTC
+ CAGCGCGAGCAATTTAATTAACCAAAGCACCAGCATCAACATTTCAAACATTGGTACTAATGCCTGCAGT
+ GCGATGCCAGCCCCCAGCCTGGCGTCCGCTGTAGTCAGCTGTAATGTCAACGCCTCCGGAACGGTACCAG
+ CGAGCACATCCATGCCCTCAGGGGTTAGCTCCTCTTCAAGTTCATTGCCTATGTCTCCGGCCGCTCTGGC
+ CCAAAGACATCGAATGGTTCGTAATGCGCGTCAAACCGTCGACTGTGACTTCAATGAAGTTGGTCGCCTC
+ CGGTTTCGTAGCTCCGAGGAGGTTTCTGGAGGTGCAGGAAATTCCACGCAGTTTGAAGATGTCCGCTGCG
+ ATTCTCCAGTTACCGCTCGACAAGGTTCAGCTGTAAATTGTTTTACTGGACCTACAGCAGCCGTTGGAGA
+ ATCTATTGATGGAACGTTAAATAACAATCAAATTACGGGTGGAGCTGAAGGGTTTACTGGATCCGGAGGC
+ AGCATTCTGAGCAGGAGACGTTGCGGTAAGACACCTAAAGACTTGCACCCAGTGCACAATCAACGTATCC
+ AATTGGCAGAACAAGTTGAGGAATGCCCGTCCAGTGGTGATGAAGGCGTTGTCAGTCCCCGTAAGCGCAT
+ CAAAATGGATTACCATCATCACCACCATCATTCCAATGCTAGCGGGGTAAGTAAATGTTTTAACAAGGAC
+ ACGACTTGTTCCACGTTTTGAATGGATATGCTTTCAAGTTAGTTTACAAGAAAAAAAATATTTTAATACA
+ ATATAAAATAATTAGAAAGTTTAATCATTAATTAATCATTAATCATTAATCATTAATAATTAATGCTAGC
+ GGGGTAAGTAAATGTTTTAACAAGGACACGACTTGTTCCACGTTTTGAATGGATATGCTTTCAAGTTAGT
+ TTACAAGAAAAAAAATATTTTAATACAATATAAAATAATTAGAAAGTTTAATCATTAAGTGTTATTATTT
+ TTTTGGTGCATATCACTCTAATGTACCCAATGTACCTAAGCTTGGACTCGCCAAATCTAGCTTTTTTTTT
+ TTCTTATTTTCTCTATGCTAAAGCATTAAAACTGGAACAGTCTTTAAAATACAAAAAATAACTTCTTATT
+ GGTAATATCGTTTTAATTTAGGTGGAGTCCACTGGCGAGCACAGCAGCATCAATAAACCAAGCCCTCTTT
+ TACTGTCCAACTGTGATGTGATACACGATCCCCTAAACCGCAAAAGCGAGATTCGAAGGGTATCCGAGAC
+ GCCAAGTGGTTCACCAAGCATTAAGTTTCCTGGCCACCTGCCCTCGGCTCCCCAATCCCTGATGCTCAGT
+ TGCCGGCGCCCTTCCATCGATGTGGGAGCTTTGTCGGCGCTCTCTAGTTCCTCGGCTTTCCGGCACGGAA
+ TCGTGGGAGCCAGCAGCATGGATCAACAGCACATGATGAATGCCTCGGCGGCAGCAAAGAGGAGGCGAGT
+ GACCACTACTATGCAACAACCCAGCTCATCCTCAACCACTAATAGTTCTAGTGGATCTGGATTGGGTGGG
+ ATAAGTAGTTTAACTCCGGCGGATGAATATCATCATCATGTCTCCAGAGGTAGGGGACATCAACTACATT
+ CCCATCACTCACACGAGGCTAGCGGTGGCGAAAGTGCGGATGGATCTCGCCCTGGTACGCCGCTGTGTGA
+ TGAGCGACCTGAAGTGCTGCCCACAGAGCCACGTCGATTGCCTCCGCCCAGAGAAAGAGTTCGGGAAAGA
+ ACCAGGGATGTGATGTGGCTCCCCCTTCCAAAGTTTGGAGTGCTTTTCTTCCAACAACAACAGTCCAGAA
+ GCAGTGGAGGAGGAGGAGCAGGAAATAGCTATCTGCAGCAGCAACTGGGAGGAGGATCTACCGGAGGGTT
+ GGGGTGCATAGGAGCTGCTTCCTCTTCGGCATGCTCCCTTAACAACTCTAGTCTTAACGCCAGTCAGGGA
+ ATGGGCTCCTGTTCTGGATCCACATTCCTGCCCAGCCCATCCTCGCGATATTGGCGTTCCTCTTCACACC
+ ACCAAAACCAACAAAATAATCACCAACAACAGTCGCAGCAATTGCACGGATCCTCATCTTCTAACACTTG
+ CTTGATGGCCAGTCCAGCACGTCCACGATCACTGAGTTCCAACTCCAGCGATTCGGATGTACCTGGCCAA
+ AATGCCGGAGGAAGTCCTTCACTAGATGAAAGACTGCGCAACTTTGAGGAAAACTATGAACGATGGTCTG
+ GGGGAAGCAGTAGAGAACATATCTCCGGTCATACGCCCTCGAGTGCCACGCCTTCTTGGCAGCTCTCTAT
+ GCACATGAATTTGAGTACTGGTCTAAATTCCCATCAGACAAGCTCGGCATCCGGAAATAGCAACAGTTCC
+ AGCGGAACAGTATCCAGTTCAGCGAGCAATTCACGGCACAAGTTTTTGGATATTGATGAACTGCAGCCCT
+ CTGACATTGTCAAATCTGTGCTAGCCAAGAAAAGTGTTTTTGATGACGATTTTCAACGGCTAAATAAAAA
+ CCAATGGTACGACCCATCCAGCTCTGATTTTGCATTGGGATCGAGTTCCAATATCGTTACAGGATCTTCG
+ CTGGTCGCTAATGTGTCCCGACATCCTGGAGGCCCATGTAGCGGAAACACCTCACCTGCTTTGCCTAATC
+ TCGCGGCGACCAAGGCTACTCCAATTATTGGAAACTGTAGTGGTGGATTGGGTAACTCGACAGGTAGCAA
+ ATCTGCGGGATTGCTTCAAAGACTAAGTAGTTTATCACCCATGAATTCTCCTCAAGCTTCGATGTCGCCC
+ TACAACAGCCCATCACCCTCGCCTTCGGTGGGAGGAGTTACCGCATGCCTGGGACAACTTACCAAACCTG
+ CAGCACCAGGAACCGCAAGTGCAGGACTAAGTGGGGGAACTGCTGCCTCCTCATCCTCACCAGCTGCCAA
+ CTCGGGACCTACAAAAGGATTGCAGTACCCGTTTCCCAGTCACCCGCCTTTGCCGAACACCGCTGCTCCT
+ CCTCCAGCTGTACAGCCTGCTCCTCCACCTCTTCCAGAAATGGGAAAACAATCTAGATTAACTGGCCAGA
+ GCTCTGGAAATAATCTAACGAAGAGCTTAAGCGTGCCAGATGGTCCTCAGTCATCGCCAGCGAGAGTTCA
+ GCTTCAGAAATCTGCTTCAGTGCCAGGTAGTACAAACGTAGGCGCCCCAAGCAGCCTTTCCTTGGATTCA
+ ACCACAGCTTCTGTGGAAACATCTGCATCTATTTCATCATCAACGTCCAACGGTAACAGTTCCTTAACCT
+ CAGCAGCGATTCACGTACAAAAGCCGCAACAGTCGACCTTTGTTGAGGAAGAGCATACAAAAAAAAGTGG
+ CACCTCCACATCCCAATCCTCGAGTTCTAGCTCTAAAAAGATCAGCAGCACCCACGACAAGCTGCACAGC
+ AAGCACAACAATAGATCGGAAAGCGACAAGAAAATCAAGAAGTCTGACAAAAATGCATCGTCCTCTGACA
+ AGCGAAAGAACTCGTCTACCTCCCAGTCCTCTAAGTCAGCTACTCCCCGCATTGAAGACGACTCCAGCGA
+ GGCCGATGATACGGCGGACAAAGCTGAAAAGAACCAGCGCCACGAGAAAGAGAAAAAGGAGCGTCAGGAA
+ AAGCGTGAGAAGGATCTCCGTAAACAGGTTGAACGGGAGGAAAAGGATCGTAAGGCTCAGCAGGAGGAAA
+ GAGAAAAAGAAGACCGAAAAGCTAAAGAAGAGGAAAAAGAAAGAGAACGGGAGAAGAAGGCCCAAGAGGA
+ TCGTGAAAAAAAGGAAAGAGAAGAGCGAGAGCTTAGAGAAAAGGAGCAGCGTGATAAGGAACAAAAAGAA
+ AAGGAAATCCGTGAAAAAGATCTGCGCGAAAAAGAACAAAGAGAGAGAGATAACAGGGAGAAGGAGCTGC
+ GTGATAAAGACTTGAGAGAAAAGGAAATGCGTGAGAAGGAGCAAAGGGAAAAGGAGCTTCACCGCGAAAA
+ GGATCAGCGCGAAAGAGAGCATCGAGAGAAGGAACAATCTCGCCGAGCTATGGATGTTGAGCAAGAAGGC
+ CGTGGGGGAAGGATGCGTGAGCTATCTTCATACCAAAAAAGCAAAATGGATATTGCTGGCGAGGCTAGTA
+ GTCTCACCGCAATCGACTGTCAGCACAACAAGGAAAATGCCATGGACACCATTGCTCAAGGAACTCCTGG
+ TGCATCCCCATCAACTCCTTCAGACAACACCCCGAAGGAGCGCTCGAGAAAGTTGTCTAGAAATTCCCCA
+ GTGCGCCTGCATAAGCGACGACTTAGCTCGCAGGAAAGCAACCACAGTGCTGGAGGTGGTGGATCATGCG
+ GCGGATCGAGTCATCAAATTCATCATGAGGATTATGTAAAGCGCATAAGAATGGAGAACTCCCAGAACAT
+ CTCGGTTCACAGCAGTAATCAAAGATTAAATGATCGCCGGGACTCCAAGGAACACAAGAGCAGCAGTTTC
+ AAAGAAGATAAAAATAGTAGTTCACATATTTCAAGGCCTCACGGTTGTGGAGGAAGTTCCGCCTCGTCCT
+ CAAAACATCACCATCGTCGAGATAAACATCATCAAAAGGGCAGTGCCAGCTCCATAGAAACGAACTCCTC
+ CATTGAAGTGGTGGTAGATCCCATTTCCCAAACCAAGCACAACTTAAACACAAGTGAGGAGGAGCTGCAG
+ TCTCATCAACCCAAAAGAGAAAAGGAGAGGGAGCACTTCAGTAGTCATGCAAATAGTTCATCTTCTAGGC
+ ATAAGAGTAAGCGAGATCATCATCACCATCGGGAAAAAAAGCGGCATTCGGTGGCGGAATCCACGAATAC
+ AGATGAAGAGCATACACCACAGCAGCATAATCCTCACAGGAGAATCTCTGCTGCGGGAAGTGGGTCTGCT
+ GGAGAGCTCAGCTCAGCAGCCACTAATACTTCGAGCGGAAAACTCCATCATCAACACCACAGGAGAAGTG
+ TGGAACGGAAGTCATCACGGGGATCTGATGAAGGACATCATTCTTCATCTAAATCTCTTCGCGCCAAATT
+ GATGATGTTGAGCTCCGCAGACTCTGACGACACAGATGATGCCTCCAAGAAGCATTCCATCTTTGATATC
+ CCGGATGATTGTCCAAATGTATCTATGTACGACAAAGTAAAAGCCAGGAGCTGCAAGAATATGCAACGCC
+ AGGCGGAGGAAAAAAAGATCAAGGCGAAGTTCTCGCAGCTAAAGCAATCTCGCGCCAAAAAGAAGCGCTC
+ TACTAGCTATGATGGAGACTCGGACACTGAGTTCGAGGATCGACAACATCGAAATAGTGGTAGTAGCAGC
+ TTCCATGGTCGTTATCCTGGACTGTCTAGCAGCGATGATGATGACGATGAGGAGACCCACCAACGGCGAA
+ TTTCCTCCGATTCGGATGCAGAGCACGGAGGTCAGGATAACCAGGGTGCAAGCACCCTAGCTGATGCTAA
+ CCGAGTACGTCAGATGCAACAGAATTTAAGAAGACTTTGCGATGGTGATGATAGCTCCGAAGATGAAATA
+ AGAAGGAATGTGATGAAGCATAGCCATTTTGGAAAAAGGAACTCCAACTCCACTAGGATTGCATCTGATT
+ CTGAGTCTCAATCCCAGCCGGCTCCTGATTTGACTATTAAGCAAGAGCATCCTATAGCTCCTGCTCAGGA
+ AATCAAGCGGGAACAGCTTTCCGACGAGGAACAGAAGTTCAAGTCTCGGCATGATTCAAATTCTTCAATA
+ GAGGAGAGGAAACTGAAGACGGAACGTGAAATAAAGACAGAGCTTGGAGATTTCTATAATTCTTCTGAAT
+ ACACCTATACTGGAAAGCTTAAAGAGTACTCTCCAGAAACTCGCAAAAAACATAAAAAGAGCAAGCGACG
+ TTTGAAATCCTCTTCCACAGCGGATACTTCAGCAGCTCAAACTCCTTTGGTGATGACCCCGTTAACTCCC
+ TCCATATTTGATGTTCATTCATCCTCCGAGTGCAAGACGAAGTTCGATAATTTTGATGATCTAAAAACTG
+ AGTGTTCTTCAATACCGTTAGAGATTTCAGCCGGCGAAAGGAGAAAGCATAAGGAAAGGAAGGAAAAGAA
+ ACGTGAGAAGCTTAGAAATATGACGGAAGCCACTGTACCCAATTCGCCCACCACCAATGATACAAGTTCC
+ GAAAAGTTATCGAAAGAAGAGCGGCATCGACTAAAAAAGTCAAAGAAATCGAAGAGCATGGATAATTCCT
+ GCAATACCAAAATATACAACTCAAGTGGAGCCCATCCTTCTACCTCACCTTCTTTGCCTGCCACTCCAAC
+ GTCAGCGCCTTCGACGGCCCAAACTTCAAAAAGAGGAGAGGATAAAATGGAGTTTATATTTGGCATTATT
+ TCCGATGAAGAAGAATCACAGTTTCCCGAGCAAGCGGAAACCAATAAAGACATTATACCTAGTTCCGTGT
+ CTACTACTGGTCCAATTGTCTCCGCTGCTTTGCAAACGTACAAACAAGAACCTTCCACACCTAACAGCAA
+ AAATGAGGAAGCACATATTCAATTAACTGTGCATGAGCCTGAGCAACAACAGCAGCTGGAGAGAAGTCGC
+ CTATCGGGAGGCAGCAGCTCATCTTCTCATGCTGATAGGGAAAGACACCGGAGAGAGAAGCGCGAGAAAA
+ AGAGACGCGAGAAATCTCAACGAGAACAGCAAAATCAAATTCACCAGAAATCTTCCAAGGTTGAAACTAA
+ GGTGGATGATGATAACAGCGTGGATATGGATGAAGCAGGGAGGGCTCTAGAGGCTCAACTAATGAGTGAC
+ TTTGATACCAAGCCGATTTCAGAAGAAGCCACTCCTTCAACGGCCGCCACATATAGATCGGATATGACAG
+ ATGTATTCCGATTCTCTGATAACGAAGACAACAACTCAGTGGATATGACTAAACAGGGTGTCAAATCGGA
+ GCAGCAGGAACAGCATAAAAGTAAAGACAAGAAGAAAAAGAAGAAGCGGTCTAAGGAGGAAAAGCAAGAA
+ AAGTTGTTGCAACAACAGCGAAGGGAATCCCTGCCAAATGTGGCTTCCACTTCATCCGCACCTCCTACTC
+ CTGGAAAGCTTACTGTCAACGTTCAAGCTGCTAGCAAACATGCAGACCTGCAATTGGACGCCAAGCATAT
+ CTCATCGCCACCCGTTTGTAAGCCATCTCCTAGTTTACCATGTCTAATAGGCGACGATGACGATGATGCG
+ TTGCACACCCCAAAAGCGAAACCTACAACGCCCTCGAGTCGTGGAAACGATGGTCTCACTCCTTCACGTG
+ AGAAACCCCGCCTAATTAGTCCCATACCCAAAACTCCAACCATAGCCAACAGTTCCACGCTATCCACTCA
+ GTCTGCAGAAACACCTGTAAGCAGTGGTACAGTTATTTCCTCTTCTGCTTTGGCTACCACTCCTACATCT
+ TCGACAGCAGCGGGAGTCAGTGCAGCCCCGGGATTAGATAATTCGCCTACCAGTGCTTCTGCTCAATGCA
+ AAAAGAAGGAAAGCTTCATTCCCGGTTTCGATGGTCAGCTTGACGATAGGATTAGTGAATCGGCCGTGCA
+ ATCCATTTCCGCAGAATTTAATTCTACATCTTTACTAGATAACATTGCAGATGAGCCAAAAATTCCGGTA
+ GCATCCCCTCCACGTGCGACTAAACCGTTGGATAAGTTAGAGGAAAGCAAGTCCCGCGTGACCATCTCTC
+ AGGAGGAGACTGAGAGTGCCGTATCCGCACTGTTGGGGGAAAGCTTTGGCACTTCCTCTACGACGGACTA
+ CTCCCTCGATGGCATGGATGAAATGAGCTCTGTAAATGAATTGGAAACACCAACTTTAGTCATAGCAGAA
+ CCGGATGAAGAGGCAGCTTTAGCTGCAAAAGCGATTGAAACAGCTGGAGAGCCTGCGTCCATTCTGGAGG
+ AACCAGAAATGGAACCCGAAAGAGAGGCTGAACCAGACCCCGATCCTGAGGCAGAAATTGAATCAGAACC
+ TGTCGTTGAGGTCTTGGATCCGGAAGAACTCAACAAGGCAGTGCAAAGTTTAAAACACGAGGATATGATG
+ GACATCAAGGCTGATACTCCGCAGTCAGAAAGGGATCTGCAGATTGATACTGACACAGAAGAGAATCCAG
+ ACGAAGCGGATAGTAGTGGGCCTAGTCTCAAGATTGATGAAACTGTGCAGAGCTCATCGTCGCCGGAGAA
+ ATCAATTAGCAATAACAGTCCTACTCCTAGGGAAACAGCAAATATAGACATACCTAACGTAGAGTCTCAA
+ CCGAAGCTCAGCAACGAGTCCACACCGCAACCTTCCGTGATCACTAAGTTGCCATTTTTGGATACGCCAA
+ AAACAGTACCAGCAGGCCTACCCCCTTCTCCTGTTAAGATTGAACCACCAACTATAAGTAAACTCCAACA
+ GCCTTTGGTGCAGCCTGTGCAGACCGTCCTGCCTGCACCGCATTCAACGGGAAGCGGCATAAGTGCAAAT
+ TCCGTGATCAACTTGGATCTGTCCAACGTGATAAGCAGTTGCTCGAACACGAGCGCGGCATCTGCCACAG
+ CTTCAGCGTCTGCATCCATATCATTTGGAAGTCCAACTGCAAGTCAGAATGCCATGCCCCAGGCTTCAAC
+ TCCCAAGCAGGGTCCGATTACACCTCAGCAAGCAATCCGGACGCAATCTTTGATAATGCAACCGCCAACG
+ ATATCTATACCAGAACAAACACCTCACTTTGCGGTCCCCCAAATGGTGTTGTCTCCTCAGTCACATCATC
+ CTCAGCAACCTGGAACTTATATGGTTGGCATTCGAGCCCCATCCCCACACAGTCCGCTTCATTCACCAGG
+ TCGTGGTGTAGCCCAAAGTAGGCTGGTGGGTCAACTGAGTCCTGTTGGGCGTCCAATGGTAAGCCAACCA
+ TCACCCCAGCAACAGGTTCAGCAGACACAGCAGCAACATGCCCTAATAACCAGCCCGCAAAGTAGCAACA
+ TTAGTCCATTGGCAAGTCCCACGACTCGAGTGTTGTCTAGCAGCAATTCGCCTACTACCAGCAAAGTAAA
+ CAGTTACCAACCCAGAAACCAGCAGGTACCACAACAACCCTCGCCGAAATCTGTGGCTGAGGTGCAGACG
+ ACACCGCAGTTAATGACTATTCCGCTACAAAAAATGACACCGATACAGGTGCCACATCATCCGACGATCA
+ TAAGTAAAGTGGTCACCGTACAGCCTCAACAGGCAACCCAATCGCAAGTGGCCAGCTCGCCACCCTTGGG
+ GAGCCTTCCGCCGCACAAGAACGTGCATTTAAATGCCCATCAGAATCAGCAGCAGCCACAGGTGATAGCC
+ AAGATGACTGCACATCAGCACCAGCAGCACATGCAGCAGTTCATGCATCAGCAAATGATACAACGACAGC
+ AACACATGCAGCAGCAACAACTTCACGGTCAGTCGCAACAAATAACGTCAGCCCCGCAACACCAAATGCA
+ TCAGCAACATCAAGCTCAGCAGCAGCAACAACATCACAACCAGCAACATTTAAATCAACAACTTCATGCC
+ CAACAACATCCGACTCAGAAACAACATCAAGCTCAGCAGCAGTTTAATCAACAAATTCAGCAACACCAAT
+ CCCAACAGCAACATCAGGTCCAGCAACAAAATCAGGCACAACAACAACACCTATCCCAACAGCAACATCA
+ ATCTCAGCAGCAGTTGAACCAACAGCATCAGGCTCAGCAACAGCAACTGCAGCAAATACAAAAGCTGCAG
+ CAAATGCATGGTCCCCAGCAACAGCAAAAGTCGCCTCAAGGAGTCGGCCATTTGGGAGGTTCTACGTCGA
+ TTTTTGCATCCCAACAACATAATTCCCAGCTTCCAGCGCGAGGTGTACCTCAGCAGCAACATCCTCAACA
+ ATTGTCCCACAGTTCACCTTGCAAACCGAATACTTTGGTTTCTGTTAATCAGGGAGTCCAGCCTCCCGCC
+ ATATTAACACGAGTTGGATCTCATTCGCAGCCAAACCAACAGCAACAATTACCACACCAGCAATCGTCGT
+ CTGGTCATCCGCATCAGAAACAGCTGTCGTCGCCAGGAGCAAATCTTCCTCTTCAAACGCCTTTGAATGT
+ GATACAAAATACACCGAAAATAATTGTCCAACAACATATTGTTGCACAAAATCAAGTTCCACCACCACAA
+ ACCCAAGGTAATGCCATACACTATCCTCAAAACCAGGGCAAGGATAGCACTCCACCTGGTCATGTAGAAC
+ CAACACCAGCTATGTCCGCTCAGAAAACATCGGAAAGTGTTTCGGTGATTCGCACACCCACTCCTACAAC
+ AGGTTTGGCAGTAATCTCGGCAAATACGGTTGGCTCTCTGTTAACGGAGGAGAATCTAATTAAGATTTCG
+ CAGCCAAAGCAGGATGAGTTGATCGAACAGGACTCAAAGGAAGTTGACAGCGATTACTGGTCAGCAAAGG
+ AGGTAAATATAGACAGTGTCATTAAGAAATTAGATACTCCATTGGCTAGTAAGGATGCGAAGCGAGCAGT
+ GGAAATGCAGGCAATTGCACCGGCTCCTATTCCCAATCCGCAGCCTGGGAATCAGTCTATGGCCCAAGAA
+ ACTGCTCTTCCAACAACTTCAATGAGTGTGAACAACTCAAACGATCATGATACAGAGGACGAAACGGAGA
+ CCAGGCAGTTGCCCCCTGCAAAGCCACCTATACCCACTGTTGGGAGACCTCCAGGAAGGGGAGGTAGTGC
+ TAAGAGAGGACGCCAGCCAAGAGGGGCGAAGAAAGTGGGAGGATTCCCGCTTAACTCGGTAACAGCTGCG
+ CCGCCTGGAGTGGATTCATTGGTTGTACAACCGGGTGACAATGGGGTGCAAACCAGGCTAAGAAAACCCG
+ TAACAGCTCCTGTAACCAGAGGCAGGAAAGGACGTCCTCCAAGGAATCTACTATTGCAGCAACAGCAACT
+ TCAGCAGCAGCAGCTCGATATTCAGCGAAAGGGAATGGAAATGGTGACGTCGGCAACATCTTCGACTCCA
+ CTGCCAACTCCTATTCCTACCAGCTCTGTGTTGACAGCTGCAGAGAAAAAGGCGAGGAATCAAGCCCTAA
+ CTCAGGCTCAAGAACAAAACCAAGTCGCAAGTCAAGTAGGAACTGGCCAGGATATCTACGAGTTCCATGA
+ AGACGGTGGTGAAGAGCCCAAGCCCAAGACAATATCATCTGTTGCCCCCAGTGCTGAGGACCAACGACCA
+ CGACTTATTCTTACCATCAATAAAACGCAACCCTCGATTAAGAATATTAGTGAAATGGAGCAAACAATTC
+ AGCAGCAACAACAGCAGCAGTCGGAGGTTATATCAAATACTGATCCAATCGGAGGAGACAACTCCGAGTC
+ TTGTAACACACGCAAATCTCGCCGTTTACAAGAAAAGGAGGATCGCAGCACAGTAGACGATATCATTGAA
+ GATGTGGTTCGAAATACCAACACGCCAACTGGAACAGGACCACATTTGCCAAAAGGTGCACAAACTCCAC
+ CACGACGTTCTGGCAGAAATGCTCAAGCCAAAAAGACGGATGCGGTACAGATCATTAATGCAGTGGGTCG
+ TCCAAGGCGTTCCAAGGACAGAAAAACAATCGGTGAACAAACAGCAAACTTGATTGAAGAAGTTACTGCG
+ TCTAATGCAACTGTTGCCGCCAGTCATTTGGCACCACCAGAAGGAGCTGGTGTGGAGTCGCATGTCCCCC
+ AATTAGATGCTAAAGAAGTGGAACCGGTATCAGTTGTGACACCAATTTCTACACCAGCGCCTGTTAGTGT
+ AGCTGCCCCGGTTACCGTTCCTGTGCCAGCCATGGTCCCCGTCAAACCTACAATGCCTCAACATCCCAAG
+ AAAAAAGCTATTGCGGCAGCAGAGATTGAATCTTACCAGGCCATCAACTCATCCATTCCCAGTGGGGGGC
+ TTCCGATGCATCAGACAGCGGCCCCTGCTACTCAAAAGATAACCGGTGGGGTTGCGGATGCGGTCAGCAA
+ GGCTCTAGTTGATCCAGTTACTGGAGTTATCACCGCTGGAATGCCCCAGGGCAAAGAGGGTAATCTTCCA
+ GCAGCTACCGCTGCTGCACCTGCCAACAGCAGCAATGAAGACGGTCAAGCAGCTCCTCCCCCGCAGCTAC
+ AACACCAGCAGCAGCAACAACATCCGCAGCAACCACCACAACAACAAGCTAATTTACAGATAAATACTAC
+ TCTGATTCCATCTGGACTTCCAAATCCTATTACAGCCTTAGGAAAATCGGTACAACTTGAGACCTCGGCA
+ GCCGCTTTGTTGAACAAACCTGTAAGTGTTCTGGTGAAAGGAAACGCCTCGCAGGTTATTCAGCAGCAAC
+ AACCGCAAATTGTGGCTCCAGCAAAACAACCCATAATCCTACAACAGAATCCCCTGCCCACTGTGCTGCA
+ CCATGCGCAGCATACCACTGTTAGGCCACCTCAACCACTGAAAGCTCACGTCCTGAATAGGGAAAAGAAT
+ ATCCAGCAGCAATTGACGCCCACAAAGCAAGCAGTAGCTCAACCACCACAGCACGCACCGCATTCCGGTC
+ ACATGTTGCTCACGGATACTGCAGGAAATCAACAACTAGTGCAGCCCCAGATCATTGCACGTCACCTGCA
+ GCAGCAACAACATCTTCAGGTCAACGTGCCGCCACCAACAGCACACTCTCCGCACTCTCCAAGAATTCCT
+ AGCCAGCAGCAACAATTGGGGCCAGGAGCTTCTATAAGTCCGCAGCAGCAGCAGCCGCAAACGGTGGTGA
+ TCAAGCAAGCGGCATCAGCAGCCCAGCCGCAAATATTGCACGTGGTCAGCTCAAAGGCGTCGGTGGTGCC
+ TCAACCGCAACAACAGCAGCTACCACCAACTTCATCAACAGGCCCCCACCTGCAGTTGGCTAAACCGAAC
+ TATAGCTATGCACCCACTGTTTTGACACCCACTTTGCCAGCCGTTCAGCAGCAGCAACAACAGCATTTGT
+ ATAAGCAAAACAATCAGCAAAAGGGAGCTCAGATACAAATGCCTCCTCACGGAATAATTATGCCTACCCA
+ TCCTGGCATGCTACTGCAGCAAAAACTACCAGCACATCTGCAGCCTCAGCAGCATCAATTGAACCCTTCA
+ CCGCCGCCTGGAAAGCCAAATCCCGTACTGCACGGACTACAGTCTGGACAGATTATGCCAGGAAGTGTGG
+ GCAGCCCACCACCGGTATCAGCTGCAGTCTTGAAAACAGCTCAGCAGCAGGTCAATTCCGTCGTACCAGT
+ AGCTGGTAAGTTGCAGAATACCCATATTGTCCTTTACGGCCATAGCTAACTTTAAAATCTTGACAGGTAT
+ ACGCACAGCCATCCCAAACATAAGCCCGCAGAGCCAGCCGAGAGTATCTCCATTGGTTTTACCACCCGGC
+ ATTTCTGGAGTACCACCTTTTGACGCCAGTCTGGTAAGTAACAACGAATAATACTTTTAATTTAAGCGAA
+ TTACATGTCCTTAAAATGTATCTTTATTTAAACTTAATTATGGCTAACCTTTAAAAATTAAAATTGAGTT
+ CTTTACTAACCCTTAAATTATTTTACAATCGAATTGCTAACTTTGGATTCAGCATGACCTGGGTGCTTAT
+ GTCAGTGGACGGCGAACCCAGAGTCCGCCTCCAGCTCATCAGCAGGCTTCGCCCATAACACCGGTAATAC
+ ACAAGTTTTACTTGCGGAGCTTTCATGTAGCGTAACCAAATTAAGTTCTTCGTGTAGTCATATTAATCCG
+ GGTATTTTGATTGAAGCATTTACTTACAAAAAAAATTGTCTGCCACTCTTTTTTTTCAGAATGATTCTAC
+ GTATCGAGGAGTGACTGCATCCAGGGATTTTATGCTCTACCAGCATCATTTAATGCGAGGTGGCGACTAC
+ GATGACAAGATGGGCAGCAGTCCGCCGCTAGAGTTACGACGCCCCGGTAGTGGACCTCCAAGGACCATCG
+ CAGTTCCCCACAGTTTGCAGAGTCCTCAGGATCGCACTGCAGCTGGTAGGTTCTTACAGTTTTATTGACT
+ CTTTAAATCTTATAACAACCCATTATTTCTTCCAGACTCTCCACAAATGGCTCAGGTTTACGTACACAAT
+ ACGCGCATTCCCCCGGCCCATTTCAGCGAAATTGCATCAAGGGGCTTGTACGATAGTGGTGCCTTACAAC
+ TGGAACCACCGCCGGCCCATCGCCCAACTGCAACCATTAGTGTGGTGGTGCCACAACAAATGCCTGCAGT
+ TTCCTCTGGAAGTCCGTTTATCGGTCGTGATGGGAGCGTGCAGCCAGGAAGCCACCATCATCCAGGCAAG
+ GCAATGGATATGCAGTTGGATGAGATGGACCGCATGTCAATGATTGCAGCTGTCGGTAAGTATCTACTGA
+ TCGCAAACCAATGTAATGAAGTATATTTAACGAATGACTTTACAATCGCAGTTCAACAACAGCAGGAACA
+ TCTGCCACCTGCTTTGCCTGCAGGCATGGAATTGGCCTCCCAGCAAGCACCACCAGCGATGGCACCGCCA
+ CCAGGTGATTCGCTGGTTACTCTGCTGCAGCGATATCCGGTAATGTGGCAGGGCTTATTGGCCCTTAAAA
+ CAGATCAGGCCGCTGTCCAAATGCACTTTGTGCACGGAAACCCTAATGTGGCAAGAGCGTCGCTTCCCAG
+ TTTGGTGGAGACTAATACACCGCTGCTGAGGATTGCGCAAAGAATGCGACTAGAGCAGACACAACTGGAG
+ GGAGTAGCCAAGAAGATGCAGGTATGTATATACAAACAAATTTAAAGGTGTGATCATCACTAATATCATT
+ TACTCAAAACACCCAGGTTGACAAGGAGCATTGCATGCTTTTGGCTTTGCCATGCGGAAGAGATCACGCC
+ GATGTACTGCAGCATTCAAGGAACCTCCAGACCGGTTTCATTACCTATTTGCAACAGAAAATGGCAGCCG
+ GCATAGTGAACATACCCATTCCAGGAAGTGAACAAGCAGCCTACGTGGTACACATATTTCCATCATGCGA
+ TTTTGCTAATGAAAACCTAGAGCGCGCCGCTCCGGATCTTAAGAATCGCGTAGCTGAGCTTGCACACCTC
+ CTGATTGTCATCGCTACTGTCTAAACCACTATAACAACCAAACCCACGGACTTTGAACGATAAAATATAC
+ CCAGATGTTAAACTTCACAGGCTTACACGACAACATAAGAGGAACCAGATAAAGAAACCAACAAAAACAT
+ GTTACGCTCTTCTAGTATTTTAAGTAATTTTAAATAGCGATTAAACAAGCAAAAGTTTAAAAAAAAGCAA
+ AGGAAAACAAAACACAACAAAAACGTAAACAAGCTGAAACATGCAAACTAAAGTTTGAATAAATAAATGC
+ AAGAATGCAAAAGTTCATTGAGGCCAAGATCACATAAAAGTGTAAAGAGATCCGCAAGAGACTCAAACAA
+ AACGAAAGAAAACCCTTTAAATTCCGACACTTTGAAAGCAAAATATTTGTCTAAATTAATTATATAACTC
+ TCCGTAATTAAAAACCTTAAAGAAAAAGCTTGCAAAGTATCGTTAAGTTTGATCTCAAGAAAGAATGTTT
+ TATTTTTGCTTATTTAAAAAGAAAGAAACAAACAGAAAAACCTACACATACAAATTGAATTGAAAGAAAT
+ GTTACAGAAAGCTTACAACATATTAACTGTTTACTGTACTATGCATACTACTACCCATACATAATATTAA
+ TATTCGATCCTAATCCTAAAACGATTAAGTTTTTATTGGTGAATAACTTTCGACTACTTCGATAGAAACG
+ TAACTACACCACGTTATACAAAGTTTCCGCCTTCGAACAACCGACCATTTTTTTTGACAGATCGGTTCCT
+ TGGCTCTATGGAATGCCTGCATATAAAACTAGTATACAGGGCCTAGCATAGACCCAAAGAACTTAAGATG
+ AGTCCGGACTGTCACCCACGCTGTTAAGCACAATTAGGTTTAAAGTTGCGCCCAGAGGCTTTTCCTACGA
+ TAACATACACACACATACATTATACTACGATTATTTATCTAGACGCGTATTTAATTATAATTAATATGTT
+ AAGCTCATTATTTTAAAACTCAGACACGTTTCACATCGTGTTTATTTCACTCTGCACCAGAGTTTCTTCT
+ ATTCAAGTAAAAGATACGGTAGTTTTCGATTTAATGATGTAGGTCTTTTGTTTGCAAAAGACGGCAAATT
+ TTTGTTTTTTCTTTACATTTTTTATCACTTTCACCACTGCCACAAACCTAACTACAACGCCCTGGTCTAA
+ ATCTAAATGTAGGTGTTCCGATCTCCCACTTCCCACTTTTTAGTTTTTGTGAGCGAAACTTTGTACAATG
+ TTGGGTAGTTTCAGGATCCTTCATTATGTTTATACCATAATTCTGACACCCCACAAAAAACCAACACGTA
+ AACATACCACTCACAAAATAATACAAAAATCTATATACTACTCTCCTTGAACACTCCCTAAACTTAAACG
+ TAATTTTTTACACAACTTGTAAATTATGTAACCGGAATAATATAGAAAGCAAAACACACGAGTGAAAAAA
+ AAAAACAAAAAATAAAAAAATACATCTGTAACATATTTAAATTATTTAGGCTCTAACAAGTAAAAAATGT
+ AAATACAGTTTAATTAGTGTTTAGCGTGTATTTAGTTGTATGTTTTAAAACTAAACCTAAAAGAAATCTG
+ TACATTATATAACATAATTAACGATACAAGAACACGAGAGATCAGATCTATAAAAGGTCACCCAGAAACA
+ GATAAACAAAAGAAGTTTAAAAGTGAATAATTCAGAAAATAAAAAGAACACGTTTTCAAGAAAAAGCATA
+ GGAAGCGCTGTTAAACAAATGTTAATGTATAAGTTGTATGATTTAAGAGACTTTTTAGTTATTTCCTAAG
+ TTACATTGAAGAAAAAGATTAAATTACACTTATTTCATACACTTGGTTTGTTTTTTATTTTCTTCGCTCC
+ CAGATTCTATAGGTTTCTCGGGCCGTAAATCCAAATCGAACCCCATAGCGAAATACAACTTATACATACA
+ TATATACATTATATATATACATATATATATATAGATGTTAATGTTATAACTGTAATTAAATAAATTCTAT
+ ACCTATGCAATCGTTGTGGGTTTTTTGGGGATTATTTTTACCAAGCTATATGCAGTGTGGAATCGATTAA
+ AATCGGGAGCACATGTCCAAATCAGGATTAGCAAAAAAAATTACCTCGTCTTCTTATTCTCCTCTCGGCA
+ CATTTCCTATATCGTGTGAGAACCTTATAGGTTTAAAGTAAATAGTTCTCACACATGATTAAAATTGTAA
+ TATTTAATCAAACAAACTACTGACTATTTATTTTTTTTAATCTTATCTTTAAACTAAAATAAACTTAATT
+ GTAACCGAAGAAGGGCTCGACGAGGTGGCAACGCTAGCCGGCGAAATATCGATGAAACCAAATATCTGGC
+ TATCGATAAGAATGAATAAACATCGTTTTAGTAAAAATAAAGTTAAATAAGGAGAAGTTCTAGTTTTAGA
+ GATTAGATACCTTAATACAGTTCTACAGCATGGCCACCCTGATACAAAGAAGTAAGTTGGACGGTTCATA
+ GCGGTTGCCATTTTGAGCTTGGCCTGTTGTGTAACATGTAACATCTATGTACAAGCTTTTACTGATGTGT
+ AAATGATTTTAGGCCTTTCCCTGGCTAAGAGCAGTACTCCTGCGCTACAATTTCTTCGCTTTAGGGGTAA
+ GATCAATATACAGCGGCCGAAAGCACCGCACTACGAGCGGGCCCGGGTAGTCGCAGTCACGCAGCCGAAA
+ TATCCGGAACTCCCAAAAGCTAAGAGCTGCTTCAAAACGCGTGCGGAGCGCACGCAACAGCAGCAGGAGA
+ ATCCATACAACGAAATCATCGCACGAGAGGTGCGGAATTGGCTGGATCATTCCCGACTGGTTGCCTTCTT
+ TCACTTAAGTTCTATAACCGCCGATGACATCTTCCGCGTGCGCGTTCAGCTTCACAAGCAGAACCTGCAC
+ CTCAAGTCCTACGGCAGCAAGATCATCGAACAGGCGGTGAAGAATACTCGATACGAAGCGATTGTGCCCC
+ TGTTCCACTCCAATCATTGCATCGTCTTCTCACCGGACCCGGAAAAGACTGCCGCACTGCTACGAATCGT
+ TCGCAGGGTGCCGCAAATGGTCCTGCTGGGAGGCATCGTGGAGGAGACCATGCTGAGTAGGAACCAGCTT
+ GTGGCCTACGCTCAGATGCCCGGCCTGCACGCGGTCCAGGCACAACTTGTCCAGACCCTTAGTCAAGCAC
+ CTGGCCACCTTATTCAGCAACTGCAGGCCCATCAGAACAGTTTTGTGCAAGTTCTTGATGTCCATGCTAA
+ AAACCAGATGAATGAGGAAACGCCAAAGTCTACGTAGAAGTCAAAAAAGTCAAGTTTGTTATATAACAAG
+ AAATCAAAAATTATATAATTGTTTTTCACTCTAAACTAGCTGTAGTAATTCTTAACTCTCGGCGCAACCT
+ GGTTTTCACGTTTACATGAATATGATCGTCGTAGTTTATCACATAATTTAAATGAGTGTAGCTAAAAGGT
+ TTTAAACTTGAAGAAAATCATGTAACGAGTGAGTATTGTACTGTAAAGTTCGAAAATGAAAACCAGAAGA
+ AGCCCACTTGACTAGATTGCACGTTTTAGCGGGGCCTGAAACTTCTGCTGGAATGATGGCGTCAGTTCCG
+ GAGTCTTCAGTCTTTAGATATGGTGCCAGCGCTGCCTGCAGTTGAAGGCGAGGTTGGCTAAGGCCTCTGC
+ TGCTTCCAGTTCGTCCTTATGATGAAGCATCCAGCGTCCACCACGACCAGCCCCAGACACATCTGTGGTA
+ AAGATCGCTTGTCCACAACTGCTATTACTGCTAGCTTTCTGCCTAAAGTGAATCGATTTTTATTTATCAA
+ AATTCACCATACCAGCCCCGAATTGCCTTACCTGGTCATATTCCACTCGATGTGATAATTGTTCCTGTCC
+ GGTGTGAATTTTGCTGCACTTTCCAGCCACTTGTTGAGTTGCGTACCCTGTTGACTGGTCGTTTTTGCCG
+ TGGAACTATCTCGCATATACTTTTCCATCATCTGATGCTTGTACTTGGTCTTACCCCCTGTTTGTGCTGA
+ TATCCGCTCGGTCAGACCTGCAGATCCTACAAACAATATCGGCTTGTATGGGGATGAAGGTTCATTATTG
+ GCATTGCCATCGCTACCAGTACTGTGGCTGGAAAACTCTTCATTATCGTCGCCTTCGTCATCCTCCGCAG
+ GACATGAGTGCATCTCCTCCTCCCAAATGCTATCCTCCGACGAGATGCTAAATTGTTCCACATTACCCCT
+ TGCATTGTGATTGTAATTTTTGATCAGATGGCCCCAGGATTTCTTGGCTTTCTCTCGCTCCGAGTTTTTA
+ AGCTTTCTTCGCCAGTTTGCAAACCAATTGCAAATCTGAGTGTAAGTAAGTCCAGTCTCTGCAGCAAGCT
+ GTTTTTTCTCCTCCCTGCTAGGATAGGGATTCTCCCGGCGACGAATTAACCAGTCCTTTAGCATCCTCTT
+ AATGTCGGGAGTAAATAATCTCTTTGTAGCTCGGGATGCTGGATGCAACTCCTCCTCTGGTGGCCAGGCT
+ CGTCTGGAAAAGCACGCAAAAAGAATAACTACATCCCAAAAACAATTTTTCAAATCTTACCTGCTGTGTC
+ GACGATTTCGTTTAGGCCGCGTTGACTTGTCCATGAGGTTCTGAAAACAAGGAAAGTAATTTAAAGAACT
+ GACACAGAATCGCACACATCGCTATCTCTGTTAAAAATACCGTGTAAGTCAATTTAGTTTTTGAACTTTC
+ AGTGGGTGGCGCTATTTCTGGCGCACCGATTTTCATGTTTTTTGCTCTGTGGATATTTCTTGCTCTCAAA
+ ATAACGAAATAAATATTTTTGTTTGCCCAATCTCAGAGCAGGAGAGCTCGAGAGCCAGATGGTGATATCA
+ CAACCATCATGAGAGTTTTTTACTTTTCGTAACAGAAGTAGAAATCTGTTAAGGGATTTTTTTTCGTCCA
+ CAACTGCTCGCAATAAGGTTGTTGTTCATGTTGTTCATTCGTTGATAAAATCCGCAAAAAAATAATGCCA
+ ATGACAAATAGTGCCAAAACTCACACAAGTTAAAATGTAAAGTTACTACATTATTAACGTCTGGAAACTT
+ TGGGAAAAGTCCAATTACGTAGGAGATGCATCGCATTTGTTGACATTCTTAGGCCATTTTGCTAACATTA
+ ATTATATAACTCGAACTTAACGTTATAGACTTGTTTTTTCGCACCGAATTAAAATTGGAATATACGTATA
+ TGTATTGGAAAATTTAAGCTATTTTATTCTAGCTTAGCTCTAAAATGTTCTTCACCCACCTATATTTGGC
+ TTATATTTTTTGATAATGTGTCATTATATTTTATAATTTTAAAATTGTCGAGTGCTTGTGCTTTGTCCGA
+ CGTTCTCGGGCGAACTAAACTCTGAGTTTTCAAAACACCCAGAAGAGGCAACGAAGATCATTATCAAATA
+ AGACGGATTCATTTAACCTATTTACAAAATACAACTAGATATGTTTGCTTATTTTAAAATGATCTCTGTT
+ CTCGGTGAAATCGACGAGAGTCGAGAGAAACTAAATTGATCGTGCTCTGTTGCTCTGCGAATTACTTGAC
+ TCTCGATTGGAAATGTTATGAAGTGATTATGCGGGGTAGGCGGACAGGATAAAATCATTACAAGTTTTTA
+ TACAAACTAATTATGAATTGAACTGCAGACTAGAGAGCAGAGCAAAGCGTACGCCGTTTCGAGGAATTCT
+ AGAGATACGATATTTTTTGGTTCGCCTGGCCCCTTATCCAAGTAAATTATCATATGGTCCGCAAATTGCA
+ AAAGACATAAAAAAGAAAGAGATTCCAGACCCTGCGAGAACGGAAACACGATGAAGTATTGGCTAATAGC
+ AGTTTGCAGTTCTAATAGCAATTGACTAATTTCGCTGCCAGACTTCTTGTAAACTAAGGCTGCCACACCG
+ ATGGAAAAATGTCACGGAATGTGGCCATTTTTACCTCGGTGATAAAATACCCCCATACAAAACGCTGACA
+ TGTAAAATTTAGCACCTTCGTGGGACAATTGTTTATATCTGAAACGTAATAGCACAGGCTAATTTGAACT
+ ATAATACAAGAAGACATAATTGCCGGCAGCCATGGACGAATCGGTGCGATATGACCGCTGTCACCAGGTG
+ CAGCTGGGCGTTTTCAACGAGTCGCAGTTGTCTTCTGTGGAGGAGGACGTGCAGAATCTGCCTCAGCAGG
+ GAACGGGAAACGTAAGTGTCTCGTTTTTCACCTGACTCATGGATGTTCCTTCCTTACTGCCATTATGTTA
+ TTCCGTTACACGATCCAAAGATCCTCTTCACCCACGACGGCGTGCTTCTGAAGAAAGCCAGTGCGGAGCA
+ CATCGCGGATCTGAACACCAGCGGCTCCCTTTCCTTGGTGGAATATTCGCGATCCATCGCGGAAATGCCC
+ CGTAGGAGACTGTTGCTCGAGTGGCAGCCCAATGACAGTATCATGATTGCGGACGACAGCCAGGATCAGG
+ GAGACTGGGCGCTGGTAGACAGGATTTCCGGGCGAACACGCACCACATCCGAGTGCCGTGCCTTCAACAC
+ TAGACCCATTGAACCGAGCGGTGGAGCGACCACCCGTTCGCGAGTCATGCGTGCCCAACTGGAAGATTTG
+ TCTTCTGTAGAGGTGCGCCATCGCGGACAGACGATCCGTTTTATGCGGAAAGGGGCTAATGGCGTCCACA
+ GCGAGTTCTTTTTCCAGCATGGAAACGCAGACCTATTTGTGCGCTCCATGCGCGATCAGCACCTAATCGA
+ GAACGCCGAGACTAGTCGCAGTGGCGGCGAGGTGTATGCCATATTGACCACCGAGAACCAAAAATTGAAA
+ AAGACGTTTGCTGAACTTGACATTGGCCAGATTAAGGCAAGCCAATTGCCACGTGAGAGCTGGCTGCCCA
+ ACAAGCTGGCCGGAATCCTGGGCAACATTCCCGATTACGTACAGCCTCCGTTCCAGCGTTCGCCCAAATC
+ TAGGCCGGGAGTCTTGATCTCTGGCGATCGGCAGACTTCACCGGACAATTATCAAATAATTGGGCTAAGT
+ GGCAGCACCAATAGTGCCTGTTCCTCAAACGGACAGTCTCGTGGGGGCAGTGCAGAGAAGTCTCCCGCCG
+ ACAGCGAGCTGGAAACTCTTAATGCCCAGGACGAAAAAATAGTTAACAACTTGCCCGATCGCCAGCGGGT
+ GGAGAGAGGTGGGTTGATATTAATTCTTAAAAGAGAGTTCTTGACACTTAAAAAGCTTAAGAATTTACTA
+ ATAGAAATAATTCTTAGGGTTCCGAACATGAGTTTATTAATATATTTTTAATGGACAGGTCATCCCCTAA
+ CCGAGACGCAGTGGCTAGAGTTTCAGACGCCCGACGGCCGAATTTCCGATAGCGCCCGAATCAAGGAGCT
+ CATCTTCCGCGGCGGCGTCGTGCAGAGCCTGCGGCCAGAGGTTTGGAAGTTCCTTCTCAATTACTACCTT
+ TGGTCGGATACTCATGTGGAGCGGATCGAGCGTCGTAAGCAAAAGTCTATTGAGTACTACAACATGAAGG
+ CCCAGTGGCTTGCTATGACTACGACCCAGGAGGCGAATTTCTGTGGCTACCGGGAGCGCAAGTGCCAGAT
+ TGAAAAGGATGTGAAACGCACAGATCGCTCTTTGCAATTCTTTGCCGGAGAGGATAATCCCAATCTAACC
+ CTTCTCCAGGGTATCCTTATGACATACGTGATGTATAACTTTGACCTTGGTTATGTTCAGGGTATGTCCG
+ ATCTGCTTGCGCCCATTTTGGAGATCCAGGTAAACGAAGTGGACACCTTCTGGTGCTTTGTGGGCTTCAT
+ GGAGCTGGTGTTTACCAACTTTGACATAGACCAGGCGGGCATGAAAACGCAGTTCGCCCAGATTCGTCGC
+ CTTATTGAATTTGCCAATGCCCCGCTATTTAACTACATGAGATCCCACGACTCGGACAACATGTACTTCT
+ GCTTCAGATGGCTCTTGGTTTGGTATAAGCGGGAGCTAAACAGCGAGGACGTTTTGAAATTATGGGAATG
+ TCTGTGGACTCGGCTACCCTGCCCCAACTTCCACCTACTGTTTTCGGTGGCCATCCTCGATCAAGAGACT
+ AGAGTGATCATCGACAGCCAGTACGAGTTCACAGAAATCCTGAAGCATGTAAACGAACTGTCTGGAAACA
+ TAGATGTTCAAAAAACCTTGCAGGTAGCTGAGGGTATCTATCTGCAGCTCAAGGGCTCTGAAACGTTGCC
+ CAATGACATACGTAGCATCATTGGCGAACCACTCTTGCCAGCAGCCGCTGGTGAAGAGATTGATGGGGGC
+ ATGGTAGATGAGGAACCTACTTACTCGGACGATGGCTTCGACGAATTGGTGAAAGAGCTCACTCCCGAAG
+ AGAAGGTTAGGCAGCAAGCTTTGCTTGAGGAGGCCTGCGAACGCTCCCTCTTCCTTCAGTTCCACTAATT
+ AAAGTGGAATAAAAACGATGGACACCTGGAAAAAACAAAGCCAATAGCCCACAGAAAAGTATGCGCAAAT
+ TACGCTGCCCTTCAAGATGGTTGCCTAACTAGATTATATTTGCGGTTGCAAACTGTGGGTCGTATCTATT
+ AATACTGTGGCTCATATAAATTCACTGTTACAAAAAAGATCAATCGAGAATCTGACTGTTTCTCCGTGTT
+ TAACACGAGTCGCCCGTAAGCGTCCGCAAAAAAAATCATATTTTGGTAAACAAAACATTGGAGCAGTGTT
+ AGCTTAGACTATAAGACTTAAAGTTTACTCTCGCATCGAAGCTAAGCGAGGCGGGCCAAGCGGATACACT
+ GATTTATATATTGTATATTATACATTTGTACTTTTTTGTAATTATTGTAAGTTCTCTTCCTCACCTCAAA
+ ACCAAAACACCCTCATCCTATATTCGATCACCTCTAATTATATAAAGAAATTAGTTCTCGTGCCTGTGAA
+ CTCAAAACATTTTAGGTATCACTTTGCTTTATCGGACTTCAACACGCCTGTCTTTTTTTTTAAGTTTAGT
+ CAATTACTGTGAATATACATCCGTATACAAGTACATTACAAATGCATAGCAAAAAGATCTAAAATACAAC
+ TCCAAAATTCACACATAAAGAACATTGCTTTTTATATGCTGTTTTAAGGATACATTTCGGAATTAATCCA
+ TCAAGAACTTGACTGCCATTTGTATTCGGGTGGCCATATCCTGGAACGGTACGGCGTGATCAAGGCAAAT
+ GCCTTGCGGAAAAGTTTCGTTAAGGGCATACGAATCGCAGACTTGACCAGGCTACCTTAACACGTCTAAA
+ AATCGAGGAGCTCAGTAATAAATCGTATGTTAATGTAATTTTTAAAATTTATTTTTTATATATTTATTTA
+ TCATCAATATCAATAGTTGATGCTTGGGTGTTTCTTGCTGTTGTTGCTTCTTCTGGTTGATGTTGCTTTT
+ GTTTGTTGTTCTGCAGTTATATAATAATTTTAATTACGAGTAATACTTACAAATTAAGTATGCAATATAT
+ GTGGTTGTTTGTTTTGCTTTTTTTTTGTGTGCCTTGTTAACGTCTCAAAATAAATTGTTCTCATAAAGTG
+ CGGATCAAATTTGTCCATAATTCATTTACTCAGCTGAATAATTATACAAAATGACCTAAATATTGCATTG
+ CTGCTCATCAAGCGTGCAAGATTCATATTCTCGGGCTTCTCAATTACAACAAAATTGATTTAATTAAAAA
+ ATTCTATTTTTCAATAAACACTTCCCACCTGTTAGTTACGCGCCAGGACTTGCATGTTGGTGTCGGTGGT
+ TCATGGGACACACAAGTGTATAATAAAACATACGAATTACAAATACAAGAGTTTAAAATATACGCTTGAA
+ AGATTGATTTGCGCCATTAGCATTCCATCCTTTCACATTTACTAATTACAGAATTAAAATGATCAAAATT
+ ACACGCAGCTTTCGGGGACACACATAAAGAATAGAGAGTTCAGTATACAACATATTGGGGATGGAAGTGT
+ GGAAAATGGTTTAGTTTGAGGAGAATACATGGTGCCTTACTATATTAAAAACAGTTAAGCAATACGAGTC
+ ATTTTAAGATTATGAATTATGTACAGGTATTATATATGTATAGAGACTGCATGTGCCAGGACAGCGCCAG
+ AAACCCAAGTATATGTGTCTCTACATTTTATGCATGGATAGTGTTTTGTTTAAACATTTTTCTGTCGCTT
+ ATCAATTATACGTTTTAGCAATAATTTAAACGGAAAATCCTCGTCGTGCAACAGCACTTTGTTTCTCTTG
+ TTACAATTAAATTATAAGCGCTTTTTAATTATGTTCGTAATTATATAAATAATTAAGCAGCCAGAGGAAG
+ GGACACTATTGACTTATCAAGCACCATATAAGCAGCAGATGAAACTTGAGTAAGTCATGGGTAAGGCGCT
+ CTGCCCTCCAGTTCAGACGGAGTTGCAGCAGTGTCGAACTTTATGGCGTTGAGACAAACCCAAATCCGTT
+ TTCTCCAAATTGGCTCCTAATCTCTATATATAGATTATATATGGTTCTTATACTTTACACAACTTTAAGC
+ TTAAGGGATCTAGTGGTAACAGTTAACCTAGCATTTAAATTTCGCCTCGATCTCGTTTGCATCCGCATCT
+ GCAGCTGGTTTCTCATCATCTTTCTGTTGTTGATTTTCTGCTCCGGTGACTTGCATGTATTGGCCGGATT
+ GGCTTCTCCTCTACGCGATTTTCTCCGGCCCTTAGTATGGGCCGTGTCATTCTGCTAGCGCTGGCGCTCG
+ GATCTGCGCAATACTCATTCGTTCCGTTCCTCCGCTCCCGATTCGCTTCCAGTTGAAAGATTAAGCGTAC
+ TGGCATCTGCCGAAGAGCGTGTATGACGAGTGGATCGCAACTCCCGTCGCTTCTCAGGCGGTTGTCCTTC
+ CACGGAACCAGATCCTTGTTCGTTACCAGACCTCGGACGCTTCAAGCGATTGGAGGAACGTCGATTCTCT
+ TCAGCCGCCGCTGCAGCCGCAGCAGCTGCAGAACTGGAGGATGAGCCACTCAGATTAGCAGCTGAAGTAT
+ TTTCAGCTGTATCCAGATCGTCCACGCTTCCGCCATGACTACTGCCTGGATTGGCAGCGGTAGGCTTTTT
+ GAGTATGGGCTGTATAATTAGCTCATCGGCTTCTTCGTAGGGCGGCGGTAGTTTCGCGGCATCCGCTGCA
+ TTTGTTATGGTTAGCGAAATGCGCGACTCGGAGCGTTCGGAACGCTCGCTGCTAGTGCTGGCTCCACTGC
+ TAATGGGAGGAGCTATGGTTATTGTAGTTTGACTGGGCAGATTAGCTGCCAGTCCCGCAGCAGCTGCTGA
+ ACTGGAAGAGGACCCCGATCCGCCTCCAGAGGCATTAAGGGGAGTCAATGTAACTTTATCCTGTTCCGCA
+ GTCATGGGCGCTGGTGTAGAGCTGCTACTGGAACTGCTTCCGCCTCTTAGACTCTTTTCTATGCTACTCA
+ TGCTGGCACCAAGATTAAGGGGTAAGCCTGCCGCAAGGGCGGCCAATTCCTCCTTTGTGGGGTGTAAATC
+ CCCACGTGCTCGTTTGGATAGCGCCTTCTGCTGTTGTTGATGCTGTTGCTCTGCGTCCAAAGCTGCAGCA
+ TACGCAGCTGCTGCTGCGTTTGCTGCACTAGAGGATGCAGATGATCCTCCCGCCGAGGATGTGGGTATCA
+ ACGAGATTCCTGATCCCAGACCTAAGGTCTTGGTATAATAGTCCATCTGTTGCTTAAAGGCATCCTGTTC
+ ACGCTGCCGTTTCGAAGAAGAGTGGCTAGTGCTTCCTGAGGCAGAAGAACCACCACCTCCAGCAGAGCCA
+ CCAGTTAAGCCAGCCAAACTAGCTAATGAACCTGGACCACTAAGAGGAAGGGATCCCCCCGCAGCCGCCA
+ TTGCCTGTGCAGCCATTTCAGCTAAAAAGGCCTGTGGGAAATCGCTGGACATGCCAGGAATTTGTGGTAA
+ TTGAGCTGCCGCTGCTGTCGCAGCTGCTTTCGAGCTCTTACTAGAGGAAGTGGATGTTCCCGTATTTGAT
+ CCGGATGTTGATGGCATTTTGCCTTGCGAGAAAGCTTGAAGCGCGGCTAAATCAGTTGGCAGAGCTCCTC
+ GGGCTAAACTTTCTAACCACTTTTGCTGTTCCTTGGCCTGAACGTTAGCTTCATTTGCGGCTTGGCTGCT
+ TCTCTTGCTTGTAGATGTGTTACCTCCACCAGAAGAGCTCGGCGTTCCTGAAAGAGGCGGCATTCCCAGG
+ GAGCTCATCAGACGTGTTGCCTGCGCCAAATCCATGTTGCTCATACGGCTCAAGGACTCGAGAAGATGCG
+ GATCCGCTCCTGGCATAAGTAGACTACTGAGTTGAGCCATGTCTGCTGCTGTGGGTGTGGTTTGGGACTG
+ ATTTCTGCTGCTTGATTGCCTGCCACGTCCGGATCCTGATGCTGAAGTTGAAGGCGTGGTAACTGTGCTA
+ GCGCCACCGCCCATGCTGGCCATAGCATTCATCAGACTTGCTGCTGAGTTGGCAGATGCTGTGGTATTCC
+ TGGACTGACTGGATTTTGATTGCGACTGATGCGACTTAGACTGCGTGGAGCTCGTATTTGAGGCCGATGA
+ AGTAGCTCCATTTAGCAGGTTATACTGCTGAGCCAACTGATCGTATGCGGAACCAAGTCCACTAGATCCA
+ AGGGAATACGGATTCAGGCCACCTAGTCCCATGGGCGGATACAGCAATGATGGATTCGGAAATAGGAATG
+ GAAATCCGGCCGCCAATTGTGATGCAGAAGCAGCTGCGTTCTTTCCCCCTGATGCGCCAGATCCTCCAGT
+ GCTTGCGCTGATAGCAGCTGCCAATTGAGCAGCTTCATTTTGTGCCTGTTGTTGCTGTTGCTGCTGCTTC
+ TTTTTACTAGCCGAAGAGGATGACGAAGTGGCGGATGATTGCGACTGCGCCTGGCTCTTGCCGGAGCCCG
+ CTCCTCCGGATGCACCAGTTAATCCGCCAAGAGTTGGCCCGGCAGCAGCCATGAGCGCAGCCAGCGACTG
+ AGTGTCCATCCCTGCAAGATTACCCAATCCTCCCATTCCTGCCAAACTGGCAAATAGGTTCATGTTGTTC
+ AGGTTACCTAGTCCAGGAATATTACCCATTCCGGGCATTCCTCCAAAAGACATGGATAGCAACGGATTTT
+ TGGGATCAAATGCAGCAAGAGGATTCTTGGGATCAAATGCGCCCAGTCCAGGAAGATTTGCTAACAGACT
+ GGGATTCAGACCCGCTAAGGAGCCAAATTGTAAGGCAGCTTGATCCAGTGCAGCTGATGCCGCAGTTTGT
+ TGGCGGGAATTTTTCTTTGAGCTGCCTGAGTTCCCTCCCGCTTGCGATTGAGCTGCAGATGATTGCTGTT
+ GGGTGTGGGACGATGATGAGGTGCTACTCAAATTAGATAATGGACGACCACCATGTGATTTCACTGCCGA
+ GGAGCCGTAGCCGCTCTCCATTGATGCGGGCCTTGGTGACGGTGTTGACATGGGATTTTGCATCTGCTCC
+ AGCCACTTTGGATCCACTTCGTAATTGGGGTTCTCCGTAAGCCTAGAGTAAAAAAAATATTATTATATCA
+ GACATTAATTTGTTACAGATAATGGTTTCAAGGCTGAATATTCCATTCTTATCAAACACTCACCATTGCA
+ TAAGTCTCTTTAGCTGCGGCGCTTTATTGCCTCCCAAGCGTTTGCCTGTCTGTTTATTGATCACTGGTAC
+ GGGCTCCTCTCCTGTCAAATTCTGTGGCCCGGGCATCGAGTGTTGCTGTTGTTGTTGCTGCTGCTGCTGC
+ TGTTGTTGCTGTTGCTTTTGCAATTGGGCTGCACTTGAGGATTGTTGTGAGTTTCCCTGCTGGCGGTTCG
+ AGCGCCGACTATTGCCACTTCCCGAACCACTTGCCCCGCCTCCTCCTACGTAATCAATGCTCAGCTGGTC
+ ACCCAGTGGACTTGTCATGTCTGAAAGCCACTTGTTGACCTTGACGTCGTGTGGTGAGTTTGTTGAAAAC
+ TTTGAACTGATCTTCATGGCCTGTTCCATCTCGGCTAGCATGTTTTCATAAGCCTTCCGTTGAGCGGGGG
+ GCAGGAACTGCATCATCTTTTGCTGTTGTTTGAGGAACGTCTGAGGGTCGGTGGCCATTGTCTGTGCCAA
+ CAGGGCATTGAGACTGTCTTTGGATGACAGACCTCCCATTGCCATATTCTGCAGGGCGCTCAAGCCGCTG
+ CCGCCGGCTCCTCCGCCGCTGGCCGACGAGCTTCCTCCTGTGCCGGATCCGCTGTTGGACGAGCCGCTCT
+ TGGATTCTGAAAGACAGATACATTCGATTAGTGAAAAATCCTATTAGATGGATGCCAATCTTCGGCTGGT
+ GAAAAGGTAAAAGCGCAGAGACTCAAACTCACTTCCAGGCACTGTGGTAACAGTGATAGTAAAGGGTTTC
+ TGATTTGACTGCTGGTTGGACGAGGATTGAAGGTTTGCTGGCGTCACCGATACGCTTGGAGGGATCTGCG
+ GTTTCTTTGATGATGGCAGAGATGGGTCAGGGAAGGTCTTTTGCTCTTTAGCAGCCGATAGGCCGAGAAC
+ GATCTCGTCCAACTTCTTCCTCTTTTTCTCCTTACCAATAACAGGCTCTTCAATGGTCTACAATAAAACA
+ AAACAAAGGTGTAAGTTGCCTTAAATAATTTCAATTTAATTTAATTTAAAACTTACGCAATTGTTTTTCT
+ TCATCAATTTATTAAGCGTGTCGTCCAATTTGCTCTTGTTTCCCATCGAGGGAAAAGCGGAACTTAAAGC
+ AGCATGTACACTGGATTTCTTAGAAGGCATAGAGAAGTCCTGAACCTCACTCAAATCGATGGCTCCCGAA
+ CTGGAAGCCGACTTAAGCATCTCAGTCATATTCATTTTCGGCAGGCTGTTAGACACAGTTTTAAAAAAAT
+ ATTTGTACAATGGGAAACGTAATGACCTATTTTAAAGAACACACCTTGATGAAAGGTCCATTGGTGCACC
+ CATTGAGGGAGGAGGAGTCTTCATTGCGGGGACAGCTGGCTTGCTGAACTGTCCAGATGATTGTCGCGAG
+ AGTGAAGCATGTTGATGAGCTGGAGGCGGCTGCATGCCACTCGAAGCAGAAGAATTGCCACCTCGACCAC
+ GACCAGAGGAGCCACTCAAGGCCTCCATGTTTGCAATCTCACTCTCCCAGTCTTTCGGCGCCACTAAAGT
+ TGAGATAAGGTTAATTGGGGTAAACAGAATTTTAGTTTAAAATACACTTACTTGTAGAACTGTTAAGCAG
+ AGCGTGGAGCTTAGCCCTTTCCGTCTCCACGTCAATGGCGATGTGTCGCTTGCGCTTCTTTCCCACTCCA
+ GACCCGGCACTCGGAACGCTCAATCCGCTCACTCCACCGGCCGAAGAGCCAGTTGCTGCACTCAGTGACA
+ TTCCGGGAAGCAGAGACGATAGGGAGGTGGCATTTCCACCTGCTGCAGCTGCCGCAACGGCCGCTGCCAC
+ AGCAGCATTGATGCTTTTAGCATCCAAGCCAGGTAAACTGTTGGAAGAAGAGGGCTTTGATTGGGTGACC
+ TGGGGAACTCCCGAGGAAGTGGATGCAGCGGACGCCGAGCTGGCAACTTGCTGCATGTGGGAGGTCTGCA
+ AGTGCTTTGTGACACCTTGGTCCGTTGTTATGGTAATGACATCGGGTGTTGTGGAGCGACGTTCCAAACT
+ GCTCAAGTGAGGAATGGATTCGTGAAGAGCAATGCTTAGATCAGTGGCCCCCTTGCAGGTTGCAAAGGCA
+ CTGTATTTACTATCCACAGGCCAATTTCCTGACTCAACGCAAGCGACAATGTGCGCAATACGGCGTTCTA
+ ACGCAAAATCCTTAAACCATCGGATCATGCACATTTCAAGCTTTGGCTTCTCCAACTTTTGCTGCTTAAC
+ AGTTGCCGGTTGAATCACTTCCAAGTCCGGAAAGCGGGCTTTAAGTTCTGCTGCCTGCTTCTTGCATTCT
+ TCTTCTACTGCTTTCTCTTTTTCCTTCATCACCTCGTCATCATCGGGATCTGAAGGACCAGCCACCAGGT
+ CGAGTATGTCTTGGTCGCCAGTGGATTTTTTGGGCACAGCTACTTCGGGTTCGAGGACAGTTTCAGATTT
+ TTCAGAGGGCTCTGATTCTATACTCGATTTTTCCAGTTTTTCCGTTTCTTCTTTTTGTTCCTCAGCCTTT
+ TCATATGAGTTTTCACCCTTCTCTTCCTCAACCTTTTCAACAACCTTGTCTTCACATTCCTTTTCGGGCG
+ ATTCCGAATCCCCAGAACAGTTTTCTTCTGTATTAGGGGCAGCTTCATCTGCCTCCATTTCTGACACTTT
+ ACCATCAGGAACTGCAGGGGAACTTGGCTTTTCTTCTGAAAATTTCTTATCCTCAGCATCACTGCATTTC
+ TCAGGCGAACCTTCCTTCTCACCATTTTCGGCAACGGGCAATTCCTCAACTTCCATTTTATCTTCGCTAG
+ GTTTGCTATCTTCAATTTCTGGAACCAATGTTTCAGTGCTAGACTTATCCTTATTCAAATTTGTAGATTC
+ GTCCAGTGCTTCCTTTTCCGTGGTTTCTGGATTAAAATCCTCTTTACCCTTTATCTTTGTACTCTCTTCA
+ GCATCTGAATTTTTATCTTCGAGATTATCAGCAGTATCATGCTTTTCAGGACTCTCTTCAGATTTAATTT
+ CTTCTTTTATGGGAGTAACCGGCGATTCTTTCTTTATGACACTCTCATTAGTCATGAGCTCATCATCAAG
+ GTCTATGACCTCATTCTTCACGGAAGCTGCCTTTTCTGCTGCCGCCTTTTCAGTCGCCGCAGCTTTTTCA
+ GTTGCAGCATCTTTTTCAGCTGCCGCTAACTTCTCTGCCTTTTCAGCATTGAAAGCCTCCAGTTTGATAG
+ TACGTTGAATCTGAGCTTCTAGTTCTCGAATAAAACGCTTCTCTGACTCTCCAAAACTAAAGTTTGGATC
+ GTTAAAGATAAAGGTTTCGGAGCGATAAAGTCCGTGCTTGAGGACGGCTGTAATCAATTCCTTGTCGTGT
+ CGACCGGGCTCCCACCAATCTGGAGTATCCGCATTCTTGGTGCAGAGTTTTAAGCGTTCCTCAAGCATGG
+ GATTCCGAGCGACTTCTCGCAATTTGGCAAGAACTTCCAAGCGATCCAGTATGAGCTTGGCGTGTTCCTT
+ TTCGATTTCTTCGATGATACCTTCTAAGCCGCGCTCCGATTCAGAGAGCTTTAAACCCGCCTGTCGTTTA
+ CACATGGCCACAAATACCTTATAATAGTCCGTCAGTGTTTCATCGCTTTTTCTCTCTAGGTGAGCCATCT
+ GTTTGAACTTGGTCCAGTCGGGCGAAAGGGAACTTCCATTAGAGGAAGCCATAGGTGTTGAGACGTGTAG
+ GTCCACACCATACCCGGTAAGAACTCTAAGAAATTCGTATTCTTCCCGGCGGTTCCATTTTTTGGGAATG
+ AGCTGCAGCCGTTGGGACTCGCGCTCCTTCGCCGCCAGTTCCATCTTTCCCTGTCGCTCCATTTTCTGTA
+ AAAATTACCGAAAATATAAAATATTTATTATAAATATTTTCGTTAAAACAATAATAAATTTTATCTTGCA
+ AAAACATGGTGCAAGTCTTAGAGTCATAGAATTAACATATTTTTAAGTTAGATTTTTAGTTTGATTTTGC
+ AATAACCAAAAGTAAATTTTTTATAAAAAGCATAGAACCCCAAAGTACAAAGGTACTGCACGTATCGAAA
+ CATAGTCTGTCTGACCCCAAGTATTTGAGGTGTTCGTCAATGTCCACAAAATATATTGGTAATAAATAAA
+ TATATCGAATTAATAACCATCTATGCAAGTATAAAAAATGTTTAAATCAGGCCATTCGAATGTTATCAAA
+ ACTTAACTACTATTTAATTAAAAATAAAGTAAGCATTATATTTTTTTTAAATAATTCTTTTCAATAATAG
+ TATATTTCAAAAAATTTTTACAACAGAGAAGCATATTTCTACATATCAGCTCAGCGAAATAGAACACCCC
+ ATATGTGATGTGCACATTTTGCAATGCAAATTCATTACGAATATTTTCCAAATTAGCTTGAAAAAATATT
+ TAAACGACCCTTTGCATTGCACCACCCATCACTGCGTCCCCAGGGGTTGGGATCACACAGCGCGACTGTG
+ TTGGTGGTGATGTGGGGTGGCCACGTTACGACACCTTCCCTCATCACTATAATCATCAGCACATAGCAGG
+ CTCCTGGCTTTCGAATTACACACAAATTTTTGCGAAAAGCAAAAAGGGAAAGACATAATGCGAATGACAC
+ GCGCATATAGAAAATAAGAGCGAGACAAAGGCTCAAAAAAAGAGAGAGGAGACCGAAACTGGAAAAACAA
+ TAAAATCATAATAATAAAAGTAAAAAATCCATTTTACACCCCTAATAACGCTTCGGCCGGAGGACAGAGG
+ CCAAAAGGCGACAGCAACAGAGAACGACGTGGAATCGGAACACGGAACAACCAGCAAGCCGCACCAAGCA
+ ATGGCGCTCAAAAGTAAGGGGCATGCGAAGGTGATTTCAAAAATAAATAGAGACAAACAAATGAATCCTG
+ TGAGACCAATTGCACGCGCCACAGCCAAGGAAGTTCATACACTCCCACTCACCCACACTTACTTTATGCG
+ CTGTTTGGTGCGTCGATTTAAACTAAAAATAATAGGTGGCACACACTGCTGCAAGGGCTAGAAACAGAAG
+ CAAACGTCACGCAAATACACAAAATTGTAAGCCGTCCTAGGGGTCAACATAGTAACAGCCATTGGATTTA
+ CGGCTGCCAAATATGCGGTTCATTCCAAAGTCTTAATGTTATAATTTGAAAAATATAAGGAGTAAATAGT
+ TATTCTATCCTTTGATTGAATTTACATTAGTTTCTATCTTTATCGAGGTAAATGGGCACAACGAATTTGT
+ CTTCTTTTCTAAATATGTACATATAATAAAAAAAATTGGCATACATGTATGTATAAATGCGTAACCTAAC
+ TGAAAACGTTATGGAATCCTTCCTGGAGCGAATCCAAAAATTAAAATGATGCCAAGTGGCGCCCAGGTTG
+ GCAACTCTGTATACGGTGTATCCTTGTGATTCCATGCCTCTGTTTGTACTGCTAGGCCTCCCTCCCCTCC
+ TAACCAACCATTGCTTGCAGGCTACGAACGATGGTATAACGAAATCCGAAAAGGGGACAAACAAAAACAA
+ ACGACAAAAGAAGATAACACGACAGCGACTCGAGGCCTCTTCTTTCTTCCCTTCTCGCGTACTATACATT
+ TGGCTCTCGCTCGCACTCACTCCGCCTCTCTATCACTCGTTTTCTCCGCACCGTTCCACCATCGCATTTA
+ CACTACACAAGTGCGAGGCGACTTGAGCGATTGATTATGAATATTAGTAGAACCGCTGGCTATGAACATG
+ GCTACAGGCTTGGAGGCGGCGGTAGGTAAATAGCAATAGGGTAAATAAAATAGAGAACGCGGAGCAATAA
+ ACAGCCGCGCAAAAAAGAATTTGAGTGAGTGCACTTAAAAGGCAATAAATAGATATAACCGTTGCACAAA
+ GTGGTTTTTAAGAAATTGATTAAGAGTAGATCAATTAAATAATAATAATACTTGAAACCACATTGGCCTA
+ CAAATTCATTTAAAAGATCACATTAAGATTCTATCGTACAACAATTCAGTCGTGAATTAAAAATTATTTT
+ TAATTTTCTTTATGTTTATATTATCAGTAATTTTATTTTGAAACGGTTTAGTGTGGACCTGCCTTACCAA
+ TAACACCTACTTGCAACATGGAATTCTCTCTCTCTCTACCCCTCACAAGCGCACACAACTTCCCAACCTA
+ AACCCTATTAAACCCTAAAAGGGGCAACGTGAACGCTTTTTGTTCATGTGAAATTTATAGGCTTAAATTT
+ ATTGTTTTGTATTTCCACTCGCTACAGACCGAATTACGAGCGAGAGGGCCAAATGATCCCCCTCCTCGTC
+ GTCTGTCCCACTCTTTTTGGGTCTCGTTCACTTTATCTTGACTAACTGCATGCACACATTCTTTGCATAT
+ TCTCTCTGCATTTTTGCATTCTCATTTTAATTAGGAGACGCATCATGTCCATGCTTGCAATTTCGCATCG
+ AAATATTTGTATTTTTTGCTTTTACCTCCAAATAAATGCCTTTTCCATTGTTTATTGTTGGCGGTATCGT
+ CGTTGCAGTTGTTGCTGCAATTTGTGAAGATTTGTTAAGATGCTCGCAGAACGCCGAGAAGCTGCTGAAG
+ TCCATGGGTTTAATAACCTCCATTTTCGAACACACGGCAATATCACAGACTCACTGGTAATCAAGAATAT
+ ATTGGCAAAATCGAAGCTTTACGCTTTCGTCATGATTATTGATTTCAATTAAGCACTAATTATCATTCAT
+ TGCGCCTCAATGACAACTATTTGCATTGTTGTTGTTGCCTCTGCAAATACATTATTCCATTTCGTTTGAT
+ TATCACTCCCTCTTCCTTTAGCGCACTCTCTTTCTCACGATTTATCGCGTTTCGTTTTCCCCGTCTTGCA
+ TCGAGTTTCCACGAGCACTTGGACTTTTTACAACTTTACACCGCGGCGCTCAAACAAATAATGAGCGGAG
+ CGCATTGCGGACTAAAATACAAGACACACTCCTCACACACACACATAGGTAGGCAAACAACGGCGATGGC
+ AGCGGCTAAAATCGAATGCGAATCAGCCAGAAAGAGAGACTCAGAAGAGAGGGAGCGCGGGAGAGTAGGA
+ AACCAAACAATCGTGAGATTAAGTCAAACGCCGTTTTGGGTGAATGTGAATATGAATGAGGTGGGCTAAA
+ ACTGAGACCGACATCCAACTCGGAGGTGAATGAGCGTCACTTGCAATAAGGGAGAGCGACAGAGAGAGCA
+ TCGACTTCGGCTTCGCGAGAGTACAATTCAAGGGAGGGCGCGGGCAGAAGCAACCTAGATGCGATTGTGA
+ CTGTGAGTGTGCAGTGGATGGACGAGTTGAAGAAGAGCGGCCGCAGCGGGCACATTGTGTCAACTGTGTA
+ ATGTAAGCAAAGAAGCGAGACAAGAGCCTGCCGCACACTTACTCGCACCTAAACACAAACCCTGGAGCGG
+ GGAGAGAACAACACACGGCGGAATCGCAGGCAAAAAAAGCTAAGGCAATGAAACAAATGTACCACAGAAA
+ CTGTTGACGACACATAGAGAACGGCACGAAAGAGCGAAAGAGCGAGGCAGCCAAATGGGGGAAGATGAAC
+ GGGGTAATGACGGACGGACGCAGGACAACGGAAAAAAGGGATAAAATAAAATAATAACAGCAGGCGCAAC
+ AACAGCGCAAAGCAAAGAGAAGTAAAACCATGAAATGGTTTAATTCGAAAATCTTTTAGAAATGACGCCT
+ AATACCTTATCGGTATGGAGTTCACCCTCGTCTCCTAATCCATATTTTAAGATATCAATATCAATTAACA
+ ATTTTTATCGTATGATTAGAAATTCGCATTGTTTTATTATTTCGACCTTTGGGCTTTACATCGACAGCAA
+ CACACTATCCAGACAGGAGACAGGGAGAGAGAGCACGAGGCAGTCAGAAAGCATGAAAGATGGAAGCAGT
+ GCCAAAGTGCGATAAGCACGTAGCCAGAGCAAAAACGAAACGAGATTATTAATCAATCCGCAAGATACAG
+ ATGCAGATACCACATGAGTGAGCGAGTCCGTGAGTGGATATTGCACACACCGAAATGCATGCATGAGTGA
+ GCAGGGCGGCTACAATCGCACAATCGATATGCGACAGAGACATATATATATCTTCGACAATGCACTCACT
+ CACACCAACAGAAATCTTGCGCAAGATCACCGAAGAGGGCAGGAGGCCACTCTTCTCTATCCTAAATTGG
+ ACTAAACTATATCGAAAAAGGGAAAGAAAGTAAGAAGGGTGATGGCAGGTAGACAAGTCGGATTTAAACT
+ TGACAAGCCGTTCAGCATATCGGTTAGACATATACTTTTTCAAATGGTTTATGAGTGACAGGTGTAAAGT
+ GAAAAATGCGCAGGCGTGGCGGCTGCATCCTTTGAATGCAGTCACTACAGAGAGAGTGAGAGAGCGGCAA
+ TGGGATCTAGCAGCGACTGTTACGAGCACACGCACAGTGGAGTGTCCGAGAGCATAAAAGAATATAAAAA
+ TTCTTCAACAAAAAAATATTACTCAAAAAGTCAGCATGGCAAAAACAACTTTTCCCTTTCAAAATTTTAT
+ GTATTTACACATCAGAAAAGTTTCGATTCGCTCCACTGTGCACACTTAAGTGGCAGCGAAATGCTAATAA
+ AATAATAAATCGAATGGCAGCACCAACAACAACGTCACTAAAAAAGAGCAACGACAGCGGTCAGCAACAA
+ AAGCAAAAGCTTCCAAGCAAGTCGAAGGTGGGACCGAAGATGGAAACAAAAAGAATGGCAACCCGCACCA
+ GTCGAATCACACGCACAGGAGGATAGCCATCAACTTCTCTATGTTAGGTGTTTCAAATGCACGTTACGTT
+ GCAACTTCAAAAACGAATCAACAGAATAAAGCAAAAAGTAGGTTTAAGCAAAAGCAGCAGCGCAGCGTGC
+ AATGGGACGGCCGCCCCGGAGGTCTGGGGGAGCAAAGGAATTCCCATTCCCAGTCCAAATGAGCACAATT
+ AGGCGTCTTTATCGAATTCTCGCGGTATGCGAAAGAAGAGAACAGGAAACCATAAGAGGAACAGGTCACC
+ ATTATCCCCGTCTCCTTTTTGCGCTCAATAATTCAGTTCGTGAGAGCAGTAGCCGAAACAGTGGTGTCAG
+ AAGCAGAAGCAGCACCAACCACCCCCCAGACATTTGGGTGGGCGCATACGAAAGGAAAAAATTATACATT
+ GGATAAATCCAGAAAATGTAAAATTACAAACACACATTGCAGACATCTAGGGAGCGGGACAGAGATAGAG
+ AGTGAGGCACTCTCGCATGGAAAACTAATACATACAGCGAGGCGGCGGCAGCGTAAGTACAGCCAACGCA
+ GCTAGGCAGCACCACCACCCGATGATATCGAATGGCCAACAACAACTACAGCAATAAAACCAAGTCGTCC
+ ACCAACGCTACTGCTCACGTCGCGGCAGCCGCAGCAACCATCGTCACCAAAGAACTCCAGTTCGTCGATA
+ CAACAACATCGGCAACGGCAGCAACAACCACTTGGCTTTGCTCTTCTTGCTGCCGCCGTTTCTTCCGGCC
+ CCCCGACATTACCGGATTGTTTCGCTCCTTTTACTTCTGTTATTGTTGTTGTTGTATGTTTGATTGATGG
+ TGCGCTGCCTTTACCGCTGCCTCTCTGCCTTTTGATAATGGCAACGTCGCCCATTCAGCGATGACCAGTT
+ GTAGGGGGAATTTCCCGAATTAGGCCTTCTAAAATTTCTACATTTCTATAGCCATGGCATATATAATCAG
+ ATGTATTGGAGCGCAGTATCGCTTTAGTATCGGCACCCTTATTCAAATCGATTCCGGACTACTCGGATAT
+ TTATAAATATGTGAATATGAAATATTAAAAAATCGTTCTCATTTGGCTTGCAATTGGCGCATCTCTAGCC
+ CGCCAACACAGTGGGATTGCTGCGCATCGAAAAGGGCAGCTTGTACAATTGACTTCGCTGTTTTGCCTTT
+ TCCCATATGTCGCCCCATGCCTTGTGACCAACACGTTGCTGGTTCCACTGTTTTGCGGTGTATCTGCTTT
+ TGCTGCCACATCAAGGGGCAGCAAAAGGCGAAGCGGAGGCAAGGAATCGAAAGCAACGGTTTTGCACTAG
+ ACAGTGGATTTGAGAAGGAGTTCGGTGTGTTGCTGTTTTTGTTTCTGCCGCCGGGTGTGCAAAGTGGTTT
+ GACATTTCCTCCGTTTTGGCCGTTCATTCGCATGCCCATTCCCATTCGCGAGATGAGATAAAATGCGATG
+ AGAAAAGAGGACGGGGAATCCAACGAGAGGACCATCTGAACATCGTGTGCACCGCATTCGGGTTCAAATT
+ GGAGTGTATGTATTTCTTTTATTTTGCATAAATTAGGCATAAGTGTATGCTGTCGGTTCTCAGCTCTGTC
+ GCTGCCTCCTGTTCGTTTTGTCGTCGCTCGCTTTTGATTCTTCGTTCAGTACGAACGCACACACACACAA
+ AAGGGAGGATACAAAGTCGCAAGGCGAGTTAACAAAATGTTCTCCTCTAAAACTTCAAAACCCCACTGTG
+ GGAATGGGTATTGACTTCGTCCTTTATTTAGGCTGATTCCCTGCATTATTTTCGTGTGCCTTCTACATAA
+ GACCATCGCAAAGTGAGTATGTGGACAAAGGTTAAAATGGGTATCAGAACTACTGCTAGGAACCCATATC
+ GCGAATAGTTTTCTGAATAGTCAAATCGAAAAACCAATTGCTTTACTTATAATAGTATACGACTTTAAAC
+ GTCACCCTTTAAACATATGGGTTAGACAAAATGTTAGGTTTTTGTTTATATTATGATAGTTTACGAATAC
+ ATGCAGGTTAGTAAGGTTAATAGTGTTTTGTGTAGTTGCGTGCTTTTTTGTCAGTGTTTTTTTTTTTTTT
+ TTATTTAGGTATCGGTTCGAAGGAGTTTATTAAAGTGTTCATAGTCTTTTAGAGCCTCAAAGCGTGGCTT
+ TTCTGTTTTTGCTTTAGCCAACGAGTGGAGGTTGGGGATTTATTTGAGTGGGGGTTGCTTATAAGGGCAA
+ CGGGATGATTGTTCGAAGTGGCAGTGTAAGTGGTTATAATATAAAAATGTTTTATATAGAGAGGAGGTAC
+ TCATCACTAACGTACATTGTTCATGCTGACCAGGTACATGGCCAATTTATTGATGTCCAAGTTGGCCAGC
+ TGGTTGACATCTGTGGTGTTGAGTATGCTGAGCATTAGGCTTATGTCGGCGGCGGTTGGCATAGCTGGCA
+ TGACTCCCGCTCCGCCCATGCCCACCTGGCCGGATCCACTACAGGATCCTCCAGCACTTGATGCGGCGGC
+ GGCTGCTGCTGCGGATGTGCTGGCCCCCTGCGATTGCATCAACGCCTGAAGACTCCGGCCACTGGCATCG
+ TGCTGAGCAGAGGATCCTATTCCGGACCCACCACTGCCGGAGCCGCTCTGCAGCTGCATTTGCATAGACT
+ GAAGGGTGGGAGTGGTGGGAACCGACAGCGGCGGTGTCGATGAAACCAATGCCTGGAGCTGTGGGACAAA
+ TGTGACAATCACAGAGAAAGAGTTGGTGGAGTTGGTAACTTTGCAAGTTCGGCAAAAAGGTCAGGAACTG
+ TCACAGATTCAGGGTGGGCTGAGGATGATTTTATTAAGATGGTCTTGATGGTAAAGAAATTAAGTGCAAT
+ CCTCTGTCAGCGTTTTACATAGTTTAGTTTATCAGCTGTTGGCTGCATTAGTTAATGATTTTTTCTTATT
+ TACAGCTTTTGATGCTTTGGGTAAATCGAATTCGGTTGCATTTTTGGAACCGCTTCTTTGTCCAAGTCAA
+ TGTCCACTGTCCGTTCTGTACGCTAACTACGGTGTACGGTTCGAAACTAACTACAGCCAACAGCTAAGCA
+ ACAAAACTACATATTTCTAACATTGGACACTACAACATAATCATGAAACGTAGAACAAAAAATGTAAAAT
+ GATTCAATAGTCATTTGGGTTAGGCAACAGACAGTTTCGGAAACTATTTGAATTTTAGATTTTTCATAGT
+ CGTTAATAAGGGTGGGTGAATATAAATCTCAAAGATAACAATTTAATTTGAAGAAAACGCTAATTTTAAA
+ GTATCACTAGAAATTGGCAAAACTAAATAAAAGAAAATGAAAACATCGTGAGCGTGACAGTTCTCAAGCA
+ ACGTACTCAAGCAAACTTGCAGCATCGAGATCTCGATGTTAATACGGACAGACAGAAACGTTCAATTTTG
+ ACTGTTAGATACTTTTCAACGAATTTAGTATACCTTTATACTCTGAGAGTAAAGGGAATATAAAATATAT
+ ATGTACTCTCATTAAAGTGGCAACGAATGGAGAAGATAATATGAAAAGGGTTGGTATGTGGATAAAGGAT
+ ATTGCACCTACCTTGGCCTTCTGCTGCAGTTTTAATTCCTCTTTCTTGTAATTCCTTTGATAGGCAGTGA
+ TCACCCGCCGGAGACGCGTGTTAAGGTCCTGCATAGATGGCCACATAGTAGTGGCGTCCTCGACGGCTGC
+ CACGGTTGGCGGATAGCTGCCGGCGACACTCTCCTCCTCGTCCAAGCCTAAATGTGAGTTTGAGTTAGCA
+ TGGTCGGTGGTGTTGTTAGAGTTAGCCGCTTTGGATGATGGATTATTGGTGGTGGTGGTGGTATTGGTAA
+ TGGTAGTAGTAGTAGTGGTGGTGGAGATGTTTGTGGTAGCATTGTTAGTGCATGATTCCGTTTTATCGCC
+ TTCAGCTCGGGCAATGGCAGCGCTATCTTTTTTGGCTTCCACAGCAGGAGCATCACCAGTTGACTCCTTG
+ GTTTCCTTTTCGTTATCTTTTTTCTCCGATTCGATGTCCAATTCTCCGGCATCGCCAGTCTGGACCCCCG
+ TCCCCTGAGCTTTTCCTGCCGCCTCGGGTGAACTAGAGTCGGCCGGATCGCAGGAAACAGAGGCTGAGAC
+ TTGTGCGTCATTTTTATTCATTTTAGGATCTGATGTATTTGCCAATTCAGGAGTTGCTGATAATGCGTCC
+ TGCTGGGCGACCGACACATCCAGATCGCTGCCTTTGCCCGGCAAGACTTCGGATTTGTATGAGGATTCGG
+ AAACGGTTGTGGCATCATTTTCGCTTTCCGTTTTGTCGTTGCCGCCGCTAGCATTTTCACTGCTACTCTT
+ ACCAGACGAACTGGGACGCTCCGGGTCGAGAAGCGAGTCCTTGTTATCGCCCCCGGTGAGTTTAGTAGAG
+ TCAGAGTCTTTGGTCGTTGTAGTTCCGTCATCGTCCACCTCGTCACCATCATCGTGCTTCGAATTAGCAT
+ CGTCTTCGTTTCTGTGGTGGTTCCAGAAAAAAGGGTTTGAATGTTAGTAGCAATTTAATGGAATTTACTG
+ ATCATATATCAGATGCAGGCCATGCCCAACGCAGTTAAAACACTGAGAGAAAATTCACAAAACACACGCA
+ CACACACACATTCAGCGCAATGTCAATGGATCAATGCATTCAATGTGAGCGTTAATGGAAGCCCCGTAGG
+ TTGCGCTGTTGTATCTGAGAATATTTCGTTGAATACCTTATCAAGAAATTATACGGCGAGAATTCGATGA
+ ACAAGCACAATGATTATTAAAATTATTAATGTGAATTGAAAGTACTTTTTTAATTTGATTTGAATAATTT
+ AAATTAAATCTAGTCTATATTAAAAGTCAACAAAACAATTATTATGATTTATGACCTTAACATTTGATGG
+ ATAAATAGCACTGTCTACCAAACTGTAATCTTTGATGTAATATTATATTAAGCGCTAATAGCTGAAAAAA
+ TGTTTGAAGCACATTTTAATGCCAAGACTTTCAGATGAATGCATGTGCACGTGGGGAATGGGAATGAAAA
+ TGAGTTTAAGCAAATCCTGCACGTTCCTTCCATTCAGGTCTAATTGGAAGCGTATTTATTTATTTTTTTA
+ ATTTTAATACTTTAGTGTGATGTATATGAATTACTCAATGGCGTTTATGTATGGTTTATATCTCTTTGCA
+ TCTGTTGTTTTTTCTATCCGGCGTGTTCAAAAAAACCTCTATATCATTTCTCAAATTCTTTCACCACAGT
+ AGCGGTTAAAACGGTTATCAATTACCATCAATATTAATGTTACGTGTGTGCAGAAGGTACACGTTGAAAT
+ AGAGATTCCTTAGAACACACCGAATTAATTTAGAATTGATTGTTTTCGTTTTGAAGACTTACATCGGCAA
+ ACTCGTGACAGCCAGATCGTCACCGGCCGCACCGGCGCCCACATGGGTGACAAAGCACAGATTGGGATCG
+ GCGCGCATTTGACGATACATTTCACAGCCATGCTTGTAGGTTCCCACCAACAGGCTCTTATCACAACAAA
+ TGGGATTCCACCATGAAGATGGCACTTGATCTGGCGTTGGCGGCGGGCGAATGGGGAGTTCGCTACATAT
+ GATCGTATCGTTCGATGAGTACATTCGATAACATTCAAATGTGTTTGGTGGATTGGGGAAGTTGAGAGAT
+ GCGCGAAAAAAGAAATGCGTTGTTTAGTAAAAATTCAATTTTCTCGGTTCAACAATTTTTTGTATGATGT
+ TAAATAAAACAAAAATCAAAAATGAGACCATAAAGGGAAATAAAGTAAAAATTGTAACATTGTTAATTGC
+ CAATTTGTACTACAGATTTACCACTACAAAATGCAGAATCATACAAAGCAAAATTTAAAAGGTTAGTTGA
+ GCCTCTTGATGGCTTTTTTTTTTTGAATTTGGTATTCGTATTAAAAAATATAAATTAATTATTGAATTGC
+ ATGTATAACTTGGCGGTTTTTGTATTATGAGGACGACTGCACGTATGGAGGTTAATAAAGATGTTGAGTA
+ GCGTGAATTTCCCTATTCGCCAGCTTTTTTCTTAAAAGTGGAAAACACCGTGCGTGCAAGCGAGGGCGAC
+ GAGCGATGGCGATCGATATCGGTGGTTGAGGAATATATGGGGATATTACCTTTCCAAATTCAGATTCAGT
+ GCCAACTGCTGCTTGGCCCTCGTACTGCTGCAGTTTTTGGTGGTTATATAATATACGTATAGATATCGCA
+ ATGAGGTCAATTAGGAATTTTTAAGGTTTGTTAAACGAATCGAAAAGATACAAAACACAGCGATAGAAGA
+ AGATTCGATACGCCGAAGATTAGTTGGCAAAATATAGAATTTAAATGTTGTGGTTACAAATGAGCAGAAT
+ CGTGTATAAGATGTACAAGTGTTAGCATTTTAATGGACAAGCAATCGAAAATACAAAGAGAGTTGCAGTA
+ TAGAGATACATAGCGAATAAAAGAGAATCACATTCCACCTGAACCTTGAAACGCCCACTGATCATTGCTT
+ CAATCAGCAGACACAAAGTTCTATAAAAAAAAGGGTTAATAATAATTAAAAAAAAAGACACAAATTGGCA
+ TTAGTAAAGAGGCTATAAAGTATCTATAACAGAAGGTTAAATTAAATACAAAATTAATGAAAACTCTTTG
+ ATAATCAGCCAGTCAATCATTCAATCAACAACAACAACAAACAAAATGATTAATGAATGCCAAGTGTTTA
+ GCAGATGACTCCGAGTGCCACGCCTACCTGATAGGCGTGTTGTCCTTTATCTGCTGAACAAAGTCGCCAA
+ TAACCTCATGTTGAATATAATAGAGCATCCTCACGCGCAGCAAAACCCTGTAAATGTTTACATTAAATAA
+ ACAAAATGTATGAAAATAAAGGGAAAAGAGAGCGAAAAAAATTGTTAGCAACAGTCCATCTCAAATTTGG
+ AAATATCTTATAACGAGTTCGATTCCACACGACTCACTTATTGGCGTGTCTGCCTAAATGCTTCTTGTAG
+ GCGCCTTCCAAGTACGCATCAGCGTCGTACTTCTCCTTCTTGCTCCAGTGATTTGGATCGTGAATGCTTG
+ TGACCGCCGCGGCTACTGCGCTGGCATTTATGCCGCCGCTGTCCTTATCGGACCCATCCAGCGCACTAGA
+ TTTGTGAGCCGGAGTCGTGTTTCCACTATTGCTTCCGGATGCAGAGCCCGGAGCAGGAGTAGACACTCCT
+ GTGGATTCTTTGTTTGACTTTCCACCGTTGCGACCTGTAAAGCAAAAGTAGTGTTTACACAAACATTAGT
+ ATATTCATATTTCTCTAGCTGCCTTCAGACTGATATATACACTAATCTGAAGGACAACAAAGCTCTAGGT
+ ATCAAAATGTAAAATCAAAATGAATTTACAGCACCACCGGATCTCTGATCGTTTTCGTTTAAAAGAGGTG
+ TTTTTGAAGGGTACTTAATATAATTGGCTATAATTTAAAATATTGCCTATACATGAAAATGATACACAAG
+ GGATATATGATTTTAAAAATTAAATACATATTAAAAATTAAATAGTTTAAAATTTCGAGATATTATGTAT
+ CTTTCCTACAATGTTACCTTTTAAGCTAGCACATTGTTCGACTCAACAACAGCAAATAAAAAATAAATTA
+ GTAGTAAATTAGAAAATGGTTTAGGCTACTCTATATAAAGAGTTAATATGAATTTTAAAGGGTATGTAAG
+ TAAAATGTTATTTATTATGTACATAAAAGTAACAGATTTGATATAGTAAAAGGCATACATTTGCATGGCA
+ ACAAAACATACACACACTTCTTTTCGTCGCGTCGCGTATATGAGTCAATAATTTATGTCTCTGTTCTGGT
+ TCAGTCTTTATTGGGTGATTCGATTTAATATTGAAGGAAGTTTTTACGGAGGAGAGGCCATTAGACACAC
+ AAATTAAATTATATTCTTGCTTTAAGTATCTGACATTTACGGATACAAATAAGTAGAAGAACGCAATTAA
+ AATGATGTAGAAAGTCCAGAGCCCAGTACAGATAGCATAAAGAAATTTTTTTACAAAACGTGTTTGCTAT
+ TTTTTTCTGGTAGACCGTTTCGTTTATATTACTTTTGTATTGGTTTTTTAAAACTCTCTACGTCCGTGCA
+ GCAGTTGGAGTGTGCGTAAATGTATCTTTTACCATACCTTTGGCATTCCTACCTCGTGGCACCAAGTTGT
+ GTAGGCCACTATGATCCCTGCTAATCTTCTGCACTTCCCCGTCCTCCGTCGGTGTTATCAAGTCCCAGAT
+ GAACGTCTTGATTTTCTCATCACCCTTGTACACCTGCAGGCAGTAAAGAAGCTGCGAGAATAGAACAATA
+ TTAATGTTAAAGCTTTTGTAAAGTGCATTCTATAAACTTTCTGACATTCATATCAGCGGGTTGAGAAGAT
+ AGTTTTACTCAGCGAAAACCTTGAGTTTTCTCAATATTAGCATGGTTGGTCATCATTTTTTTGCACACGT
+ TTATTTTTGGTTTGAGTTTCATTTAACTTACTATGATGCGAGCACAATCCTCGACGTCTACATCACGCCA
+ ACCTCGTTTGAATTGTCCTAACTCCAAAAGTTCCGACCACCGGCCCCAACTGAAAAAAAAGTATTTACCA
+ ATGAGATCACGTTTGTTTGTAATATGCCTGGGCAAAGGGATAGACTAGATAGACTTTGTTGTATGTTACC
+ AATCTAGTCATTGTATACTTTCCCTTTATCACCAACAAACCGGTCAAAATACATATATTTCAAACAAATT
+ CCATAAATTATTCCTTAACGTTACTGGTCTCATGATGAGCACGTCAGGACACAGCCTTAAAACCGACACG
+ CAGAGCAGACGCTCGGTGAAATCTCATCCAAGCAAGCTTCACGTATTCGAATATGCTGCTCCGCAGGACT
+ TGGACGTCGTGGCTATTATCTACAAGTTCTATCTGGAGGACTTTCGCAACTTTACGGAAGAAGAGCGGCA
+ ACTGCGATTGTCCAGTTTGGACGCCATCGACATGCTCCACACCATAGAGCAAGTGCATAATGATGTGGCT
+ ACTTTAAGGCTGGAGAACCACATAATGGTCGAATTCCTTGAGAAAAACGATCCAAAGTTGTTATTGGGAT
+ TGAGACAGCGCCGTACTTCCATTCTTAGAAAGTTGCAAACAAAGCGAGGATCGGCACAGGGAAGTCATGG
+ CGTGAATAGCCGGCACTCCAGCTCCAAACGCTCCATACCCATGTCAGTGAATCAGCTAGTATCCATAAGT
+ GGCATATCTGCTCCAGAAAAGCGACGTGGAATGGACTACAAACTAAATTTTAAGGCCAAAGCCGAAATGG
+ CAGAGAAAAGAGCAGCTGAGGTGGAGAAGCGGGTCGCGGATATTGAAAGAAATGGTGGGTTAATTGCATT
+ TTAGATCTCGTTTTCAAAACTCATTCATTCACAATGCACTTTTTAGCCATGACCGAAGTGAAACAGTTAA
+ GAGCCAAGATAGAAGAGCTCCGCTTTCGAAGTGAGGAAACCATTGAGACGGAGAACAACTTTATGCTCCA
+ CTTTTTACGGGATGAGAACGATGTGGCCTTTTTGGAGTCTGCAACTGAGCGACAGATTGAACGGAAATTG
+ CGCAAGTTCACTTCAAATTGGTTTAAAAATGCACGCGCTTTACTGGGAACTATGAAGTTAACCATAGTAT
+ CGCTTCAAGAAACATGTCAGCAGCATCGGGCGGATTTGATAACCAAATCAGACCTGAGTGGTATCCTGAC
+ GGCTGTAGATTTTGAAAAACTTATTATAAAGAGAACCGAGCTGGTGAATCAACTGGAAGAAAAAAACATA
+ CACATGGCGGGACTTAAAGGAGTCACAGGAAAAACTTCCTTGGCCATGACTGAGGAAAAACAGGCCATGA
+ TGAACTTGGAAACAGAAATGCGTACCGTTCTGAATAGAACGGATGAAGTCACGCGAGCCATTCAGAAACT
+ GGAAAAGGAGGTGGCTGCAGTTCAAATGCACAATACCAAAGACTACGTGACTCTGGATGAGCTGAGAGCA
+ CAGCTCCAGGACTATGAGGCCCCCAGTGTCAGCGAGTATATCGAGCGAAAGGAAGAGGCCCACGTCCTTG
+ AAAAGGAAGAAAAAATGCTGCAGAGAAAGATCTACATCCTCAATATGAAGCTCAACAATGCCATACGTCG
+ GCGAAATCGGCTCGAAGAAAATTAAATTGTGGCATTTTAGCTCGTTATAAACTTACCCAAAGGAAAGCAG
+ TCCCTTTTCCACTTTAAAGCACTCAGACTTGGCCCAGTTACCATATTGAATTTCCTCCAAGCCCAAAGCA
+ GCTAATGCATCCCGTTCTCGTGGAATGTATTCATCGTTGCCCTTCTTTTCACGAGCACGATCTCGCTTCT
+ CCTTGCGGCGACGGGAACGGAGCCCTAATTGGATTTAAATGATTAAAATGCTTTACATAAGAATTTTCCC
+ TTTTTTTCAGCCTTACCTATTCCTCCCTCCTCGTCGCTATTCTCATTGGAAGATTCCTCGGAATTGAGCT
+ CCATTACGTCCTCGTGGCCGTAGCGTTTGATTTGGGTGCGTCTTCTGGGTTCGGACAAAACCAAGTCCTC
+ CGTTTCATCCCTTTCGCAAGCATCGGGATCAATGTCAACCTTTTTGGCCCACTTGGTCCAAAAATCAGGA
+ TCATCTATCGTAATATCCGACCGGTTACCGGATGCAGCAAATGAAGCCTTTGAGAAGGTTGAACCCTTCT
+ CCGATTCCATTGTGATGACTTGAGTGCGTCGCTTAAGGATTGAATCGATGTCCTCTTCGCAAAATTTGTC
+ ACCAGCATTGTCGTCATCCATGACGGCCCCGTAAGCACCCTTTTTTAAAAGATCTTCAATTTCTTTTTTG
+ GACAGCTGCTTGTTATTGCCATCTTTAGACCCTTGGGTGTTCATCGACTGCAATACAGCCTTGTCCAATC
+ CAAGTTTCATTGAAGCTTTGTCGAACATTTCACGCTCATAGGTATTCCTGCAAAGCAATCTATAAATCTT
+ TACCATCTTTCTCTGGCCAATACGATGGCATCGGGCCTGAGCCTGTAAATCGTTTTGTGGATTCCAATCC
+ GAATCGTAAATAATAACAGTATCAGCAGCTGTTAAATTAATACCTAATCCACCAGCTTTGGTGCAAAGGA
+ GAAATACAAAGCGATCGGAACCTGGCTTGGAGTAACGATCGATGGCCTCCTGGCGGAGATTACCGCGAAT
+ GCGCCCATCGATTCGCTCAAAGGGGTATTTTCTGTACACTAGATAATCTTCAAGGATATCCAAGCAACGC
+ ACCATCTGACTGAATATTAGAACGCGATGGCCGTTTGCTTTTAGTTTAGGTAGCAATTTATCAATTAAAA
+ CCATTTTACCAGCGGAAAGAATCAGATTTTTATAATAGGACTCAGGATCTTCGCCATGCTGGGACTTGAA
+ ATCATATTGGATTTGTTCCTCCGCTCCATTCAAGAGATAAGGGTGTATGCAGCACTTTCTCAACTCCATC
+ ATGGTGTTCATAAGGTTTGGGATATTAGCAGATGTGGTCCCCTTTTTCAGGAAACTAAAGTTCTGTTCCA
+ GTATACCTCGATAATATTTCTTTTGTATGTTAGTTAGCTCCACTTCGATAATGGTTTCTTCCTTGGGCGC
+ CAAACTTTTCTCTACGTCGTCTTTTAGACGACGTAACATCATTGGTTTCAGTAGAGCTTGCAGCTTATTT
+ ACTTCTTCTTCAGTGCGAAGACTTCCAAACTCAGACATGAACTCTTCCTGTGAGGAGAACTGCGAGGGTT
+ CCAGAAAGTTTAACAGCGAGAACAGCTCGCTGATGTTGTTTTGTAGGGGAGTTCCGGAGAGCAATACTCT
+ GTGCTCCAAATTTAACTGTCGCAGACCCTCAAGGAGTTTGCAATTCCTATTCTTAAGACGATGTGCCTCA
+ TCAATCACACAAAGGCGCCAGTTAAAGGCTTTTAAGTCCATGTAGTCTGTCACGATCATTTCAAAAGTGG
+ TGATCAAAACGTTAAACTTGATGGGCTCCTTCAATACCTTTCCACTTTCTGTCTTATAGTAATATTCATA
+ GTCCTGTATCATTTGTTTACTTGTCACCGAGCCGTGATAAACAACTACGTTCATATCCGTCCAGCCCTCG
+ AACTCTCGCTGCCAGTTTGGAATTGTAGATAGAGGAGCTATAACTAAGAAAGGTCCTCTAATGCCGTACT
+ CATATACAGAGTGCACAAATGTCAAACTTTGAATAGTTTTTCCAAGGCCCATTTCGTCAGCGAGTATGCA
+ GTTGTGGGTGTTGTACCAAGAAAACTTCAACCAATTAAGACCCTCAAGTTGATAGGGTCTAAGGCTATTT
+ CCTCCCTTATAGACGGGCGTCTTTTCCAGTTTTTTCCACAATTCTGGATGCGGTCGTTTTTTAGACTTCC
+ ACTCGCTCCGTTGAGGGATTTTGTTAAAGCGCAGGTACTGCTCAATTTTGTCGTTATCTACATCTTCTTC
+ TAGCTCCCAAGTGCAATCCTCATAGGGAAGCGACTTCCACTTGACCAGGTAGTGCTTCGTAGTCTCTCCA
+ CTGGTTTCGTCTGTATGCACAGACATGTCTAACACTCTATCCACTTCAGTAAAGTCCTGGTTGAAGGGCT
+ CGTCTTCGATATTCTCAAATATATTCAATTGCTGAGACTGCTTTTGCTGAAAGCGACGAATCTTAGCAGC
+ TACGCGGCGATCACCCTTTAATAGTTCCTCTTCTGTTCGCCACTCGCAATGTAGATAACTGAAATTGCGA
+ TATTTCACAAAGTACTCCTCCACATCGATAAAGACGGGCTCTGGCTTATTTTCCATATCAGCTTCTGTTT
+ TCTCGTCATTCTCCTTCTTAACGGATTCTTCTCCCTCCTTGACCCGCTCCTTTTCCCCTTCAATTTCTAA
+ ACTTTCCTTATTCTTTTCTGTAGTAGCCTCTTCGGGGTTGGAGTCATCAGTAGATTTTTCGTCAGATCCC
+ TCTGCTTTCGATACAGCCGATTGGTCATCATTTGCCTTTTCATCAACCTCCATTTTCTCCAAGACAGTCT
+ CAGGTTCCTTGGCGTGGTCTGCTGTTAAAACGGTAGAGGACTTGTCTTCCTCGATGGCTTTAGAATTTTC
+ TTCAGTTTTCACTGTTTCTGATTGTTCTTCTGGTTTACTTTCCTTATCTGATTTTCCAACTTCATCATCT
+ ACTTCCATTTTGTCCTTGTCCTTATTGTCTTCATCCGATTTCTTAGAATCATCAGGCTCAGATTCTTCCT
+ TACTGTCTACTTCCATTGCGGAGGATTCTAATTTCGTTTCCTCGGAATCGGTTAAATCTTTCTTGGATTC
+ ACCCTCAGTTTTGAATTTTTCATCTCCCTCAGGTTTATCAGTAGTGGCTTCATCTAATTCAGATTTCTCT
+ TCATCTTGTTTAGGTTCGGGTGCTTTTTCTTTGGGTTTGTCCAGAATAAGTTCGCGCTTTCCCATTCGCA
+ TGGCTAAAACTAATTGAACCACCATGCTGTCCTCATCGCCAGTGTTTATGTACACGTAATTGGGTTTGGA
+ AGACATGGCTGCATTTGCAGCATCAGTAGAGATTTGTCGCTCCTTCTCCGCTACTGCAGAAGTACTCGAA
+ CTGGCTTCCAGTTGACTGCTTTCATCCAGTGGTAGATTTGACTTTTCTTCACCCACCTCCTGGGCAGCGT
+ CTCCCTCGGCACCAGATTGAGGTTCCGTTTTTTCCACATCACTTCCTGCATTTGAATTACTCGCATTCGC
+ AGATGGTTTCTTATCCTTCTTTACGGGAGATGCCACTAAGAGAGAGTTCTCATCATCGGAGAACCTTAGC
+ ATAACATCATCGATGTATTTCTTTCTTTGAGTATTCCTTGACGATCTTCGCTTGTTGGAATCCATTTCAG
+ AGTCTGGTGGCGGTGATGGAGGTGGAGTTCTGTCCAGTGTGTCATCTTCGCCATCGGATTCAGGTACAAT
+ GCGACCCCTATTCCTTCGCTTCTTTAGTGCCTTGGCGGAAAGAGATCCACGGTTCTTGCGAGCACTGCCA
+ CCCTCCTCAGAATTTGCATTGCGGCGACTCCTTGCAGTGGATCTTTTACGATCTCTTCTGCTTGGTGTAG
+ AAGCAGGATCTCCTGCCGAATCTGGAACAGAGTCTACTGTTTCATCGCCGGCCTCCGCTTCCTTTTCATC
+ TTCATTGGAGCCACGCGGAATTTTTGAAACGGGAATGTCATCGTAGTCTGGAGATTCTCCATCCACTCCA
+ GTTCCTCCCGAAGTGGTTTCAGCTTCACCATCAGCAGATCCTGCTTTTGGTACCAATGGCTTGTTGTCTT
+ CCACTTCGCTACCCTCTCCCGTTTGCTCAGCCCCATCTTCTCCGTACTGTTTCCTGCGTTTACTAGCACC
+ AGCTCGCTTTTTTACCGCTGCTGGTGTCTCGGTAGAGTTGGGATCGTTTGGATCCTTGGGCTTCTTCGCC
+ TTCGGCGTTCTATCTCGTGGGGGTTTATTTGGATCCTTAGGTGTTCTAGGCTTGCGGGGCTTCTTCTTTT
+ TGCCACTGCCATCAGTCGAGGTATCCAGTTCGTTGGCTGAGTGCACATCTTGAGAGAGATCACCCATCCC
+ TTCACTATACTCCAGCATACCGACCACACTGGTATCTCCCGCTCCTTGAGTCACGCAATCCTCAGAGACG
+ GGTAGTTGTGTCGTTGGAATACTTGAAACGGCGTTGGCTGCTCCCATTGCCACATTGCCGCTGATGTCCA
+ TCAAATCCTGCTGCTGACCCACCTGGGCTTTCTCACCCTTCTTGGCGCGAGGCTTACGCGGCTTATTGGC
+ ACTCTTTCCTCGACCTCTTCCCGTGGTGCTAGATACTTGAGGGCTCTCTACCATTTGCTGGTTAAGCAGG
+ GGGTTTCCTGGTGGTCCATACATTGGCGGAACGTTTTGGAACAATAAGCACTGTGGACCGCCAGCACACT
+ GATCGTTTACCTCGTGCTGCGTCAGAAGATTTAATCGCTCCTGCATACGCATTAACTTATCTTGGTGTTG
+ AAGCTCATGTCCTGGAGGCATGCAATACAGTTCCTGTATCTGCTGCTGCAGTGCAGCAATTTCTTGTTGA
+ TGCAGCATCGGATAAGGTGGATACATTCCTGGCGCTCCTCCATACGGAGGCATCATGGGAGGCATGTGCC
+ CTTGTCCCTGAGCCTGGGCCTCATATCCGGGGGCGATAGGATGCATAGGCATCCCTATAGGAGGCATCTG
+ TTGCTGAGGCGGTTGTGTAACGGGGATAATAGGATCTGCAGGGGGTGCAACTCCAGGGGCCGATTGAGAT
+ TTATCCTCTCCGGATTCCTCCACTGTTTTGGGTTCCTCTAACAAAGATTTAGATAGATCCCCTAAAGATT
+ GTCCCAATTGAGTTTGTTCCATCTCAGCGGTGGGCTTTTCTTGCAGATCGTCTTGTATTGTTGGCAATTC
+ CGTGCTTAGAGTTATGTCTTGAGTTTTAGAAACACTGTTCTCATCCTGTGGCAAATCAGTTTCATTGGCA
+ ATAACTCCTTCCACAACACCGAGTCCCTCACCTTCGCTTTGATTCTTCTCAAACTCCGCATTCGAGGACT
+ GAGAATTGCTATCTAAAAGTGCTGCTGCTGCAGAAGCTGCATTGGAGGCCACGGCAGCAACTGCCGCTGA
+ ATTTGAAGACATCGAGTTGTTATCAAAAAGACCAACATCTACTCCAGCATTCTGGGCCGATTCCGAATTT
+ CCTCCGTGCGAATTCGTGTTGTCCATGAGCAACTGTTGCTGGTTGTTGCTGCTGCTGTTAATGCTGCTTT
+ GCGAATTACTGTCGTGCACCGACGTGGGCTGGTTGTTGACAATGCTATTGGTGCTACTATTGCTACTGCT
+ GTTGTTGCTGTCATTAGCAGCCACCGCCAGAGTGGAGGAATCATTCGAGTTGGCTGTTTCATTGAGAATG
+ CTGCTCAGGTGATGTGATGGGGTCGAGGGTTGCTGCTGCTGCGTTTGCTGTTGCGGCTGCGACACCTGTT
+ GTTGCTGGCTTTGTGGTACTTGTTGGGATGGTTGTTGTTGGGTTTGATGTTGCTGCTGTTGCATTTGCGC
+ GGGTACTGGCGAACTTACATGAGCGGGCGACATTGTCTGTTGGGATGCAGCCGGTTGATTGTCTCCTAGT
+ ATGTTAGCGAAGGGATCAAATTGCTGCTGTGACTGATTATAGCTGGGTAGATGTTGCTGGTGGTGCGGCG
+ ACTGTTGCTGCTGGTGTATTGGAGACTGGTGCTGCATTTGCTGGTGGTGCGGCGATGTTAAAGTCGCCTG
+ CGGTTGCTGTGGTTGCTGCTGTTGTTGTGACGTTTGCTGTTGCTGCTGCGTCGGCTGTGTTGTCTCCATG
+ GTAGGTTGAATTAAATGGTGCATGTTAGGCAGATTTTGCTGATGCAACGGCGAAGACATGGCCGCCAGTT
+ GGGGTTGCTGCTGGTGCTGATTCTGAGCACCCCCTGTTGCTCCACTACTGTTACCACCCCCAACAATATC
+ GTTGATCGAGTGCTGCAATTGATCGTTGAGTGACTGCTGCTGGTGTTGCTGTTGTTGCTGCTGCTGAGAG
+ GCGGCCACTACTGGCGGTTGTGAAGTCACCGGTGGTACAACTTGTTGCTGCGCGGTTTGTGGTTGCTGTC
+ CCATCGGCTGACCATACATGCTTAACTGCTGCTGGTGATGTTGCTGCTGAGCCTGCAACATCGCCGCCTG
+ TTGCTGCTGCTGCGGAGGTGCTTGTTGCTGCTGTTGTACCTGCTGTTGTTGTTGTTGGGCCTGCTGCTGC
+ TGCAGGGCCGCCAAGTGCTGTGCTCCATGAGCCGCCCCCCATTGTTGATGTTGTTGCTGCTGCTGTTGAG
+ GGGAAGCTGGCATCCTAGGACCCACGGCACTTCTGTAAGCCGATGGGTAGTCCATGGGTGGTAGTCCGAG
+ AGCCTGAGATGGCATCACCATTTGTTCGAGGGCCTGTAATGTGTTAACGGGAGCAGCAACTGGCGCAGGA
+ CCCTTCGCTCCCGCTCCGCCTGCTCCACTTGTGGGCGGCTGTGGGCGTGGCGATGGCAGGCCTACCATGC
+ CTTGAATGCTGTGCTGGCTTGGCTGATTGCTTACAACCTGTTGCGGCTGCTGCGCTTGCGTTTGTTGTTG
+ CTGCTGTTGGGGGGGCGGTGGTTTCGCCGGCGACACGCCAACTGGTCGCGGGGACATTTGTGGGTGCGGC
+ GACATTGTCGGAGGACGTGGCGACATTTGTGGGGAAAGCTGAGGGAAAGGTGCACGATACTGGGGCGAGG
+ AATTTAGCTGGGCAGCCGCCTGTTGATGCTTGCTGCTGGACATGTAAGGCGGCGCTGACTGCTGCTGTTG
+ TTGCTGGGTCTGTTGTTGCTGCTGTTGCTGTTGATGGTGGCTTCCGTAACTAGGAGGCATTCCCATGTGC
+ GGCGGCGGCAATCCAGCACCCGGCAACTGTTGCTGCTGCATTAGCGAGACGTGAGGTTGCTGCTGCTGGG
+ CCTGCTGTTGCTGCTGCGATTGGAGCTGCTGCTGCTGGTGGGCACCCAATTGCTGCGCAGCCTGCTGCTG
+ CTGCGCTGACAAGTGGTGACCCGGTGGCGCTCCTCCCGGCACATGCTGTCCGTAAGCAGAAGCCTGATCT
+ AGTCCTGTATGACCGTAGCCCACATGCTGGGGAGCTCCTCTACTTGGTTGGTGTTGCATGGGACTTCCGT
+ ACGGACTGTGAGCATAAGCTTGAGGCGTGGGAGGTTGTCCCGCCTGGACGGTGGGTGCTCCCACTCCAGG
+ ATACAACGGATGCTGACCAGGAGCTTGCGGATAATGCTGCGGCAGTCGAGCCTGCTGCTGACTCTGCTGC
+ TGCTGCTGTTGTTGTTGTTGCTGCGCCTGCTGTTGCACTTGCTGTGCTTGCTGTTGCTGCTGGGGCGTGG
+ GCGGTTGCTGCTGCTGTTGCTGCTGGGGCGCCAGTGATCCGTACCCCGCCATCATGCTCTGCTGCGCGCC
+ GTATGAAGCAAGTTTCTGCTGGTCCTGTTGTCCATAGGCGGGCATGTGTTGACGATATGCGCTAGCGTTG
+ CTCTGACGCTGTTGCTGCGACGGTGGAGCCGCTTGCGGATGCCCATAGGCCCCCAGTCCGGCTCCGGGAT
+ AAGCCGCTGCCTGGCCCGGAACCGAGGGCGCCGCTCCCCAACCGCTTAGATCGCCCATTCCGGCACCAAC
+ TCCTACTCCAACGCCGAGGCCCATAGCCGCCTGGTGATCGGCGGCCCCCAGCCCGTAGAGATTCTCCGCC
+ GTTGGCTGGTACGATGGGTATTGGGGCTGTTGCTGTAGCGGATGTGGGGGGCGGTGGCGCGGCGGATAGC
+ CGCCAGGCGGTCCCATTGCACGCGGGTTCGCCGCGGCTGCGGCTGCTGCGGCAGCTGCCGCATCATAACG
+ GTAATAGGGATCTCTGTGGATCAGAAAAAGAAAACAGTTGGATATACAAAATTTGGTTTCTACTCGCCAA
+ CGAAATTGAGTCTATTTTTCCAAAACATAGGGCTAACACTCACCCTTGATGATTTCCGTGAAACATATTT
+ TGTGCATTTCCATCCATCAGATTTTTTAAACGCAGCGCACACAGAAATGTCCGTTACGCGTCGAAAGACG
+ CGACGCCGCTGCGTTTCAGATTTGGTCGTCAATTGGCTTAATTTTGATGCTGCTTTCTGCGCGTGGCCGT
+ TGTCAAAATGTCGGAAGCCTAAATGTAGTCGATAATTGAGAGCCAGACAATTGCGGAGAAGTTTCACTTC
+ TCAGGGGATAAGATGTTTGTTCCTCACTTCTCACTTTACCCCGTGGATCAGGTCGGTCTCTGGTGTCTCA
+ ATCCACCTTCGCCTTATCGATTATGATTATATATTAGTTGGTTGTTGGTTCTAACTACTAAGCTTAATTA
+ CAACTGGTGTGCAATTTAACGTCTTGTTGTTGCTTTTATAGGGTAAAAGTCATTTGTGTTTCGTGTTTCG
+ CGCACTTCATGGCCGACCTTTGACATATTCGCAGTGAAACACATTCGCTCACAGCTGAAAAAGAACATTT
+ CAGAAAGATTTCGAATAAGTTATTGTTAGTACTAATCAACTTTTTTAAGTTTTTCACGAAAAACGGTAAT
+ TTTTCAACGAGGAGTAGTGCACATTTCGGTTTTGAGCGTATTTTTAGAGAGCTTTAATTTAAGTCCGAGT
+ AAGATGCATATAAAAGGATATTGATCTGGAAAGAGAAGACAAAAAGTATGATGTATATTTGTTCGTAGGC
+ TTTGTAAAAGTTTTTTTTAACAACATGGGTACATTTATACTCTATGAATGAAAAACACTTTTCGTTGCAA
+ TAGCTCTAACTTTTAAGGGGAAAAGCTATACGCTTATGAATATCACAGAAGGGCACATATAACGTACAGT
+ TTTACCCCCCAAAATGTTGAGCAATATTGTCCAGATTGTACAATTATTATTTTGATTCCGCTATTTTACT
+ TAAAATGAAAGTGCTTACTAAATAAACGGTTCACTTCTTCTGCTTTGTGATTTTATAGGGAGAGTTGTGA
+ GTGGAGTGTGGGTACGAATCTTGGGTGAAAATCTGGTGCAGAAAAAACGAGAAAAACAATGGCAACTCTA
+ TCGATTTTTCGCATTGTCTCAGCGGCTGCTTATAGACGAAAATCTAAAGTAGCAGTGGAAAATCCGCAGA
+ GAGAAAAAAAAAGGCGGGTGGGTTGACTGACTGGTTGTTATTGTTGGATGCTGCGAGAGACCAAAGATAT
+ GCAAATGGGCGGCGAAAAGGGGGAGTGGCAGAGAAGTGCTGGGGTGGCAAGGTGTGGTGTCTGTGTTATG
+ TGTGTGCAAATGGAAAGTGGAAAGATATAGAGACAAAACTACTTCGGAGAGTACATAGAGATATGCACTT
+ ACACACATAGGCAGACAGACAGACAGACAACCGAAATTCGGTGTTCAGTGTAGTGTTATAAATACGAGTG
+ CGAAAGTTAAAGGCAGAGGGAGGGGTTCGGTGTATATCACTCACACACTCAAACGGCACATAATCGGCGA
+ AACTTATGTGGAGTGCCTGACATGGGCTAAGCGGCGGGCTTAACACCGCCCACCCCCCACCAAACTATTT
+ GCCTCCCGCACTCACCTACCCTCGCCGGGACTGGCCCCTTTGTGGGTTTGCCGTGAGTAGTTCGCGCTTA
+ TTGGACAATCATTTAACCAGTCGTCGTCCCCTCTACACCCTAAGAAATCCATAGGTAACTAGTTTTGATA
+ AAAATCTCAAAACAAGACCATTTGCGGTCCGAGTTGTATTAAAAATAATTAAAACTACAAAAAATATTTT
+ TATTTGTATTTAACATTCATCTTATCGTCCTGCCAGGCAGTAAATATGTAAAATCAGTGCAGTGCAAATT
+ TTTCTTGCAGTGCCAAATTGTGTTGGTTCCCTCCAGGTGCTTTGACTTTGCCGTAATCAATTACATTTTG
+ CTTTTGCAATTTCAGCTATTTATTTATTTAGTTTCAGCTCTTGCCATTATTATTAGGTGAGTGGTATGTA
+ TGTATGTACATACACAGGCCCGTTTAGCTCCATGGTAATGGTGTGGCTGTGCGGCGCGACTTTACTGTGT
+ ATATCTGGCAGATATCTATCAGTATCAGTGAGTGGTAAGTGTGGTAAGTGTGGTGTGTGTGTCGCATTTT
+ TCCTTCTTTCGCTTTAGTTTTCACTTCTTGCCCGCTTCTTCCCATTTTTTGGCGTGGCTGTTTTTACACA
+ AACAAATCGGGCATAGTAATTGCAAAAACAACAAACTAAAAGCAATAGTATCATACATATGTATGTACAA
+ GTGTTACATACATACATACATACGCGCAGTCCGCGTTTGGGTAAGCAAAGCAGACATCTGAAAAATTGTG
+ AAATTATACTTTACTTATTGCCTCTCTCCGTCCACTCTCCTACGGCACTGTCTGTGTTTATGTTCATGTC
+ TGCGTCTATGTCGTTTTGTGTCTCTGCGCACAACTGTACGTTTGTTTTAAATAAGCGAAAAATCGATTAA
+ AGGTGATAATAGACAAGCAAATTTCAGTGTGTCCAACGACAAAGACGCGAGCCACATTTTTGTGACCCGA
+ CGATGACTACACCACCAACAATCCGATCCAATCCAATCCGACAAACGAACAGCACAGCGCCACCACCATC
+ ACAACGCTGGATTAGCTTTGCGTTTGGGCCGGGTCTGTCTCTGCTTCTTCTGATTCTGCCTTCCCATGCT
+ CCCCCACGTTATGAGCCATGAAAATCGCCCCCAAAAGAGTTTACTCAAGTCACACATTTCTCGCCGTTAG
+ AAAAGTGTTTCTCGTCGGTTGGCATCAACGTAAACAAGCGCTTTGTACGCACCACTTTTGGGGGCAAAAG
+ GCTCAAAATACATTTTTTTAAATAGGATTAATACCGCAGCACAAATATCTAACTATTATTTCTCCCAAAG
+ CTGTACGAATCGAATCAAATAAACCTGAATGAATATTTCTCAAACTTATTTTGCAATAGCAACAATAAAA
+ CACAAAAAACGAGGAGAGGGTTCGTTCACCTTTCGTCGTGGGCAAATGTATTTAGTTAACTCACAATTTT
+ AACAGTTGCTTTGTGCTCTTGCTTCGCCTTTAGGGCCGACTTTGCCAGCTCTTTTATCTTCAACTTTTTA
+ AATGATGCTTTAACTTTTCAAATGACCCACAGTCCTTCAGCGGCTGCAGCCGTGCGGTAAGAGTGAGAGT
+ ATTTAAAAAAAAATCCCTTTTTAACCCAGCCCAATAACGACATCTAAAAAAACAAAGTATTGTTCACACA
+ TAATGCACACTTTACGTTTTGCGGTGCTGTGCACAGTTGTGTTTGCAAAGTGTCGTCACATAATAAAAAC
+ TCACAAACTTGATGGGAGGATGCATATATGAACGTATATGGTAGAAATGTATGCATGTATGCATGTGAAC
+ GAATGAATCTGGGTTTAATAACAATCAAGTCAAGTGGCTGTGTCCGCGCTAACAGTAACTAAAAAGTACA
+ GTTGGTTTTTGTAAGAAAAGCCACATTCAACAGCGGCACCCAAGTCCGTCACTTAGCGCGGTCCAAACAG
+ AGCCGAAGAGCGGCTGAAGCAAGAGAATTAGGGTAGAGTGGGGGGCGCTGGCGAAGAATAAGCAGAGCAA
+ AGACAGATGGGCGCAGCAGCAAAACGCGCACTCACACACACATACACAAAAATGGTAATAAAATAGGTAA
+ AGTAACAGCGGCAGCTGTAGCAAAAGAAGAAGCACAATAGCAGAAAGCCATACACAGTTTTCGGAAAAGC
+ CAAAGAGCTTTGGTCTGCTGTTGAGAGCCATCCGCTAAAACTGAGTCTGCAACAAGCGAAAGGTACACAC
+ AACAACAACAAACATCCCACAAAAGTTAGTTGGGCAAAAATTACAAACACGTCACCGCCTTTTGAATGTG
+ TAACGGAACATTTATGGCAGGCCCATTTGGCGTTAGAGATGAGTGGAATGCGGTAGTTGCAGCATTGACG
+ CCAAGAAATTGATCAAAATGCATAAACTTCGCTTATCTAAATTTGTGTATAAAAATAAATTGGACAACTG
+ TCATTGCGACTGACTGATAAACATGTGGTTTATCGTAATGATAAGAATTGCGTAAATGCATTTTATTCCA
+ GTCGTATGTTTTAATGATTATTTTTAAGATCAAATATCATTTATTTATCAGTTCAATACCCACCTGAATA
+ TTGGATGAACCCTGAGGAAAACTCTTCCAGGGACTAAAAGACCTAATCGGTGGATGCATTGACATGCAAT
+ GAGAATAGTTTTGCAAACAGTCAGACGGGAGAATCTGGAAGTGCAAAACTGACGCTATGTTTCCCGCTAG
+ AACTCCGAAAACTAAAGGAAGCCGAGCACACACACATGTAGGACACAAGTCCTGACCCGATTATCGAGTT
+ GAAACTGTTTTATAAAATTTGCACCTGGACCTAAACCGGATCGAATGGATATAGAGCCGCCCATTGTGAA
+ TCTAGCAACAATAAAACAGAGAGAACCCCGAAAGAGCGAGAGTGGAGAGTCGCTCTCTCAAGAGCGGTGT
+ ACCGGCTGAAATCGAGCGAGCGGCGAAAACACACGACAAAGAGAAACGAGAGAAAAAAAAAAACAACCCA
+ ACAAGTGAAACGAGCAAAAATTTTGTCGGCAGAGAAAAAAACAAAAAGCAAAAGCATGGCATAGCGTACG
+ ATAAAGAGCAAACCAAAAGCAAAGCATGTATATCACGTGCTGCGGCAGTGGATGGGAAGGGGCAGACGGC
+ TGAGTGGGGGGCCGTGTGCCGGCCTTTGGCGGCAGAGCTGTCAGCGTCGTAGCCGACAACGAATAGCATG
+ AAAGACAAACAGAAAGGAAAAGCGACTGAGAGACAAAACGACAGAACGACTGTTTCGTATAGAAAGAGAG
+ TGGGAAACCGAGGTTGCGATGAGCCAGTCAAAACAAAAAGTGCGAAAAAGCCGAGGGAGCCAGGGCAGAA
+ AAAGGAGAGATTAAAAAAGTTTACAAGGCTATGTACAAATTTGATAAGTTTATGGTAAGCAAAACTTATG
+ ACCTATATGAGCTGTTTCAGTCATTAGATGCAAATACAATTTCTAGAAAATTATGTTTACACATGTGCAC
+ TAGTAGGCAGTTTGTGAACTTTAAATAATTACATTTTTTCGAATCGAGAAAGTTGCGCTGTGCAATTGCT
+ GTTGGGTGGTCATCAGATGAGAGAGATTGCAAGGGGAAAATCGCGAAATGAAGCAATGCAAAGAAAAGAC
+ GGCGAATGGCGGCGACAACATTACGGCGACAAGTACAAAACACGTATTATGCATGTGTGCGTGAGTTGGA
+ GATTCGCATGATTCGTGCAAATTCGCCGCATAGTTGTTCCTGCTGTTTTATTCGCATTCGCATATCGTGA
+ TGCCTTTTGTTTGTACATGTGTATCTGTATCTGCATCTGTGTGTGTTTGTTGGCCTGGGTGTGCTGTATT
+ TGTGAGTTGGGGTCGTCGTCGTTCATATGTTTGCCTTGTTGTTGCTGCCTGACGTTGTTTGGTCGGTTTT
+ GATTCGGTGTTTTGGGACGGATGATATTATATGGTCGCTGGTCTCTGTCGCTGCCTTTGCCCGGTTTTCC
+ GTCCATCGTTCGGTTCTCTCGCCCGTCATCACTCTTCTTGTTGAGCTCGTCGGTCATTTTGATTGGGTAC
+ AGTGGTACGTCAAAAGCCTGAACGGAACCTTACCAAAATCTTAACTACAGATTACCGAGTGATTATCCAT
+ CTGTTAACAGCAACACATTTAATATTTTAATAATTTCACAATACTTTTATTAAATTTATAATTTAATTCT
+ GTAAAAACTAATATCCATATATTACCACCTATTTTACTTGCAGTCCGAGAAAAGAAAGCTTTACTATTGT
+ TTCCCAATGATTTCTAACATACCCCCCACCAACCCAGCTGGTGTTCTTCAAATTTTCACGTCACATAAGT
+ TATTTTTTCGCCTTTTACTTAAATTTTTTCGGCGAAGCCGAACGAAAACAAGAACAACTGTAAGCAATGA
+ GTGGTGGAACTGCCCACTCGCCCCAACTTTAGCATTATTCGCATATTAACGAGTGGGGGAGGGAAGAATA
+ CGACGAGAGGCGAGGTGTAAAGGGAGAAAACAGGCGTGTGACGTTTTTTCGCTGCTTTTTCTTCTTCTTC
+ GCCGAAAAGAGTTGATTGAAATTATTTCGCTGGCGTTTGTGTTTGTGACTTTTCGCTCAATTCGTTTATA
+ TGTCTGTGTTGCGTGTCTCGCTGAGTGTGTGTATCTGTTTTCGGTTAAAGATACATAATTATTTCTAAAA
+ AGCATTTTCTGCCTGGCCATTGTTGTAAATCGCTCGCACTTTCACGACTCCGTTTGGAGAGGAGTACTTA
+ CATTAACAATTTACTTGAAAATAGTATTACTCACCATTTTTAAATTATTTTTTTGCTGCTAATCCATTTG
+ ACTTTATCTTGTTTATTATCGCAGGTTCTCACAATTTACAGTTCATTTGTACGGTTCACGTTGCTCTCTT
+ TAGTTTTTTTTCTCCCGTTTTCTTTTGTTTTTCGGTTTGGTTTTTGGTCACGCAATCATTTTGGACGCAA
+ GTTATCGATAGTTAAGCGCAACGAAATGACAGATGACGGCGAATGAAAGGGCAACAAGAAGCACAACAAC
+ AATGCTAATTCAAGTGTAGATACACATGCGAAATAATAATTGTAGCACAATTGCCGTTGCAAGAAGAAGA
+ CGCAATGGCAAAAACTACAAAAGCGCAACGGTTGCAATTGTGACTGTTGCTTCTTCTTCTCGCGGCCCGA
+ TTCCATCTCACTTACTCACTAACTCACACAAACGCGCGGTAATTACAATTAAAAGTAGTTTTTTACAGCC
+ GAAAAGAAACAAAGAAATCGATAGATATTGCTGGAAATGAGGGGAAAAATCTCTGCGCCTTGGTAATTGC
+ ACCAGTAAAAAAAAGAAAAAAGACGAAGATGGAATGGAATGGAAAAAAATTGTTACAGCCGCCGAGTGGA
+ AGAAGAAGAGATGCACAACAGACGACGCGACGCGTCGAGAGCGGCGACAAGCGCATGAATTTTACGCTCT
+ CTCATCAATTGCGCGTCGTAGCGGCGGTGTGTGTGTAAGAGCAGACCAGCATATCAGAGAAAGAGTGGCC
+ CGGCTAGAAAAACGTGTGTCCAAGCACTGCCAACTGTGAGTGTGTGCACCGAATGAGAAGAGAGCGAGTG
+ GAGCGAGGAAGATGGAGGCAGACAGATGAGTTGACACAGCGACCGAAGCAGAGCAAAAACCAATCAAAGA
+ GGAAGAGCCGCAAATGGGGATACCGTTGCATATGTGCACTGTATCTATGTGAGTGCTACTTTAGACTATC
+ AATATAGAAATATTGATGACAGCTACAGTGCAGCTTGGACCAAGAACACCAAATTTGTTATAAAAAGAAA
+ AAGATTGCACTCGAGTTGTTGGTTGTTTTGCAGCACAGATTAAATTTGTAGAAAAAACGAGGAGAAATTT
+ TATCTGCAACAGAATCGTCTTCTCAAACCTGCGGATGTTTTGCTAGATTTTCGAGTAGTTTTCCTGTTTA
+ TTTCTTAAATTAAAATCGAGCCATTGAAATAAACCTAATCGAAAAATAAGACAATTAATTTGGGAATATG
+ ATTTGCACTTCGGTTTGTCCCATCGCAATAATAACAAACTGTGAAAAGAGCAACGAGAACGTCGACTGCG
+ ACGTTGGCAGAGCAACTGTAGCAATGGCCATTATGGTAGATGGATAAATGCGCCACGGGGCGTGAGTGAG
+ GGTGGGGAGAGATTGTCTCCTGCACAGGTGCAAAATGTGCGGCGCTGCATCACCCGAATAATGTTGGCAA
+ CACTGCAGCGAAACGGGGCACAAATACATACACAAAATGTATGCTACAAGCGTTACGAGAAAAAAAGTCC
+ TAGCTATAACCACCAACAGTTTTAATTTTTTTTGAGTAAAAAGCGGGAGTAAAGAATATGGCGAATAGAA
+ GTTGGAGAAAGAAATCAAATGAGCAGGCAATAATCAACGTGATAATTACACTCAAACATGATGAAGACGA
+ AAACGCAAGCGAGCATCGCACACATACACAAACTTCCCGATGATGACCATTTTTAATTGTATTAGACGGT
+ CGCCGCTCACATTTTCGGATTTGATTTTCGATGTTCTTCGGCAATTTTGCCATTAATTATTCGCACACAC
+ ACATACACGAACACAGGCGCATAGAGAAATGCACTTGGAACTGCGGGGGAAAAAACAATTGAAATTCGAC
+ GGCTGCTACTTTTCAGCTTTTCTTCGTAGTCTCGCGAAATATATTTCTTTTGCTTTGCCGTTTTTCTTTT
+ CGTCTCGTCGCTTGTCTTCTTGCTCTTTTTGCTTTCTCTGTCTTACTCTCCACTCTCCTCTTTGCACATT
+ TTTTCTTTTCAAGTGACTCGGTTTCGACCACTTTTCAAATGCTAATTTTGCTTAAAATACGCTCAACTCC
+ GATCAGATTTGGTGCTTTTCCAGATGCCGGCACCCTGGCAAGCGTTTTAAAGCAATTTTTCTTAATTACT
+ TTGCACTTTAAATTACCGTTTAACGCAAAATTCTAGCAGCAAATTTCAAGACAACGCGACACACACATCA
+ AAGACCTCCATTTTGTTTTGTTGTTGTACGCTAGAGCTGGGACGAAAATCAATGTTGCCAGAAGTCCCGG
+ ATACCCGCCAATCGATGGTTCTTCTTTTTATGCCATCGATATATTATTTTAAATATCGCTACTGACATCA
+ CTAATGTACAAATGACAACAAACGGAAATATTATTTAACAAACAACTTAAAATTTAACGATAATTAGCAT
+ AGTCAATCGGGTATAGTTAGACATGTAGCTGCTGAAGTAAAACTGTCGACCTTTTCCTGGACCCAAACCA
+ CGTGCAGCCTAGACCCAAAACCATTACGTTACGTTAGCCGGCTTTCGTCGTAAAATCAAAACTAGCCAAC
+ TTATTAAAAAAGCTGATGTATTTTAGTTAAAGGCTACGCCACTTTAAGTCGTTTAATAGCGTGCTCAGTT
+ CCGTCTTTGACTTCAAATGCATCCGCTTTTCCAATTTGCGGTTTTAGACCCTTCATTTCGTCTTCGGTGC
+ TTTTCTCGTCCTCAGAGCTATCCGAGTATATTATGGGACCGTTTCCTTTGAGAAACATGATGGTTTTTCC
+ CAGACGACGCGCCTCAGCCTTCAGGAAAAGTTCCCGGCAGTGCCCGTCCACAGCATTTTTCCCTTGGTCC
+ TCTGATAGGCCGAAGATAAAGGCCCTTTAAAATGTTAGTACCAATTAGACTTCATCTTAAAGGTAATCTA
+ GTTAGCTATATCTTACAAATTAGCAACGTCGTAAGGTCCTCTCAGCTGGAATTCGTGCGCCGCACCACTG
+ CTGAAGATAACGTTCTTGGACTTCCCTTTGGTGCAATAGTTCTGGGCGATCTTTATCATGTCCTTCCTGT
+ TATTCGAATCGCAGATAGATGGAGCGTATTTAATTTCGAAGAACATGCCCCGACGGACTGCCACCTGGTA
+ TGCTTTTCGGTTTACCAAGAGTCGGGACCCAGCCACAGGATCAAAAGTTATCAAGTCCCCATTGAAGGCA
+ GTGCAGCAGTGCTTAGATGGTCCGTGTTAAATGATGATTTGAAGGTGGTACTTATAGTGACTTACCGTCA
+ GGGCGGCATCTGTTTTCGGTTGGCCAGCGATGAGATTGAACTTCCGCAGATTATGGGAGACACTCTACAG
+ CAACAAATACAAATTAACTTGCTATTATCCATCATCAAGTGTTCCTACCATCGCGTGGGCCACATTGACG
+ TCTACGTAGAGAATGGTGATTCTCTGCAGGATTCTCAGCTTGTCCTGGAACTCCTTGCGCAGATGCTCGA
+ TCTTATGAGGCTCGGGAAACATCTCGGACCCACGTTTGCCCGGATCCTTTTTGCTGTGGTCGAAACTCTG
+ GTCGATGGCCACTGTTTTGTAGCCCGCTGCAACGAGTATGTCGGATGTCGTGGGAATCTTCTGTATGGTC
+ ATTTGTTCTCACTCACTTTCCACCAGCTCGTTAAGCAGGGCCCGCAACACGGAGTCGTCCTTGTTGTATG
+ GTATGCTGAAATCGTAAAATGGCCTTGTTTGCTCCATTTTAGGCTTTGTTTTGATTTTCGTTGCCCACAG
+ CGTGCAACCGGTGTTTAGAGTGGCCAGCTTTCGCCAGATAATTGAAACACATTTTAGGGCACAAATAACA
+ CGGTCACACTAACAGTTTTTTTTTTTTACATAGGAAACTTTAAAAGTATAAATGCACAAATAGAATGGGT
+ TCGCATAAATTGGCCAATTCAACCGGTTTGGGGTTTGCTTATGAAAGAAACCCGCCATGGAATCAAAAGT
+ TTGAATGAAAACAATCAATGCGGTTTTTAAAACAAGCTTTTTTTTATTCGCAGTCATAGAAACAAAAACA
+ AGAAGGGTGTTTCCTAAAGTACAGGTTTAAGGTCAAAGCGGCTCCTGCGCATCCGTTGGGGCTATCGTCA
+ GGTCATCGTCTGAAGTTCTCGTCACCTTCTGGTGGTCCTGCGGGGCGATGTGCTCCTCAAAAAGCTTGGC
+ CCTGGCTCGGCGGGATTTGATGAAGATCCCGTGACCAGGACAATCGCGATCGTTGTTGTAGCACCTGTCC
+ TTGCAGCACACGCGGCACAGCTGGAACTCGCACTTGGATCCCTGGGGATTGGCGCATTCCGAGCAGTATT
+ CCAGGCGCCTCTCGTGCCGATGCTGGATCTGGGCCTCCGTTTTGTTGGGTCTTCGCTGGCGTCTTCGAAG
+ TTTCTTCATCCGTTTGCGGGAGATCTCCTTGCCGTCCTTGTCGAAGTACTGCCGCTTGGTTCGGTTGGGA
+ TCCTCAGCCTCGCGCACCTTTTCGGCAATCTTCTGGCGATGGGATTCGGGTGAGGCGCGTATATATGGTT
+ GACACAGCCAGGGAGAAAGTGGCAGCTTTATTGGGGAATATAAAATATTCGTGTTATTTCAGATCCACTC
+ TATTACAAAGATCCGTTCGAGCAACTTACATCTTCCTCTGATCCAGCAGCCATTTGTTCGGGCTCGTATG
+ GCACCTCGCCCTTGTGGAACGGCTCGTATTTTGCCCGTACTTGTTGCACGACGGCTTGGAATTGCACGAG
+ CTGATTTGCAGTGGCTAGGTATTGCCGTAACTCAGAGTTCTGCCGGATATTCATGCTACGAAATAGAGAA
+ TTGATTTTGAAAAATCGGTTTAGGTTCGGTAGTGTAGAGACTTACATGTGATGGAAGAGCTTGAAGAGAT
+ GTCCTCGTATAAAGGAACTCGGGCACGGATGGAGCTGAACGAGCTCCAAGTACTCATGGGCCATTTGCCA
+ GACGGGCGGTGAGACTCCTTTAAAGATGGCCGGATTGTGCAGATTACCCTCGGCGCTCATTACACCATCG
+ ACTCCTGTTTCAGTCAGACAACGATGAACGTCGTCCAGGGCCAGGATGTTTCCGTTGGCAAGCATTGGAA
+ TCTTGATGTGCTGGCGCACATTCTTAATGTAGTTCCAATTAGCCACCCCGGTCAGCGGACCCTTCTGCTC
+ TCTGGTCCTACCGTGGACAGTCAGAAGCTGGCAGCCGGCCGCCTCCAGCATCTTGGCATACCTAATGGTC
+ TTCTCAAGGTCCTCGAAGATGCGAATCTTGCAAGTTACAGGAACGGCTAGTTTTGCGTGCAGTGTGCTCA
+ CTAGGATAATATAGCAGTTGCAATCACTAGTTCCATAAACAATCAAAGTAGCCTGTGCTACTCACCAATC
+ TCTGTCAGCAGCTCCCACTCATCCTGCAGGAAGGATCCGTAGTGACCTCTCTTGGCAATGGCCTGGGGAC
+ AACCCAAATTTATGTCCACCGCGTCGCAGTGGTCCTGCGCCAGGAGTGCTGCATCCAGGATTTGTTGAGC
+ ATCGTTGCCACAGAACTGGATGATCAATGGCCTGTCCTCGGGACACGTCTGCAAGGCATCCTTGCGATAC
+ TTGGGGTCTGTGGCGAAGAGGTTCGCATGGTACATTGGCGAGTAGCAGAGTTCGGCGCCATAGCGTCGGC
+ ACAGCATTCGCCAGGCCAGCTCGCTTTGATCCACCATGGGAGCCACTACATAACGCGGGGATCCCAAGGA
+ GGAGCGGTAGAAGTTGTATCCGGTGGGCTTGCTAGGTCTTTGGTGCGCGGCGTCTTCATCGTTCACCATG
+ GCAAATTCAAATGAAATCTAAAAAAAAAGATTGGATTGATACGCCTATTGGCAAAAGTTGAAAATATTCC
+ ATGCGACAGTGATTATCGGCACCTTTCCCCAAGCCCAAATGACATTAGTCATCCCGCTAACGGGTTGACA
+ AATACCCGCAATGCAGTCTAATATTGTGGCTCATTCTTTACCGGACAGCAGAGGGCTGGATTTCCCAAGG
+ CACCTACGCATTTTCACAACTAGCTAATTAGCGCCACATTAGCGGCGAAAGGGAGCGGCCGAGCGAGCGA
+ CTGGGAAAAGCCACGCACAGTTGGGCAAAGCCAAACAAATTTGCATTGAGCTCACACAGGATGAAAACAG
+ AAACGCGGAGCTAAGGGTCGCTGAAAGCCTACTCTATATTTTGTATAATTAGGATAGAATGTCATTTTTT
+ AGATCTTGATAGAATAGGATTAATGCATGCCTTTTGCTCGAACCATCTGATTTCGTCCCGATTACTCTTG
+ AAGACTCGTTTTTTGCATTAATTTTGTAATTTCACTTTTGTTGCATCTGCAACTGCAATTGCAACGTCTA
+ ATGTCTAGTGCTTGCTCGAGTTTGCTCCAATTAAATTTCTTCAACGACTACACCGGGTTTTCTTTAATAC
+ CTTCTCGTTTCGCTTTCGTTTTTGGGGCTTGGCCCAGGCATAGAAGCGTGAAAATTGCGCTCTAAGTCAA
+ TGCACATCAACAAAAGCAACAATTACGAGAAAAGCCGAACACCAACTACTGCCACAACATACAACAATGC
+ GCACACTAATTGAGTTATTCAAGTTGTGCATGCAACTCAAAACTGAAAAGTTCAAACCCTTCTTTCCACC
+ GGTTTATCGAAATTATCGGACTGCGTTGCACTGCATAAGGGGACACACGTAAGTTTAAAATGGTTTAATT
+ GAAAGCATGAGGTCGAAAGGCTATGAATTCCCATTAAGTTAAAATACAACATTTAAGGTAACAACTATTA
+ AAATTTTACCCTTATCAAGGCTGGTAACAAATGTTACCAAAAGTAACCATATGTATAATCACTAGTTCGT
+ GTCCATATTATCCGGCAGTCTATTGGTGACGAAACGCACCTGCTTCTCAGCACATCCAAAAACAAGGTAT
+ CTCTGCTATCGCTTGCACAATAAGTTGCACAACTTGGCTCGATTCGAATTTTACTTTGCAGAATCGTAGA
+ CAAACGCAGTGAAAAAGAAAAAGTTTTCACATTGAAAGTTTACTGACCGGAAATGGCGTGCAATTTTATC
+ AATGGCGAAGGCCGATTGTCATCTATATAGTAATCTTCTGCCTGCTTGCCAGGACTTTTCAGACTTTCCC
+ TGTTGCTCAGGTTTTTTCGCTGACAATGCGCGGAGCCATTTCAAGGCAATGTCTGTAAGTAATTAAAGTT
+ TAAATGGGCGGGAAACTTTCCGGCCCCCGAAAGTAAATTGCATAATAAGTGAACCGAAATAAAGTGCAGG
+ CCCCAAAAAAAGGGGCGTGGCTGCCGTTTCGCTGCCAGCTGTTGGCTTCGTTATAATTATGCCCAAATTA
+ CAACGAAGTTACCAAATGAGGCGCCCATGGGGTCCTCCAGAAGCAGGAAGGGATCGGGCAGCCGCGGCTC
+ TGGGCACTTGCAATTAAGAACTTTTCCAAAAGCGGAGGGGGAGATCAAGCCCAACTGCAGCATGAATCGG
+ CAGAATGTACAAGTGATTTATAAGTTGCAAAGAAAATACATATTCCTTCAATAATTTGCTAGAAAAGGTT
+ TCATTTGATCTATCATATATACATTTCCTATTTCTAAAGAAATATATTCTCTAAGTGATACAAAATGATA
+ AGCGATAGTGGTCTTGGATGAACTTCTCCTGCAGTAGGTGCCAAAATATCTGGCCATCCCGTCCCCATTA
+ CCCTACTTCTATTCCAAGCCCAGCGGAGTAAATTACATAATTCGCAGTCCAGGCCCACAAATTCGGGCGG
+ TTAGCCGCAGGGTGGCCAAAGTGTGCAATTGCGGAGACCGCAGACAGTTGGACTTTGTTTCGCATCTGCC
+ GGATTCGGGAGCGACTAATTGAATCAGCCGCACACTGGCAATCGCTGTTCAAAGCTTTCGATTTCTGCGG
+ CGCCCGGCCAAAGATAATTAATAATTTCCGCACCAATTAAGGCGGTCCAAGACCAAGAGCAGTTTCGGCT
+ TTCACTGGATACCCCAGAACCAGGTGCGGGTTCACCCGACCATAGCTACCATCAACCTTCGGACACGCCT
+ CCGAAGCCGCACATCGCATGCGGTGGAAATCAGCCAGGCCCCGGATCCTGCTTTGCCAATTTTCAAAGTG
+ GCCCTACCAACGAATTCGTAGTGGGCGCAGTGGGTAATGTATTTATTTACTTCTAACCTTGCTACGCGTT
+ GGTCAGGTGCCCTTTAAAATGCAAAACTGTAAAATCGTGTCACGAATCAAAACTCCAAATCGAAAATCCA
+ CTTTCGGTACTCTGAGATGGCAGATAAAGATGAAATATCAACCGGCCCAGGAGAAATGTGCCGATGCTCC
+ CAGTTGCCCCTGCACTCACAACCTCCAATGCCACCCATGAGAAAACCATGACACCCAATCGAGCGGTGAG
+ GGCCACTCCAGTTCCAGACTGCGAGCGAAGAAAACTCGATAAGAAATTGGCGTAGCACAAAAAAAATGTG
+ AATTAACTCGCTTGCCATTCAACGAGGCGTTAAATCCTTTCGAGCAACAAAAATGGTTTAGAATGGATAA
+ GAAGGGGAGTGACCTGCTGAGTTCGCCATTTCAACTTTGCCATCATCTCCGTCTAATTCTTCTCTGTGGT
+ TCTGTTTTTGCGTGGCTCAATCCTACACCGCGACAAATGCGCATAGCACTGAGTTAGAAAAACTCTTTAT
+ TTTTCAGTCAGTAACCTAGGAGTTACAGTGGATATTCGGTTGCTGCGCACTTCTCCATTCGCCATTTCTT
+ TTTTGTTGGTCTCACACTTGATTTGCTGGCGAACTTGTGCCGCGACAAGCAAAAGGAAAAGCTGAAATGG
+ ACAGGGGGCAAGGAGACGGGCTCACTCGAAATGGCGATGACAGCTCCAAAATATGACCTCATTCCCACAC
+ ACAGACACACACACGCATGGGTTTTCCATGAGCTTTCCCAGCGAAAGTTGGCAAATGAATTTAAAACTCA
+ ATTCCAAATACAAAGCAGTTGATACACTTTTTACACTCTTAAATTTAAATATTGTATGTATTTTTTGTTT
+ ATATGATATTTTGGATTCGTATCAAGTGACAATTTCTGCATTTCCACTCAAACTGTCTCTACTTTATTCG
+ CTTCCCCGTGCCCAGCAAATGCAGTGAAATTTCAAGTGGTCAAGAATGGGTTGCAAAATTGGACGGGGGG
+ CACCGTTTGGTGTGGTCGGTTTAAGCACAAGCTTCTCAGCACCCTGTGGAAAACCTCCACCCCATTTGAC
+ ATGCAAGTGGAAACTCCCCGTGGCGTGATGGCAATCAAATTGCAAAATAAAAACTCTCTTAGCGTGCAGG
+ CGCAAAACGCAACACAATTTAAAGCACACAACTAAATTTAAGGAGCAGCAGCAAAACGGAAAATGGAAAT
+ TGTTCCCAGAATCGACCGTATTGTCCCTATGTCGGAGTGTCCTTTCTGAGTAAAGTAGCGCCAAATGTCT
+ TTGAAGTGATGAAACGTGGTTATAGAAAATCAAACAATAAATTCAAAGTTAATAATTAGGAGGCTTAAAA
+ TGTTATACACATATAGAAATTGCCTTCAAGTATCCGCCATAAAGCCTTGTTCCTTGTGTCCGCAATCCGT
+ TCGCTGACGTAATAGACCACAATAAAAGGCCGAAGTGTGTAGCCAGCTCGCATTTTAGCCGTTTCAAGGA
+ CATTGTGATGGCAGCTTGCCCCCAACGCTAAAGGGGCAAGGACTTGAGGAGATGATGCGACAATTTGGCG
+ TCTTTGGATGGGCGTTTCCCCGCCAGCAAGACACAACTGAAATGCGGCCAAGTTATGAATGATATGCATG
+ GCATATGGGGATCTCTGTTTGCCAGTCCTCAATCCTTGGAGCGGACTCAAAAGGGGCAGCCTCCTTTACT
+ ACTCCATCTTACCTTGAATCCCTACAAATTGGTTTATTAATTGATTCTAAGGCGCCAATGCCTCGGGTTG
+ AGGGTTCCTTGACGCGATTCCCCTTCTTCCAGGTTATGTTCGCTTCCCACTTTTCATGAGACTAATGATG
+ CCTGTCAGCCTTGAAATCCAGCTTACACAGGAAAACGACTTTAGAAAGACTCTTTCGCTATTAAAACGTT
+ AATATTTATACTGCACATGTTTCTGTTTTGCTCTCTGTACATACGAACTTAAGCGGAGAACCAGATTCTT
+ AGACTGTGCAAGTCCCAAATTGAAGGGTTGTTAGTGGGCCTTGTCTGGTAACTGACTGTCCTTGTATCAT
+ AGGTCTATATATGAAGGATGCGGATGAGCCTGGATCGTGTGCTTGTGCACTTAATTATATTTGCAGGCCC
+ AGACGGTGAAGCTGGCGGTGACGTAGCTAAGAGAGGCAAAAGGACCAAATTGAACGTGAATTTTGTTGAT
+ TGACTTTCAGACAGAGCCAATGGACAGGAGTGCTCTTCGTCTATTTAGTGAGAGGGGAACATTAGATATA
+ AGATTATCTAGTAAAAAATTTAAAAAAAAAAATATATATATATAAAAACTGGAATATTACTAGTCATTTT
+ TTTTTTGCAAATTCAAAACGATTCATATTTCGTAGCTACTATTTTTGCCGCTGGTGTAGGCGCGCACACA
+ CACACACACAGTCAAGCGAACTGAGATACATAGATACCCCACAATGTAGTATCCTTGGGCACTTACAAAT
+ ACACACTCCTTGTGTTTATCTGTTGCAAAGTGAGGAGCAAACAAACAAGCCAAATGACACGTAACCATAA
+ ATCCCCGGCATTTTATTGCCAACGCGTTAAGCTCTGCGTCTGTGTGGGTTAAGAGTTGCCACGGTGTGTG
+ TGCGTGTGTGGCATGCGTTTGATTTGTTTTGGCGAGGCAAACATATGACACAAAAGACAGCTAGGCAGCA
+ TAAAAATACTACAACAATTTTCCTTGTTAATTTACGTGCAAGTATATATTTGCATAAATAATAAAAACAA
+ GAAAAAAAAGTGCCACAGCAGAGAAGTTTTAATACCACAAGTGATGTATCGGGGGTTTCCCTTATTCCAC
+ TTCGCTTAACGAGCCTTCCAAGACCCAAAACAGGAGTTAATTTTTAATTCACCATCATCAATTAGCATAA
+ TTATATTATAGTACACCATAGTATCCCCATTTATTACTTTTGAAAACTAGTCAACCACTTACAGAAACCA
+ GAACATTGCGCATACGCAGCGTGTACAACGGCGAGCAAACATGGCTGCAAAATACGCCACAGCACGATGA
+ AAACGTCCACATGACCGGGGAAATGACTCAAAGCCCGGTGGAAGCCATAGAAACTATTCTCCATTCGGCT
+ GGTAAATATTTAAAATGCCAACGAAAGGGGGTCAAAAGTCGCCTCTGAGCACCGACAATCAGCAATGATG
+ AGCCACCCATGTGCCGCCTTGTTGCCAATGATAGTTTTATAGACACCTTGTTGTTGCAACACTCTGTTTG
+ TTGTCTATCGTTTTTATTCCACTTTTCTGTGTGCTCTTTTTGCTAAGCGCACATTTCACGATTTAAGTTT
+ TCTTGGGAGCGATTTACAAGTCACTTAATTGCTATGGGGCGGCGCACATAAGAAACTAACAAACTAAGCC
+ AACATTATTTTATTTTTCATTGAACAATTTTTATTTTTTGTTTATGGTACAAAGCATAGTCTTTAAATGT
+ CAAAATGTCTTCACATCGATTCATAGCATACTTTCTGGGGCTATAATCTTCTCATACATTCGTTTCTCGT
+ TATGCGAACTCATACAAATTTTCGCATTTCTTCAATTAAATTTGTCTCCTGTTAGAATCTGTTTATTCAC
+ ATTTTATCAAAATATATATAGGTTTTTTTTTATAATCGTGCTTTTATTTTTCACACTTAATTGGCCTGGC
+ TAAATTATTATAATTATTGTTTACTTTTCAATCTTTAATTTGTTTTCGTACATTCTTTACCCGACTCCAG
+ TCTCATAAACTTTTCTTATTCTTCTGTTTTTCCGTTTTCATTGATAATTTGTTTAAGCTTACGATACAGA
+ TAAAACTACCCAGAAGTGATACAAAGAGTCATTAACTAAATTGAAAGGCATATTAGACGGGCAGAGCGGT
+ CGGATTCACCTAAGTCAGCATGTCCTGTACGTTCCACCTGGCTGATAATTCAACAAAGGAGCCGAGAGCC
+ AGAAGTTCGTTGAACCAGCCAAAAGGGAAAAGCAAAGCAACTGAAAATGTCATTGCAGGGCACAAGGCGA
+ AACAAAAGGAGTATGTTGGCCCAAGTGGACTGGGAGTTGGAGCTAACCTAACTACCAATGCTAATAACAG
+ CTCGGAGAAGGGAAGGAACGGTTGGAGCAGGGGCAACTGTCTCCACTGGTGCGCCTTCGCACCCAATTCT
+ GGCCCAATCAATCATGAGTCGTTTATCCTACAGGCAAACCGAGAAAGAAGAATACGACTTTTCAAGGAAG
+ GTGTTGCTTTTACACTTGAATAAATGCATCTCGAAGTTTGTGGTAGTAATGCAATATACAAAGATATTTA
+ GCTTTACAATTATGTGCAGAATAATCATAGTAGAAAGTGCCATATACAAAGACAGAAAATCATTAGGTAT
+ AACACCAAATTGGATATCAATTAGGACCAATTTAAATTCCAGTGCTTCTCTTTCTGTATGCCAAAAATGA
+ AGAACAGTTTCGGCTTGCATGTCAAAAAAGCATAGCGACAGAGGGCAGAAAATGTTTTATAATTGATGCA
+ CGGCAATCACCAGGACGACAACTACAACAAAGGCAGCAAGAGTATTGCATTTGTTGCCATAGGGAAAGTC
+ AGTCAAGTGGGAGCAGACCCCACCACCCCCCCACCCAAATTTGACGAGAATCTGAATATTTCTGCTTTAT
+ GCCTCGTAAACAAACTTCACCACCGGGAGTCAAGCTAAAAGTTCGAGGGTGTTGCCTGGCAGTCCGCTCT
+ ACGCCCCCACCTTTGGGGGGCGTGTCCAATAGCCAAGAGCTGGCGACATGACACGAACATGCAATTAAAG
+ TCGAATATATTTTTATAAAAATAAATATCCGCTACGTCGCGCCATTTCACCTGTATATACCCTTTAAAGC
+ AGTTTCGATTGGTAACGCCAAGTGCTATCAAATTAAACATTTTCAGACGGACATCAGCACACCCACGTCA
+ TCCCAAAAGAAAACACACCCACACACACAGCCACAGAGCGCCCTAAAAAGTATGCAGCGAGTTATGCTTG
+ CGGAAATAAACGGTGGAAATGGGAACGGCAGGAAAATTGTTGCTCCAACCGTCTGTGCAGCACAGTGCGC
+ ATTGAAAATCCATTTACAGTCGCTGCATTATGTTATTTTGAGTCATTTACCAGGCGTCTGTCTCTTGTCA
+ CTGGAAACGAACTGAGCTCGACCCGAAGCCACCTGCAAAAATGCATGTCAGCTGGGAGTCAAGTCCTCTT
+ TTGGATACGGGCTCAATGACACTATTCTAACCATCATTTCCCGAATCCATGAAAGGGGTCCTTCGCGAGG
+ CAGCAACATTTGCAAGGCAAGTTGCATACAATCCGCCGACAGGCGGACTCAACTAAAACTTGTTAATTGG
+ AAACAAAGCTATGAGGAGCGTCTTGGATAGCGGAACAAATTCGGTTTACTACTATAACATCAGTATATTG
+ AAAGGCCACAGCACCGTTTGCCAGTTTAAAAAAGTTCACCAAAATTAAAGTAAGCGTAGAATGAATGGGT
+ ATTCTGAGTAGACAATTCGTGATTGAAAATAAATTGTTTCCAAAAAATGTTCAAAACGAATCTGAAAGAA
+ TCTTTTCTTGAAGAACACAAATTGAAAGTTTGTATTGAGGGTAACATATTGATTCAGAATGGTCACTAGT
+ CGGAACTGAGAGCACTAAAGCTCAACCTCGAACTCAACGGGAACGTCCCAAACACAAAGCGATTCTTTCT
+ CTACCAATCCATCTATCTGACACCACTGCCACTCCCACCTGCTCAACTCCAGCCGGTTAAAAATGGACTT
+ TCCCCGCTGTCAGTTTCAATAACATGAACCACCGACTGTCTGGGGCAATAAAAAGCAGGAGCACCACCTG
+ AATCCCGGAGTGTCATGTGCGTAGTCGGTACGGCTGTCTATCCTTGTCTATCCTATTATAACATTGCCTT
+ TAAGCCCTGGTAGCAGTCCGACTGACAACTGAGGAGGATGAGCACATGCACTCATCCAATGACGCTTTTG
+ ACGCGGTTCCATTTCCCATTTTCCCGACTTGCGTCGCTTTAATTATTCAGTTTTGGAATATTTAATGGGC
+ CGAGGGACAGTCGTCAAAATCAAGTTTAGAACCCAAGACAATTGCCATCGTCATGTTTTTTATGGGAATT
+ GAGATCGAATCAAAACATTTGCGTAACAATTTGGCAACATGCTGAATTTCCTTCTCTTTGGTTGTGGGAT
+ GATGAAACGGATTCAGATACAACCGAAGCTTCAGCTGCAGATACAATACGTAATAAACCGACGCCTTTGC
+ TTGCACGCTTTCCAAAATGAAAATCAATACTAGCAAAGGGGTGGGTGCGGAAAAATGAGTAGTCACCCAG
+ CTCGAACTCTTGAGTACATTCTGTTGCATATTTTATCAACTCAACTGCGAAGTCATTCAAAGGTTGGTAA
+ ATACATGTTTAGTTTGGAAGAAAGCAGCTCGATGCATTTGGGGACTCAAAATTTCATCTTTTGATGATTA
+ AGTTAGAAAAGAGAAATATAAGATTCTATTTCGAAATTCCGCTGGTCGTCAGCAACGCGGGTTTTTTTTA
+ TACTTTCTTATATGCTATAAAATAATTTGAGTTGGGAGCAATTGTGATTGACTTTCTTAAAATACTATCT
+ TTAAATAAGAGATTACAATTAAACAATATAAATAAAGCCGTTGATTGCCACCTATTAAAATTAGCAGTAA
+ AACTAATAACGTAGCAAACGTGAAAGAGGACACAAAATTCCGTCTCTGCAATAAATCCACATCAGACTCT
+ TCATAAACCAAATATGCAATCCAAAAACTCAGACAATGGAACTTCGACCAAAAGCGGTAATTAAGTTTGG
+ CAATGAAACCGCATCGCATCAAAGGCAATTTCCTTTCCAGGCCCCGACAGTTAACCTCCCAATCCACTCC
+ CACTCCTCCTCGTGCGTAATTGATTTTAGTTATGACTTTCCACGCTTATGTGCGAATTAATTGATTTCCG
+ AAACTTCAACAGAACTGCTTCGGTTGCGGGTCGCGGGGACTATGGCTAAGGTTAAAGCTAACCTAAGGAC
+ TAAAGAGAAACAGACACTCATCTAGGTGCTGCTCGAATTGGAGCTGAGACTCTGCAGGGAACTGTTGGAT
+ GCGGAATTCCTCAGCGTTTCCCCTGCCAAGCTGCACAGATTCTGGACTAGAAGTGCCGAGGAGTTCGCAG
+ ATCCTGAGTTGCGATTAAGCATAGGCGAGGACATGGCTTTGGCCGGATTGGAGTTCGAGTTGGCTAGATT
+ CTGGTGGTGGTGCCTCAGGGGCTGGGGCGAGGTTGGATTTGACAGGCCGGACTCGTGGATGGGCGATAGT
+ GTGGGAGATCGTGTCCGCAAGAAGTGCTTCCGCCTCTGTCGGCGATAGACATTCCCGAAACTGGGCAACG
+ TTCGGCTGTTGGTCTGGCTGTTATGCTGACTGTGCTGCAAATTGCTGGCGAACCCCAAGGTTTCAGCCAA
+ CTCCGCCAGCTCTTGGGTGGTCTGGTTCATTTTTCTCCTCGTAGGCGGTGGCAGAGCAGGCGGCAAGGTC
+ AGCGTATAGGTGGTCACGCTGTCATCCCTTATCACGGATGTGGGCAGCAGCATCAGCTCCTTTTTGCCGC
+ ACGAAGGGCTCGTGCTGGTGCTCAGGTCGCTGCTCTCCAAGGAACTTCTGCTTGGCGAACTTGCGGGCGG
+ GGTTGGAGTGGCAGTCGAATTAGCATAGCCACGTCCAGCTGCCTGCAATTGCAGCGGACGTATTTGATTT
+ TGTTTTATTGCAGAGCCACCGATATTCTGGTGCTCTTTGGCAGCGATACCATGATGGGCCCCATGGCGAC
+ AGCGTGGTCTTCGATAGCGTCCCAGTAGGCGCAGCATGTAGCGGAGACGGGAACTTCTAGGTGGCGTAGG
+ AGTGGCTGTTGTTGCCTTCAGAGGCAGCTCCTGGTCCAAGCCGCCGTTTAGCGTGCGTATGAATTGGATA
+ GGCAGTTCCTGGGCGTTTAACTTGGCTGCCGCTGCTGCTTCCTCGCTTTCGCGAAACGTTAGGGCAGCAA
+ GAAGGTCATTAGGCAAGTCGGGGCTATCTGGAACCGCGGCACAGCAATTCCATTTCCTTCGCCACCGCTG
+ ATGCTTGGAAATATTCCCGGCTGCTGTGGCCGAAGCGGAGGAGCCGCCAGTTTGACTGGTTAATGTGCGA
+ GTGCTACTGCTTCCACCGGCGCTGCTTACAGCTCCTGAAGATCCTGTCCCTGGTCCTGATCCTCTTCTTA
+ GGCGGAATGTGCAGAGAGTACATTGCTCGGTGTACTGCAGATAAGTCGCTGGTCTCAGATGACGTGGCTC
+ GGCTGAGATCAACGATCCTTTAGCCAAACTCACCCTGCGCTGCAGGGAACTAGCTGCAAAGCTAGAGCAA
+ CAATGGAAGCTACTCAGAGTATCCGGTTCAACTTGGATTTGCGGAACTGCCTCCTCCAGAAGCGAGCAAA
+ CATAGATGGCCTGCCCGCTCTGGTGGAACTCCCTGGAGCTGGCACAGCAATGCAACCGCAGGGATTGCTC
+ TGTTTGACCAACCGATTCCTGTGAGTGCTGGCTTGGATGTGGGGCACTGGAACAGCAGTAGAGCTGCTGA
+ CCTCCTGGCAAGGACTTGGACGGATTATGTGGCTCGGGCAATGAAGCCGAGAAGTGCACGTTGCCATTTT
+ TGGGCGCCCGCACGCCGGGAGCTCCCTCCAGAAGCTGCTTGGTCTTGGCATCCTGAGCCTGACGGTGGTT
+ TCTAATGTATTCATAGGTGGTCAGTCCCAGGAACGAGATGTAGATGTGAAAGAAGCATAGGTGGAGCAAC
+ AAACCCGCACTCACTGCGGCGAGCAGTCCCAGAACTCCCAGCAGAAACATGAAAATGGTTTCATTTAATC
+ CAATTCCGGTCACTACTGGCTGCGTTTCGGTGTGATTCGTGGGGCTAATTCCAGGCCGCGTTGCGCTTGC
+ TTCTATAATAGCTGTAAAATTCTCCAGAAGGGTGGGCAGTGTCGAGATGGTCATATTTGCCTGCTCCTCG
+ TCCCACATTTCCTGATGAACGTCCTCCTCCGAAGTGTGCTGCTCTATCAGCATCATGGTGCCGTTGCTCA
+ GGCTTAGGGTGATGTTTATGAAGTCGCCGCTTTCAATTGTGTGGCTCGACTCCGTGGGGCACCAGTAGAA
+ GCTTAACCAGTCTGGTTGGATATAGTAAAAAACGATCTGGGCCACCACCGCGGCCACGATGACCAGGGTG
+ GCCACCACAGCGCTGACCACGCACATCAGGAAGGCCACATAGTTACGCGATCCGATGCAGTGGTTCAGCC
+ ACTTGCAGTGGTGATCAAACTTGCCCACGCACTTGTTGCACACGGAACAGTGCTTGGTGCGGTTCGAAGA
+ GGTCCGGATGTTGCACAGATGGCACCTCCCGTTTTCTATTACGTGACTGTGCTTCGACCGGTCAAATTCT
+ GGGACAATCCGATCGTTGCGATGCACTCGCCGCAACTCCTTGTCCGCAGGATCTGTCAGTAAAGCCGTCA
+ AATGAGAGGCGATGTGCACCAGATAGAGCCCGGTGATTAGTCCGTAGAGCGGTCCTTGTATGCGGGCATG
+ AAAGGCCGGAATGAGCACCCAGTAGCTAGCCACTCCAAACAGGAGGAGGACGAGCCAACCAAAAATTTGG
+ AGGGGATGCAGTGGCAGCTGTAATCCGTGTAGTCGTCTACCCTTCCGGTGCTGGACATCAGCGATGTTAC
+ TCTGGTAGCTCACCAGCTGCGAGAGCCGGCACAAGTGCAGGGGTTTTTTATTTGTCTCAGCCTGTTCACC
+ CGGAATTATATTTTCTGGGGAATCTTCACTTCCCAGGGAATGGGGCTTCCGTACTGGAGTCACTACTCCC
+ TTTGCGGGACTTTCGCTGTGCGACTCCGTCAAGCCGGCAGTGCTTATGGTTATGATGTGATCCGTCTCCG
+ ACCTGACGCCGTAGGCTCCTTTGGGTCCCGACTTTAGTCCAGCTGCTGTTGTGGACATTGTGTTATTGGG
+ CCTGGAGATAATGGCTCTGATGATGATGATGATGTGTGAATGATGAAAGGACCTGCTTGACAGCTGTACA
+ TTACATTTAATGCTAGACCACGCCCTCGACGAATGATGCAATCCAGAAATGGGAAGAATTCATATAATTC
+ CCAACCGATTTTGCAGCATGTTTTAATGGTTTGATTGCGGATTACAAAAGTGTATTAGGCATCCTTAAAC
+ AGTTTTGAAGTTGTAGCTTTAGAGTCCAATTAAATGTTGTTGCCTTTTTATTGTCTTCTTTTAAATTTGC
+ ACTACTTCACTTTGCCTGCCATTTAATATTGCATCCTTCGATTGGCTTATTTTTACGGACGAAGCTTTTT
+ ATAAATAATCTTCTCCACAACAGTTTTTTATGTTGATTTTGTTCTCTCCGTCCGTCACACACATACACAC
+ AATTTTATAGTTATATATTTTCATTTGTTGTTGCGAAGTACAAATGGCGCAGTTATAGGTTCGTACGTAT
+ ATTTATTTTCGTTTTTCGCTTAAGTCCACTTTGTTGTTGTCGTCCCTGAGAGGGGGTGGTTACTCTGGCA
+ GCGGGCGCAGAAAAACAGGATGTTCGCCACCCCCCTTTTTGCGGAATTCCTCTCTATGGTTTTCCTTCTC
+ GTTTTGCTATTTGTTTGTCTCCCACACATACACAGAGACAGGAAAGCGCAGGGACGCAGGGACGCATAGC
+ CGTCCCGAGGTAAAATAACAGTAGAACTGGCGAAGGCATTCGCGCTTACCGTTACTTGAGCGCACGAAAA
+ CGAACAACCGACTCCTTCGACCGACGCGACCAAACGAAACAACTCCGCACAGAGTAACCAACTTGGAAGC
+ TCGTATCGTTGATTTAAAACGAACGGTGCTGCAGCACTCAGAAAAATAACGACATTAAGTGCAAAACTGA
+ TAGTGGAAACTGTAGTGAAACGTACTTCTTTATATATAATGCTGAATTCCATAAATTCGTATAAGTTTTA
+ TATAATATATTACATTTACATTTTCAAGTAGAATTTTTTTCAGTGCTCCCTTATGTTCGACCAGGTTTGA
+ CGACCATTTCGCATTGCTAAAGCAACGGAGTTGCTTTTTTCTGTTGTCAAACAGAAACAGATGGGTTTAA
+ AAAACAGTGAACTATGTAAGCTAGTGTTCTAAGCTCAATTTCTCTCCCGTGGTTCGAAGTCGCTCTCAAA
+ CACCGAACCGAAAGCTTCGTCTGATTGAAAACAAAAAGCCTACCAGTTGAACGACGACGCTTTTCAATCT
+ ATAGTGGCAAGCAACCAGAGGAGGGTGAAAGGGAGAGTTGAGGACAGCTGTGTGCGGTTTTGCCGGTATT
+ GTAAGTCATAGGAAAATTATTAGCGGGAGAGGATTTTCATTGGCCCACCAAGGGGGTTTTAAGAAAAAGG
+ GCACCCACACTCAATTTACTTAAAATTCTATATCAGAATTTACGTTACAAGTCAAAGGCCTGAATTGATA
+ TGTGGCCAAGACATATTGTTAATAACTGTCTGCTTAGTTGCATTCAACGAATGTGGTAAACAGCCTGCCA
+ CTTATTATATTATCATTGTGTGTACCACATGTCTATAAACGTTGTCTCAATAAAAGTTAAAGCACTACTT
+ TTGATTCCCAAAACTAACTAGCCATTTAGCCGAATGACTCACGCAGCCATCCCTAGGGACCCATATCACA
+ GGAGGAAGTAACTATTTTGAAACGCTAAATGGAAATAGGAACACAGACGACCGCTAGCGATTGGCACGCA
+ CCTTTCATTTTCCAGCATAAGTTTGCCTGTTTTCGGATGCCACCATCATTTTTTATTTATTCCATCGGCA
+ GCGGGGTCGGAAAGTAAGAGGGGTGTCCTAGGTGTTAGATGAAATGGAAAGTACACTCGAGAGAATATTT
+ GGAGCACGTGCTGCAGCAAGTACATTTCAGCACTTGATGTGATTTTATTTACATGGAAGACGGCTAGTGA
+ GAGTGGGTGTTCTTTTCCAAGGAAAGCCCTACGCAGACATGTTGGCGCCGGACCGAACGATTGGTAAATA
+ TTTATGCCCGAGATGCCCGCATCTAGAATCATCCACGGACGCCAAACTGGGTCAGCGGTCGGAAAAAGCG
+ GGTGGAACATAAGCCCGGATAGAGACAGCGAAATATTGAGGAGGATAGTCAACCGAGGATTTATGTAAGC
+ CGAACTAACGCCCTGGAATCTGCTGGAGCCAGGGTAATGACAGCTTCGATCCCGATTCGGCCTCTTAGGA
+ TGGGACCACAGATTCATGCAGATAGCTATAAAACGGTTGTTGAGACTGCTTAAGAATATATATATTTTAT
+ ATTGCAAACTATTGACTAAAGTCAATATACAATCGGCAGGGAAAAAGTATAGAATATTGTTAAAGTAGGC
+ GGGGCTACTACATTTTCATAAGGCACTGTTCGAAATTAGTTTTCTTGGAACGCTCAGAGAGTAAATGTTA
+ AGCACAAATAATTTAGGCTACTGTAAGTTTAGAGCGACAAGATGATCGATATTTTGTCGCTGCCGCGGCG
+ AAATAAGGTGTCCGGAAACCCGGCCCTGCTAAAGATGATCTCCTACAAGACTGGACTACCCATCAACAGT
+ CTACCCGGATGGGAGCTGATCCCTCTTAATTGCAAGCTGCCAATGCTCAAATGTCCCGGCAATCAGGTCA
+ TATTCTCCAAGAACAAGATCGGACAGGACGTAAGTGCTACCAGTAGAAAATCAGCTAGAACCTTACTTTA
+ TCATCATCATTCATACATATCCACCAGTTCAAGAGCGGTAAACAGGAGTTTGAGTGTTCCGTTACCGAAC
+ ACATCCCGGAGTACAATCCGCTACACGACTCCAACCTAAAGACGTTCTACTCCAATGAGCGTAATCTGAA
+ GCGGTTGAGGGAAAACGGTGAGATAACGCAGGACAACGATGTAATATGCAATCTGAAGGACTTCAATCAG
+ CATCGCCAGGAGCTGCACAAATCGCAGTTGTACTACATTTTGCAGGCATACAAGCGGCGCGAGTCGGAGC
+ AATATGATCGAATGCTGATCGCCAACGCGGAGTCCATCACAAAAAAGGATCACCAGAATCTCGCAGCCCG
+ TCACCAGTGCACTGAGGAGGTTCTTGCCAGAAAGAAACTACAGGAGCAGGAACGCCACGAAAGAAAGGTC
+ CATCTGCTGAATATCACATATGAGAAGTTTAAGCGCTTAGAGAACCTGGCCACCATGCAGAATATGTTGC
+ TGGAGCACCGCAAGATGCTGACAAACATGCGTGTAGCTGCCCACATAAGCATGTGCCAGGATTTGATGAG
+ AAAGCTATTGATCAAACAGAAGAAGCTCTTCCAGTTCAAAAAGGATCGGTTCAACAAAAACATGCGAATC
+ CTGAGGAAACAACGGCTGGTAAAGAACACTGAGCACCAGATTCAGTCGTGGAGGAAGCGACTTGATGAGC
+ GAATTGCTAATCAGCGTAGGATCGAATACCTCCTGCAGGAGGTGGAAAAAGAGCGAGAGGCGTTTATAGA
+ CAGGCACAAGGCTCATTACAGAGAAAAGTGGCAACGGATTCAGGACGAGATTAAGGAAAGAGCTCAAAAG
+ GCCATCACTGCTCGTCAGCCCAAAAGAAAGCGCCGCAAGAAGAAGAAGTCGACACTTCAGGAACGCAAGC
+ CATCATTCTGCGATGAGTATCAGGCCACCTTTGAGGGATTGTTAGACAGTGATCTTTGTTACGCCTTGAA
+ TGCAGCCATTGCCATGGAGGGTCAGACCGCTCTCAGCTTCGCACCAGACGACCCCATCTATAAGGCGGCA
+ CAATATATACTGGACTACATAATTTCTGGTTTAAACGACGATCTCAGCGAGGATGAGTGTGCCTTGCAGG
+ TGCTGATCTCGCGCATTAAGGATTTTGTCTGCGATGCAAAGAAATATGTGCACTACGTAAGTGTTAATAG
+ CAGTCCCTCTTGACATACCACTAATTCATTCCGCCTGCAGAAAGCTTATCAGATCATTGGATTCGCCAGA
+ GACCACAAAGCCATGGAAGTGCCTCCGTCGATGGCCAAACAGCCGAAAAACCACTCGCGCGCCTCCCATG
+ TATCATTTAGCGGTGTAGCCAGCACCATTGGCGTGGGCAGCTACGAGATTCATCCGTTCGTGGACGTCCG
+ CCCGTGCAGCGAACGTCGGGCCACTCCGGCGGGATCATTAGCCTCTCTGGTTGTCAGCCAGATCGGCGAA
+ CAGGTAATACAGGACAAGGTGCGCCTGCCGCATCTAAATCGCAACCAGATCGTGTTCATAGAGCACTACC
+ TGGTGAAGTTTAAGCGGGATCTATTGGTGGGTCTGGACAAGCTGGTATTTGCAGCGATTCAGTGCCACTT
+ TGAAAACCGTATGATGGAGGTACGAGAGGAGCTCCTTCTGCTTGACAGGAACTATTTGTTCGAGCAGATT
+ GCCAGGGGTATCCTCAGCTATGCGGTTAATCCGCTCAACTATCAGTCGGTGCTTAAGCTGGCCGTGAGCG
+ TCCAGTCGTGTGAAATCATCTGGGAGCTGCAGCAGACGATGCTCAAGCCAGGCATCGATCCCCGGGGCCA
+ GAATCACCCAGTGTCCTGCGGCACCGAGCAGGAACGCGAGACCCTGGCTCTCTGCATACCCTAGGATCCT
+ GTCAAGCAGACAGGGCAAGGAAAATTGATCTTAAAGCAGGATGCCTTAGCTCTGGCGGGAAGTAGCCCTA
+ AAAATTACTTGTATATTTCGTTTCCGAGGCACTTACATACTTCAGAGTCCAGGAATATTCATTTTCAATA
+ TGATGTCCTAAATTTATGTACTATGTTTTCTTTTATCGTTTAAAATGCTTCCTTATAAATAAGTTGAGTA
+ TAACTTTAAAAATCAGACACCTGGATCCTTTAGTTAAAAACTCAAAGCTCTTGAGATTTAATCGTAGAAA
+ ACCAATAAATTTAGGTAAATACACTTACCCAAAAGTTTTTTGCAAAGTTTTTTCACTGAGTTTCATACGT
+ TTTTCCTAGTAAACACTATTAATTTGATTTTTTATTCAAAAGCGTGGAAGCAACAGCTGGCAAAACACAA
+ AACCAGGGCTGCGTCGGCTGATACATTTCGATAAATAGGTCTGCCCTGGTTATCGATATTATTCCCCGGT
+ ATGTATTGTACAAAAATTAATTCAACTTCATTCTCGTTTTAAACAACAGAGGCGTAATTCCTAAATTCCG
+ TAAATATTAAAATGAAAGAACTAAATCCATTGGTATTGAAAATGTATTTATCTTTCACGTTCCTTTACAA
+ CTAACTCACGCTATAACTATTTAGAAAAATTAAACGGAGCTCTATAAGAATACATCATGGAGTTAAAAGG
+ GGCGCCCGGGGCGCCTAGAAGGGGAAATGGAAACACTTGAGGAGGTAGACTGGCTGCGGCCGATACGGAG
+ GCTTTGGTGCCTCGTTTCCGCTTCTGTTTGGACACAGGAGCTGGGTGAGGCTCTTCGCTGGACTCCGAGT
+ CATCGCTCTCGCTGCTGTCATCTTCATCTTCGTCGTCATCTTCCTCGTCATCTTCTTCGTCATGATCTTT
+ CGGCTCCACCTTCATCCTTTTCTGTGAAGACTTCTTTATCTTTTTTATTGACGCCTTTTTGTCCTTTTTG
+ GGTTTTGCTGAAACTGGAGCTGTGACTGTGCCAGCAGGAAATCCAAATCCTTGCTCGCAATGAAAGGCAG
+ TCATTTGCTGCATGGCAAACTCCACAAACGACTGGATGGCAATATTTAGATTGGGCGGGTTTGGACAGTT
+ TTTGAGACCATGATAACTACCGGAGCAATTACGACATATCATCTGACACTGGAAGGAGGTGTGGCCCTGG
+ AAGAGATTTTTTTAAATTGGGTAACATTCTTTTAAAATATTTACCTTCTTGTCGCATATGCCACACACAT
+ CCACGGTTTTACCCTTGTTTTTTTGCTTTCTGGCCTTCTTGTCGTCTTCAGGTTCGGTGCTTTCCTCCTC
+ ATCGGTAATGGTAAACTGGCGCTCCTGAGAGCCCATGCAGACAACATCCTCCTCGGTGTTCTTTTCCATC
+ TTTTTACTCTTTGCCGGCGGATGACTCTGTTCATCATCGGTGTCGCTGTCCGAAGTTGAGGAGTCGGAGG
+ ACGAAACTGGTTTTACAGCCTTTGGTTTCGGAGTTGATGCTACAGGTGTTTTGATGGCCTTCGCTTTTGG
+ GGACGGCACCACCACTGCCTTAGTGTTGACTACCATTTCCCCTGGTTCGGGTTCAGACTCCTCTCCCGAA
+ GTAGATGACGACCTAGAGGAGTTAACCTTCTTCTTTTTAGGAGATTTGGGCTCCGCTTTGACAAATTGCT
+ TTATTTTTGACTTGTGCTCCATTTCTTTCTCCTTCTTGATATTGATTAGCGGCACAGTAGGTTCTTCTGG
+ CGTAACAGCCACATCAGGTGGTGCAACAGATACAGGTGGTGGTGGCGTCAAGTCCGCAGCGAAAGTAACA
+ GGTGGCAGGCTCTCCTGTCTGAGAGAGGAGGGAGCAGGCGAGGATCGAGGCAGAGGTGGGTCTTCGGTAA
+ AGTCCCCCACATTATCGAAGTACAGCATGTTACTTTGGCCAGGACTAACATGCTGATCCTTAGGTTGCCA
+ CGAGTTGTTACGGCCACCACGCCTATTGGAATCTCTGCCGCGGTTCCCTCGCCTGCCACCCCAACCACCA
+ CCTCCTCCGCCACCGCCTCTATTTCTTCGGCCCCCTCTCTTGTTTGGCTGATGATTATCCAGCTCCTGTT
+ GGGGATCTCTGAACTTGTTAAACGCGTTTCCATTCTGCCCACCTTCCGATCCAGCGTCTGGCCAGTTTCC
+ ATTGGCGGCGCGATTTTGGCTGTGGCTGCCTCTTCCCCCGCCTCCACTGCTGCGCCTCTGCTGATTGTTG
+ CGGCCGTAATTCGAAAACGGTTTTCTTTCCTCTCCTGAAAGGTTCCAGCCGGATTGTCCTCCACTGTTGT
+ GCATTATGGAATTGTTAATATTTATAAAACCGCCTAGTTGCGGCGCACGTGTTGAGCCGATTGGGGTTAT
+ CGATAAGATCCGATTGTTGGTGGGACTGCCGAAGTGGCTTCTTTCAAGCCAAAACTGCTATTCATTATAT
+ GTATATTAAGTTTGAATACCTTATATATAATATAATATATATATATAATACTGTGACAATATGTGACATA
+ ATACATGTAATGGACTAAAATGTGAAGTGACCAATGGAAGGTTTTTATAAGATTTAACATATATAGCTAG
+ ATTCGATAGTTTCTCAAACTGGCACCTCAGATGGTCAGATGGACGATATTCAGTTTAACCACAAATAACA
+ ACGCTATGAATTCTACCAATCCGAAGAAAACAGAAGATAATGATCGCCATGAACGTCAATTGCAGAGCCG
+ CACCAAGGACTGGGGCAAAACCAAGTTCAAGCCAAAGAAGTATGTCCAACCGAAACCAGCGCTCGTTCCA
+ CAAGCTACTGCGACGCCCTGGCAGCATGTGAAGAACGACATAATTACGGATTCTTCGGACCGGGGACACC
+ AGGATGTGGACAGCGAGGACGCAAGGCAGTTCATGCAGCAGCGTCAGAAGAACCACCGTCGAAATGTCAT
+ AGAAGCCAACCGGTCGCAGGATACTACATGGGAGCCCTTCAACGATGAGAAGCCCTCCACGGAAAGAAAA
+ CAACAGCTCTCCACGGACGTTGAGAACTTCACTTTTAAGGAGCGGAACTTTTTCCGAAAGCAACTCACTT
+ TGGGTTTCAATTTAACGAAAAAGAATGCAACACTTAAATCTGCCCTAAAGGACTTGAAATATAGACAGCT
+ GACAAAGGACAAGTTCGAATTAGAACGTTCGAATCATACACGTCGAAATGTGAAATCATCAAATGCGAAA
+ GAAGCAAAGGGTAGCCATCCCTTTCAGAAAATGCGAGATAATGCACATCCTTATCGAAAGAAGGGACCAA
+ ATAGGAGAAATCCGTTTCAGAAAGGGCCACATAATGAATAAGTTTAGCTTATTTTCCCTTAGGTGACTTC
+ ACAACCCCAACTGGCAAAACATGAAGTTTCAATTAAAAAATAAATAAAAGATTCTTTGTCGGGTGACAAA
+ TCAGAAATGTATACACAACATTACTACACACTTTATGCAAATCTTAAAAATAGTGGTACAAATACATGTG
+ GAATAGGTCGGCGAAAATAAATAAACTAAACAGAGTTCGGCTCCTCCTCCGTTGGGAGGAGCAAGAGGAG
+ ATTGAAGTGGCGCTCGCTGCGCCATGGTTCCAGCCAAAAATCGTCCAAATGAAATCTCAGCCATGTACAT
+ TGGCAAGCTTGGCGATGAGGTGGTTAAACTTGCCGTTGGTGGTCACAGACTTTTTGGCCGATCGCACTTG
+ TTCCGGCGAGTGCTGCAGAAAGTAAACGACGATAAATTCGAGTGTTTGATTGGCTTCCTTAGGGTACATC
+ ATGTTAAAGGTATAGTAGTAGCAGATTAACTGGGCCAGAATGTCCGGCAGGTCTTCGTCTTTGGCGGCGA
+ ATGTGGCCATTATCTGGCCTTCAATGTAGACCTTCGCCTCCATTTGCGATTCCACGCCGTCGGCCGTTGT
+ TATGGGTGAATCTGTGGGAAGATAAATATTTTAAAAGTATTTAAACACTTTTAGTGATATTAATTTTTGT
+ GTACTTACTGACTAGAGCCACCCAGGGGGCGTTTGTGGGATTCGTGCTTTGCAGTGATTCCTTGCTAAGG
+ GAACTGTTCTCGAGGTGCTTGAAAATGTAGTCGGGATCCTCATTAAAATAGTACGCTATGCCACGCAGGA
+ AATTAGCGTTGGTCTCGTCCAAAGAGCTGATCTTCTTGTTCTTTGAACTCTTAAAGAACCTGAAAAAGCG
+ ATCCTTTTCGGTAGCCAAGCGCTTCTCTAGAGCCCGGGGATCGATGGACATAAGCAGCTCAAAGTGCTGG
+ TACAGCACAGCCTTGTCAAAAATATATGGCCAATTGTCCTTAATGGCCGTTATATCTGGGATCTTTTCGC
+ TGTTATTAAAAAAGGAGCGCTGCAACGGAAAGCACTCTTTCATATATTCGATTATGACGGACTGTTCCAG
+ TGGGGAACTGCCTCGGTAGCTGGAGATTAGTAACTCCTTTTTGTGCTCCAGATCCCTGTTAAGAGCCAGC
+ GATTTTGCATCACCATTGGAAGCACCACCTCCGAATTTTCGTTTTTTATTAGGGATGTGGATCTCAAAGG
+ TTCCCGAGCTGCCGCGTTTCTGGGGTTTGTTTAGGGCATTGTTACGGTTGATCATCTTGGATATGAGCGA
+ TTGCGGAGTGGTGGCTATAAACTGTCCCTCGCGGTCTTTTTCGAGTAAGGAGTCGGGGTACTTTTCAGCC
+ GCCTGTTGGGCGACCTGCCGGAAAATCCGTATGGGAATGTGGGCGGATATTTCACGGAGAGCCTCCACCA
+ AAACATTCGCAAGTGTATTCAACCGCTTGCCCAAACTCCCCTTTCCCTTTAGTAGTTTCATTATGTCCCC
+ AGGCACCTTGCTCCAGGGTATCGAGAACTCCTTGAATAGAGCAGAACTCTTTGCACTTGATGGCGTTACG
+ CTGGACAGTGACATGGTTTCGTCATTAGAGACCGTCGAATCGTTCGGGTTCGACACAATACTGTTGTTGG
+ CATAGAAGCTGGGATCCACCGAGCTGCCGGCGCGTTCGGATCGGTTGAGGGGCGATGGCGGAGGAAGCAC
+ CACATACTCCTCCGACTCGGCGAGGAGCATCAACAGAATCTTCTCCTTGGCAGCGAACAAGAGCACGTCG
+ TCCTCGCAGATCTCGCAGCCGTTGCTCTCCAGGACAATTGTGTTGCCGCACAGGCCGTATTTGTGAGCTA
+ CCGAATACAAATATATTATTGATATAAATTAAATAAAATATGTACAATTATTTAATTTCTATCCTAGATA
+ AATATATCACCCATTGATCAAATTTATATTTTTAAATGCAGAAATGCTCTAAGCTTAAACCCAATAGATT
+ CTTATTAAAGACTGTCTACTGGTTAATAACTTCCAACTGGGCAACGTTCATTCGGAATACTGGATGAATA
+ GATACCCAATTCGTCGGACGTTCCTTACCTTTGTCGATTACATCCTTTCGAGTGGGCAACGACATGAAGG
+ TCTTCTTGATCTTGCGATCGGCGCTGCATATGGTAATCAATACTTTGTCAGCCAGCTCGGTCTTCGGCTT
+ GCCCTCGTCGTCGTCCTTCTGGCTAGCATCAGTGGAATGTGTCGGCTCTACGGCTAAAAGGTAAACGTTA
+ ACCAGGAAACTAGACTAGCTTCGAGCAAGTTTGCTAACCGGGGGCTTTCTCACCGCAGCTCTCTGGCTTT
+ TTCGCTCCTCCTGTTTGTACACCATTTTCGATTGTTGTTGCCTTTGCGAGTGCGACCGGCGCTTGGTTTG
+ CATTTTGATTCGGACTGATCGGCGCCTGCTGGGTGCTATGATCGCCGCCGGAACTGGCGGGCGGTGCGGG
+ GGCAACGTCCATGGCTTCTATTTGCGTTTGCGCGACTCCAACCAAGCCCTGTTATCCGTGTTTTTGGACC
+ GTGCCGTGAAATAATATTGCAGAATAGGGATGTAAAAACTACATCGATGCTTGGTGCGCTACTATCGCGG
+ TGTTATCGATACTCCGCACCCAGTGTGACCGTCGAGCGCATGGCATAAATAAATAAGCCAGCGGCCAGCA
+ TTGCCATATAGTCAAAATGTTGCGGGGAACACCTTTTTCGTTTGCTGATGCATTTCTACATATGATCATA
+ TTTCTTATTTTATGTTGATGTTATCTTATGTTACGATCGAACAAAATAAATCCGATTTGTTTGCATATCA
+ TTCGACTTGTTGCAGCTATGACCGATAATAACCGATGCCGACCGATAACATGCAAATCTCGCTGACCGAT
+ AACATGGGTATATTTAAACTGGCCCTGAATGGTCGCACATTTGTTGCTTCAGCTTCACGTTGAGTCGCGT
+ TTATTTTTGTTTTCCTCCTTGGTTCTTGTTTTTTTTTTCTCTTTTTTAAAAACACTGCAATCCTTCAAAG
+ GGAACAATTAAACCAGGATATCCCGAGTCCAACGAAAGCGCCTTCACGATGCACTGACGAACCGCTGAGC
+ AAGAAACGGGCATTCAGCCCATTAAAATTCACACAAGGCAGCTATTTAATGATTTTTATAAGCGGATGCA
+ GTACTTAAACTTTCCGCGCATGCCAAACATTATGTGAGTGACTCGCCTCTGGCAAATGGTGTGGGCAATT
+ AAAATAACTTGGTTATTTACAAACCGCAGGATGTTCCTGGAGGTTGCGATCTTATGCCTGTGGGTGGTCG
+ CAGACGCATCGGCCAGTTCGGCCAAGTTCGGCAGCACAACGCCCGCAAGTGCGCAGCAGTCGGATGTGGA
+ ACTGGAGCCCATCAATGGGACTCTCAATTACCGACTGTACGCCAAGAAGGGCAGGGACGACAAACCCTGG
+ TTTGATGGCCTAGACAGCAGGCACATCCAGTGTGTCCGACGTGCCCGTTGCTACCCCACCTCGAACGCAA
+ CCAACACCTGTTTCGGCTCAAAATTGCCCTATGAGCTGAGCAGCCTAGATCTCACCGACTTCCACACCGA
+ AAAGGAGCTGAACGATAAGCTGAACGACTACTATGCCCTGAAGCACGTGCCCAAATGTTGGGCAGCTATA
+ CAGGTGAGGAATCTTAATAACATCTAATGTACCTAATGATTTCAAAAGGTGGGGCCGAGTCTGTATGAAA
+ ATACAGATTGTCGCATTATTTTCTGATAAGGAGGTGCATTAGAAACAAGTTAAGCGCACAACTGTGATTA
+ CTTAATTACGCTTTGTGTTCAAGCAGTGAAAGTAATATGTGAATTGCTTTATCTTGGGAAGATTCAGATA
+ TATATACATATTCAGTTGTGGCTCAAGGTTTTCTGTAGATATTATAGTATTTCAAATCCATTTCTTCAAT
+ ATTCCGGATTAGCTCAACACACCCATTTTTACATGTTTATAGCCCTTTTTGTGCGCCGTCTTTAAGCCGA
+ AGTGTGAAAAAATCAACGGCGAGGACATGGTCTACCTGCCATCTTACGAGATGTGCCGAATTACCATGGA
+ ACCCTGTCGCATTTTGTACAACACGACGTTTTTCCCAAAATTCCTTCGCTGCAACGAAACACTCTTTCCG
+ ACGAAATGCACAAACGGAGCACGAGGAATGAAATTCAACGGAACTGGCCAGTGTTTAAGTCCTTTGGTTC
+ CGACAGATACGTCAGCCAGCTATTATCCTGGCATCGAGGGCTGCGGCGTGCGATGCAAGGATCCACTCTA
+ TACCGATGATGAGCATCGGCAGATCCACAAACTGATCGGATGGGCTGGCAGCATATGTCTTCTGTCTAAC
+ CTTTTCGTGGTGTCCACCTTCTTCATCGACTGGAAGAATGCCAACAAGTATCCGGCAGTAATTGTGTTCT
+ ACATAAATCTTTGCTTTCTAATTGCTTGCGTCGGGTAAGTTTTGAGCACTATTTTGCATTTGTATTCTTA
+ ATCAACCACGTATTTACTATGCAGCTGGTTGCTTCAGTTTACTTCTGGCTCGCGAGAGGACATAGTATGT
+ CGTAAGGATGGAACACTTCGCCACTCAGAGCCTACAGCCGGTGAAAATCTTTCTTGCATAGTGATCTTTG
+ TGCTGGTCTATTATTTTCTCACCGCTGGAATGGTTTGGTTTGTGTTCCTCACCTACGCCTGGCATTGGAG
+ GGCCATGGGCCACGTCCAAGATCGGATAGATAAGAAAGGTTCCTACTTTCACCTCGTGGCGTGGTCACTA
+ CCCCTTGTGCTTACCATTACCACGATGGCTTTCAGTGAGGTGGATGGAAATAGTATTGTGGGCATCTGCT
+ TCGTAGGCTATATCAATCATTCTATGAGGGCAGGACTACTTCTTGGTCCGCTCTGCGGGGTCATCCTCAT
+ TGGTGGATACTTCATCACCCGCGGCATGGTGATGCTTTTTGGACTGAAACACTTCGCTAATGACATTAAA
+ TCAACTTCGGCGAGCAACAAAATCCATTTGATCATCATGCGCATGGGAGTCTGTGCTCTGCTCACTTTAG
+ TTTTCATACTAGTGGCCATTGCGTGCCACGTTACGGAGTTTAGGCATGCAGACGAATGGGCCCAGAGCTT
+ CAGACAGTTTATAATGTAAGTGTAAATACTCGTTTATAACTTTTTCCATACGCCTCAACTAGATAATTCT
+ TTTGTTTAGCTGCAAAATTTCTTCAGTTTTTGAAGAAAAGAGTTCCTGTCGAATTGAAAACCGACCTAGT
+ GTTGGCGTTCTTCAATTGCATTTGCTGTGTCTATTTAGCTCTGGAATCGTAATGTCCACCTGGTGCTGGA
+ CACCTTCTTCAATTGAGACTTGGAAGCGTTATATAAGGAAGTATGTTTTACCATCCTACCAAAAGTTGCA
+ TTAAAGTTATCTGTACTATCGATTTTATAACCTTTGCAGAAAGTGTGGCAAAGAGGTGGTCGAAGAAGTG
+ AAAATGCCGAAGCACAAGGTCATTGCCCAGACATGGGCCAAGCGCAAGGATTTCGAGGACAAGGGCAGGC
+ TCTCCATAACGCTCTACAACACCCACACAGATCCCGTGGGGCTCAACTTCGATGTGAACGATCTGAACTC
+ TTCTGAGACGAATGACATCTCATCAACTTGGGCTGCATACCTCCCGCAGTGCGTAAAACGTCGCATGGCT
+ TTGACGGGAGCAGCGACAGGTAACTCGTCAAGCCATGGACCGCGAAAAAATTCATTGGATTCCGAGATAA
+ GTGTGAGTGTTCGACATGTTTCCGTTGAATCCCGCAGAAATTCGGTGGACTCGCAGGTATCAGTGAAAAT
+ AGCTGAAATGAAGACCAAAGTGGCGTCCAGATCAAGGGGAAAACACGGAGGCTCTTCCAGCAACAGAAGA
+ ACCCAAAGGAGAAGGGATTATATAGCAGCTGCCACTGGAAAAAGCAGTAGGAGAAGGGAAAGCAGTACTT
+ CAGTGGAGTCGCAGGTCATCGCGCTCAAGAAAACGACCTATCCCAATGCTAGTCACAAAGTGGGCGTGTT
+ TGCTCATCACAGCTCCAAGAAACAACACAATTACACCAGCTCCATGAAGCGAAGGACTGCTAATGCCGGA
+ TTGGATCCCTCTATTCTTAATGAATTCCTGCAGAAAAATGGCGATTTTATATTCCCATTCCTCCAAAATC
+ AAGATATGAGCTCTAGTTCGGAGGAGGATAATTCCAGAGCATCCCAAAAGATTCAGGATCTTAACGTGGT
+ TGTAAAGCAGCAGGAAATAAGTGAGGATGATCACGACGGAATAAAGATTGAAGAACTGCCAAATAGCAAA
+ CAGGTGGCATTGGAGAACTTTCTTAAAAACATAAAAAAATCTAATGAATCCAATTCTAACCGACATTCCC
+ GAAATTCCGCAAGAAGTCAGTCAAAAAAGTCCCAAAAGAGACATCTCAAGAACCCTGCTGCTGATCTAGA
+ TTTCAGGAAGGACTGTGTAAAGTATCGGTCTAATGACTCACTTAGCTGCTCCTCTGAAGAGCTGGATGTG
+ GCTTTGGACGTAGGAAGCCTTCTTAACAGCTCTTTTTCTGGAATATCCATGGGCAAACCACATAGTAGAA
+ ACAGCAAAACCAGCTGCGATGTGGGCATACAGGCTAATCCTTTCGAGCTAGTTCCCAGTTACGGAGAAGA
+ CGAACTGCAGCAGGCCATGCGACTCCTAAACGCAGCCAGCAGACAAAGAACTGAAGCAGCCAATGAGGAT
+ TTCGGAGGAACGGAGCTGCAGGGCTTGTTGGGTCATTCCCATCGGCATCAAAGGGAGCCCACGTTTATGA
+ GCGAGTCGGACAAACTCAAAATGTTATTGCTGCCTTCAAAATAGCAAGACTAAATAAGCAATTGATGCAT
+ TTACTTAAGGTTCAAAAACTCTTACAATATTGTAGTTTTTGTTCTAAGAAATCAAATTGTTAGCGCTGAA
+ AATAATCGTACAATCTTATCTATTTTACGAAATCGTAATATTGTTATGTTCACTGTTCAACGATTTATAA
+ GAATATATCGCTTCACTAGAATTGGAAACCCAAATGATATTTAAAACAAACAAATACGAAATTGTAGTAC
+ ACAAGCCAGAGCAGTTTACATGCGATGAACATTTAGATTCTTCTTAATCGATTACTGGAACAGACTGAGC
+ GAAACTAGAACTACGAATTACGAATACTCATAGTCATTAGGCTGCAACTTTATTTTACAGATTCATCACC
+ CCATCTAGCTTGTAAGCATTCGAATCTCTGTGTACGTTTGTGAATGACTGTTTCCTTAATCCTGGTACTC
+ ACGCCAAAGTAAATGCCAAAGAGGATAATAATTTATTTTCATTATTTTTCTTTGCCGTGGGTACAGGACT
+ TTAGATTGTAGATTATAGATTTAAGTACGATATAAATAAGCCTCTTGGGCACACAAATCGTACCTCAGAA
+ AGTGCCTTCAAGTTTACAAAATTATACATAATAATTTGTGTAACTAATAAACGATTTTAAATCCTCGAGT
+ CCTAGCCTTGCTTTAATTTCTGTTGATTTAGGAGCTTAAACTCCGGACCCCAAACGACGTTGTTGGCGAA
+ CTCCCCGAGCAGATAGCAAACCAGGTTGAACCCCACAAGTAGTGCCAAGAACACGTAGCGCAGGTATGCG
+ GGCAGCACTTCCAGAATGGGATACACCCACTCGCCACTGAAGTAGCGAACAATGTGCAGCCAGATGATGT
+ AAAGCAGGATGAAGGAGACGTTGCCCGTGATGCCTGCCAATCGACTCGGATAGCGGCGGAAGCAGGTAAA
+ CAGGTCCATAATGGCCAAAAGGGCCACATTCGTGTGTACCACGTGATTCAACCAGCTGCAAATATTGAGA
+ AACACAGGTAAATCAAAACTCGCCTCGCCTGATGAACAGAAAGTTTAGACAGGCTCGAAACAAAAGAGAC
+ TCCAGCAGACTAACATTGTGCATTGTACGCAAGTTAAACCGGCGGAAAAACATAAACACTTGCCTGGGGA
+ AAATCGCATCCAGCGCTGAGGGAAAGATGAGCTCACGGTCCCACACGTAGATGACCCAAAACGAGAGGCA
+ GACATTGTGGGCGACAGGAAAGGCAAAGGCGGCGAACACATAGTCCCTCACCGATCGCAACATGGATTTT
+ GAATCCCCGGAGACATTGTTATCGCCGAAGAGATCGTTCAGCAGAGCCAATGAGTGGTAGATGGCCTGTA
+ GAATGACGTCCAAGAAGGTAAGGTACTTGAACTTGCCGCCCCACCGCGCCTTCAGTTCATCCTCGTCTAG
+ CAAATCCGTGGGCCAATGCACCCGGAAGTAGTGAAAGTATATCCCATACGAAAACTGCGCTGCCGCCAGG
+ AGATGGACCAGGAATCTCAGGTATTTGAAGGCACCGCTCGTATAGGCATCGTTGCAAGTGTTCAACTGGG
+ CTTTAGTGGCCTCGACAGCTTCCTTGGCGGCGTTGAACTCGCGCACCTGCTTCTTGCTCTTGCCCATTTC
+ CTCCAGAAAAGGTGCAAAGGGCACCGCACGCTGAGCAAAACAAAACAAATAAAGCTAGCCAACAGCTGAT
+ TAGGGCGCAACACACGTCGAGTTTCATTCCAGCAAGGAGGCGTTTTTAAGCTAGAACTAGCTTTTTAAAG
+ CCAAATCGATATGATAGCGCCACTTGACGTTTCTCTGATCTTGAAAAGCAGTTTATTCCAAGCTTCCCAC
+ CTTAAAACAGTTTTCGCAGCTGATGAAGAGTTTAATCGCTTTATTATGGTACTAGAATTGAATAACAGTG
+ GTATTCAAAGATGGCGTTGAATCAGTGTGCTTGATATGAGAAGTTTAATCGAGAAGGCATTTTTGTATTT
+ TGGTTAGTCTAGTAAACTTATCGAAAGACGCGCGCGCTCAATGGAAACTACGGCTATAATTTCAGTTACA
+ ATGTATGCGTAATAAAAATATAATGAATATCATTAGCAAACGGGTTTCCATATTATGATTAAAGACTCCG
+ AATTCAATATTACTGGAAAATATATTATCGAGTTGATGTTTCAAGTTTCGTTTATTATTTCTCACATATT
+ TTGTACGCCTTCTTCAGTTAACTTTGCAGTACGATTTTACATACTTATGAAAAATTTCTTTGGCTGAGAA
+ GATCGAACAATATGAGCAAAATGTATAATCGAGACCTGTCAATCACTATTTGTATTTTGTGGCTAATTAA
+ CGCAACTACATCGAACAGAAACGGGTCACAGCCTCCTAGTTGGATTTGCGCTTGGCCAACTTCACTTCCT
+ TGGCCCAGACGGTATTGTTGAGGAACTCGCCCAGCAGGTAAAGTGACAGCGTGAATCCAACGACGGCCGC
+ AAAAAACAGGATGCGTTGCGGAAGCTGGAGAACCTCGAGCACTGGATACACCCACACACCCGAGTAGTGC
+ TTCACCACGTGAATCCAAACCAGGTAGGCGCCCATGAAAATGGCCAGTCCTGCGAGTCCTTGGCTTCGTT
+ TTGGGTACGACCTGTACGAGATGAACAGCTCCAGGATGATGAAAACCACTATGTTGGTGTGCAGGACGTG
+ GTTGAGCCAGCTGAAAGAGTCGAGCGAAGATATTATCAGAGTGTCATGAAAAAACAATGGGTGAAATCAA
+ GACTTTTCAGACCACTTTTTTAATTTTATCCCTAAATATATTATGACGTACACATCTTTCAAGCTTTGTC
+ GTAGCAAGCTATCTGAATAAATTAATTACTTTGAAAGTAAAACCAGAGCCCCAAAACGAGATTATAGGGT
+ CTTAAGGTTTAGTGTCTAAGTAGCATTTTATGAAGATGGTTTATTACTGAAATGAAAGGAAAAACGTTGA
+ TCTAATTCCTTCAAATGTATGAGTACTTGTTAGGATATATATATAATTGAAAGATATAGTTCCAATTAAA
+ TCGAACTTAAAAAGCCTGGATATAAAGAAACACAATTAACACAATACCGTAAATAGGCATGTCAGTGGTA
+ TAGAAAATGGATATGGCTTGAATTAGACATGCTTAGAATGCTAATCTGGTCATGATTCAATTTGTTGAGC
+ AGAATATGCCTTATGCCAGCCAGGCCACCTTGATATCACCAGCTTTCGAGGTCTTACCTGGGGAACACGG
+ GGTCCAGAACCTTGGGGAAGACTAGCTCCCTGTCGATAGCGTACAGTGTCCAGAAGGTCACGCCCACATT
+ GATAGCCACTGGAAAGGCCAATGTAGCCATCAGCCAGTCCTTGAACCTGCGAACCGCCGGAGGTTTCTTG
+ GGTGTCAGCTCATTAGTGCCCACGAAATCGTTGACCAGCGATACAATATAGTACAGTGCCTGAATTATCT
+ GTAAGTGCAAGAGCATTTGACGTGTGTGAGATAATGCGAAAGCGGCTAGATTTGAAGGGTTGCTTAAGTG
+ AAGTGGAAGGAATTACAGTTAGCGAAAAAACGTTGCACAAGCATTTCCTGTACAATTTCAGCGACAATAG
+ GAGGCGAGATGTGAGTTTGTTAGTAAAGCACTGAATTTGGAGGGATTCAATTAGTTGCTTTGCAGTGGAA
+ TGGTATATATATATATTTATTGTAAAAACTGCTTTAGCGAAAGTTCTCCATATAAGATCTTCAAAAAGCT
+ CTAACTTTTATACACTGGAGACCTTGACAAATCCTCTTCATCACTCAAGAAAAGCCCATGATTCTAACTA
+ CTGTCCTATTCATTTTCTCTGTGTATCTTAATAGATGCGTGCGTACAAGTAACAATCGGAGTGAACTTTA
+ AACCACGCTGCGTTCGTGATTCTAATGGGAGATGGATATTACCGCATCCAGGAACGTTAGGTATTTGAAT
+ TTGCCCCCCCAGGGATGATGGATCCTCATCTCTGGCTCGCTGGTGGGGAACTGCACGTAGTTGTAGTCGT
+ AATAGATGCCGTAGCCAAATTGCACGACTGCCGTCAGGTGGAGCAGGGTCCTCAGAGCCCCGTAGACGCC
+ CTGGTACACGGAGTTGCCTCGCACGGATGCCATTTTCCTGCTGCAGCTGCTCTGCTCTCGATTGATTTTT
+ CACGGCACCAAAACACAAACAAACCGGTCTGGTCTGTCGCTCCGAAAGTACTACTGCTTGCGAGTCGGAA
+ CCACCCCAAAAAAAGGGGCGAGCGGTGGAACAGTGTGCCCGAGCCGAAGCAGGGCCGCAATACCAGGTGT
+ TCGGATATACACATATATGTATGTACCCCCTTGTAGGGTTGTAAGCTACATCGAGATTTAATATGAGCTA
+ AAGTTTTAACATTTTGATTGTGGGCTGAATACATCTGTGAAGATGTGGATTCATTTTAAATTGTGACTAG
+ CTTTGTTGAATTTGTATGAATTTTTTGTTTTTAATTTATAAATTCGTGATGTAATTTTATGAAAATATTA
+ TTTTCTTCAAAACCATTCAGAAATTGATGTTGAAGTCAATTCTTTGACGATAATCATGAACGAAATCTAA
+ AATATTCACTCTCGTCTACCGTATGAAGCCACATATCATTCAGGTTGTATCAAAATACATTGTTCTAGGC
+ CAAAGGTATCTTTACTGACTACAAGCGATTAGATTTGAGTGTATGGGATCGAACTAGAACATCAGACCAT
+ TACAAATCAAAAACCAGTTATGCATCGCCTTCGTTTAACCGGTGTAGAGATTTTCGATATGAACGCATCG
+ GCTTACCGCACAAATAAAAGTTAGGAACTTAAATTTTCCGCCGAAGGGCACCGTGTTGGGCATGTCGAGT
+ GTGTGGAAGATGTACACGCCATAGTTGAACTGCAGCACGGCTGTAAAATGGAGGAGCAACTGCACCGCCT
+ TGTTAAAACCCGGCGAAGTGGAACCTTTGCTAGTCGATTTTGACTTGGGCTTGGCCATGTTGAATCTCCT
+ GGTGCCAGATATGTACTGATTGTGGAGTAGCCAGAGTCCAGTCACTAGCAGCAAGGAATATACGATTGCA
+ TACAGTAGTCACTCACTAAGCACACCTCCAAACAATCGTGAAACTCTTCAAAGTATTGCTACAACATGCT
+ CGACTGTTCACTGTATGTATTTTCGCTTTCGCTTTGAAACTGATAAGGTGCGCTTATCACCCGCACTCTC
+ AATCGCCGTAGTACAAAGTATTTCCACTTCAGAATGAATTGGCAGAAGCTAAAATGAAATCCGAAAGCGG
+ TCGCTTAATCCGCATCGGTACGCCTCCGTCCCACGTCCCTAGATCCGTGCATATCTACGGATTCATATCC
+ TATGGCAACTGGGGGAGGCACGTGCCTTCCCAAGCGTGTCTATGAATAGATACGGATACACATGAGCCAC
+ ATTTATGAGCCGGGGGACAAAGGCTTCTGGAAATATCTTCGCAGCTAATGGCAACTATCGTTTCCCGGTC
+ CCATCACCACCAATCCACCCCCTGTGAAGGTCAAGGAACAAGGCCATCGCGACAAAAGGCACCGCTAACT
+ GAATTACCTGGTAAAATTATCAGGTGCTCTCTTGGTTCTTTGCCCTTTCGTTACACGCGATGCATCGATT
+ GTGCGTTAGTAATTGATTCACTGAACAATAATATCCGAAAATATTCACGCAGATCCGCCTACAACTTGTA
+ AATAGAGTTAATTACTGGACCATCTGCGCCCAGGAACATTTATAATGTAATCATAACAAATACTTTAATA
+ AGCAGATCTATTAATATACATATATAGAACACACAATCTTAAAATTGTACATCAGATTATACGTGATGCT
+ CCATTGGTGCTTTCGAATCAGGTTTCTATGTCTTATTTTTGAGAATCTTAATTAGATGGTCTCCTCGTCG
+ GTGTCCGCCTCGCAGGTTTCCAAATTGATTTCCGTAAGCTCCTGTTCATCCACCACACTTCTGGCGTCCA
+ GATCACCAGTCTCCATTTTGGGGACACTCAGGATTTCATCCTGCTCCTGCGACTCCTTGGCAGCCTCCTC
+ CAAAGCTCCTCCCTGCTCAAACATCGGATTGTCAAAGGCTCGCTCCCTCACCTCGCCACTTTCCGGATCG
+ TAAGCCATAATTCCCAGACGATCCACACCAGAAGCTCCTCCTTCACTGGATCCACCCTCTGCGCCACCAT
+ TGTCGAAGCGGTTAAACAGCAGATTCCGGCGCAGTCTCAATCCCAAGTGACGCCACCTCCAAAGACGGGG
+ GTCGTGGATCCACTGTGGTATGCGGTTTAGGTAGGGGTTCTCAGGCATAAAGTGCGCCAAAATGACCACA
+ GAAACCAGACCCACCAGTGCCATGCAGAAAAGGATGAGAACAATCGAGGAGAAGCTAACATTCGGATTAT
+ AGGGTCGACCAGAAACTTTTAACGTTGTTCCTGTCTTGTTCCAATTGTGTTCGTTTTGCTGTAGAAACTC
+ CAAGCTCCGTTCACTATATTTATGGCGATCAGTTACCACCGCCTGCAGGCAGTTTCCAAACTTCTGGGAG
+ CCCACAAACTCCACGTGTAGGCCGATCTGATCCTTCAGGCTCTCCTGGCTGATGAGGTTACTTATCTGGG
+ CCACCAACTCCTTTCTACTGCCCTCGGTGCAGTGGGTCGTGGGCGTGGATAGAATGGCCCCGCAGATTAG
+ GCAGCACGATCCCAAGGGTCGAACTGGAGACAAGCAGTGGGGCGTCTCGCACTGCTCCTGGACATTATGG
+ CAAACGGGTTCCAGCAGTCGCTCGAAGTCCTTGTGGCAGCCACACAGCTCTCCTCTGTAGTACTCCACCT
+ GGACGTACTCGGCATTGTAAAAGAGAAACTGGCCCAGATCTCTGCTGATAAGTTGCTCCAAGTACGTTTT
+ GGAAATGGAAGAACCAGCCAGAATAAGCTGTCCCAGCCTCAGATACTGCACGTTTTCTAGGTCAAAGGCC
+ AATGGTCCGTGCCCCTTGATTATGACCTGCTCGTCATCACAGGGAATCCTCTCCAGCTCTGGTGTGAATG
+ TGGAAAATTCCTTAGATTTGTCCGTCCAGGTGCCAGGATCGAACCATTTACTCGACTTCGGTGGCTTCAA
+ ATAGGCCTTATTCTCATCGCTCTCACAGGAGGGCTGCTTATCAGATCCAAAGGTAATGGTGGATTCCTCT
+ GCCAAAAGGATCGCCCCTTCTCTGGGGAAAACCAAGCCATCAATGGATATGTCCTCGGGCAAGGGCAGCA
+ GAGCTGGGTAGTACTCTGGAAAAACGACCAAATCCTGTGCACAAGGCAAGTGGTCATCTAGCCAGGCGGT
+ GGGATCATTGAAGTCCATTCCACCGCCATACCACTTGGTGGCCAGTGCCACATGGAGCCCCACCAATGCC
+ CAGATCAGCCATTGCCAATGCAAACCCATCGTGGAAACTCAGTGAACTCTAAACTAAATCTGAAACGTTC
+ GGAGAATTCCATTCGATGATGTTGCCTCTTATTTGGGGGCGGATAACAATCAGAATTGGAACCAACGAGA
+ GCAAATAAACACAGGGGTGATGGACAGCAGATGTAAGGGAAATCAGGCTGATGGGGACAACTCATACCCT
+ ATCATTTTTGGGAACATGTTCTTATGTTACTTATAGTTACTTTTCAATGTTTATAAAAATATAAATGGAG
+ TTTGTATATGTATATTGTGTTTGTAAATGACATTTGGAAAAGCATGGAATTCATGCTTTATATTCTCCAC
+ AAAGATTTTGCTTATATATATATATTTTTTTTTTATTCTAAACACAGCTAATCCTATTAGTGGATCGAAA
+ CCTAAATCTTTTCTTTAAATATATTTTACTAATAAATTGTTTCGAATCGAAGAGAATTTGGCAAAAAGCG
+ TACACAGATAATTTCACGTTTGCTTCAACAATGCAATTGTTTGTCAGAACATAGTTAGTTTATTTGTATT
+ TTGATTGCGCCGATATAAACAATTTCAGCACACCAGATTTTTAAGATGCCCAGAAGACCAGAAGAAAGGT
+ AAAAATTCGACAACGAAAATAATGAACCGGATGGTAGTGGCACCGAAAAGTTCTCGTGATCGTTTCAAGG
+ GACTACATAAAAGAAAAAGATCTGTAGATATAAAGCACTTTATGCTGACCAGATCAAAGTACTTTTTGCG
+ GGACAGACGGCGTTAATCAAGGGCGAGCAAGGTCATGCAATAACAAACTAAGATGTTCCTGGAAAGACGC
+ ACGGAAATGGAAAGCCGTGGTGTGGAAATATGTACATATGTAAAAGCATCGTATCAAAAAAGAGCACAAT
+ TCCTTCTCTTGAATAAATGCAATTAATGCAAAAATATCTTCATTTCTGGGTCATATCTTAAAGAGATTGA
+ GCAGAAATATTGTCAAGTTGAGAAAAATGTATGGAGATAACATCAGAAGTGGACTCGTTATATATATGTA
+ TGTATTTTATAGCCCATTTTAAAACCAGATTTGTGGCAGCATACATTTTTCTTCAATTACAAGTACAATT
+ TCTCTTAAGTGACGTTAATTTCCTTATTTAATACATTTTTTCTTTTTTTTTCTGTGGGCCGAAATTCAAG
+ ACATATTTATTTACCCATTCGAAATGAAATTCGTTCACCAATTCAACAATGAAACATTCGCTTGTGCCAG
+ TTGCCAAGGAGCTGCGAGAAAAATGCAATAATCCATCGATTTTCTAACAATTTAACGATATGTAAATGAG
+ GCGTCAGAAGCACCGAATAGCAGAATACCAAATCGAAGCCAACTGCCACGTATGGCACATTTACATTGGC
+ GCCCATCAGATAATCTCGCATTCGTCAAGAAGTGGAATCAAAAATCTGGAAAACCGCGAACATCTGAGCA
+ AATAAACACTTGGGGCGAGAAAATGCCGAAAAACGCTTTCCCACACGGAATGTGCATTGCCATCAGGGAA
+ AAGTGCAGCGCGAATGAGGAAATTCGGCGAGCACAGCTCCCGTATCTGGCGGATACTCCTCCGTATTCCA
+ CAGTTGTTGACCCCGCCTGGCCGATAAAAAGAGCGTGCAAGTAAGAGAAAATCGAAGGGGAAAGGGGGCG
+ ATCCCCAGCGAACAGACAAACAAATAAACAAACATATGGCACACATAAACCCGAACATCGGCATACGGGC
+ CTAGAATATAAATAATTTTTCCTTCGCTGATTTTTCTGGTCTCGAGCTCAACACTTGAAACAACCGATGC
+ TGGCCGCATTTCCGTCTTGTTTTTTAATTTCCCATAATTTCTCACATATGTATCTCTGTATCTTTGTGGC
+ GCTTTCGATGGGCACGCCGTAAATTAACTTACCAGCGACCAGTAGGACAGCAATTTGATTTTCTGGGGCA
+ GCGATTCGGGAACCAGGCGGCGATTGAGGCTCGTCTTCAGTTTGTAGCTCCTTTGGATCTCGAAGGAGCT
+ GTAGTAGAGTCCATAGGCGAATTGGCCGAGTGCACACAGGTGTATGATTGTCACAAAGACGCGCGACTTG
+ TATAGCTCAACTTTGGTCATCTTGTGGATTTTTCAAAGATCCTACACAGGAAAAGCCAAAGGAGACTTCA
+ CGTTACACGGGCAGAAAAATTTTGCAATATGTTCCTCAAGTTCTAATTCGCTACATTTCAGTGTTCCATA
+ TACAGTGCATAATTTAATTATATATCTAAATCAACAATTGTGAAATTTTCATGTAGTACAAAGTGCTAAG
+ TATAAAACTTTTTTTTAGGCAAAGAAAGAAAGAAACCATTTAGAACTACTATCCCTTGATAAACTGAAAA
+ TAAATTTTTCTTCAATTTTAAAAGAAAAATTGGTGTATTGTTTTTGTCTGTGCTTTGCGGTGGGGCGAAA
+ GAAGTGAATTAAAATCGTCGTCAAGGTGTTTTAGCTCTTGAGTCAAAACACCTCGCTTTCGTCAACTCAA
+ AGCGCGCACAAATTTAAATCAATATTTGCGTCACCGACATAAATATTAATGGAACCTAAAGTTGGCCAGG
+ AATATCTTGAAAAAATCTTGAAAATCTTGACCGCCCTGGAAGAAGATCCCCGTGGCTCTTGTTTATAAAT
+ CGGTTATGTTAATAACTTAATGGTTTTTATGGCCCTTAAAAACAATTGTTGATTGCCTTTCGTTTGATTT
+ CCACACTCTGAACAAATCACCAGGTCCCCGGCACACGCACGCTAAGTATTTTCTTGATTTCTTTTTGGCT
+ TCGCTCGGAGGAAGTGCTCGGCTGCGATTTTCCCTTGACCGCGGGCACAACTGAGCGTATGGAAAACTGG
+ AGTCGCACTGTTGCCCATACGCCGTGTTGCCTCCTGCCTTTTGTACTCGTTTCCATTGTACTTGGCTGTT
+ GCTTCTGTCTCTGCCTCGGTTTTGTGGTGTCGTTCCTCCAGTCGCTCGCATCAGGTGCGTGCTGCGCATG
+ TCCGGACCACCGACCACGGAAGACGGACTCCGGGCTTCGCATTCCGGATTCGGGAGTGTGGGCTCCATTA
+ TGGGTTAATGATGGCCAATCACCTGAATGAATCGCCCCCACCCATTAAGATGTATGTTGCTTAGTGAGTA
+ ACCAGATGAGTCGAAACAATGCAGGCATAACTAAAAAGATATCTTTGCGGAGAGATAAGCATCTGCTTTT
+ ATTTTTAGGCACTGCGTCATAGCTGTAGATAAAAGTATAAAAAACCTAAATAAAAAGTCATTGATAAAGG
+ CTAGAAGTTCTGTAGTACATATGTATGTAGATACTAGATACGGAAATCGCTATTATATACATCACTTCGA
+ AATTGTATTTTCGTCTAAAGCTTCAAGTTTTCAATAGTCTGAGATTTTCTAACTGCAATTGGCTTTAGGA
+ CCCCCAAAAGTGTTGCGCTGATTTGAAGGGAATTAATTTGATTTTCCCGCGCACTAACTCTGGATAGGGA
+ AAACTTTGCTTCCGTAAACTGGCCACTCTCTTGTCAGCTGTGTGGTGCTGTTGTTTTTCTTTCAAATTTA
+ AAGTCATGTCGTAACCCGAACCGACTTCAAAACAACACAACCCGACAGCCAAATTCCTAGTGCAGGCATT
+ TTAGGCGGAAATCTCCAGCGGCAGACCGGTGCCCAGTCATGTCGACCGCTTCGCGAGTGACTTTGGGACT
+ GGCGGTCTCCATTTCCACAGCGATCATAGGTTATGTGCACTATAAACAATCGGCAGACCGGTAAGTAAGC
+ CAAATACTCCGGAATAAAGTTATAGCCTCCGATCTCTAACTTCCAGCCTGAGACTGCACGATGGTGTCCT
+ GAGGGACGTTGAGCAGCAACAACGGCGCAAACACGAGAATACCTACACGCTGCAGCAGCAAATAGACATG
+ ACCAAGCAACTGAAAGCCAGGGAGGCGTCTAGCAACTCCTCTGACACGCCCGTACCTCCATCGACGCATC
+ GCGCACAGAGTAATCTTCAAGCGGAGAAGCCAGCAGTGCAAAATGAAGGCGAGGCTTTCAGAGGTGTTCC
+ TCAGGGTGGAACGACTAATCACGATGGAAGCCCGCCAACTGACATAGCTTGATCACAAATATGCCCCTAA
+ ATATGCACCTATTAAAATCTAAGACTAAGTCGGGGAAAACAAGAATTTCGTTGTTCAAATGTACGCATTT
+ TTGAAGATTTTAAGATTTCGTCTTAAGACAGTTGACAGCATCATTTACGCTGTTGATCGTTTTCAGTTGG
+ TGAAGCCATCTGCGCATGGAAATATAATTAAAACAACGTGGTAAGATTCAATCTTACAAAGCGAAATAAG
+ ACTGCAGGCCTAACAAGGGGTGGTGTCTTCTGGATGTTATCCATACCTGTGAGGAGTCTTTTATTTTGAG
+ TGCCTGGACTTTTTGACAATTAGACCCATTTCTTACTATGGCTTCCAGTATAATATTACTCAATTTTATT
+ ATTATGAATGTATGTATAGTAAATTACAATTCTAATGGGCGCTCGGTAAAATATTTCGCGGGGGGTTTGT
+ ACATAGGTGGTGGAACTCCCCATCGTCATTTTCCTCCTCCTCCTTCCATCTCGTTTACTCAAAAGTGATA
+ TAAAAACGTGGAAAACCAACGCAGAGACTAAAATACACGATGCTTTGCGTTACTGCTTGTCCGTTGCTTT
+ CTCTCTCAATTGCCACCGTACAGAAAAAATGTCCAGAATATTTAATACCGTCCACCACCACCACCGCCTC
+ CTCCGCCACCACCTTTGCGGCGATCGCGATCGTTTCCGCGATCATTGCCACGCATGTTGTCCCGCTCGTT
+ GTTCAAGTAGTTTCCTCCGCCGACACCGTCGCCTCTGCCGCCTCCTCTTCGACCCGGGGATCGGGACCTG
+ CTGCGGGAGCCGCGACGGCGTCCAGGGGATCGGGAACGGGAGCGGGCACGACGGCGGCGGGAGTAGAGGT
+ ACCTTCGCAGCTCACGCGAGATGGGCTTCAAGTGCATGAAGTTGCAGAAGCCGGAGCGGGTACATTCGCC
+ CATCTCGTACTGCCGACAGCAAGCCTCGCGGAAGTCGGTCACCGGCGATAGTTCCGAGTACACCGGTCGA
+ CCACCGAACCACCGGTTGTTCAAATCGTTTGCCGCCTTTTCCGCATCAGCCTCGTTACGGAATTTGATGT
+ ACACATTGCCGACCAGATGGTCGCCTAGGTTGTCGCACACGTTCATCTCCTCGATTTCCCCGTACTTGTC
+ CTCGCACTCTACGAACACGTCCTCGAAAAAATTGTCGTAGTGTTCTTGCATCTCCTCGTCGGAGACGTTG
+ GCCACCAGATGGGAGCCATCCGCGGATTTGGCGGAGTTTTGGGGGTTCACGTATAGATTTTGGAGAAGCA
+ CCGTCTGCGAGAAAGTGGGTTTGTTGTGGATGCGAGAGCACCGGTCGCCGTGGCGGCAGGCGCCGATCTT
+ GAAGTAGAACGAACAGTTCACCCTGGGAAATGCAACGCCATTTAGTTATTAATCCCGGCAACGTTAAAAT
+ AAATGTGCCATGCGACTTACTTGTCCTTTTCCGTGCCAAAAATGGATGCCAAGTACTCGGCCATGCTGGC
+ GGCTTTACTGTGGTGTTGCTGTGGCCAAAATGTGTAACTTATCTACCCGCTTGTCTCTGCAACGCGGTCA
+ AACTGCAATTATGTTAGCCGCCTGTTTATTTAGTGATAATTTTCAATTATTTTCGGAAACCGAAAAAAGC
+ AGCGTCTGGTCGTATTTTGCACGGCGTTGCCAGCCTCGAATCTAGAGTTGCAAATAAAATCGATGATTAG
+ TTATCGATATTTAGTGTTTTTGGCAGCATCGTTTTTCGATACCTCTGTTCTTAATTTAAATGTTTTAAAA
+ TATGCTAACATTTTAAATATTAATTTCAAATATTTAAATATTAATGCACTTAAAAGCCTGAGGACTTATT
+ TTTCATTTGACTAGAAAAATTTTACAATTCAAAATAAGAAATTGAGAAAATTATTTACGCAAATAATAAT
+ ATAATATAAACATAAATAAACAATACAATAAAATAACATTTAAATTCTATAAAGCTCAAGGTATTATTTA
+ TATTTGATCAACAATTTTTTTAATTTATATAAGCAATGGAAAAAATTATTTAAGAAGGCTTGCTGGTTTT
+ GTTCCCCGCTTGAGAACGAGCTAAGTTCTAAACCGCAGTCTGGAAAAAGATTAAATTCAGTCGCAGAAGC
+ ATTGACAACCCTATCGATTGCTTCTAGAAAAGTCGGCATTTTTCGCATTTTCACCTGGCACGGCACATTT
+ CGCAGCGTGTTTTATTAAAAAGTCGTACAAAAATACAGGAAAAACTGTAATTCGACAGCGCTATCCTCTC
+ CCTTATCAGAAATGGACAAGGTAAGTGCCCGAGACAAAGGAAAGGCGTTGGCATTTCCAATCAAAAACCC
+ TTGCGGTTTTCGCAGGTGAACGAACTCAAGGAAAAGGGTAACCAGGCGCTCAGTGCCGAGAAGTTCGACG
+ AGGCGGTGGCGGCGTACACAGAGGCCATCGCTCTGGACGACCAGAACCATGTGCTCTACAGCAACCGTTC
+ GGCGGCATTCGCCAAGGCTGGAAAGTTCCAGGAGGCGCTAGAAGATGCGGAGAAGACCATTCAGCTTAAT
+ CCCACCTGGCCTAAGGGTTACTCACGCAAAGGAGCTGCCGCTGCGGGTCTGAATGACTTTATGAAGGCCT
+ TCGAAGCGTACAACGAGGGTAAGTTCAAACACAGCTCAGTTATATGCCATGAATCACCCGACCTAACCTC
+ ACTAACCTCGGTTACCGGCGCAGGTCTCAAGTACGATCCCACGAATGCTATACTCCTGCAAGGCCGCATG
+ GAAACTACTGCCTCGGCTCTGAGCTTTATGCAATCGCAGGGGGATATACCCATGGACGTTGATCCCCAGC
+ AGGCACGCAGCCGCAGGGCTCCATCGCCACCGCCGGCGAAACCGGCTGAGCCCCCAAAGCCCGCTGAACC
+ TCGGGTAGAGGACATGACTGAGGAGCAGAAGAATAAGTACTTCGCGAGGAAGGAGAAGGAACTGGGCAAC
+ GCCGCCTACAAGAAAAAGGACTTTGAAACGGCCCTAAAACACTACCACGCTGCCATTGAACACGATCCCA
+ CGGATATCACGTTCTATAACAACATAGCTGCTGTTCACTTTGAGCGCAAGGAGTACGAGGAGTGCATCAA
+ GCAGTGCGAGAAGGGCATTGAGGTGGGGCGCGAAAGCCGCGCCGACTTTAAGCTGATAGCTAAGTCCTTT
+ GCTCGCATCGGTAACACCTATCGTAAGCTAGAGAACTACAAGCAGGCGAAGGTTTACTATGAGAAGGCCA
+ TGTCCGAGCATCGCACCCCTGAGATCAAGACCTCGCTGAGCGAGGTGGAAGCCAAAATCAAGGAGGAGGA
+ GCGAATGGCCTACATCAATCCGGAGAAGGCCGAGGAAGAGAAGGAGCAGGGCAACCTTTTCTTTAAGAAG
+ GGGGACTACAGCACCGCTGTAAAGCACTACACCGAGGCCATCAAGCGCAATCCGGATGATCCCAAACTCT
+ ATAGTAACCGCGCCGCCTGCTACACCAAGCTGGCCGCCTTTGATCTGGGCCTCAAGGACTGCGACACTTG
+ CATCAAGCTAGACGAAAAGTTCATAAAGGGCTACATCCGCAAGGGCAAAATTCTACAGGGCATGCAGCAA
+ CAATCTAAGGCGCAAGCCGCTTACCAAAAGGCCCTGGAACTGGACCCCAACAACGCGGAGGCCATTGAAG
+ GCTACCGTCAGTGTTCGATGAACTTCCAGCGCAATCCGCAGGAGGTCCTCAAAAACGCAATGTCCGACCC
+ GGAGATTCAACAGATCTTAAAGGATCCGGCTATGCGTATGATCCTCGAGCAGATGCAAAGCGATCCCAAT
+ GCGGTCAAAGAGTAAGTACCCGTTTGGCTTTATTCGTTCGCTTTTTTGGGTTTCATTGGTAAAATCTAGA
+ AATTAATAGCCCATTTGAAGTTAACAAGCAGACTTACGTTTCTTTGGTCTTATATATTATTAACAACCTG
+ TATACTATATTTTAATTAACAACCTCTATATTTCAGACACTTGCAGAATCCTGCCATCGCCGATAAGATA
+ ATGAAACTGCTGGAGTCGGGCATCATTCAGATTCACTAGGCACTCCAGATCCACAAACGAACATCCTCAT
+ ACAATCACTAACTCACACACAAACCCCATTGATAAACATTCAGGAGAGAACCATTACGCATTATTATGGC
+ GTCTCTAAGCTGGTTAACCAATATATCGTTTTTGATGAAACGGGCCACAATTAATGCTAAACGTAATTAC
+ CTAAGAAATCACATCGCCTATTCGCAGAACGACGATAACTACCATTAACAGAAATTTAAACTAAAAGGAG
+ AAAACAAAATCATTGATAAATGTCTGCCTAATTGATTTACGCAGACGGGTGGAGTAGGCTCCAAACGTCA
+ TGGTCCTTATTTTCTTACTACAATAAATATGCTGTAGCTTAGCTCTAAAATAAGTTTCTGTTTGTACAAT
+ AAACGAGTCACGGAAGGGTAAGCTATGATTTTGAATTTGGCGCCCAAGGGCTACAAGATGGGTAACTTAC
+ GGCTTAGCAGTCGTTCTCTAACGTTTTTCCAGGGCTGCCAAATTATTTAGAATATATTTTATATTTATAC
+ AAAGAATGATTTGCGCCAATCGCCTTTTAAATAAGAAATTTAAATGTTATTATAATGCAAAATCGCATAT
+ TTTCGGAAAAAAGCATAGACTGCAAATCTTTATTTTGAAAAAATATAATTTCGAATGAATTAAGTTGTGA
+ AATTAAAATGATTAAAAGCAACAACCTGGCCAACCTTTTTGTAATTATAATGTGTGAAATATTTTGTATT
+ CTTGGGCAGCCCTGTTTCCCGCGCTTACGTTATTATATCCAACCGATACGTAGTTTCGTCTTGCTCAACA
+ CTGCAAGCCGCCAGTGCTACAAAGGCCCTGCAGCTCACTCGCAGCAAGTGGCATGGCAACAACAGCGCTG
+ TTCAACACCGCACGATTTCTACCCGAAAATAATGGTGTGCTGATATATTGTGATTAAACCCCAATTTCTG
+ TCGTCCAAAAGCTCCGCACGGGAATGTTTTGATCCAGCTACAACTGAAACAATTGCACGCCAATTAAAAG
+ AACCAATGAGTGGGTAAAACCACGAAAATAAGAATCAAAAGCGAACCATTTTTTTTTAAACAGTGTGTCG
+ TAGTGTCCGTCTTATGCGTTTGTGTTGGTGCGTGTGTGCGTGCGGCTGCTAGTGTGAGTGTTCCGTCGAA
+ TCGCGAAATCGAGAATATAGAAAGATGTGCTCCATTCGCTGGTGGTGAGCTATAGCTATAGCGATATCGC
+ GAACGGGGGGCGAGTAGTCCGCAGCCCGAAATCCAGATCCAGTTCCAGATCTATATCCATTGATTCTTTC
+ GCCGCTGCAGCATCCGCAGCGCCAGAATTGCGACCCATTGAAAACCCCACAAGACCCACAAAAGTAAGTA
+ TTTGCGTTTCGGGGGCGCTTGGCAACAGGCCCGAGTGCGTTGAAGCGAGAGGTCGCTAGCGGGGTGCCTG
+ GGGGCGGGAGCGAGAAGGCTAGATAGAGACCGGGACGCCAGCGATTACATGCCTCGTTTTTACACAGAGT
+ TGTTGTTTTCGCTTCTGGTGGGGCGCAATATTTGGCCAATATTTATTAATGGATTGGGTCCCTCAAATAA
+ CGAAATAAAGGCTCATTGCCAAGACTTCGATTTCACTAGAGATTCTCCTTTTTCAGCTGTTTATGTTTCA
+ AATTAGAGTTATTAAATGCCTCAATATAATGTCGTTTTAGGATTGGGACAATCAGATGAGATCACTTTAT
+ GTAGATACTCTTAACATTCTGGATAATTTATTAGCTTGAGGAACTGCAATCTATTCATTTGTTTTCATTT
+ TCTAACAGGAATTGCGATTATTAACAGAAAAGGAAATTTTCAATGTAAACCCAATGTTATATTTGTTTTT
+ ACACTTGTAAACTAAAATTTAGTTTAAAAAATAGATAAAATTGCATACATATAAGATAGGGAATTTACAT
+ GAAATACTTTATCAATATTTTAAATAATTTTTTTAAATTTTAAATTAATTCTTATTGTGCAGTGCAACCC
+ TCCCCGCTCCACTACTCGACGATGCGGCCACAGGCGCCCGGATCGCTGGTCGATCCCAACGAGGACGAGC
+ TACGCATGGCCCCATGGTACTGGGGCCGGATATCGAGGGAGGAAGCCAAGAGCATCCTGCACGGAAAGCC
+ GGACGGCAGCTTTTTGGTGCGGGACGCCCTCTCGATGAAGGGCGAGTACACTCTGACCCTGATGAAGGAC
+ GGATGCGAGAAGCTAATAAAGATATGCCACATGGATCGCAAGTACGGCTTTATCGAGACGGACCTGTTCA
+ ATTCGGTGGTGGAGATGATCAACTACTACAAGGAGAACTCTCTGAGCATGTACAACAAGACGCTGGACAT
+ AACACTGAGTAATCCGATTGTGCGAGCCCGCGAGGATGAGGAGTCGCAGCCGCACGGGGATCTTTGTCTG
+ CTGAGCAACGAATTCATCAGGACCTGCCAGCTGCTTCAGAATCTTGAGCAAAATCTCGAGAATAAGCGCA
+ ACTCATTCAATGCGATTCGAGAGGAGCTGCAGGAGAAGAAGCTGCACCAGAGCGTATTCGGGAATACAGA
+ GAAGATATTCCGCAATCAAATCAAGCTCAATGAATCCTTCATGAAGGCGCCAGCGGATGCCCCGTCCACG
+ GAGGCAGGAGGAGCTGGAGATGGAGCTAACGCAGCCGCATCCGCAGCGGCCAATGCCAACGCTCGCCGGA
+ GTCTGCAGGAGCACAAGCAGACACTCCTCAATCTGCTGGATGCTCTTCAGGCCAAGGGTCAAGTCCTTAA
+ CCACTACATGGAGAACAAGAAGAAGGAGGAGCTACTGCTCGAGCGACAGATCAACGCCCTGAAGCCGGAA
+ TTACAGATACTGCAGTTGCGCAAGGACAAGTACATTGAGTAAGTCCCGATTTGAAGTCCTTGCAACTACT
+ TTTAGCTATCAATAGTAATGCAATATATAGTAATTAATATCTGGGAATGC
+
Index: llvm-test/MultiSource/Applications/SIBsim4/y.fa
diff -c /dev/null llvm-test/MultiSource/Applications/SIBsim4/y.fa:1.1
*** /dev/null Thu Feb 15 17:46:25 2007
--- llvm-test/MultiSource/Applications/SIBsim4/y.fa Thu Feb 15 17:46:09 2007
***************
*** 0 ****
--- 1,4334 ----
+ >MUSSPSYN Mouse spermidine synthase mRNA, complete cds.
+ CGGGTTGTGCTGGGGGGGTCCGCGCGCCCTGCAGTCCCGAACCCGCTACGCGCTCCGTCG
+ GCCCGCCCGCCCGCCATGGAGCCTGGCCCCGACGGCCCAGCCGCGCCCGGCCCCGCCGCC
+ ATCCGTGAGGGCTGGTTCCGAGAGACCTGCAGCCTGTGGCCCGGCCAGGCCCTGTCGCTG
+ CAAGTGGAGCAGCTGCTTCACCACCGGCGATCGCGGTACCAAGACATCCTCGTCTTCCGC
+ AGTAAAACCTACGGCAACGTGCTGGTTCTGGATGGCGTCATCCAGTGTACTGAGAGGGAT
+ GAGTTCTCCTACCAGGAGATGATCGCCAACCTGCCGCTCTGCAGCCACCCCAACCCGCGG
+ AAGGTGCTGATCATCGGGGGTGGAGATGGGGGCGTCCTACGGGAAGTGGTGAAGCACCCC
+ TCTGTGGAGTCGGTGGTCCAGTGCGAGATTGATGAGGATGTCATTGAAGTCTCTAAGAAG
+ TTCCTGCCTGGCATGGCCGTTGGCTTCTCCAGCTCAAAGCTGACTCTCCACGTGGGCGAT
+ GGCTTTGAGTTCATGAAACAGAACCAAGATGCCTTTGACGTCATCATCACCGACTCCTCA
+ GACCCCATGGGCCCTGCTGAGAGCCTCTTCAAGGAGTCCTATTACCAGCTCATGAAGACA
+ GCACTCAAAGAAGATGGCATCCTGTGCTGCCAGGGTGAGTGCCAGTGGCTGCACCTGGAC
+ CTCATCAAGGAGATGAGGCACTTCTGCAAATCTCTCTTCCCCGTGGTGGACTACGCCTAC
+ TGTAGCATTCCTACCTATCCCAGCGGCCAGATCGGCTTCATGCTGTGTAGCAAAAACCCG
+ AGCACCAACTTCCGGGAGCCAGTGCAGCAGTTGACACAGGCCCAGGTGGAGCAGATGCAG
+ CTGAAATACTATAACTCGGACATGCACCGTGCCGCCTTCGTACTGCCTGAGTTCACCCGG
+ AAGGCCCTCAATGACATAAGCTGAATCCAGGTGCCACTGTGACACCACCCGAGACCTCAA
+ TCGGATTGGACCAAGGATCTTCCAAGTTGTCTGGGGACCACCAGTCCTGGACCAGACTCC
+ CAGATGACTCTTGCCCACCAACCAAGTGTTACAGGCCCCATGATGCTGCCTGGCCTGGCC
+ TGGCCTGGCCTGGCCTGGCCTGCCCTGCTGGGTGGACTCAGTCTCTGTCTGTCTATCTCT
+ GTGGCGTTCAGCCCCACGCCTATACCAGCTCTGTACAGCACCGCCTATGCCCTGTGACCC
+ AACAAAATACATGTGTATTCCG
+ >MUSSPSYN Mouse spermidine synthase mRNA, complete cds.
+ CGGGTTGTGCTGGGGGGGTCCGCGCGCCCTGCAGTCCCGAACCCGCTACGCGCTCCGTCG
+ GCCCGCCCGCCCGCCATGGAGCCTGGCCCCGACGGCCCAGCCGCGCCCGGCCCCGCCGCC
+ ATCCGTGAGGGCTGGTTCCGAGAGACCTGCAGCCTGTGGCCCGGCCAGGCCCTGTCGCTG
+ CAAGTGGAGCAGCTGCTTCACCACCGGCGATCGCGGTACCAAGACATCCTCGTCTTCCGC
+ AGTAAAACCTACGGCAACGTGCTGGTTCTGGATGGCGTCATCCAGTGTACTGAGAGGGAT
+ GAGTTCTCCTACCAGGAGATGATCGCCAACCTGCCGCTCTGCAGCCACCCCAACCCGCGG
+ AAGGTGCTGATCATCGGGGGTGGAGATGGGGGCGTCCTACGGGAAGTGGTGAAGCACCCC
+ TCTGTGGAGTCGGTGGTCCAGTGCGAGATTGATGAGGATGTCATTGAAGTCTCTAAGAAG
+ TTCCTGCCTGGCATGGCCGTTGGCTTCTCCAGCTCAAAGCTGACTCTCCACGTGGGCGAT
+ GGCTTTGAGTTCATGAAACAGAACCAAGATGCCTTTGACGTCATCATCACCGACTCCTCA
+ GACCCCATGGGCCCTGCTGAGAGCCTCTTCAAGGAGTCCTATTACCAGCTCATGAAGACA
+ GCACTCAAAGAAGATGGCATCCTGTGCTGCCAGGGTGAGTGCCAGTGGCTGCACCTGGAC
+ CTCATCAAGGAGATGAGGCACTTCTGCAAATCTCTCTTCCCCGTGGTGGACTACGCCTAC
+ TGTAGCATTCCTACCTATCCCAGCGGCCAGATCGGCTTCATGCTGTGTAGCAAAAACCCG
+ AGCACCAACTTCCGGGAGCCAGTGCAGCAGTTGACACAGGCCCAGGTGGAGCAGATGCAG
+ CTGAAATACTATAACTCGGACATGCACCGTGCCGCCTTCGTACTGCCTGAGTTCACCCGG
+ AAGGCCCTCAATGACATAAGCTGAATCCAGGTGCCACTGTGACACCACCCGAGACCTCAA
+ TCGGATTGGACCAAGGATCTTCCAAGTTGTCTGGGGACCACCAGTCCTGGACCAGACTCC
+ CAGATGACTCTTGCCCACCAACCAAGTGTTACAGGCCCCATGATGCTGCCTGGCCTGGCC
+ TGGCCTGGCCTGGCCTGGCCTGCCCTGCTGGGTGGACTCAGTCTCTGTCTGTCTATCTCT
+ GTGGCGTTCAGCCCCACGCCTATACCAGCTCTGTACAGCACCGCCTATGCCCTGTGACCC
+ AACAAAATACATGTGTATTCCG
+ >ref|NT_037436.3|:1-300000 Drosophila melanogaster chromosome 3L
+ TAGGGAGAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTCTTTGATTTTTTGGCAACCC
+ AAAATGGTGGCGGATGAACGAGATGATAATATATTCAAGTTGCCGCTAATCAGAAATAAATTCATTGCAA
+ CGTTAAATACAGCACAATATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTAATGAGTGCCT
+ CTCGTTCTCTGTCTTATATTACCGCAAACCCAAAAAGACAATACACGACAGAGAGAGAGAGCAGCGGAGA
+ TATTTAGATTGCCTATTAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTCTGCTCTCTATATAA
+ TGACTGCCTCTCATTCTGTCTTATTTTACCGCAAACCCAAATCGACAATGCACGACAGAGGAAGCAGAAC
+ AGATATTTAGATTGCCTCTCATTTTCTCTCCCATATTATAGGGAGAAATATGATCGCGTATGCGAGAGTA
+ GTGCCAACATATTGTGCTCTTTGATTTTTTGGCAACCCAAAATGGTGGCGGATGAACGAGATGATAATAT
+ ATTCAAGTTGCCGCTAATCAGAAATAAATTCATTGCAACGTTAAATACAGCACAATATATGATCGCGTAT
+ GCGAGAGTAGTGCCAACATATTGTGCTAATGAGTGCCTCTCGTTCTCTGTCTTATATTACCGCAAACCCA
+ AAAAGACAATACACGACAGAGAGAGAGAGCAGCGGAGATATTTAGATTGCCTATTAAATATGATCGCGTA
+ TGCGAGAGTAGTGCCAACATATTCTGCTCTCTACATAATGACTGCCTCTCATTCTGTCTTATTTTACCGC
+ AAACCCAAATCGACAATGCACGACAGAGGAAGCAGAACAGATATTTAGATTGCCTCTCATTTTCTCTCCC
+ ATATTATAGGGAGAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTCTTTGATTTTTTGG
+ CAACCCAAAATGGTGGCGGATGAACGAGATGATAATATATTCAAGTTGCCGCTAATCAGAAATAAATTCA
+ TTGCAACGTTAAATACAGCACAATATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTAATGA
+ GTGCCTCTCGTTCTCTGTCTTATATTACCGCAAACCCAAAAAGACAATACACGACAGAGAGAGAGAGCAG
+ CGGAGATATTTAGATTGCCTATTAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTCTGCTCTCT
+ ATATAATGACTGCCTCTCATTCTGTCTTATTTTACCGCAAACCCAAATCGACAATGCACGACAGAGGAAG
+ CAGAACAGATATTTAGATTGCCTCTCATTTTCTCTCCCATATTATAGGGAGAAATATGATCGCGTATGCG
+ AGAGTAGTGCCAACATATTGTGCTCTTTGATTTTTTGGCAACCCAAAATGGTGGCGGATGAACGAGATGA
+ TAATATATTCAAGTTGCCGCTAATCAGAAATAAATTCATTGCAACGTTAAATACAGCACAATATATGATC
+ GCGTATGCGAGAGTAGTGCCAACATATTGTGCTAATGAGTGCCTCTCGTTCTCTGTCTTATATTACCGCA
+ AACCCAAAAAGACAATACACGACAGAGAGAGAGAGCAGCGGAGATATTTAGATTGCCTATTAAATATGAT
+ CGCGTATGCGAGAGTAGTGCCAACATATTCTGCTCTCTATATAATGACTGCCTCTCATTCTGTCTTATTT
+ TACCGCAAACCCAAATCGACAATGCACGACAGAGGAAGCAGAACAGATATTTAGATTGCCTCTCATTTTC
+ TCTCCCATATTATAGGGAGAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTCTTTGATT
+ TTTTGGCAACCCAAAATGGTGGCGGATGAACGAGATGATAATATATTCAAGTTGCCGCTAATCAGAAATA
+ AATTCATTGCAACGTTAAATACAGCACAATATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGC
+ TAATGAGTGCCTCTCGTTCTCTGTCTTATATTACCGCAAACCCAAAAAGACAATACACGACAGAGAGAGA
+ GAGCAGCGGAGATATTTAGATTGCCTATTAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTCTG
+ CTCTCTATATAATGACTGCCTCTCATTCTGTCTTATTTTACCGCAAACCCAAATCGACAATGCACGACAG
+ AGGAAGCAGAACAGATATTTAGATTGCCTCTCATTTTCTCTCCCATATTATAGGGAGAAATATGATCGCG
+ TATGCGAGAGTAGTGCCAACATATTGTGCTCTTTGATTTTTTGGCAACCCAAAATGGTGGCGGATGAACG
+ AGATGATAATATATTCAAGTTGCCGCTAATCAGAAATAAATTCATTGCAACGTTAAATACAGCACAATAT
+ ATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTAATGAGTGCCTCTCGTTCTCTGTCTTATATT
+ ACCGCAAACCCAAAAAGACAATACACGACAGAGAGAGCAGCGGAGATATTTAGATTGCCTATTAAATATG
+ ATCGCGTATGCGAGAGTAGTGCCAACATATTCTGCTCTCTATATAATGACTGCCTCTCATTCTGTCTTAT
+ TTTACCGCAAACCCAAATCGACAATGCACGACAGAGGAAGCAGAACAGATATTTAGATTGCCTCTCATTT
+ TCTCTCCCATATTATAGGGAGAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTCTTTGA
+ TTTTTTGGCAACCCAAAATGGTGGCGGATGAACGAGATGATAATATATTCAAGTTGCCGCTAATCAGAAA
+ TAAATTCATTGCAACGTTAAATACAGCACAATATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGT
+ GCTAATGAGTGCCTCTCGTTCTCTGTCTTATATTACCGCAAACCCAAAAAGACAATACACGACAGAGAGA
+ GAGAGCAGCGGAGATATTTAGATTGCCTATTAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTC
+ TGCTCTCTATATAATGACTGCCTCTCATTCTGTCTTATTTTACCGCAAACCCAAATCGACAATGCACGAC
+ AGAGGAAGCAGAACAGATATTTAGATTGCCTCTCATTTTCTCTCCCATATTATAGGGAGAAATATGATCG
+ CGTATGCGAGAGTAGTGCCAACATATTGTGCTCTTTGATTTTTTGGCAACCCAAAATGGTGGCGGATGAA
+ CGAGATGATAATATATTCAAGTTGCCGCTAATCAGAAATAAATTCATTGCAACGTTAAATACAGCACAAT
+ ATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTAATGAGTGCCTCTCGTTCTCTGTCTTATA
+ TTACCGCAAACCCAAAAAGACAATACACGACAGAGAGAGAGAGCAGCGGAGATATTTAGATTGCCTATTA
+ AATATGATCGCGTATGCGAGAGTAGTGCCAACATATTCTGCTCTCTATATAATGACTGCCTCTCATTCTG
+ TCTTATTTTACCGCAAACCCAAATCGACAATGCACGACAGAGGAAGCAGAACAGATATTTAGATTGCCTC
+ TCATTTTCTCTCCCATATTATAGGGAGAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCT
+ CTTTGATTTTTTGGCAACCCAAAATGGTGGCGGATGAACGAGATGATAATATATTCAAGTTGCCGCTAAT
+ CAGAAATAAATTCATTGCAACGTTAAATACAGCACAATATATGATCGCGTATGCGAGAGTAGTGCCAACA
+ TATTGTGCTAATGAGTGCCTCTCGTTCTCTGTCTTATATTACCGCAAACCCAAAAAGACAATACACGACA
+ GAGAGAGAGAGCAGCGGAGATATTTAGATTGCCTATTAAATATGATCGCGTATGCGAGAGTAGTGCCAAC
+ ATATTCTGCTCTCTACATAATGACTGCCTCTCATTCTGTCTTATTTTACCGCAAACCCAAATCGACAATG
+ CACGACAGAGGAAGCAGAACAGATATTTAGATTGCCTCTCATTTTCTCTCCCATATTATAGGGAGAAATA
+ TGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTCTTTGATTTTTTGGCAACCCAAAATGGTGGCG
+ GATGAACGAGATGATAATATATTCAAGTTGCCGCTAATCAGAAATAAATTCATTGCAACGTTAAATACAG
+ CACAATATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTAATGAGTGCCTCTCGTTCTCTGT
+ CTTATATTACCGCAAACCCAAAAAGACAATACACGACAGAGAGAGAGAGCAGCGGAGATATTTAGATTGC
+ CTATTAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTCTGCTCTCTATATAATGACTGCCTCTC
+ ATTCTGTCTTATTTTACCGCAAACCCAAATCGACAATGCACGACAGAGGAAGCAGAACAGATATTTAGAT
+ TGCCTCTCATTTTCTCTCCCATATTATAGGGAGAAATATGATCGCGTATGCGAGAGTAGTGCCAACATAT
+ TGTGCTCTTTGATTTTTTGGCAACCCAAAATGGTGGCGGATGAACGAGATGATAATATATTCAAGTTGCC
+ GCTAATCAGAAATAAATTCATTGCAACGTTAAATACAGCACAATATATGATCGCGTATGCGAGAGTAGTG
+ CCAACATATTGTGCTAATGAGTGCCTCTCGTTCTCTGTCTTATATTACCGCAAACCCAAAAAGACAATAC
+ ACGACAGAGAGAGAGAGCAGCGGAGATATTTAGATTGCCTATTAAATATGATCGCGTATGCGAGAGTAGT
+ GCCAACATATTCTGCTCTCTATATAATGACTGCCTCTCATTCTGTCTTATTTTACCGCAAACCCAAATCG
+ ACAATGCACGACAGAGGAAGCAGAACAGATATTTAGATTGCCTCTCATTTTCTCTCCCATATTATAGGGA
+ GAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTCTTTGATTTTTTGGCAACCCAAAATG
+ GTGGCGGATGAACGAGATGATAATATATTCAAGTTGCCGCTAATCAGAAATAAATTCATTGCAACGTTAA
+ ATACAGCACAATATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTAATGAGTGCCTCTCGTT
+ CTCTGTCTTATATTACCGCAAACCCAAAAAGACAATACACGACAGAGAGAGAGAGCAGCGGAGATATTTA
+ GATTGCCTATTAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTCTGCTCTCTATATAATGACTG
+ CCTCTCATTCTGTCTTATTTTACCGCAAACCCAAATCGACAATGCACGACAGAGGAAGCAGAACAGATAT
+ TTAGATTGCCTCTCATTTTCTCTCCCATATTATAGGGAGAAATATGATCGCGTATGCGAGAGTAGTGCCA
+ ACATATTGTGCTCTTTGATTTTTTGGCAACCCAAAATGGTGGCGGATGAACGAGATGATAATATATTCAA
+ GTTGCCGCTAATCAGAAATAAATTCATTGCAACGTTAAATACAGCACAATATATGATCGCGTATGCGAGA
+ GTAGTGCCAACATATTGTGCTAATGAGTGCCTCTCGTTCTCTGTCTTATATTACCGCAAACCCAAAAAGA
+ CAATACACGACAGAGAGAGCAGCGGAGATATTTAGATTGCCTATTAAATATGATCGCGTATGCGAGAGTA
+ GTGCCAACATATTCTGCTCTCTATATAATGACTGCCTCTCATTCTGTCTTATTTTACCGCAAACCCAAAT
+ CGACAATGCACGACAGAGGAAGCAGAACAGATATTTAGATTGCCTCTCATTTTCTCTCCCATATTATAGG
+ GAGAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTCTTTGATTTTTTGGCAACCCAAAA
+ TGGTGGCGGATGAACGAGATGATAATATATTCAAGTTGCCGCTAATCAGAAATAAATTCATTGCAACGTT
+ AAATACAGCACAATATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTAATGAGTGCCTCTCG
+ TTCTCTGTCTTATATTACCGCAAACCCAAAAAGACAATACACGACAGAGAGAGAGAGCAGCGGAGATATT
+ TAGATTGCCTATTAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTCTGCTCTCTATATAATGAC
+ TGCCTCTCATTCTGTCTTATTTTACCGCAAACCCAAATCGACAATGCACGACAGAGGAAGCAGAACAGAT
+ ATTTAGATTGCCTCTCATTTTCTCTCCCATATTATAGGGAGAAATATGATCGCGTATGCGAGAGTAGTGC
+ CAACATATTGTGCTCTTTGATTTTTTGGCAACCCAAAATGGTGGCGGATGAACGAGATGATAATATATTC
+ AAGTTGCCGCTAATCAGAAATAAATTCATTGCAACGTTAAATACAGCACAATATATGATCGCGTATGCGA
+ GAGTAGTGCCAACATATTGTGCTAATGAGTGCCTCTCGTTCTCTGTCTTATATTACCGCAAACCCAAAAA
+ GACAATACACGACAGAGAGAGAGAGCAGCGGAGATATTTAGATTGCCTATTAAATATGATCGCGTATGCG
+ AGAGTAGTGCCAACATATTCTGCTCTCTATATAATGACTGCCTCTCATTCTGTCTTATTTTACCGCAAAC
+ CCAAATCGACAATGCACGACAGAGGAAGCAGAACAGATATTTAGATTGCCTCTCATTTTCTCTCCCATAT
+ TATAGGGAGAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTCTTTGATTTTTTGGCAAC
+ CCAAAATGGTGGCGGATGAACGAGATGATAATATATTCAAGTTGCCGCTAATCAGAAATAAATTCATTGC
+ AACGTTAAATACAGCACAATATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTAATGAGTGC
+ CTCTCGTTCTCTGTCTTATATTACCGCAAACCCAAAAAGACAATACACGACAGAGAGAGAGAGCAGCGGA
+ GATATTTAGATTGCCTATTAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTCTGCTCTCTACAT
+ AATGACTGCCTCTCATTCTGTCTTATTTTACCGCAAACCCAAATCGACAATGCACGACAGAGGAAGCAGA
+ ACAGATATTTAGATTGCCTCTCATTTTCTCTCCCATATTATAGGGAGAAATATGATCGCGTATGCGAGAG
+ TAGTGCCAACATATTGTGCTCTTTGATTTTTTGGCAACCCAAAATGGTGGCGGATGAACGAGATGATAAT
+ ATATTCAAGTTGCCGCTAATCAGAAATAAATTCATTGCAACGTTAAATACAGCACAATATATGATCGCGT
+ ATGCGAGAGTAGTGCCAACATATTGTGCTAATGAGTGCCTCTCGTTCTCTGTCTTATATTACCGCAAACC
+ CAAAAAGACAATACACGACAGAGAGAGAGAGCAGCGGAGATATTTAGATTGCCTATTAAATATGATCGCG
+ TATGCGAGAGTAGTGCCAACATATTCTGCTCTCTATATAATGACTGCCTCTCATTCTGTCTTATTTTACC
+ GCAAACCCAAATCGACAATGCACGACAGAGGAAGCAGAACAGATATTTAGATTGCCTCTCATTTTCTCTC
+ CCATATTATAGGGAGAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTCTTTGATTTTTT
+ GGCAACCCAAAATGGTGGCGGATGAACGAGATGATAATATATTCAAGTTGCCGCTAATCAGAAATAAATT
+ CATTGCAACGTTAAATACAGCACAATATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTAAT
+ GAGTGCCTCTCGTTCTCTGTCTTATATTACCGCAAACCCAAAAAGACAATACACGACAGAGAGAGAGAGC
+ AGCGGAGATATTTAGATTGCCTATTAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTCTGCTCT
+ CTATATAATGACTGCCTCTCATTCTGTCTTATTTTACCGCAAACCCAAATCGACAATGCACGACAGAGGA
+ AGCAGAACAGATATTTAGATTGCCTCTCATTTTCTCTCCCATATTATAGGGAGAAATATGATCGCGTATG
+ CGAGAGTAGTGCCAACATATTGTGCTCTTTGATTTTTTGGCAACCCAAAATGGTGGCGGATGAACGAGAT
+ GATAATATATTCAAGTTGCCGCTAATCAGAAATAAATTCATTGCAACGTTAAATACAGCACAATATATGA
+ TCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTAATGAGTGCCTCTCGTTCTCTGTCTTATATTACCG
+ CAAACCCAAAAAGACAATACACGACAGAGAGAGAGAGCAGCGGAGATATTTAGATTGCCTATTAAATATG
+ ATCGCGTATGCGAGAGTAGTGCCAACATATTCTGCTCTCTATATAATGACTGCCTCTCATTCTGTCTTAT
+ TTTACCGCAAACCCAAATCGACAATGCACGACAGAGGAAGCAGAACAGATATTTAGATTGCCTCTCATTT
+ TCTCTCCCATATTATAGGGAGAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTCTTTGA
+ TTTTTTGGCAACCCAAAATGGTGGCGGATGAACGAGATGATAATATATTCAAGTTGCCGCTAATCAGAAA
+ TAAATTCATTGCAACGTTAAATACAGCACAATATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGT
+ GCTAATGAGTGCCTCTCGTTCTCTGTCTTATATTACCGCAAACCCAAAAAGACAATACACGACAGAGAGA
+ GCAGCGGAGATATTTAGATTGCCTATTAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTCTGCT
+ CTCTATATAATGACTGCCTCTCATTCTGTCTTATTTTACCGCAAACCCAAATCGACAATGCACGACAGAG
+ GAAGCAGAACAGATATTTAGATTGCCTCTCATTTTCTCTCCCATATTATAGGGAGAAATATGATCGCGTA
+ TGCGAGAGTAGTGCCAACATATTGTGCTCTTTGATTTTTTGGCAACCCAAAATGGTGGCGGATGAACGAG
+ ATGATAATATATTCAAGTTGCCGCTAATCAGAAATAAATTCATTGCAACGTTAAATACAGCACAATATAT
+ GATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTAATGAGTGCCTCTCGTTCTCTGTCTTATATTAC
+ CGCAAACCCAAAAAGACAATACACGACAGAGAGAGAGAGCAGCGGAGATATTTAGATTGCCTATTAAATA
+ TGATCGCGTATGCGAGAGTAGTGCCAACATATTCTGCTCTCTATATAATGACTGCCTCTCATTCTGTCTT
+ ATTTTACCGCAAACCCAAATCGACAATGCACGACAGAGGAAGCAGAACAGATATTTAGATTGCCTCTCAT
+ TTTCTCTCCCATATTATAGGGAGAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTCTTT
+ GATTTTTTGGCAACCCAAAATGGTGGCGGATGAACGAGATGATAATATATTCAAGTTGCCGCTAATCAGA
+ AATAAATTCATTGCAACGTTAAATACAGCACAATATATGATCGCGTATGCGAGAGTAGTGCCAACATATT
+ GTGCTAATGAGTGCCTCTCGTTCTCTGTCTTATATTACCGCAAACCCAAAAAGACAATACACGACAGAGA
+ GAGAGAGCAGCGGAGATATTTAGATTGCCTATTAAATATGATCGCGTATGCGAGAGTAGTGCCAACATAT
+ TCTGCTCTCTATATAATGACTGCCTCTCATTCTGTCTTATTTTACCGCAAACCCAAATCGACAATGCACG
+ ACAGAGGAAGCAGAACAGATATTTAGATTGCCTCTCATTTTCTCTCCCATATTATAGGGAGAAATATGAT
+ CGCGTATGCGAGAGTAGTGCCAACATATTGTGCTCTTTGATTTTTTGGCAACCCAAAATGGTGGCGGATG
+ AACGAGATGATAATATATTCAAGTTGCCGCTAATCAGAAATAAATTCATTGCAACGTTAAATACAGCACA
+ ATATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTAATGAGTGCCTCTCGTTCTCTGTCTTA
+ TATTACCGCAAACCCAAAAAGACAATACACGACAGAGAGAGAGAGCAGCGGAGATATTTAGATTGCCTAT
+ TAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTCTGCTCTCTACATAATGACTGCCTCTCATTC
+ TGTCTTATTTTACCGCAAACCCAAATCGACAATGCACGACAGAGGAAGCAGAACAGATATTTAGATTGCC
+ TCTCATTTTCTCTCCCATATTATAGGGAGAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTG
+ CTCTTTGATTTTTTGGCAACCCAAAATGGTGGCGGATGAACGAGATGATAATATATTCAAGTTGCCGCTA
+ ATCAGAAATAAATTCATTGCAACGTTAAATACAGCACAATATATGATCGCGTATGCGAGAGTAGTGCCAA
+ CATATTGTGCTAATGAGTGCCTCTCGTTCTCTGTCTTATATTACCGCAAACCCAAAAAGACAATACACGA
+ CAGAGAGAGAGAGCAGCGGAGATATTTAGATTGCCTATTAAATATGATCGCGTATGCGAGAGTAGTGCCA
+ ACATATTCTGCTCTCTATATAATGACTGCCTCTCATTCTGTCTTATTTTACCGCAAACCCAAATCGACAA
+ TGCACGACAGAGGAAGCAGAACAGATATTTAGATTGCCTCTCATTTTCTCTCCCATATTATAGGGAGAAA
+ TATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTCTTTGATTTTTTGGCAACCCAAAATGGTGG
+ CGGATGAACGAGATGATAATATATTCAAGTTGCCGCTAATCAGAAATAAATTCATTGCAACGTTAAATAC
+ AGCACAATATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTAATGAGTGCCTCTCGTTCTCT
+ GTCTTATATTACCGCAAACCCAAAAAGACAATACACGACAGAGAGAGAGAGCAGCGGAGATATTTAGATT
+ GCCTATTAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTCTGCTCTCTATATAATGACTGCCTC
+ TCATTCTGTCTTATTTTACCGCAAACCCAAATCGACAATGCACGACAGAGGAAGCAGAACAGATATTTAG
+ ATTGCCTCTCATTTTCTCTCCCATATTATAGGGAGAAATATGATCGCGTATGCGAGAGTAGTGCCAACAT
+ ATTGTGCTCTTTGATTTTTTGGCAACCCAAAATGGTGGCGGATGAACGAGATGATAATATATTCAAGTTG
+ CCGCTAATCAGAAATAAATTCATTGCAACGTTAAATACAGCACAATATATGATCGCGTATGCGAGAGTAG
+ TGCCAACATATTGTGCTAATGAGTGCCTCTCGTTCTCTGTCTTATATTACCGCAAACCCAAAAAGACAAT
+ ACACGACAGAGAGAGAGAGCAGCGGAGATATTTAGATTGCCTATTAAATATGATCGCGTATGCGAGAGTA
+ GTGCCAACATATTCTGCTCTCTATATAATGACTGCCTCTCATTCTGTCTTATTTTACCGCAAACCCAAAT
+ CGACAATGCACGACAGAGGAAGCAGAACAGATATTTAGATTGCCTCTCATTTTCTCTCCCATATTATAGG
+ GAGAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTCTTTGATTTTTTGGCAACCCAAAA
+ TGGTGGCGGATGAACGAGATGATAATATATTCAAGTTGCCGCTAATCAGAAATAAATTCATTGCAACGTT
+ AAATACAGCACAATATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTAATGAGTGCCTCTCG
+ TTCTCTGTCTTATATTACCGCAAACCCAAAAAGACAATACACGACAGAGAGAGCAGCGGAGATATTTAGA
+ TTGCCTATTAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTCTGCTCTCTATATAATGACTGCC
+ TCTCATTCTGTCTTATTTTACCGCAAACCCAAATCGACAATGCACGACAGAGGAAGCAGAACAGATATTT
+ AGATTGCCTCTCATTTTCTCTCCCATATTATAGGGAGAAATATGATCGCGTATGCGAGAGTAGTGCCAAC
+ ATATTGTGCTCTTTGATTTTTTGGCAACCCAAAATGGTGGCGGATGAACGAGATGATAATATATTCAAGT
+ TGCCGCTAATCAGAAATAAATTCATTGCAACGTTAAATACAGCACAATATATGATCGCGTATGCGAGAGT
+ AGTGCCAACATATTGTGCTAATGAGTGCCTCTCGTTCTCTGTCTTATATTACCGCAAACCCAAAAAGACA
+ ATACACGACAGAGAGAGAGAGCAGCGGAGATATTTAGATTGCCTATTAAATATGATCGCGTATGCGAGAG
+ TAGTGCCAACATATTCTGCTCTCTATATAATGACTGCCTCTCATTCTGTCTTATTTTACCGCAAACCCAA
+ ATCGACAATGCACGACAGAGGAAGCAGAACAGATATTTAGATTGCCTCTCATTTTCTCTCCCATATTATA
+ GGGAGAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTCTTTGATTTTTTGGCAACCCAA
+ AATGGTGGCGGATGAACGAGATGATAATATATTCAAGTTGCCGCTAATCAGAAATAAATTCATTGCAACG
+ TTAAATACAGCACAATATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTAATGAGTGCCTCT
+ CGTTCTCTGTCTTATATTACCGCAAACCCAAAAAGACAATACACGACAGAGAGAGAGAGCAGCGGAGATA
+ TTTAGATTGCCTATTAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTCTGCTCTCTATATAATG
+ ACTGCCTCTCATTCTGTCTTATTTTACCGCAAACCCAAATCGACAATGCACGACAGAGGAAGCAGAACAG
+ ATATTTAGATTGCCTCTCATTTTCTCTCCCATATTATAGGGAGAAATATGATCGCGTATGCGAGAGTAGT
+ GCCAACATATTGTGCTCTTTGATTTTTTGGCAACCCAAAATGGTGGCGGATGAACGAGATGATAATATAT
+ TCAAGTTGCCGCTAATCAGAAATAAATTCATTGCAACGTTAAATACAGCACAATATATGATCGCGTATGC
+ GAGAGTAGTGCCAACATATTGTGCTAATGAGTGCCTCTCGTTCTCTGTCTTATATTACCGCAAACCCAAA
+ AAGACAATACACGACAGAGAGAGAGAGCAGCGGAGATATTTAGATTGCCTATTAAATATGATCGCGTATG
+ CGAGAGTAGTGCCAACATATTCTGCTCTCTACATAATGACTGCCTCTCATTCTGTCTTATTTTACCGCAA
+ ACCCAAATCGACAATGCACGACAGAGGAAGCAGAACAGATATTTAGATTGCCTCTCATTTTCTCTCCCAT
+ ATTATAGGGAGAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTCTTTGATTTTTTGGCA
+ ACCCAAAATGGTGGCGGATGAACGAGATGATAATATATTCAAGTTGCCGCTAATCAGAAATAAATTCATT
+ GCAACGTTAAATACAGCACAATATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTAATGAGT
+ GCCTCTCGTTCTCTGTCTTATATTACCGCAAACCCAAAAAGACAATACACGACAGAGAGAGAGAGCAGCG
+ GAGATATTTAGATTGCCTATTAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTCTGCTCTCTAT
+ ATAATGACTGCCTCTCATTCTGTCTTATTTTACCGCAAACCCAAATCGACAATGCACGACAGAGGAAGCA
+ GAACAGATATTTAGATTGCCTCTCATTTTCTCTCCCATATTATAGGGAGAAATATGATCGCGTATGCGAG
+ AGTAGTGCCAACATATTGTGCTCTTTGATTTTTTGGCAACCCAAAATGGTGGCGGATGAACGAGATGATA
+ ATATATTCAAGTTGCCGCTAATCAGAAATAAATTCATTGCAACGTTAAATACAGCACAATATATGATCGC
+ GTATGCGAGAGTAGTGCCAACATATTGTGCTAATGAGTGCCTCTCGTTCTCTGTCTTATATTACCGCAAA
+ CCCAAAAAGACAATACACGACAGAGAGAGAGAGCAGCGGAGATATTTAGATTGCCTATTAAATATGATCG
+ CGTATGCGAGAGTAGTGCCAACATATTCTGCTCTCTATATAATGACTGCCTCTCATTCTGTCTTATTTTA
+ CCGCAAACCCAAATCGACAATGCACGACAGAGGAAGCAGAACAGATATTTAGATTGCCTCTCATTTTCTC
+ TCCCATATTATAGGGAGAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTCTTTGATTTT
+ TTGGCAACCCAAAATGGTGGCGGATGAACGAGATGATAATATATTCAAGTTGCCGCTAATCAGAAATAAA
+ TTCATTGCAACGTTAAATACAGCACAATATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTA
+ ATGAGTGCCTCTCGTTCTCTGTCTTATATTACCGCAAACCCAAAAAGACAATACACGACAGAGAGAGAGA
+ GCAGCGGAGATATTTAGATTGCCTATTAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTCTGCT
+ CTCTATATAATGACTGCCTCTCATTCTGTCTTATTTTACCGCAAACCCAAATCGACAATGCACGACAGAG
+ GAAGCAGAACAGATATTTAGATTGCCTCTCATTTTCTCTCCCATATTATAGGGAGAAATATGATCGCGTA
+ TGCGAGAGTAGTGCCAACATATTGTGCTCTTTGATTTTTTGGCAACCCAAAATGGTGGCGGATGAACGAG
+ ATGATAATATATTCAAGTTGCCGCTAATCAGAAATAAATTCATTGCAACGTTAAATACAGCACAATATAT
+ GATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTAATGAGTGCCTCTCGTTCTCTGTCTTATATTAC
+ CGCAAACCCAAAAAGACAATACACGACAGAGAGAGCAGCGGAGATATTTAGATTGCCTATTAAATATGAT
+ CGCGTATGCGAGAGTAGTGCCAACATATTCTGCTCTCTATATAATGACTGCCTCTCATTCTGTCTTATTT
+ TACCGCAAACCCAAATCGACAATGCACGACAGAGGAAGCAGAACAGATATTTAGATTGCCTCTCATTTTC
+ TCTCCCATATTATAGGGAGAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTCTTTGATT
+ TTTTGGCAACCCAAAATGGTGGCGGATGAACGAGATGATAATATATTCAAGTTGCCGCTAATCAGAAATA
+ AATTCATTGCAACGTTAAATACAGCACAATATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGC
+ TAATGAGTGCCTCTCGTTCTCTGTCTTATATTACCGCAAACCCAAAAAGACAATACACGACAGAGAGAGA
+ GAGCAGCGGAGATATTTAGATTGCCTATTAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTCTG
+ CTCTCTATATAATGACTGCCTCTCATTCTGTCTTATTTTACCGCAAACCCAAATCGACAATGCACGACAG
+ AGGAAGCAGAACAGATATTTAGATTGCCTCTCATTTTCTCTCCCATATTATAGGGAGAAATATGATCGCG
+ TATGCGAGAGTAGTGCCAACATATTGTGCTCTTTGATTTTTTGGCAACCCAAAATGGTGGCGGATGAACG
+ AGATGATAATATATTCAAGTTGCCGCTAATCAGAAATAAATTCATTGCAACGTTAAATACAGCACAATAT
+ ATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTAATGAGTGCCTCTCGTTCTCTGTCTTATATT
+ ACCGCAAACCCAAAAAGACAATACACGACAGAGAGAGAGAGCAGCGGAGATATTTAGATTGCCTATTAAA
+ TATGATCGCGTATGCGAGAGTAGTGCCAACATATTCTGCTCTCTATATAATGACTGCCTCTCATTCTGTC
+ TTATTTTACCGCAAACCCAAATCGACAATGCACGACAGAGGAAGCAGAACAGATATTTAGATTGCCTCTC
+ ATTTTCTCTCCCATATTATAGGGAGAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTCT
+ TTGATTTTTTGGCAACCCAAAATGGTGGCGGATGAACGAGATGATAATATATTCAAGTTGCCGCTAATCA
+ GAAATAAATTCATTGCAACGTTAAATACAGCACAATATATGATCGCGTATGCGAGAGTAGTGCCAACATA
+ TTGTGCTAATGAGTGCCTCTCGTTCTCTGTCTTATATTACCGCAAACCCAAAAAGACAATACACGACAGA
+ GAGAGAGAGCAGCGGAGATATTTAGATTGCCTATTAAATATGATCGCGTATGCGAGAGTAGTGCCAACAT
+ ATTCTGCTCTCTATATAATGACTGCCTCTCATTCTGTCTTATTTTACCGCAAACCCAAATCGACAATGCA
+ CGACAGAGGAAGCAGAACAGATATTTAGATTGCCTCTCATTTTCTCTCCCATATTATAGGGAGAAATATG
+ ATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTCTTTGATTTTTTGGCAACCCAAAATGGTGGCGGA
+ TGAACGAGATGATAATATATTCAAGTTGCCGCTAATCAGAAATAAATTCATTGCAACGTTAAATACAGCA
+ CAATATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTAATGAGTGCCTCTCGTTCTCTGTCT
+ TATATTACCGCAAACCCAAAAAGACAATACACGACAGAGAGAGAGAGCAGCGGAGATATTTAGATTGCCT
+ ATTAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTCTGCTCTCTACATAATGACTGCCTCTCAT
+ TCTGTCTTATTTTACCGCAAACCCAAATCGACAATGCACGACAGAGGAAGCAGAACAGATATTTAGATTG
+ CCTCTCATTTTCTCTCCCATATTATAGGGAGAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTG
+ TGCTCTTTGATTTTTTGGCAACCCAAAATGGTGGCGGATGAACGAGATGATAATATATTCAAGTTGCCGC
+ TAATCAGAAATAAATTCATTGCAACGTTAAATACAGCACAATATATGATCGCGTATGCGAGAGTAGTGCC
+ AACATATTGTGCTAATGAGTGCCTCTCGTTCTCTGTCTTATATTACCGCAAACCCAAAAAGACAATACAC
+ GACAGAGAGAGAGAGCAGCGGAGATATTTAGATTGCCTATTAAATATGATCGCGTATGCGAGAGTAGTGC
+ CAACATATTCTGCTCTCTATATAATGACTGCCTCTCATTCTGTCTTATTTTACCGCAAACCCAAATCGAC
+ AATGCACGACAGAGGAAGCAGAACAGATATTTAGATTGCCTCTCATTTTCTCTCCCATATTATAGGGAGA
+ AATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTCTTTGATTTTTTGGCAACCCAAAATGGT
+ GGCGGATGAACGAGATGATAATATATTCAAGTTGCCGCTAATCAGAAATAAATTCATTGCAACGTTAAAT
+ ACAGCACAATATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTAATGAGTGCCTCTCGTTCT
+ CTGTCTTATATTACCGCAAACCCAAAAAGACAATACACGACAGAGAGAGAGAGCAGCGGAGATATTTAGA
+ TTGCCTATTAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTCTGCTCTCTATATAATGACTGCC
+ TCTCATTCTGTCTTATTTTACCGCAAACCCAAATCGACAATGCACGACAGAGGAAGCAGAACAGATATTT
+ AGATTGCCTCTCATTTTCTCTCCCATATTATAGGGAGAAATATGATCGCGTATGCGAGAGTAGTGCCAAC
+ ATATTGTGCTCTTTGATTTTTTGGCAACCCAAAATGGTGGCGGATGAACGAGATGATAATATATTCAAGT
+ TGCCGCTAATCAGAAATAAATTCATTGCAACGTTAAATACAGCACAATATATGATCGCGTATGCGAGAGT
+ AGTGCCAACATATTGTGCTAATGAGTGCCTCTCGTTCTCTGTCTTATATTACCGCAAACCCAAAAAGACA
+ ATACACGACAGAGAGAGAGAGCAGCGGAGATATTTAGATTGCCTATTAAATATGATCGCGTATGCGAGAG
+ TAGTGCCAACATATTCTGCTCTCTATATAATGACTGCCTCTCATTCTGTCTTATTTTACCGCAAACCCAA
+ ATCGACAATGCACGACAGAGGAAGCAGAACAGATATTTAGATTGCCTCTCATTTTCTCTCCCATATTATA
+ GGGAGAAATATGATCCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTCTTTGATTTTTTGGCAACCCA
+ AAATGGTGGCGGATGAACGAGATGATAATATATTCAAGTTGCCGCTAATCAGAAATAAATTCATTGCAAC
+ GTTAAATACAGCACAATATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTAATGAGTGCCTC
+ TCGTTCTCTGTCTTATATTACCGCAAACCCAAAAAGACAATACACGACAGAGAGAGCAGCGGAGATATTT
+ AGATTGCCTATTAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTCTGCTCTCTATATAATGACT
+ GCCTCTCATTCTGTCTTATTTTACCGCAAACCCAAATCGACAATGCACGACAGAGGAAGCAGAACAGATA
+ TTTAGATTGCCTCTCATTTTCTCTCCCATATTATAGGGAGAAATATGATCGCGTATGCGAGAGTAGTGCC
+ AACATATTGTGCTCTTTGATTTTTTGGCAACCCAAAATGGTGGCGGATGAACGAGATGATAATATATTCA
+ AGTTGCCGCTAATCAGAAATAAATTCATTGCAACGTTAAATACAGCACAATATATGATCGCGTATGCGAG
+ AGTAGTGCCAACATATTGTGCTAATGAGTGCCTCTCGTTCTCTGTCTTATATTACCGCAAACCCAAAAAG
+ ACAATACACGACAGAGAGAGAGAGCAGCGGAGATATTTAGATTGCCTATTAAATATGATCGCGTATGCGA
+ GAGTAGTGCCAACATATTCTGCTCTCTATATAATGACTGCCTCTCATTCTGTCTTATTTTACCGCAAACC
+ CAAATCGACAATGCACGACAGAGGAAGCAGAACAGATATTTAGATTGCCTCTCATTTTCTCTCCCATATT
+ ATAGGGAGAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTCTTTGATTTTTTGGCAACC
+ CAAAATGGTGGCGGATGAACGAGATGATAATATATTCAAGTTGCCGCTAATCAGAAATAAATTCATTGCA
+ ACGTTAAATACATCACAAAATGGCCGCTCAAAAACAGGCTTGAACATATAATGACTGCCTCTCATTCTCT
+ GTTTCATTTTCACTCCCATATTATAGGGTGAAATATAATCGCGTATGCGAGAGTAGTGGCAACATATTGT
+ GCTCTTCGATTTTTTGGCAACCCAAATTGGAGGCAGACGAACGAGATGATACCATATGCAAATTGTAGCT
+ AATTTTCTCTCCCATATATATAAGACCGAAAACGGCTGTTTAAAAGTTCCCAATAGATTGCCAATATTTA
+ AGTCTATATATTTCTGAGAATAAATTGACCAGATTAAATATTAAAGGCCATGTTTTTGTATTGCTTTTTT
+ TATACCCCTTACTCATATATTTAAAGGGGTACACTATATTCGTTGAAGAGTATGTAACAAACAGTATGAA
+ ATGTCTCCGACTATATAAAGTATATATATTTTTGATCATAATCAAAAGCCGAGGCGATCTAGCCATGTCC
+ GTCTGTTCGTATGAACGTCGAGATCTCAAGAACTATAAAATCAAGAAGGTTGAGATTAAGCAGCATATAG
+ ATTCTAGAGACAAGGACGCAGTGCAAGTTTGGTGACCCATGTTGTCACGCCCATTCTAACGTCCACAAAC
+ CGCACAAAACTGCCATGCCCACATTTTTAAACCATTTTTCCTATTTTTTTCACATTTTATTAACTTTGTA
+ AATTTCTATCACTCTTCAAAAAAAAATTTGCCATGCCCACATTTTTTAACCATTCTTCGATATTTTTTCA
+ AAATTTAATAAATAACAGCCCAAAACAGCTACGCCCACATTTTTGAACCATTTTTCAATATTTTAATATA
+ ATTTTAGTAGTCGTGTAGATTTCTATCGACTTGCCAAAAAACTTTTTTCCACGCCCACTCTAGCGCCCTA
+ AAGCAGCCGAACCGGTTACGCCCACACTTTCTAACAATCGTTAAATTTTTTCTTATTTTATTGCCAGTAT
+ CTTTCGATATCCCAGAAAAATGATGAAATTTCGTTCACACGAACGGGTTTCTGATATTTGGGGAACTCGA
+ ATATAGCATTTTTATGTTGTTTCTTCTCGTAAATCTGTGGAAACAAATCGATTCCTTTTCCTATTTTATA
+ ATATAAAAAACTTGTACGCTAATCTTGGTACATTTTAACTGCGGTTACAGATCATGAATAGACTATATCA
+ AAAATTACTTGCAAAAAATCGAACAAAATAAACTATGCTTATATTATAAACTTTAACCTTTTCCGTAACA
+ ATGCAACCGTTCCCAAAATCTTTATTTTTAACAAATAGAAAATTTTGAATATAAATAAATTTTTCGTATT
+ ATGAACTAAATTTTGTATTTAGGTACATATATGTATTAGGGTATTAGCTAATATATTTTTGTTTTTTTTT
+ TTTTTTAATTAAGTTGTGAATATCTATTGAAATGTCTGAAGCAATTCCGCTCCTACCAATACTTTTATAA
+ AAAAGTTCAATATTTTTTTAAATTTCCTGCCATTTCTATTCTATTGAAATTTTTCTATCTTACTCCCACC
+ AGACGTGTAACATATTTTAATTGCTTGAAGATTGACTTTCGCTCACATCCACAGGGAAAACAAGAGAGAA
+ TGCAGTAGTCGAGCTCCTGACTCCAGGTACCAGTTAATCAGTTAGAAGCGTAAAAGAGAAATTTAAATAT
+ TTTTTAGGAATATTGGTAGAAATGGGGAAAAAATAATACAATAAAAATTAATTTAAATATTGTTCAAAAG
+ TGTGGGCATAACAGTTTTGTGTGGTTTGTGTGCGTCTGAGTGGGCCTGCCCAAACAATTTTTGGCTAGCC
+ GATAGAAGTTTGCAAGACTAAAAAAATATATAAAAAAATATCAAAACATTTTTCAAAAGACGGGTTCCTA
+ AGATCTAATCTTTATACCGACAGACGGACGAACATGGCCAGATCGACTCGACAATTGATCCTGATCAGAA
+ ATATATATACTTTATAAGTTCGGAAACGCTTCCTTCTACCAGTTACATACATTTCATTGACACTAGTATA
+ ACCCTTTACGCTAGGAGTGCGTATAACAAAGTTACCATATCTGGTTTGTGTAAAAATACTGATGACAGAC
+ CGTTCGTCAAGAAATACTGACAGTTATTGTATAATTAGGTTAATTTAAAAATTAATTGAATTTTAGGACG
+ GCTTATATTTGAAATATACTACAAAAACATAAAACTTGGTAAATTTATGAACGGTCTGCTTTCGGAATTT
+ CAGCAGAATCGGTTGGCAAGCAATTCACAACGAAGAGCTATCAGAGCAAACCGAAAACACAAATCAACAA
+ TGTTGCAGCAAGAGTTAATACGTTGGTGTAAGTTTACAAATCAGTATTCATTAAATCTAGATAGCTCTTT
+ GCGCTAAGAGTGCGTAAAACAAACAGTTACCATATCTGGGTTGTGTAAAAATACTGAGGACAGACCGTTC
+ GTCAAGAAATACTGACAGTTGTATAATTAGGTTTATTGAAAATTATCGAATTATCGGACGGCTGATATTT
+ GACATATACTAAAAACATAAAATTTGGTATATTTATGAACGGTCTGCTGTCGGTATTTCATCAGAATCGG
+ TTGGCAAGCAATTCACAACAAAGAGCCATCAGAGTTAACCGAAAACACAAGCCTTTTATGCAGCAAGAGT
+ TAATACGTTGGTGTAAGTGTACAAATCAGTAGGGACCACAAATTAACGTTCTTTTACGTATACAATATTT
+ CAGATAAATCCCACAGGTATGGAACACCATAAAGACACCGGTCAATTGCACCACTACGTGCAGTACGGAC
+ TTTCCGAAAGTGCACAGATTTTCGGATGCGCAAAAGAGCATCACATCTTGAAGACGCTCTGAGGAAAACT
+ GCTCCAAATCTAGTCCACCAGCATTAAACTACCGGTGGCTTCAATCTGGTTTAGGAAGAAGACCACAATA
+ AAGTGATCAAAGATAATCAGGTCTTCACCAATTTAAAGTCTACTACTTCAACGAATGAGATAGTCGTCCT
+ GCAGGCAAGGAGTCATACCAGTTGGCCGAGCAATATCAACAGCAGCAGATGGAATCGCGTGATGAATCTA
+ GTATCTCCGTCAGGAAGACGGGCACGTGTACAGCGAGGACAACAGTGATTTTGGAGTGGAACAGGTGGAA
+ AACCAATCCCAGTTGAAAACCAATCCCAGTTCGATCCCAATGTTGTGGCCTTTGTGCCTAGCTTTGACGC
+ ACAGAAATCCTCTCCCCCGCAGCCTGTTGCGGAAGTTTATCTACTTGGTGTTCAGCCCCGCTAACTTTTA
+ CCGCATGGCACCCTTGACGACCTTGTTGTGGAAAGTCTGCGTAAAGAATTTCAAAATTTCTGGAAGGGGA
+ AACCTGTAGATGCAGCTGAGCTGTTAAATGATTTACAAACAAGCCGACATCTCGGGAACCATTAAAGAGA
+ CATTTAAAGTCAAAAAGTGGCCAACTGAAACCCGTTAAAATCCGCTTGCGACCGCAACTTGGCCCGACTA
+ AGGCAAAAAATAACATAATCCTGTCAAGTCATGCAGACAGGGCGATTTACATTATAATTTTAAATGGCAA
+ TGGATTAGTCATCATCAGTACCTGCTTATCTGGTTTTCCTGATTTTTAAATCAAATCTGTGACTGTATCT
+ CTTACCTTTCCTCTTGTACCTCGTTATTATAAAATGCGAAAACCCTCTGCCAAAGGACACTATAAAACGA
+ ATTTTTTAAAAGACGCCAAACAAAATGGCACTTTTTGTTGAGAAGAAAATATGCCGATAAGAACGTTTTA
+ CTTGTAAGACGCTGCAGAAAGATTAGGAACGAAAACTATCGACAATGTTTACTTGTATAATCTGAGCTTT
+ CTAAAACACAAAAATAGTGTACTTTTACCATACGCTTAATTTCGAAATTAATCCGGGATATACAGTTGGG
+ GATCCAGATTTTAAATTCGTGAACACAGCTGCTGGAGTAGGGCATTTCCTGATCGATCTGTTAGTTTTCG
+ GACTTTTACTTTGGTTGTTGTAAACAATATCCGCAAGTTTCTCGCAAAGTGGGTTGCGTTGTGCCGTGCC
+ TCAGTAGAGCACTACACACTACCTTCGATTGAGTTCGCTGGGATTTGGATTTCGTTCACAGTCCAAGTTT
+ GGACCGTGCTAGGAGAAGATAATGATCCGATCACTCAATTAACTTCATGCACCCAGTGACGTCATCAGTG
+ CTTTACTATTCGGTGTCTATATAGTCTATTTTGTTTAATTTCTTACACCCTACATTTCGATACGATTCGA
+ TTTTCGTTTGGAAATTGTCTGAAGGTAAACAAGCATAAATTGGACGTTCAAGCGTAAACAAATCGGTTTT
+ CGGAGCAAAATACAAAAATCGTCAGTTGAGAAAGTCTCTCAAATGGCGCAGTTCTGCATTCTTGGAGTCC
+ TCCTCATTCTTTCTGGAACACACTGCTCGTGGGGATTCCATGAAGAGACACATTATCCGTGTGCCTTTAT
+ CGATACGGCAAACATAACGGGGAGCTACGGCTTAGATGGCCCATTTGTGCACAACTGGACGGTGATTCCC
+ CGTCACTTCGTAGCCGTGTACGACTTTGTCATCGAAAATGGCATCCGCATCCCCGCAAGCAGGCATCTCA
+ GAGCCTGTGTCTGTAAGACCAAACCCTGTGTACGGATTTGCTGTTTACGGGGAGAAATCTACGACCTGGA
+ GAAGAGGCAGTGCTTAGTCCCTGTGGCCGGGGTGTCCAGCCTTCCCTCCCATAGCCATATGGAGGTGGAG
+ TTGGGCAACGGCAGTCTGCGTCTAGTGAAACTGCAACCCCGTTTTAGCATCCACGTGGAAACACCATGTG
+ AGCACATGAAAGCCGTAACCAAGGGCTCGGAATACGTTCACTGGACACTTCATGAGGTCGGTTGTGAAAT
+ AAACCTTCCATCACATTAATGGCTTTACATCGCCTTTTCAGAACGGAACCATCAGCCACCGAGGACACAT
+ ATTTTCTAAGCATTACTGCTTCACTCCGCTGCTCCATGGGAACTCCACCTGGGAGTGGCAGCCATTGGCC
+ TGTGCACCAGAAAAACTATATTTCGTCTTGGGGGTGCGGGAGTGGACATACGCCATATGTAAGTAGCAAG
+ AGGAAACATTTTTCCAGCAACTTTCAGCAATTCATTATCCCAAATATGCACAATACTGTTTTCACAACAA
+ TACATAAAAGTAATTGCTAAAGCACCAAAAAACAATCGATGATAGCATTAATAGTTTGATAGTCAGAATT
+ TAATTTACCCAGCGTATTCACTTTCCAGGTCTCTTGATAGCTATTCTATCAATGTTTATCGTGCTGATGG
+ TCTACCTTATGTGTTCGGAAATGCGCAACAGTTTCTACGGTGTGGCCATAAAGGCGTACGCCATTTGTAT
+ GATCTTGGGATATGCCCTACTGGCTTATCTCACGCTCCACAACCCAGCAAATCTCTCAAATGCGGCTTGT
+ CGTATTCTACGTAAGTGGTAAATTTGAGTATTCTGTGATATTTAAACATTCCCTTCTTTTTTTTTTTTAG
+ CAAGTTTGGCGTTGATGAACTTGGTGCTTTCCTTTTACATTCTGAGCTTTATTGCATTTAAGCTGTACTT
+ GAGCTTTTATGGCGTTGTCTTCACAAAACTGATGTTTTGGCTAATATTTACTCCCATCGTACTGGTAGCC
+ GTGGGCTGGTCTTTCTTTGTGGGTTTCAGTTATTACGGCTCTAGGCTCATCTTCGGAGGCGATACATGCT
+ GGTTTGATCGTAAGCACTGCCAATCCATATATGTTTTATAATAATTAATTGGTATTCCACATCGCTAGCA
+ CGCAATTGGTCCGTTATGATATATTTTTACGCTCCTGTTTTCGTGGCTTGCGCCATTAGCGGTTTCTTCT
+ ATGTCCTGAGCCAGATCTACATCCGTGATCAGCCAGATATCGAGACGGAGAAGAGCTTCGAGTCCATAGA
+ GAAGAACCGATTCAAATCATTTTGGAAGTACTTTGGCTACACGGCAGTCGTATGGGTCGTTTGCATATGC
+ TCCTTTGCCTTTAACTACTACTGGGAGAACAGATCCCACCTTAACTACGCTGTAAGCTTCTGCATGGCCT
+ TCCACGGGTTTGCGGCCCTCTATGCGCTGATTGGAAAGAATCAGCAAATCCAAAATTTTCTGCGGCGCAT
+ AGATAAGTAAGTTGATAACTATGAATTTTAAGTACTACTGTTAATATATACTGTTGCAGTGGCGAAGATA
+ CCTGTGAAAACTCAGTTCCGCTCTCGAGTTTTGGTTAACTTTTCTTGTTGTGCCCACTGTAGCGTTAGTG
+ TAACTGGAAGCAGTTGAGTGTATCGACAATATCTGTGCAATGTTTTTAAAATCACTTATCAGCATAGACA
+ AAAACCATGTATTTTAAATGTAAAATTTTGTAGGATGTGTGTAAAATATATTTGTAAAATTTGAACTCGA
+ ACAAAAAAGTACACTTCTACCCTTTAAACGAAATTACGATAATAAAGATACAAAAAATAAATATATCTGA
+ AAAAAAAATCAGGTCTGGAATTTCTACAATTGTTAAATATGATAACAAGTCCCAACAATCCTTTCAGTAT
+ AGAACAAAACATGGAATATACTTAAGCCATGTGAAAGAACACATAACATATTAATATTCTAAACAATTTG
+ AGCAGTTTTCTTGAGTTTACGCCTCCAACAATTTATCCTTCACCTTTCTTGAGTTCCAAATTCCTGGACC
+ GTGATCAAGTTTCTCCAGTCTTATTTCAAGTCCCGATTTTACTGTACCCTATCCGCATCGCCAAGCCCGG
+ TGTTACTTCCCCGATCTCTCTATATTATAAATGTGCGCCGATTTTATTTAACATCAGAGGTCAATGGCCG
+ CAAAACAGACAGAGAGAGAGAGAGAGAAAGTTGGTCAGAGCCACGAGAACTGCATCCCGACAGGGGGCTG
+ TCAAGAGCAAGGAATCAAGTGGAATGTTGGTGGTGCTCTTTTGAAAAGGCTTCGCAAACTTTCCCCCTGT
+ ACACCCCCTTGCCAAGGCCTAATCGCAGAAAACCCACCCGGGTCGGAGTCCCCAATTCATTTTCATGCCG
+ ATTATGCTTCGGGTTTTGGTCCTGCTCTTTTTGGCTGGGCGTACAGCAGCAGGACTCGGGGTACACACTA
+ AGAGAGGTCTAAGAATATAGAGATAGACAAGGAAAGCAGATGGATCGATAAAACGTAGTAAAAATGCTCG
+ TAGTAATGGAAGCTGGAAATAACATGGCACAAACAGGCCCCAAACTGCATCGACAACACCATCACAATCC
+ AGACGTGCGCACTGGAAAATCCCGAGAGGTAGGACATGTTTGGCGCGTTTTTCGACTGCATGTGTGCGAG
+ TGTTCTGTTTTGGTTAGATACGTATGAAAAAGTGAAAAAGCCTATATTGACCGCGCCCGGTAGATCGCAT
+ AGGCAATATCGATATGGGAAATCATTGACTAACATTTGCAGACATTTAGTTTGGGACACATTAAAGTTAA
+ TTTGACTCGCACTATCAGAAGTGGAATCGACTTCTATTACACAGAGTTAAAGGTTTAGATCTTTTTTTTA
+ TGAATAAAAGAAAATGAACTTTTAAATATTCAACACAAAACACTCTTATAGAACATTGAAAACTCTTCCA
+ CTTAGAGGAACATCCGATCACTTTTCGGTCCCTCCAATGAATAGTTCCTCCACCTCCTTATAAACTCACT
+ TCCTACTAAAGCAAACGCACTACAATAACTTTTAATTTAACAATTTTTCAAAAATGCAAGCGTTACACTT
+ TTTATGCGGTTTATTTAAACATTTTTCAAAATGTTTAATGTTACCATTGTCACATTGGCTTGGAAACATA
+ CTACAGTATAATTCGCTTAGCTGCATCGATAGTTAGCTGCATCGGCAAGATATCTGCATTATTTTTCCAT
+ TTTTTTGTGTGAATAGAAAATTTGTACGAAAATTCATACGTTTGCTGCATCGCAGATAACAGCCTTTTTA
+ ACTTAAGTGCATCATATCAGCTGTTTTTTTTGCCAATTTCAATGAATATCATCAAAGTTAGCTGCGCCAT
+ CTATGAATCATTTTTGCATATCTAAAAGATGGCAAGAATGCCAACTCGTTTCAGTATCTGCGCATGTCCG
+ TTTTTGTTTTTGCTTTGATCGTGATTTTTGTGTTTTTGTTTCTTATGACACAAAGTTATTAAAATGGGTA
+ AAACAAAGCGTGTCGTTGGACTAACACTAAAGGAAAAGCTTCAAATAATCGAGTTAGTGACCAACAAAGT
+ GGACAAAAAGGAAATTTGTGCCAAGTTCAAATGCGACAGATCCACAGTCAACCGCATTTTACAAAAAACA
+ AATGAAATTCATGAAGCTGTGGCCGCGTCAGGTTTAAAAAGAAAGCGTCAAAGAAAAGGAGACACCATTG
+ CTGAAAAAGACAAACAATGCGTAGAAGTTGACATTGTATCGAATATTAATTGGAATGAATATGCCAATGT
+ TGATGCAGATGAGGCTTGCCATGGTCAATTAGATGATGATGAAATCGTGCGCTCTTTAGTTCAAGATGCA
+ AAAACCAGCGATAACGAAGAAAGCCATAGTGATGAAGATGTGGACGATACTGAGCGTCCTACTTTTAAGG
+ ATGGGTTTGCAGCAATTAAGGCTTTAAAGTCCATTTTTATGCGAAACAATAATGATGAGTTTTTGCAAAA
+ CTTGAATTCTATGGAAGACAAGCTGTTTAATTTACATATAAACTCAGCTGTATTGCAAAAAAAAATTACT
+ GACTATTTTTAAGTTAGTTTTAAAAAGTGTTTTAATCAATTCACCATCACTTAAATTTATATGTCGATCT
+ TACTTATCATTAAGAATGAAATTATCAGTTCCTTTTATGTTTAACATTGTTATAAAGAAATAAATTCTTT
+ ATTTTTCCTTAAAAAAAAAAAATTAAGTTAGCTGCATTTTTAAGTTACCTGCATCGAGGCATTGTGCAAA
+ GTACTCGAGGCAGCTAAGCGAATTATACTGTAATGCAAAAGAGAGTGCTATAGTCGAGTTACCCGATTAT
+ CAGATATCCGTTACACAACTAGTGTGAATGAAAACGCGTAATTTCATAATCCTTCTGCAAAATCGATAAA
+ ATGAGAACAAATTTTATAATTGTTCAAAAGTGTGGGCGTGACCGGTTTGGCGGCTTTAGGGCGTTAGAGT
+ GGACGTGGCAAAAAGTTTTTTGGCAAATCGATAAAAATTTACAAATCTAAAAAATTATGAAAAAATATCA
+ AAACATTTTCAAAAATGTGGGCATGGCAGTTTTTGGCGGTTTTAGGACGTTAGAGTGGGCGTGGCCAAAC
+ ATTTTTCTTGCGAATTGATTTTCGCTAACTAAATCGGTTTTTGTAAGCGATTACTAAGCCTTAAGAAAAT
+ TGTTTTTAAAAGTACTTACATTTCAAATGATTTAGCAACTGGCAGGAAACAGTTCATCGGATAAATTTTT
+ TGTCATGTGATTATTTATTTTAGTTTCAAGGTGCTTCAATGGTACAAGTACCAACACGGACCTGTTAGAC
+ CTCTGAGGCGATTGCTAACCTCTTCGCCAATTTGAGACTCTCAAATCAAAGAAAAATTCACAATTGTAGA
+ CCATCCACTTCAGGGCCCCCCAAAACTGTACAATCTTATATGGTTGCGACACGTGTTAATGCTTAACACA
+ ATTTTAAAGATCTCTTTTTTAGAAGTTTTCGTTATGCTTTCTATGGGAAATACGTCATAGTCCCCCCCTT
+ AAGTGTTGAGAGAAATACGAAAGCAATTAAAGCTACACAGTTTGGAGTGAAGAACTTAAGGCAACCACCG
+ CATTATTGGTTGCGTTATCGATCATTGGTCTCTTTCTTCCCGGTCTGAAAAATTTTAAACGGCCGATGAA
+ GATGTTTGTATTATCATTAGCCATTGGTAAACGTTTGTCCAACGCTCAATTAAGGAAAAAACTCCACCGC
+ CGATGTTGCAGCATTCCATCTTGCAACTAAACCGCGGTAACTCTCCATCCAAGGAAGATTCGACTACAGC
+ GACATCATTGCAGTCCAAAATTCCCATGCAACAATGTTGCAGAAGAGCAAAAGCATATCGTGCCGGCATT
+ GGCAGCAAAGACAACAAACACAGCTACGGTAACAGCGACATCATCGCGGCATGAGTGTGCGTTTTTTGTA
+ CATGCCCTCGGGTTTTACAGGTTATTTAAAGGAGTATGCGCGTTTGGGTGGGCAAAAAACACGGGAATAG
+ TTTATTAAGGGAAACTCAAAAATAATATTATTTTCATAGATCCCATTTAAAAAACAAAAGCAAATTTAAA
+ ACTTTTAAATTCCAAAATGGCGTCCTTTGGTCGACCTGACTTTTTGGTCTTTTAAATGCTTTAAGCCATT
+ GATATCGTTAAAGGAATTCCAGCGTCTGGCGAACGCTTTCTTTGCGGGTCAACAAAAGATTAAGAAGGGG
+ AACAACCGAGATAAGGTGAGATAGTCGGCCACTATGCGAATTTGTAACTAGGAACATGAACCTGCACGGT
+ ATTGGGCAGCCGCCTAAATGTTGCCTTGCGGCAACAATGTTGCAACTTCAACAAAGACAACGATGGCGGC
+ ACGTTAATGAAGTGATTTGCACTTTTTACCAGCTACTTTCTGGCCACCAGCGGTCGAGCAATCCCCGTTT
+ CCAGGAACAATCCCATCGAGGCGGTGGGTGAAATTTATGACAGCGGCTGTGGATCATCGTGTCAGTTTTC
+ AGAGCTAAAAAAAAAACTTGAAAAATCAGATTCCAAATGCGGTTTGTTTTGTACGAAGGCTAAAAGACCT
+ GATCAAGGAATCAATTCCGACATGGCGAAATAGAGCACTCTTCTCGAAGTAGAGGAAAGCTGAATCGATT
+ ATTATGATCTAAAGATGGGTGACGCGGATTTTTTGGATAAAAACTTAAACCATATGCAAACCAATAATAT
+ TTAGTATACAATAATTTGTATTCGATCTAAAGGCTTTTTCCAATAAAAATGAAAGCTCACTGATGATCTA
+ TTTGTTCAGTCAATGCCGATCGTGATCGATGCCAGATATATTGCATTTTTGGCTTCCAGAAAGCCTCTCG
+ TTCTCTCTATTGTTCTCGAACACGATTCTCTCCAAACCAATTTCTTTTGGGATTCAGTTTTAGCTTCTCC
+ AGAAAAGCTTTAGCTTCTACCATTGCCAGACTGAGACAAACATGAAAACGGGAGCATATTTCACATTTCC
+ AATGCAGAAGTACCCCATCCTTGTGTTTTCTAGGTCCTAAGCTTATGCTGGATATGGCTGGCCGAGAGTT
+ AACCATTTTTTAACATGTCAACATCTCTATTAGAAAACAGCTGAGAATCAAAAAAGTAAGGAACGAAAAA
+ TTAGTCAGTTGCTTTAGGCAGCTGCGTATCCTTACAAATTACATTAACATTTACTGGGGCCTTCTAACAG
+ CGCCATCTGTTCTGTCTCAAGAGGAGTAGCAACTCACATTTATGGGCCACACCACTCCCCCTTCCTTTTG
+ CCGCGTTAAATATGCAAGGATTTTGTTTAGCATTTTTCGGAAAAACTGAAAACAACATTTACTCAATTTA
+ AAGTCGTGTCAAAGAAACTTCTTCACTAGTGGAGATTCAGAGGATCAAGAAACATTGAAGGCTCTTTAGA
+ ATTTCTTCTGAAAACCCCCTAATAGCCCCATCTCAATAACCTTCGCTCTTTGACAAGCAAAACGTTTGCG
+ CTTCATTTGACATTTTCCTATTCTTACATCGTGGCAACTTAAATGGGTTAAGGTTACTACCTGACAGTCA
+ ATACAGGACTAGCAGCTTTACATTCCCCACTCCATGCCCCATAGCCGAAACTTTTACCCACTGCATCCCC
+ GACCACGAAACTTTATTTCGCTCTTTCATCAAAGACGTCGCACTTTTTTTTTCCATCCTCTATACTTTCT
+ TTTACAGTACTGATATATTTCCTAGGTTTTGTATTTACTATACTATAATGTAAAGGTATAATATTTCTAA
+ TTTTTGAAAACCTTATTTATCTTGTTAATAACAATTCGCCGAAATGTTGTTTATTATTATATAGTTGGAT
+ TAAGAGCTATGACAAGTCTTTTTAATTCCTAATAGCTGCGACCCAGACTTCTTACTGGGCTATACTGCCT
+ ATAGTCGAAAAGCAATTCAGCATTAATCTGAAGGCGAAAAGGTAACCATTTGGGCGTGGCCCGCTTACAG
+ ACTCGAAAAAATAGAACAGTGTAATGTAAGAACAGTGAAACTACAGGCCCAGACGAGTTGGCCAGGAGTA
+ GGAAGAAGCCACCCACAGGAACTGGCGACCAAAGTACAGTCGGCAACAGTGGCGACAGCCATAAAGACGT
+ CTGCTGCAGGCCGGCAATTGGCGCGGGCGTTGAGCCTGGGATCGGAGTGGGGACTGCTGCACTGCCCACG
+ AAAAACGACATCTGCCCAAATAACCTGCCAGTTTCCACTGACGCCGCATCCGAAAGCTAACTACACTATC
+ GTTTGACTTCGTAAGTTTCGCATGAAAGCTGGAATTTTTGATGCGTTCTCTATCCTATAAAGTTCGCTTA
+ CCTACTTGAGAGATCCACCAGAAACATTATTCATACACATCTAACTACCAAACTATGCGAAGTGATATCT
+ CACACAAAACAAGTAACGAATGTAAAAAAAATATTTCTGATAATTAGACGAAGAACAAAAGAATACAAAA
+ TGCTATGAAAATAGTGAGTTGGAGAAATTGTATTACCTAAGCTTTATGTACTTATGTACATATTTTGAGC
+ CGAAATCATAAAGCTTATGTATATTAGTTATTATTAAAAATAAACATAAACTTACTAGTTTAATGCACAA
+ GTCGCTGTAATCTTAAAAAATAAAAATAACTACAAATAATAAAGGTGCCTCAGAAATCATAAAGAATTGG
+ ACATTAAGGCTGGTTAATCTGTAAATTTAAATAACATAATAACGTAACAACAAATCTGTGTTCCATTTTT
+ TCTGCAGCAATCCCGATTTGCTGCGTACTTTAGTTTACTACCTTTTTTTTGTTGGATGTGCCCTTGGCTT
+ GTCTGGAGTTTGCAATTTTGGGTTCGTTGATAAGTACGGGTACCAACGCAGGCGCGCAGGAGATCTGACT
+ GTGCGTTGGTGATGCTAGTGAATATGTGTGGATGAGAATCTGTGTGATTTTGAGCAGGGCATTGTACTCC
+ ATTCACGCAGTGAGACTTTCACATTACATTATTCGGACCCGAAATTTAAATTCCATTTGGCAATCCTCCC
+ CGCCGTGAAAGCTCTCTGGCTCTCTCTCTTTGTTTCAGCAACCCAGCATATTCTCTTTGTGTACAGAGAA
+ GGGGCTCGTACCCGGACATCCCTCACCATAATTACAAGATAAGTGTTTAATGTCAGCGGCGCTCAGACCC
+ CAAAAGGTGGTCCCATTACGGCTTCCCACAGCCAAATGCGACTACTGGCATTCATGAATGAATTCCGTTT
+ GTGGAGCTACTTGGGTACGACTCCTTGATGCCTGGTGAATATTTACGGAATCGATAAGTTCAAATTGATT
+ GGAAATTTCAAAAGCGTCCTGGAGGCCAAATTTCCTTTGGGACTAAAGGCTAACCAAATACATTGAAATC
+ AATAAAATAACTTATTGATCGACCACTTAGATATTATAGAAAGACTTCTTAAATGAGATCGTATAATACT
+ ACATATCCTACAAAACTGCACACTCCCATACACGTCCTTTGCTTGTCGGGTTACAATTTCCACCGCCCGT
+ CCGGGATTTTCAGCGTACGGCGCTCAGAAACAACAAGAACCAACAACAAACGCAGTCACAGTAGCAACAA
+ CGAAAGAGAGGCTGCGTTACAAGCCTACCGTAAACCAAACAAAGATGTTGGGGCGGCTGGTGCCTGTGAA
+ TTAAGTGTGGTTCGGTTCGAAGAGGCATAGAATAATGGTGGAGGCTGGTCCAGAGAAGTGGAAACAAAGT
+ GAATATCGATTTTTGGACGACAGATACAACACCACTATCGATTGATAACAAGAGGCAATACTATAGTCGA
+ GTTCCCAAACTATCAGATATCCGTTACTCAGATGGAAGTGTGAACAAGAAATTGTAATATTTTTTGGAAT
+ ATCGGTAGAAATTAAAAAACAAAATTAAAAAAAAGGATTGTTCATAAGTGGGGGCATGTCAGTTTTAGGT
+ GGTTTGTGTGCGTTAGAGTGGTCGTTACCAAAAACTTTTTTGACAAAACAATAGAAATTTACAAGACTAA
+ TAAAAACATGATCGACTCAACTATTGATCCTGATCAAGATTATATATACTTTATATGGTCCGAAACGCTT
+ CCTTCTACCTGTTACGTACTTTTCAGTATAGTATAGTATACTCTTTTATTATACGTGTAACGTCTGTAAA
+ AATTCCCATAATTGCTTGCTCTCTTCCGTTTTCATTCTCCGTATTTGTTTTGCTCCTCTTTCATTCTTGC
+ ACATGGCATGGGGCGGTAATGGGTGTAGGGTTTACAGTAATTCCCCATTGCTCTTTTAACTGTCAGAAAA
+ TTGTCTCCGGCGTTCAGAGAAACACGCAGAATGCAAATGATTTTTCCCGCTCAAACATCGAAAATCAGCT
+ TGCATTTGTCGGGTTTTCTTGTTCAGCATCTTTTTGATCTTTGATCTAGTACGACTTTAAGAAGGGGTCA
+ TTCTTGGGTGCCCACTTGAGGATCGTAATAATAAATTAGTTGGAATAATTATGCCAAATTATGTAAGCAA
+ AGGCCGAGGTTGACTAACTTGACGGACTAACTTGATAAAGGTACGAACATCTTGCTCAATCAACTGGTCC
+ GAATACAGCTGGTGGAAAACTGCGCAGTCGTTTTACATGCAACACCACAAGCACGAAAAAAAGAAGACTT
+ GCAGACAGCGAAACTTGACCCAATTCCAGTTCGTGAATCATGCCTCAAAATCTCCGTTTTTGAGTGTCTC
+ ACTTCTCGGATTGTGTATGTTTGCTTTCCATTCTGGTAAAAAATGTCGTTTATAACGCGCCTTTTGTGTT
+ TGGCTTGTGGCTACCTCCATACTGCTATTCGCTCCACTCAACACTGCTTCCGTTTCCGCACTTGAATGGC
+ GTGCGCCACAATGGCAGCTCCCTTGGACTTTCACCATACCATACCATCTGTCCACTTTGACATAAACGGG
+ AAACGGAAACGTAAATTTTGCGCCCATGCGTAAAAATAGGCTGTAAAACATAGGGAGTGCGCTTGCGAAT
+ GTTCCAGGATGCGGTCCTGTGGCCCTTTGTGTCTACATAAGGATGTGTGACAATAGCACCGACTTAACAT
+ CCCCCGTTGACCAAAACTCGGGCCTACTATTTTTAAAACGCTACAAAGTTTTGTTTCAATGGACTTTTTT
+ TCGTTTTGTTGCGTGTGGAGATGGACTAACCGCGAAGGTGGAGATGTTCGTCATGTCACCCACGCCAATC
+ CAAAAGTAAAATTTAAACCTAAGATGTGGACTCCGGAAACTATTATTGTGCCTTGAAACATCTTGTAATA
+ ATAAAATCAAATTAGCTATGGATGGAGCTCAGAATGTAACAATATTCGTTAATTTTATAAGTTTAAAAAT
+ GGAATAAATGGAATTCAATATTTTTTTTGTAAGTGTAGTACTTCAATGTAATTCAGGAAATTATCGATAC
+ TTTATCATTGGTAATCTCTCGCCCCCACCCTTTTGTTTTTAGCAGAATGATATAATAATGATGAATGATA
+ TATATAAAACTAACCCATATCAAAAGTTTTAATAATATGTAAATTATTCTTTCCCCGATTTTGATAAACG
+ TCTAAACGTGATAAACTTTTGTTTCAGTTTTTTTTAGTTCTCACTATTTTTTCAATGAGTTTGATTGGCT
+ TCTTTCTGGCATGTCCTCCCTTTTTCATGTTTGCTTTTTTTTTTTGCCCTGGGGCTTTCGTGGTTGTGTC
+ CATATATTATTCATAGTTGACAAGAAATGTGTAACAAATCGTTATTGAGTTATCCATGTGAAATAAGAAG
+ TTAACGGATGTAAAAAGAAAAGGGAAAGCATAGCAGGTCCTAATAGTTTCAGAACACGTCGCCTGCTTCA
+ AACCAAAAATTAATAAATATTCTCAACATTTCCGAAGTTTTCCTGGGGTGTGGGCTGATATCAGATCTAC
+ TAAAGTTGAAGCGTTTTTGGGGTAGCCCTTAGAAAAATGTGAGACGTTAAATAGTGTATGAAAATTTATC
+ TCAGATGAAGGTTGTATTAACTACGACGCCTATCAATAAATCATTTGTTTGGAAATTTTCAATATTAAAA
+ ACTAATTTTAATACTCTAATGTGTAGGCGGGATAGATTTGGGTGGTTTTTAGAGGTCAGAGTGGGCGTGG
+ ACAAAATGTTTTCAGCGTATCGATTAACGGGTATAACATTTCCTAAACAAGCGTACATTTATATGTAGGT
+ ATGTTTTCCCAGATGGAGCCCCAAAATTTTTGTGATGCTATTTTTTTTTTAAGAAAAGACAGAAAATAAC
+ ATCTAACAACATCTCTAATGGCACTTTTACCCTCAGTCTGTACCATAAAGTTGCAACTCTGCATTTGTTT
+ AGCACTTTTAAATTGCGCGCGCAAATTCAGATTAAAGGCACAGGGTTTCAGTTTTAAGCGTCACTTGCGA
+ GACAGATTTCGTTGGGCAAAATTTTTTTAAAAAAATTAAAAAAAAAATCAACGAATTATTATACTTAAAG
+ TATTCAACTAAATTAAATTTGATCGTATTTTATTTATCAATTAGTCTTCCTACATACTCCAACGAGAATT
+ TACCACAAAACATAAGTCAATTTTTTCCAGTGGAATGCGAGTCATTTGTCGTCTAAATTTTCGCATTGGC
+ AAAATTACTTTTATGCAAATGCATAGCACATAAATGCTTCACAGCATTGTTGTTACGACAAGTTTGCAGA
+ TGAGTCGCTAACTTGGGCGAGGGTGTCGAAGGGGCGATTAGCCACTTTCGCTTGAGGCGTAAAAAAACGT
+ TCGGTTCGATGTATTCGAGTGTCTTGGGCTCCAACGGCATCGAGAAAAAATCCTTGACCAGTTGGTTGGC
+ AGATATATAGTGTGCGGAGTTATATGTAGATGCTCGTAGGTGGGCCACAAACAGGAAATGTCTGAGATTG
+ TGTGGGAATGGCACCAAATGGAGGGGAAGGCAGTTACTAAGAGCCTGGGATATTCCATAATTAAAATGTG
+ GCACACCTATTGAGATTCCATTTGCCAACAGATTCTACAGATGTAGACAAGGAGCCAATTAGTTCAGAAC
+ GGTACCCACTCTAAAGTCCACAAATATCTACTCATGTCCTGCTAATTTCTCTTAAATTGCCGAAAATTTT
+ TTTTCATATATTTATAGCACTCCCACTATTTAAGAAGCGGGTATCTGATAGTCGAGAATTATTAAAATGT
+ GGCACACCTATTGTGATTCAATTTGCTAACAGATTCTACAGATGTAGACAAGGAGCCAATTAGTTCAGAA
+ CGGTACCCACTCTAAAGTCCACAAATATCTACTAATGTCCTGCTAATTTCTCTTAAATTGCCGAAAATTT
+ GTTTTAATATATTTATAGCACTCCCACTATTTGAGAAGCGGGTATCTGATAGTCGAGAACATGAATCTAT
+ ATAGCCACTATAGCCACAAATCTTTCGTTGGTTAATAATTGAGTTCATAATACACCATAGCTGATTTCAC
+ ACCGCACCCATCTACAGATCTCCCAAGATATCAACTTTCCGTACCTTGTGTCATGATCATCATTAATCAC
+ GGCCGCTCCATTTGATTATTCTCCTGGTATATTTCGGGTCGGACCGAGTAAGACATCTAGTCAGCCCAAA
+ GTCCCATAACTCATTCATAGCACGATGACATTCCGTACTCATATTCATTCTTGCGCTTGGCTCGAAGGCC
+ CGGGACTAAACGATCGTTTGGAGTGGAAAAAAGTGTCAAAAGTCAATGTACTTCTAGAAATCTTACTATC
+ GAATAAGGTAAAAATAACAAATTTATTAAAAACAAATTACTGAGTAAGTTGAATTTATTTGTGTGAAATA
+ AAATAAAATATAAAATAAAAATAAAAAATATCGAATAAGGTAAAAATAACAAATTTATTAAAAACAAATT
+ ACTGAGTAAGTTGAATTTATTTGTGTGAAATAAAATAAAATATAAAATAAAAATAAAAAAGTGTACCTCT
+ AAAGAAAGCGTTATTTATTATTTTGCCTTTAGAATCATAACAATTTCAATTTTTCAAATGTCTTATTAGT
+ TTAATTCAGCTATTTCTAGCGATGCATGAAGTCAGTTTTGGTCGAGTGCCGTTTGACGTGGTATTGAGCT
+ GTGTGTGCCAGTGTTATCGCTCTGTTTACACGCATCCAAAAAAGTAATGAACTATAGTAAACCCAAACAA
+ AAGCCGGGCAATGCAATGCGTGTGATTCAAAAACAGGGAAGCAAACCGAATTAAAAAACAACGCAATGTA
+ TGTCACGTACACGTTTAATGGCGAAATAAGTAACCGCAGTCTATAGAAGTCCAACTCCAACTCCGAAAAA
+ CCACTGCTTAAGAACGTCCGCTTTCTGAACTTCTTCTCACGAAAGCAGTTGGTCAAACCGATCACGTCTC
+ TTTATCTTTTACTATACCCGTTACTCATAGAGTAAAAGGGTATATTAGAATTGCTGAAAAGTATGTAACA
+ GGTAGAAGAAAGCGTTTTCGACTGTATAAAATATACATATCAATAGCCGAGTCGATCCGAGAACTCAGGA
+ ACTATAAAAGCTAGAAGGGTGAGATTCAGCATACAGATTCTAGAGACAAAGACGCAGCGCAAGTTTGTTG
+ ATCCGTGTTGCCACGCCGACTGTAACGACGACAAACCGCACAAAACTGCCACACCCACAGTTTTTAACCA
+ TTTTTCGACATTTGTTCATTATTTTCCTAGTCTCGTAAATTTCTATATGTTTGCAAGAAACTGCCACGCC
+ CATAATTTTTACATTTTTCTAATATTATTCGCCATAATCTATCGATATCCAAGAAAAAATATAAAATTTC
+ GTGATCGCATTCACACTAGCTGAGTAACGGGTATCTGATAGTCGGGGAACTCGAATATAGCATTCTCTCT
+ CTCTCATATCAATAGCCGAGTCGATCCGAGAACTCAGGAACTATAAAAGCTAGAAGGGTGAGATTCAGCA
+ TACAGATTCTAGAGACAAAGACGCAGCGCAAGTTTGTTGATCCGTGTTGCCACGCCGACTGTAACGACGA
+ CAAACCGCACAAAACTGCCACACCCACAGTTTTTAACCATTTTTCGACATTTGTTCATTATTTTCCTAGT
+ CTCGTAAATTTCTATATGTTTGCAAGAAACTGCCACGCCCATAATTTTTACATTTTTCTAATATTATTCG
+ CCATAATCTATCGATATCCAAGAAAAAATATAAAATTTCGTGATCGCATTCACACTAGCTGAGTAACGGG
+ TATCTGATAGTCGGGGAACTCGAATATAGCATTCTCTCTTGTTTTGATTAAAGTCGACCGGGGTCACGCG
+ ACGTCAGTTTTTATTAAGAGTTCTTTAAATATATTTAACACTACATTTGAAAGAGTGCTTCACATTTCAT
+ TTTAAAATTTTCAGTATTCCCAGTATATAATCACATATATATTCCATGTTATTATTACTTTAATTTATTA
+ AATGGATGTTGTTAAAATATCAAGATTATCTTCGACGAAATATGAAATAAGAATAATATCCCATGAAATT
+ TAGGAGTTAAGTTTTATTTTACACTTGAAAACGGTGCCTGAACCAATAGCCCCATGGTCATATTACATAT
+ ATACATACATATGTATGTATATAACAAACAAAACGGCCCCATCTTAAATCTCCAGATAGAAATGGATTTC
+ TAAGCAACACAAATTGTAAACAATTGTAATATCTGGTCAAATAAAAACAAGCAAAATAAGATACGGTTCC
+ TAACATAATAAATACAGTGGGTCAAAGAAAACCAGGTTTTTTAAAACTTCTAATAGTGTATCAATATCAA
+ TGTCCATTTTTCATCATCATATAAGAATTTTGTAATTGATATTTGTGTTTATGTTAAAATGTTAACCTTA
+ GAAATATTTGTATTTGCATTTTTCTACAATTTTATTTTACCACTTTCAAATACACGAAATACTACTAATA
+ AAACATGTATACAATTATTTATACATTTGTGAATACACTCGCGCTCGCATTAAAAATCAATTAATTAAGC
+ AACAACAAAAAGACAGCAAAACAACAAGACCGGCGTCATCAGTTTTGGAATCGGTTTCTTTACTCCCTTT
+ TTTGTTTTTATTTTGCCTTGTCTTGTGTCCCGCTCGCACATATTGTACCATATCGCATAGAACGAAGATT
+ TGTTGTTGTAAGTGAAATTGGCACGCGGCGCAGTCCGCGTCGCCGCTCCATTCAAATGTTGTGAAATTCC
+ AATTCCTCCCTCTCCCGTTTTGAAACTTTTTTCGCCCACAACAGCACACACACTTGCATAGCTTATAATT
+ GTTTGTTATTTTTTTGTCTCGCTTGCACACTGGTTATCGGATTTCAGCAGAAATATAATAAGGAAGGGGG
+ TACTCAAAATACTACTACCAATATTTCGCTCTCGCTCACAAACCACCACACCATTCCATTCATAGGAGCG
+ AAAAAATTATTTACGATTTATTTTGATTTTTACAGGACGGAAAGAATGAGAGAGTCGATGTAGAGAGAGA
+ GAGGGGTTTTGGTGTCATCGGGGACTGGGGTTGGGTACGAAACGAAATGGAAACATAGCCAAACACAATG
+ GTATAATTTGGTGCGCGCGGGCGCACAAATGTATTGTGGAACCAGAGTTCATCCACTCGTTGGTGTCATT
+ TCCACATCGTTCCTGAGTGTATATACTCTTTAGTTTTATTTCCACCATTCCTATGGACATCTACCAGCTC
+ TCTTTGTTCACCACGCTTGTTTTTATGTATTCTCTCTGTTTTTGCTTCTGCGCCGCTCCCCACTATTTTC
+ GTAACAAACTGTTTCATATTTTTGTAGACTGTACATATTTCGTTTTTTCATTACATATTTTTGTAGTAAT
+ AATATCTAAAAAAATAAATTAAATTTTTTTCCTATAGCTTGCATTCAGCGAACACTTCAATGACTCGAAA
+ AAAAATGTTTCCTCTATAAAACTACTGCAGTGTCTCCCAATTTAATTAATCTTCTTTTTTTGAAAGAAGT
+ GTTTTCGTTTCTTAATAAGTTTTTCGTTTGTTTTGTTTGATTTTTTATTATAATTGCCAAACGAGGCAAT
+ AAAGAAAATGGATAACTGAAGTGGCGGTGGGGTTCTGAGCGAGTATTGGATATTCGACAACCTGGGCGCT
+ ATCTACATAAATTTATTCGCATGTCACAAAAATGCGACATCCTCTCTGGAAAAGTTCAAGAATTTCTATA
+ ATTACGAAATTTTCCAGAATATGTACATATGTATATAAATTCGCATTACACAAGCCAATATATGTACATA
+ TTTTATACCTAGAATTAAACAATGATGATTTTTATGTAATGTACATACATATGTATATCCCATTTATTGT
+ ATATTGATTATAAATACAATATTTATTGAAGAAAAATAAATAATAAAACGAAAGAAAACATAGGTTAGCT
+ AATCGGATTAGACAAAATAAACTTCAAGACTCCCACATAACTTACGTGAAAAAAGTGAGTCGTAAAATAT
+ AAAGTGGCGGCATAAAAGGTTAACCCAGTCGGACTCAACTTTTATTTTATTATAAACAAAATCATTTGGA
+ GTATTTACCAGAGACAAACAACGAATCAATCAACCCTTGGAGGACTGTGCTTGTAATGTCTAACCCAAAT
+ ATGCGTGCCAGTGCGTGTTGAATCGAGTAGATCTCCGCTTGTATTTGTGTGCGTTCATGAGGGGGAAATG
+ TGGAGCGCGGTTTCTATGGCTTTACGTTTTCGAAACTGGGTCAAACAATTGGGTCAAGCAATGAAAATTG
+ TCTGGGCTTCCTAGCGGGTTTTCATTTTCCGGTCAGCACATCCTTTTCATGCAATCAGCATACATCACAG
+ TGTGAAAGTCAAGGGAAACCCAAGAAGATCAAAATGCCAGTTCAAATAAAAATCCGCATCCACATCAACA
+ GCAGATTCCGCATCATGGCGGGTTCGCGTGAGCGGTTCAAAGTCCACAATTTCAGCTCAGAGCACTCGGT
+ TGTAACGGACTGACTACAGTCGATCTCTCTCTTTAGCTGTTGCTTATTTTGTATTTTGTGTAAGATATCA
+ CAAGAGATTTGGAGAAGTCTGTATCATCTAAGCGGCAAAATGTAAGTTTTAAGATAAAAACTACAGAAAC
+ AATACTTGGGGCAGGGCTATAAATTATGTTCAATAATATTCATCAGGGTAAGGGTGTTTGACAAGTAGTC
+ TCCGGAAGTTTGACGGCCTTTAATTGGTATTTATCTTTAAGCTACAGTCTCAAAAAGTTGGCTTGGAGAT
+ TAGTTTATTTTTGCTCTGCGCTATGCCTTTTGTTATTGGTTTATTTTTGCACATTGCATAACTGTTCATT
+ AGCAAAGGCCTTAAGCAACAATAGCAGAAAAAAACAACAGCAAAAAATTAAACGAAAACAACAAAAATGT
+ GCCAAAGTACGTCACACAAAGCTTCAAACGCTTGAAAACGCTTTCGATCGACACACTCTCAAAATATTAT
+ TCATAGTTTTACTTTCAAGACCTGAAAATACTATGAAATTTTAAATCATTTGGGGACAACAATATATAAA
+ CTCAAAAAAACATTGAACAATTTGCATGCTAATGATTAACTGGAAATACTTGGGAACCCAATTTTATTAA
+ AGAGCGGGTAGTAAGTATACATGTACATATAGATGTTTGGGTTGTCTTTTACATTCTACTCAGCTTTAAT
+ TATCACAAAATGATCTTTACATGAACTCATCAGCACAAGAGATATTTCAAAGACTGTCGGTTTCGGTTAC
+ ATCTATTAATGCTTCCGGATTTTTATGTTGCTAAGGAGCAGGAGAAAAATAGTACTTTGTATATAAGCTG
+ TGCCAAAAGTGCTCGGTTTCCTTACCCTATCTCATACTTCAACTTAGATGACTGAACTTTTTCTCTTTTT
+ GCAGAACACAAAAAGCCATTTTATGAATTTAAAAATAAATGAATATGATAAAAATGAATGAACTGAATGA
+ ATGATAAGGTGACAGTAAAAGCACAATAAAAAGTGCCCCTAAAAACTTTTATACAATGTTATTTTTAATA
+ ATTTAGTTTTCCAATTTTCGTGCAGTGCCTTAAACTGACAGCTCTCTACTTGACACTTTTGTCACGTCTG
+ TCACTTGGCTGAGTCTAAGCCAAACGATGACAAATTACTTAGAAAGTGCAACAAAGTTGTAATAATGGGG
+ AGGGGGTAAAATGACAAGCTAAAAGGGGTAGTGTTGGGCGGGGTGCGGTTTAAGGTGGTCCAAAAATTCA
+ ATTTCCGCAAAAATGTGGTCCTTGAAACTGTTGCACAAAATCATAAGTAACATCCCCTCCCCGAACATAC
+ CCACCAAACCTCTTAGGCCCCTTGCTAGTCGGGGGTGGCAGTGGACAGTCGACAGCCGCGTTTACCCATC
+ CCGGTTTTCTTATATTTTGCCCATAATTGAATTTCGTAGCAGTGCAAACTAGGTTTGGCTTTGTGCATTC
+ GGGTGCGGCCATATCAGATGCCAGTTGCTAAGCTAGTGGAAGAGCAAACGAGAAATTTCATAATTTCCCT
+ GGCGTTGGAGAATAAAATGAGGAAAATTAAAAAATGGTTGTTGTGGTGGCCATAGTGTTTTTTGGTACAA
+ AAACAAATCAAAGAAATGTCAAAACATTTTTTAAAAGTGTGGGCGCGGACGTTTAAGGCGGTTTGTGGAA
+ GTTTTTTGGCATATCGATAGAAATTTACAAGACTAATACAAAAATCAAAAATTAGCAAAAACTTTTCCTT
+ TTTGGGCTCCTTGAAAATACTCTGCAGATCCTTCTGGATTGATTCATTCTTATTATTTTTAGATGTAATA
+ TTTACCATTTAATAAATTGTTGCGTGTATTATTTAAATTCTTACCTAGATCAATATCTGAATATTTGACA
+ ATTATTTACATCATATACATATGCAAACATATATTTATAAAACATAACATAAATTTATTCACCCTCCATA
+ TCTGCATGGAAACAATGAAGTGAGGCATAACCCCATACTACCAGATAGCAAATTAACAGTATACTAGATC
+ GTATTCCGGATGTTTTGTCGCAAAAATGTGCAGCGATGTAGCCAGCTCTTAAGCACTCGAGATGCCTTGG
+ ATACTTCAGTAGTGTACACGCGCCGACATTTGGTCTAGACCCCTCCGCATACACACTACCCCTGCTGCCA
+ CTAGGACTGCGGTTTTAAGTACCTGAAGCCCCCCGATTGCACCCTGCTACACCTTCCTTACCTGATTACA
+ CACGCGCCTCTTTCTGCATTTACGACCAAAAAAAAAATAATAAAAAGTAGGGAAATGGGAATTACGATAA
+ TGGTCTATGGCAAAAATAACGAACGGCATATGTACACTACAAGAAACGAACGTTTTTGGTAAGTTACAAA
+ TATGTTTCTGAGTTCATATCTTCAGAGTAAGCTAGAAATAAGTTTAGCCAATTCAAAGGGCTATTAAGTG
+ GAGGTACACTACTGCTAGTATGTTTAAATTGCTCAACCCCCATTTTATGTCATTTCTTGCATTGTATTCT
+ ATCTAGATAGATAGAAGGAATTGGTAGCCATTTGTGTGTAACGGTTCCTATTGTTCTTGTAGTTTTTACG
+ ATTTCCTTGTAGGTAAATGTCAAGTACAAATCAATACTCGAGTGATGAGTGAGTAAATAATAGGTCTGCA
+ CGTGTGAGTTTTTTACTTTGTATTAAAATGGCCTTGGCAACGTTTGTTCACCTTATTCTGATGAAGTTAC
+ ATCAGCAACAAATACACTAGCCACTTGACAAAATCGCATTCTTCTGTTAAATACCGCTTGGGCTTGATAC
+ CGTTAACAAACAGTGCGAAAAAGATGACCAATGCCAATAATGAATATTTACAAGCTCATTTAGTAAGTGG
+ TATTCTGCTATTGAGCAAGTGTAAATCAATTGTTTAAATTGAATTTTTTTGGGGTCAATTGTAAAAAGGC
+ TCAGTTAAGTTTGTTTATTAGATCATCGTAGTAGCCCAGTTTAACGTTGGAATTAAAGTAAAAAACATTG
+ CGAAAGAATTTATTTTGTCGCGTAAATGGTATGTATTATCAAATTAAAATAAATAAAAACCAATTACAAA
+ GAAAATACAAAATCAAACGGTTATTCTTTCTATCTTTGTTACACTATTTTACCATTTTGAATCTTTTGAT
+ ATGATCATATTTATTATCAATTAATGACAACATTTCAAACACATGCTTCCGAAAATTTTTCTTTTCGTCT
+ CAATCAATAATTCCCATGAAGCGGTACCCCTTCATGAACAGGCCCAAGGCCAAAATATTAAGTTCCATCG
+ TCTTCCACACATCTACAATCAAGATGGCCACAACCAAAGTCAATATCCTTTCTAGTGTATTTGCCCGGAC
+ GTTATGAGACATTTATTATATGTAGATAGAAAATTGTATTTTATGTTTGCAAAGCTTCCAGTCTTAACAA
+ AAACGACATAGGAGAAAATGCGTTTCAAGCAAGAAACGAACTTCATTATACCCGTTATTAGTAGAGTAAA
+ AAGAATGTAACAGGCAAAAGGAAGCGTTTCCGACTATATAAAGTATATCAGTATCAATAGCCGAGTCGAT
+ CTAGCCATGTCCGTATGAACGTCGAGATCTCAGGAATTATAAAAGATAGGTTGAGATTCAGCATATATTC
+ TAGAGACAAATACGCAGGGCAAGTTTATTGATCCATGTTACCACGCCCACTCCAACGCCCGCAAACCGCA
+ AAAACTTAAATTAAAATGTTTTCTCATTTGATACCCCAAAATCTATCGATATCCCAGAAAAATGATGAAA
+ TTTCGCGTTCGGACTCGGACTAGCTGATTAACGGGTATTTGATAGTTGGGGAACCCGACTATAGCATTCC
+ CTCTTGCTTTTTTTTGTTGGCCATTTCTACGCCTCACGCATTGCGAAACTTTTTGCCGATATGAATGAAA
+ AGCTACAACAAGGTAATGATGAAATATCTGTCTTTGCACTTCGCATTTTTATATCTAGATTTTTGAGTTT
+ TAGATCTACCGTTTTATCAATGTTCTGTTGGTACTATCAATGTTTTCGTTTTATAGCGGTATGAACGTGC
+ CAAAAATCGAAAGTTTCGATCGCAAAATGCGGTAATGCTGAAGCCAAAAGGTGTCACATTATATGTAGGT
+ GGCAAACGGACACGGGTCGTATGCGTAATGTTCTTGGCATTAGGTCATAAATGGCCATAAATAGCAATGC
+ CGTCGAGGAGCTTATGAAATTCTAAAAAAAAAGACGAGCAAGCGCGTTTATTTCGGCGTATGGGTCACTC
+ TTATAAGAATTTCATAAACCCTCGATTGTGCACGCGATTGGAGAATCAGGTTAGCATGATCAATAATTCT
+ ATGATTATAAGTTGAATATGCAGGTTAAATATTTAAAACTAGTAAACTCAAACAACGGAGAACCTGCAAC
+ AGTCGATTTCCTTGACTTTCAGAGAATTTCGTTTCTATTTCACAAATATCAACTCTATTTGCAGCAGTTT
+ GCTGTTCGTTCACAACAGGTAAAAAAAATAACTCAATAGAGATATCTTCGATTATCGGTATAAATACATA
+ TTAACCCCTTAGGCTGTTGGAATATTACGCTCGTAGCTTGGCAGATGTTGTTTCCCTACCGACTTTGGGG
+ GTATTCCCCCATTCAAAAGCAAAATCGCAGATGCGAAAAACGAAAGTTAACGAAACTATAAGCTAACGGA
+ AATTGCTGTTCGTTGATTACGAATTGTAATTAACACTCTGTCGCCGATCGGGCTTCAGGCGAAATCTATG
+ GAACTGAACTCTTAGAGCACACGAAAAAACGCGTGCCGATTCACAAACATTTTGTATCACAATTCACACA
+ CGGCCTCTAATCATTTTATTTGGCCAATAGTTTCCTACACACGTAATTAACGTGAAGGACAGAATATAAA
+ AAAACACAAAATTAATAACCAGCTCACAACTGTCAAATATTGCTAATGTTAAAAAACCCTTCTTTATTAT
+ TTGGATCATTACTTTTTCCTGGCACCACAACTTAAATAGGTTACAGCAATGCCGAAATAAAGAATATAAC
+ TCGAGTTCTATTCGGAAAAAAAATTGTCAATGTGTTTTATTTTCCAAACTATTAACCCCTAAAGACCATT
+ CTACAGATCGTCGGCGTTAGCTTTGCGTTTTATGGTCTTTTTTCTTATTTCAGGTGTGAAAAGTTGGAAG
+ ATAGTTACAAAAATCAAAAAACAAAGTTTCTCATGTAAAATAAGAATATAATTTTTTTATTTTTTATTTT
+ CATTTATCTTAGTCTGTTTTTTCGCAGATTCACACGGAGAACTTTTGCCAAGTGATTTTTGTGGCGAATG
+ TCGGGGAATCTGTTTTCGCTGTTCGTGCAATAAATAAGCAAATTTGCATTCAGCTCAAATACAAAAACAA
+ ATGCATAAATAAATTAAAGTAATTCGAAAAATTTCGCACACGACCTCAATGAGTCATCAGCGATGGAAGG
+ GGACATCAACATTTTCCCTTCTTTTCTGCGCAAGCTGAATTTAAAAACACAGTCCCAAAATGTGTAGGAA
+ AAAAAAACAAAAATAAAACATTGATTTATTTCGTAAACAAAAATTTTAACTGAAAAAACGTAAAAAAAAA
+ CCACAACAAAATTGTTGTCATGCCCGTTACCGAATCGGTAATCGCTTTTTTGATAGCTTCTACATTTTCC
+ TATAGTACTTAATGTGTGTTCTGTCTATATGGCTATCCCATGCGATCTTCACCTGCCTTCGATTTTCGCA
+ CGTCCTGTATTTATGCCCGCTGTTAGCGATGCTAACGATGACCTCAGAAAATCCATGTTTGCCCTCCATC
+ TTCCATCATCACACATAAATGCAGACCAGACAAAATGCACTTATCCTGCCTGGTGGGAGAGGCCTCAAAT
+ GAAGTAATAAGCAGACTCGAGGGGCATAATCGGCTACCACTGTGACTGACCAACACGCGGCAGGTGCTTG
+ ATATTTTCGTGTTGCGAAGTTTCTCGAGGACTAACTGAAATGACTGCAGGACTCCCTGCAAACGAGGCCA
+ TGCCATTTGGCCGCTTTCTTAGAGGAACAGGCTGCAGCTGCCATCTGATCCCTTCGTCAATACCGAACGC
+ AGCAACACGTGGCAGGGCAGGTGCGAGCAGCAGGCATTAAACGGCTGGTTTGCATTGTAACTGTGTCAGC
+ TGCCGTTGTCGTTGTACTTGTTATACTTGTGTTTGTTGTATTTATTGATCAATAATTTAACCAGAGCTTA
+ TTGTTTTGCGATATTGTTAAGTTACAAAATATATGATGTTGAATAATATCCTTATTGTTTTTTAAAAATG
+ ATAAAATAACAACTAACCAAACGAAAACGATAAGGTATCTTGTGTTCGAAATATACTTGTACACCGCTTG
+ TTTTGTTTTTATTTTTGTTTACCTTTGTGGCTGTGACAACTTATTAAGGATCCCAACGGTTAGTAACTTA
+ CGTTGATCCGTCGGAAGGTGAGGTTAAATAATTAGGATTTAAAGTATTTATTTGAAGGCAAACAAAGCAC
+ GAGCCGGGAATAAGCCATCAGAGTGGGTGGCAATAAGATGGCTTTTAAGCTTGAGTAGTTCCTGAGATCT
+ TGATACAGACGGAAATGGCCAGATCGAATCGGCCATTGGTCCTGATCAAAAATATATGTATACACTTTAC
+ CCTTTTACACCACTAAAGGTTTGAAGTTTACCAGATAGTCGAAAGTGAGAAAGCAGTCATGTTTGGTTAA
+ TGGCATTGAACTGTACATAATAATATCAGCGAAGTAAAAAAATTTTTTTCCCCGGATTATAATATCCTCG
+ CAATATGTAGTGGTTTGTCGTTTTAAAAAATACCCCTGAGTATCGAAAACATTTATTTTTGCCGTTGTGC
+ ATTCTAAGCATTTGTTAATTGTGTCAGCGACATTTTGATTGTACAACCAACGGAAACGAAACGGGACAGT
+ GATTGTCGCCCTAGCTTTCCCTCCCACCACGACATCCACAAGTCACCTGGCAATCAGGAATGTCAGCAAG
+ CGACTTTGTAGCCACAGTGTAGTAAAAACTCCGTTGGATTTGACTTGATTTTATTTTACCTGACAGCTGA
+ GCTGTCTTCCTCAGTGTCCGTTGCCTGATGTCTGGTGAAACCTCTTTAAAACCCCTATCTTCAGTTTCTT
+ GGGCCATCAGGTAATACATAATTTTGCTGATGCGGAACAGCGTCGTGTTCGCATTACATCCAAAGTTGCC
+ CCATGGATCATCATCGACTTTATGCTAACACAACCACTATCGCACACACGCCAACTATACTTTGACAAAT
+ TGCAACGTTTCAATGAATTCGAATCGTTTGGCATTGACACAAATAGCTTTCAAATTGCACAGACAAACAA
+ GCACACACACATGTTGAATGGGTTAAATGCTGCGGTGGGACAACGGGGCCTCATTGCATTGGGGCGTGTA
+ ATTATTGTTGCTGTAACAAAACAACATTCGCAGCAGATACTCCAAAATCAACAAATTGGAATCTTTAAAT
+ GGAATAGTACTAAGTGGGACCAAATCCAAAGTTAAAGAATTTTACGCATTTAAATATTTCTATCGATATT
+ AAAAATACGAAAAAATGTGTATACAACTAATAAAGCGAGCTTCGAAACAAGCCTACCAAAAAAATTGAGC
+ TTTAATATTTAATATTTAAAAAAAAATGGGGTGTCAGCAAAAGACTATAAGCCATACTGGTTTTCTCACA
+ AGGCGAAAATCTCATTGTACGTATGTACCTTAATATGAGTGCTGGTGCAAATTTTGCCATTAACAATAAC
+ AACCACATAACAGACACCATAGTGACCATATAACAGCAACAAGATCGGCAACAGCAATTGTCAGCAGTTG
+ CAACCTTCTCATCCCTTCTGCCCCTCTCACCACTTTGCCACCGACGCACTGTAGCCCCGTCCCGAATGCC
+ AGGAAAGACCCAAGGATAAACGTCTCGCTCGTGCACGCCTCATAGTGACCTAGTTTCCAAAGCGGAATGT
+ AAACACATTTGACCTGGAAAAAAGAGTTTTTGTTTTGTAAACAAACCCCGACTGCGCCAGAGACTGAGGA
+ GGCTCAAGGTGTGTGCATGTATGTATATATGTGTATAAACTGTGTTTTAGGCCTTATCGGCAACAAACGT
+ AAAATGCGTAAAAATGCGCCAGCAATATAATTTAGTTGGTGATGTTGTGACTTTAAAGTGTATGTTAAAT
+ AGTTATGTTCTTTTATGGAAGACCGAGAATAAGATTCGAGAAATGCTGATAAACACACTCAAGGGTGTTC
+ GAAAAAGGGACTTAGGGAGATTTAGGTTTAGACTTAGGTGCTCTAGGCTTTAGACTTAGGTGCTTTGAAA
+ TTTATGGGAAGATATGGAAAATGGCCTTAACTGAAGTATATCGAAATAATTAAAAAATAAACTGTAAAAT
+ CGCAAAAGAAAATTCTAATAAATTTCTGGGCATTTTCTTAACTTTCCGTTCTCTTATTATTAGTTTGTAA
+ AATGAGTTTGTTTTTTGTTGTTCTGTCTGTGTAGTTTGGGGGTTAGTTTTGCGTTTAATCTTGGGGTGCT
+ TTGGCGTTTTTAAATGTCGTTTTCACACGACTTTTCATCTTAGTTTTTTTCTGCAAATTTGTTATTTAGC
+ TTGTAGTTTCATCTTTTGCCAGTGCAATCGCAAAATTATTGTAATAGTATCATCTTTGCCATTCTTACCA
+ TTATATAAAGATAACCAAATTCTTAGTGGTAAGACTTGCGTTGTTAATTAAATTTTAATTGCATTGGTTC
+ CAACTTTTAATTAGCAACGGCAATCCCAAAAAAATGTGAAAAATATGAAAATGAAGACAAAAAATATCAG
+ GGGATGGGGAGGGGGAAATTCGCAGGAAAACAGCCAAACACAGAAAAAGAAAATGTGTGGCCAAAGCAGA
+ GGCTTGTTGTCAGCACAACCAAACAAAAGACAACAAAGGGGAACTACAAAAACAGCGCAACAGAAAACTG
+ AAAACCACACACAAATGGCAAGTGCAACAAAGCCAAACAAAATTTGCCATTCCCTTTTTTGCACATTTGC
+ CAGCACTTCACTTAGCAACATTGTTGCAGTCACAGACGAGTCGAATGAGGTTTAAGGGGCTGCCGACAGC
+ CAGCTCAATGGAAATGTATGCATTTGCAAAATAAAAAAGGTAGGCTTAAGACGGCAAAAAATGCAGATCG
+ ACTGCAAAAATTGTGCGCCTGTGCCACAGGCAGAATGTAAAAGATGATCGCGATTGCAGGCAAAGAAATC
+ CAAACAGATGAGGGTTTTGCGGGGGTAGAATATGGGTTCACAGAGGCCGAGCCGAAAGGACTGGGGGATG
+ TCGGTGCAAGCCAGTTGTCACAATGAGACCGTGGGCGTGTAAAATATATGACGTACTTTTGCATACCATA
+ TCCCTTGAGAAAGTAACACTATTTTAAAATGACTTAACGTTAAAGCTATCAAAACTGAAATAGGAATTAC
+ TTGTTTTGCTATTAGAGACAATTTCCACATTACTACACATTTTACGGTTAGGGTACTATGCAAAGAGTAT
+ CGAAATGTTAGCTAAACAATGACAATGATTTTATTGCCCAATGGTTATCTATGATTTTAAATGGGCTTGA
+ AAAAAAGCAGATATCAAAGTTTTATTTCACTCGCACTGTAGCCATCTCCTTTAACGTGCTAATGAGTTCA
+ ATGATTTGCAATTGTTGTCTAGCCTGAGGTCTGCAAACTGAGTCCAATTCGTTGAGGAACAGAAAACGGA
+ GGCTAGCATGATGGGACCATAATCATCATTAATACGTCGGCGTCGTTGGTCGCACTAAACTAAGTTTTTA
+ TCAGTCTGCCAAGGCAGCGGAAAGCTCGGGGTTAAGTTTGGCGGCAAAAAAGGGGGAGGGAGAGTTAAGC
+ AAAATTAAAATAAATAAAAACTTCAAGTTTAAGCGCTTAAGTTGTTTGTTTATCTCCACCTCTTGGGCAT
+ AATTCAACTGCAACATTGTTGCGCCTAATGCAGACAGACATAATGAAGGAGCTAGTCACAGACGGATTCA
+ AAAATGCGTTGAGATGGCGATTCGCAGTCTATTTGGCCATAGTATTTTGTGTCATGCGGCTGCTAATAAA
+ GCTAACACTGTAGAAAGGAACCACTGACAACTGATTGATAACCGAGTTGAGACAGGAACGAGGGTCCAAA
+ ATGGGAATCTGCTACATTGTCAAGTTCCTGTTAGAACGATTTCATATGTATCGTGCAATTTAAAAACTCG
+ AATGTTCTGTTAAAAATTACAATCAATGAAAGTCTTGCATGGACTAGACATAAAAAGTTAAAAGCATTTA
+ AATTCCATTTTCTAAAGTAAATTTATATTTAATATAAATTGTATTTAATTGAATTGCTCATATTGTATAT
+ AATGGTTCAATAAAATTCATACTCATACTGAAAGTTAGAAATATATATATTGGACACACAGATTCTGGTG
+ ACGACGTTGTTCAAGTATGTTTCAAAACGTAACGGCCTAACCTGCAACGCAATATCCTTTGAAAAATTGT
+ TATAAACATTTTTTTCAGTATGTCAACATAATTTTTAGATATCTACCCAACACTTCCAATAGCACCATAA
+ CGCGTATCTTATAGTCGAGGAAACCGACTATAGCGTTCTATGTTGTTATTAATTCGGGTGGCCGCAAAAG
+ GATTAAAAAAAGAAGCGGCCAGAGCATCAATCAAAGGAGGAGCGGTAATCGCCCTTTTTTGTACAAAATA
+ AAAAATTAAAAAAATGTACCCCCAAAATTACGCTAAATTTTTGTTGGCGAGTGTGCGCTTTTTTCTGCAT
+ GCCCAATTTAAATTTAGTCAGAAAGAAAATTTGATGGAGGCGAGGACATAAAATGCGGAGTTAAGGGAAT
+ AATGGGGATTTGTGACAGAAAAGGGGGGCTGCGGCCCCCATATGTGGATTTTGTAACAATAATGAACAAT
+ AACATATTCAGGCGCTGACATTAAAGAGTAGACGTTTCTCCTATGTTTTAATTGGCTTAGTAATCCATCA
+ AAGCGATCTTTAAAACTATCCCTAAAATAATAACGAAAAATTTAAGATCTACCTACAAAAGTTAATTAAA
+ ATGTTAACAGAAAGTCACTCCCTTCACTCCGCTGGCATTGCACGATAATCAAAACCTAATACGAAAGCCG
+ ATACACCCGCATTAGTCCCCATTTGAAGTTGATGAGGCAATCAAAAAAATTTCCTACTCCCTAGCTAGGG
+ GAGAGACAAGAATTTGTTAAGCACTCGCTGTCACGACCCTGTGAGCTAGCAATGCCAACATTAAATAAAT
+ ACTTGCGGCGTTGCCTAATTTTTGTACGCACTTGTTTACAACAAATATACATATCCTCCAGCTTTTTTCG
+ AACTTTACCGGTGGCTTGGGACTGACCGAGTCCATTGCCAGGAGTATAGAAAGCAAAGCAACTCGCTTGG
+ CCACTATCACCGTGTTTGTCGACTGGAACACCTTAAATACCAGTGGGGAGGGCGGAGAGGTGTCGTTACG
+ AAGAATAATCACTGCCCGCGGGACTGAAGAATTTACTAGGGGGTGGGGACAACTTAACGTGATTTAATGC
+ AGATAATAAAGCAAAACATATACTTTTGACTCCACATTTTTACGGTGGCGTTGTTAACCCAAAAGCTGTC
+ AAAAATCACTTAGGGGATCTTCGATCGTATTTCAAGAACTCGAAATACTGCTACGCTTGGGAAAGATAAT
+ TAAAACAAGTCATTTCGGATTGACCATAAAGTTTCCACTCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG
+ CAAAAGATAAACTTGATAGAGCGTAACCCAAACCAAAAATTTTCCATATTGAAAGCCAAAGTATTCCCAT
+ TCTTGCCAAAGAAAATTGAATTCAATGGAATATTAATTCACAATGGGTAATCAATTTATCTATATATATA
+ ACTTTTCCCTTTTATTGAAAAGTGAATATTTTTAGTAGTGTTGGAGCAAAACTTTATTGTTGGATTGTTT
+ TTAAATTAGAAACGTAACAAATATGGCGAAAAACTTGAACGTCGGCCAAACGCACTACGCTCTAGCATTG
+ AATGTACTTAGTTTTGTAACGATGTGTCCTAGGTGTTAATCGAGTATTTATTGTGTGGTGTGAAGTAATA
+ CTTATGCACTAATTAAATTTGCTTTACTGGGTTTAGGTGTATGTTTGGTGTAAATGGGTATTTTGCAAAT
+ GCAAAATGCAAAACGCAGTCGATAACAATGTTAGCCACATCCTTGAACAATTTTCACTCACAGAAAAAAG
+ TCACATGCACACTCACTCACACGACAACTGAAAACGTTCGACATACGATCCGTATGCACGCTAGTTGTTT
+ GCTGCTCTCCATTTCTGATTCTTCGTTCCCATTTCCCACGACATTTTTCACATTTCATTCCTGCTCGATT
+ GGATGTAGCCAAGTGTTATGCAACTGCTAAAGGACTTCATCTTGTAATTTCTTTGGTGATTTGCGTTGTT
+ TGAGTTGTGATTTGTGTGGTGTTGCCTTTTGTGCCTCATCTGGCGTCGATCTCCGCCTCATCCTAATCCT
+ GGTAAGGGGCCACATCCATTTTAGAGCAGATAGCATTTCCGCCGCCAGCAGGAGCAGGTGCAGTGCCCAT
+ GACGATAGTATCGGCAGAGGCACTTCAGATACTTATAGCCCGCACAGCAGTGATGCGAGTGCAAGTGAGA
+ ATGCGAGTGATAGTGGCTGTAGCAGGAGCTATCGTGCAGACAGTAGGAGTAGCAGCCGCAGTCGCACATA
+ TTTTTGCCTTGTGTAAGGTCCTTTTGCCTTCACTTGTCTGAAGTCTATATAATCTGGACTTCGCTGTGCG
+ TCCCAGCTCCTTTGCACGCTGTTGCCCAACTGATTTGTTGCCAACGCTTCCATTTTCCACTTGGCTTAGG
+ TTAGTTTGCTTCGACGGCCATCAAGTGGAATTGGTCTCTCATAGTTACGGGCACGGGCCCAAGTTTGATC
+ GATCACGAAGATACATTTGCGTATTTAGGGTTTAACATTCGTACCAAGAACCGGAGTGAGTTGTAATATA
+ TGGGTTAGCAATGTTGTTGTTATGGCAATTCATATGAAAACCATGTCAATTGATTTTAGCCAACTGCATC
+ GCCTCCGTGTCCAGAGTACGGGAGAATACGAGAAAACCGCATAAAATTAATCTTTTTTTTATGGGAATGA
+ AAGGTGGTTAAATAAATTTTCAAGGGTACATTTTTGATTTGTAGATATTTCCAGAGTATACCCTCGTCTA
+ GACCCATAACATGGTTTACCTAAACTTTTTTGCCTGGTACCGCACACATTACTCAACTCGAGTCGAATGA
+ TTAATTTGTAAAATTGTCGCTGATTTTATGACCGAAATATTTTTTGCATTTGGCGATATCAACCCGAAAT
+ AGACTTGGCCACATGCAAATTCATGTCTGACCCACATTGTCGACGGGGGTACGAGTCACCGTCGCCGGGG
+ ATATACAGATAGAGAGCTCTAACTGCTCTAGTGCTGCATTCGATGACACACGCGGCGAATGCACAGCTGA
+ CGCTTACACATCGTGTACGTTTACACAGACGCGCGGACTTACAAACTCTGACGGACTGCAAATGAGATCA
+ GATCGAGGAATCTGCACGTGATGAGCTCATAATTAGTTGTTGTTTGCTGTCGCTAAAACACCCGGATTAC
+ AGCTTTTAGTTCCCAATTTTTTCACGACCCATAGTTTTTACTCGCCCACATGCGAGTTGCTTATAAGATA
+ TCCCCATTTTTATTATCAATTTTATATTTTTGGGGGCATGTACATAAGTATAAGCAATGGGAAACGTTTT
+ TTCAGCTAGGCAAAACCGGGTTAAAAGAAAATAGCAGGGGTTTGAATGTTTTGTAGTCGAGAATGTTTTA
+ AGTGCACGGTTTTCAGCAGTTTAGTTGGAATGGTTTTAAGTAAGACTCAAGGGACAGTGAGGCACAGACA
+ AACAACGACTATAGAGATTTCTATAGTCGACTACCCCGTCTATCAGATAAGCATTACCCAGCTAATGAAT
+ TTGCTAGTGTTAAAAAATTTAATTGCATGACAGTTTGGGCGGTTTAAAGGTGTAAGAAAACTGTAAGAAA
+ ACAAAAACAACTGTTTTTGGTGTACCGGTAGACATTGGTAGAGTGGGCGTGGCCACATGAATCAACAAAC
+ TTGCACTGCGTCTATGTCTCTGGAAACTGTATGCCTAAGTGTGGAAGCTTTTAAGGAATAAAAATTAAGA
+ CTGCCAAAAAAAAAAAATTGTGTTATAAAACAGAATGCAGTGATTTGTTCAATACTCGTAGAGTATTGGT
+ AAAGTAAGGCGTTTACAATCCTACAAAAAATAAAAAAAGTAAAAGATTTGGATCACTAGCTGATTCAATC
+ TGGCTTTGTGCCATGAGCTCAACAAGTTAAAAAGTTCAATTTGGGCGTGCAGATCTAGTCGCGCTGTGAA
+ CACATCTTTTCCGAACGTTCCAACGCCAACTCTAACGCTCGCCAAAATGGCACGCCTACATTTTAGTATT
+ TGTCTTACCAATTTATACCCCAAAACACGATTTGGTCACACCCACTCCAACGTCTACAATTGCATTTTGG
+ GCAGTTTGGGGGTGGAAAAAGTTGTATGCCAAATCAATAGAAAATAACAAGACTAATAAACATATGAAAA
+ AATATAAAAACATTTTTTAAAAGTGTGAGCGTACGATTTTTGGGTCACTGGAAAAAAGTTTTTAGGTAGA
+ TAGATAGAAATTAAAAAAAATAGGGCACACAAAAACAAAATAAAAAAAGAACATGCGCTGCGTCTACTAT
+ GTACACACATTGTATGTATGTACATATGCATGTGTCTGGGATCTGCATGTCTAATTTTAACTCTCTAGCA
+ TTATTCGTTCATACGAACAGACGGACGGGCAGATGGACATGGCCAGATTGCTTCCGATCAAAAATATAGA
+ TACTACATATGTATATACTTTATATAATCGGAAAAGCTTTATTCTACCTGTTTCTTCTACTCTACGAGTA
+ ACGGAAATTAAAAAATAACGTTAAAAAAGAAAAAAGAAGGGGAGACCCTGCCTAGTTTAAAAATGTAAGT
+ AAACAAAATTAAATTTCCAACTGCAGTATCTCAACCCCCAGTTCGATTGCAGACTGGAAATCGGCTTGTC
+ GCCAGCGAATGCATTCCTTCATATCATATACGTTCAGCATAAATACAAACATATAAGAATTCTGTGGATT
+ ATCACATCACGTGGATAACCAGAGGGGCATGTCGGTGTTCCTGGAAAAAGTGGGAGAATATGGAGGGTTG
+ AACTGCAGAAACTGCCTGCTGGTATTTGGTTTGTCAAAGAGCGTGCGTAAACTTTGCAAAGTCCATATGA
+ CATTGACTGGCGGGGAATTGTGGGTGTATCTTGGAGACCATCAAGGCCAAAGTGGGGCAGATCAGATTTT
+ TATGTATATCGGGTTAGTAGTTTAATCCCAACAATTTTCAAAAGAACTTTTAGCGATGACACATTATGTA
+ TTTTATTGCTACCTGTCTACATTATATTAAAACCTCAATGTGAAAGTGTTTTAATAACATTCAAAAATAA
+ AACAGATATCACCATATATAACACGTCTTTATCGATGTAATTACATTTCTGATCATAGCCTTTGGATATC
+ ATAATATTATAACTTTAACGATTCGCGTCTGGTAAATACCATTACACACACGAACATTTGTATTATTTTT
+ CGAGCATAACGAACTTGTAACTACTATTCTCGAATCAACGGTCCCAAATGATGGCTTTCCATTCAAGAAT
+ AGGGTGCCCTTCCTTGAATGCAAGGTACATATAAAAAATCATATAGCGCAATGTAGCTAGTAATCAGAGA
+ AACCTATACCCCGCCGTCGGCCGATTATCACCTTTTCAAGTCTCGTGCTGTGCTCGCATTTGTCGTCATT
+ GCCTCATAGTGACCCCTTCGAAGAACCCAATTTGTTGAATTATCTGCGTCAACTTGTAATGGAAACTTTT
+ GTAAACTTTTCCATATAACCGCGGCAGGGGAAAACTACGACAAAAGTGACATAGCCCATAGAAAGGTGAA
+ ACGAAGAAAAGTATTTGCTCGAAAAGTGCAAAGTGGGTAAAATTCCATTAGACCTCGAGTTCAACAGATA
+ TTCGAATTATTTGCGCTGCTCATTAGTAAGCCGTTTATGCCAGTCCTAAGTCACAATAACACATAATTTT
+ AAATCGCCTCAATGAACATATAAGCAAATTGAATTGTATTTCAAAACAACTGCGTATTGACGTCAGTACA
+ GTCTGTCTGTGCCTGATGGATGCATTCATTGACATTTAGGCGAGACAAGAAACTCACCAGTCATAACTTA
+ ATGATCAAAACAACCGGTAAGTTAACGGGTTTAAATCTGAGTTCTCTATACGAAAACATGATATTTACCT
+ CTTTGAATTTTAAAAATAATAATGCTAATATTGTTTAGTCCAGAAATGCAATTATTAAACATTACATTTA
+ TTAATAAAAAGTTAAACTCTAACATGGCTTAAACAAATATTTTTTAATGAGTTAATTCCCATAGTTTAGT
+ AATTTTAATATATTCTGTTTAGTAATTTTAAAAATGAATTTTCCCTGTTTTACATGCGCTACGAAATATA
+ GAATATTTAGCTACGATTAAATTCAGCCAAGTTTTGCGGATGACTAATCACAAAAACTTTACAATAATGC
+ CAAACGGAAAGGGGAAATGCTGCGCCTGCACCCAAGTCAATTAGCATAAGTATGTTTTGTGTGAATTTGT
+ GAATATTAAAAAATTTCAGCGAGCTGTTTTTTTTCGGAAGCATATAATGGATGAGCAGATCCGAACTTTT
+ TCGCATTGTAGCTTCCTTCGCTTTTGTTAAGCACGATTAAAATGCGATTGCAATGCTGCAGGTACAAGCA
+ GCACCCTATATGAGTGGATCTATATCCTCTATACGAGTGGATCTCTCGAGTATGTGGCTTGAATGAAAAG
+ TTATGAATTCATTTTTTGTCAAATTATCTTGAACTTACAGACTTACGATCTATCGAAGCACACAAAAACA
+ AGATAAAGTCAACTTCATGAATGAGCCACGCCAAACAATGGAAAAAATGGTAAGACAAGAAAATACAATT
+ TTTATTTTTGCTTCGCAATTGCTCGAAAAGTGTCTACCATGATGTGTTTTGTTTTCAAACTAAATATGGG
+ TTTGAGGTGAGTGGAACTCGAATAACAGACCAGGAATGCAAGTTGATCCAATTCCAGATTTTCCTGATGA
+ CCCTATCCTATTATCCTATTCATAGATAAAATATCTCTTACGGGAGACTAATTTATATATTTCATAAACT
+ TTCCTATATTTTTATGAATCAATCCATTTATTTAGACTCAATTTTCTAGATTCTCGAACCTTCTAAATAT
+ TAATTTGATAGGGAAACTACCGCAAATATGAAATCATACAGAGACCGTGCCAGAGACTAGTCTTTTCTTA
+ TCCAAAGTTGAGTAGTTCATTTCACTTTTAGACGTTCTCATTGAGAATCTTCTTGGATTATACGGGTTCT
+ TCTACTCGAATAAAGAACTAGCCCTACTCGACTTACGTTTCCTATCCAAATTTCCTGTTTCTTGTTTCAT
+ TGTAAAAGCCAAGCGACAGCATAGAAGACAAAACAAATTTTTGTACGTTTCGGTATTTTTGGTTCACACG
+ TGCTTCGTTAATAGATAGATAGACTACCGAAGTGATGGTGAAGTATGTTTGGTGTATTTAAACTTTTTTT
+ TTTGAGAATAAAGAAGTTTGTGAAGGTGTGTTACCTAATAAAAAAATTTCCCGATCCGAACCACATTGGA
+ ACCATGGTAAAATGACAATGAATATCAAAACATTTTTCAAAATTTTGGATGTGACAGTTTTGGACTGTTT
+ TCGGGAGTGGCAACATTTGATAACAATATTGCGCTGCGTCTATAAGACTCTAGCTTTTATAGTTCATGAA
+ ATCTCGACGTTCATACGGACAGCCGGACACGGCCAGATCGACTAGGTCATTGATCTTTATCAATAATATA
+ TATATGAATTTTTAATGGTAGAACCCACTTCCTCAAACCTATTTTATACCTTTTTACGTATCTATTGTAG
+ CATACATTTAGATGCGAGCACTTAGATAGGCCGGGGGTATCTGAACAAGTCAGATAACCAGGATGGCACA
+ GAGCATGTGGATATAGATATGAGGTTGGAGCTGACTAAATGAGATACTTAAACAGACTGCTGCACCCCAT
+ TGCAGACCAGAGGCATTCTTTTGAATTATGAGGCCGCTCTTGGAAATGAGGTCGTGATGCGATAGTAGGC
+ GAAGTTAAGTATCGAATAATTTAACTACAACAAAAATATAATAAAATTGTCTATAAAAATTGGTAGTACC
+ AACTCGGTTTCGCATATAAAATATATATGTGTCGTGAAGAGTCTTACTAATTCTTCATCTTATTCTTTAC
+ TGTCCCACTGATTTGTCCATCCCCGTGCATTTGCTGCATTGCATTGATTGAGTGTTGAGAGGCAGAGATG
+ CGGCGCTGTTTTCTGTTTGTTATGTTTGGCCAGGCCAGCAAAGCAATAAAATTTAATTGCCTTGCTGGCG
+ AAAAATAAACCAGAAAGTTAAGAGTAGGAAGAGAAGCAGAAGTAGAAGTGAAAAGGACAAAAACATACCT
+ CCTATGGGAACACAAACAAACACATTTGGTCATCTTAATGGCTACGACCTGTAGCGACGACCAGGCAGGT
+ GCATCCCGCGACGAGTATTTTTTATATTATTGTTTGGCCGATGGGGGCTGGTACACCCCGCCATAATAAA
+ CCAATAAAAAATTGCTGCTGCCGTCGCTGCAGCCACTTGCAGTTACAATCAAGTGATTTTTATTAGAAGC
+ GAGTCTAGAGGGGCACTATGGGGCATAAATGGCAATAGCCATGGTATGTAACCAAAACAAATCAAACTAC
+ TACTACTAAATGCCTAAATTACTTCGAAGTTGAGTTGCTCTATGGGAGGTATGAGGAAATATCTAAACAA
+ AAATGATTCACAAGTTATTAGTGTAAGTTCATATATAAATAAATCCCTAGGTTTGTCCAAATAAAATGAA
+ TTGGAATTGGATACTACCTAAAATGTTCATCTAATATTCAAAATAAAAACTGTGTACCCAGACTTAGCTT
+ GCTAAAATTAGTGCCAGTTTTAGTTGTTACTTATAGGATTCTTAGTGTGTTAACACTATATTTATTACAT
+ TATATTACATTACTACAACAAATAAAATTGTAATTTAGCTGATATCCAATAACAGGCTAAAAATTACTTG
+ GTACTACATATTGCATGGCAGATATCATAGGGTATCACCTCTGGTGCAGCAACAACTCTAAAAACCAAAT
+ CGGCAACGTGTAATGAGCCGCTTTCTTCACTCGGGGGTTTCCTCTCTTGCTGATTCTGGTGCTGCTGCTG
+ TATGGTAAATAGCTTTCGATTGCATGCCTCCTTGTGTCTATGTCTCGTAACGGAGGCAAAGTAGTGGTAG
+ GGTTTTAGAAGGGGTTGGGGTTTAATCGCCTTATAGGAGGCCGCCGCAACTGCTTGTCTGAGATGGACGC
+ GGCGCGATTGCTTTAGTCATGGTCTATGGAACACGTGCGATAATTATGGTAATATTTGCATTTGCGTGTG
+ GCTTGGTTAAACAGTTGAGTGAGTTACTGGGCGCCAAGACGCGACTTGATCGCCGAAGAAGACCACTTCC
+ GATGAATTGGACACGTTTTCGGGCTATGACTTCTAGATTTCTTCAAAGCTGCTCTTCACAAATCGCTCCC
+ GATCCACCGGTTTGTGCTTAATGGCCTTTAAATAGCCTGCGCAGCCCACAATTATGTCGGATTGCTAAAC
+ ATTTTTTTTAAATATTGTGCAAATCGAGATCTCAGGAACTAGAACTAGAAGGTTGAGATTAAGCATAACT
+ CTGACTCCATAAAACCGACCCAAAAACTCCCAAGCAAGCGTTAAAAAAGCAAGACCAAACAAATCGAAAA
+ CTATCCCAAATCTTGGTTGGTGCCATTTGAACGAAACCAACGGAAAACAAGAAATCGCGAAATAATTTTG
+ GTTTTGGATTCTATTCTACCTGGTCGAGGTCATTGAATGCAGTTCTCCCTGATTTCTGATTCCCAGATGT
+ CCACTCTGTTTAAGTCCACTTCGATTACGTACTGTTGAATAAATCCTCATTTGCTCTCTACATGTATGAG
+ GCGATTCTTGGTTTTAGAACCCGAAAAGTCGATTCTTTTTTGATTCACCGCCATCGGAATTCCAAGAAGG
+ ATATCGTCCCGTCTTAGTCGCTTTCTGGCCTCGGGACGCTTTTTGCGCTGTTCTCATTTAAAGCATTTTA
+ TGGCATTTTGTTTAAGTTGCCGCTTCATTATGATTTTTATTGCCACTTTAGCATGGCTCCTCCAAAGGAG
+ TTGCCATCTCTCATTTTTCAGATCTCAGGTGGGAGGAGGCATTGTGTAGGTCTCGTTCTGTTTGAATACT
+ ACGAGGAGGTTGGATGTTCAATGTTGGACCTTGGACCTTGGAACCGAGAGCTCAGCATAAAAACCGCTTT
+ TAGGGCTCGATATAATTTTAGTTATTCATTTTTATTCCCGACTTCTGCGCGCGAATTCACTGCGCATTTC
+ GGCCAGGTGATTGCCCTTTCGGGCATTTCTTAAGAGGTATTCGGTTTTAATATCCTTTCTGTCCAAATGG
+ GAACTGTTCTTGTCGTGATCCCCTTTGTTTTCATCTATTTCAATTTGAAATGATATCGCTCTACTTAATG
+ CAGACCATAAATTTGATGCACTATCGCTGGTAGAAGTTTAGAACTATAAAGGCAGACATTTCAATTTTCA
+ GTCGTGCGTCAACAATTTCCAAAATAGAGAAATATAAGCAAAATCCAAATATATAATAATAGATTGTAAG
+ TTTAATAAATAAATTTAAAGCATAAAGATTGCGATAATTCTTTTAATTCACTTAGATTTTACTAAAAGTC
+ TGCTCTTGTACAGTTCAATGAGCTGTTGGACGGTAAATCCTCCAAAAAACCCAATTTCCTCAGAAAAGCT
+ TATGATTCCCCCACCACAGCTTAGCCTCACCCAGGTACAGAAAGAGAATTAAAACACCTAAATGTCTCTT
+ TCGAACAACTTTTTCTTTTATGGATCATCCTTTTCGGACCAAAACTAAACCCAAAAGAGACGCTGAAGAA
+ GCCAAGGTCTTCCCGTTATCGAGGGCCGTCAGAATTTGATTCAAGAGCCACGTAACCATAGATGCCCATA
+ AAGACATTATTGCTTCGATGCCAGACGGTACCCGGTGAACTTGACAATGAACTTTCGGTAGACCAAAATT
+ CTAGGGAAAACACAGCAAAAGCTTCCATAACTATTTCCTGTCCTGTCTCTGATTCTTTGAGGAGCTAAGA
+ TACCTAACATGCCTAACAATAAAGGCCGAAATACATTTCGGATGAATCTCATTCAGATGCACTTCGCACA
+ TTAACGCCCTAAATCTGGGATTTGAATCCGATCCCTTGATCATGTCCTTTATTCTTTATTGTGCGTTCGG
+ TGTGGAAATGTCTATGAAAGAGAGCGATAAATACAGTAGTGCTTCCAGGAACTGGCTGGTCGGCGGTCTC
+ TTTCTTAGTCCTCTTTTGGTCCTCCTTTGATGCCAGTCTTCATTCCATTTCACCCATTAATCAGGGAGTC
+ AGAACCCCTCGATTAGGGATAAGGAGGGCAAAAATCAATTAAAGTCCCAATGCTTCTTAGCCCAGGTTAA
+ GCCCGACCACACCCTCTTGGGCAACCTTAGTTCTCCCCATATGACAATGGCTATTACAATGTCCCCATCG
+ GCATCCATGTTTGAAGCTCCTCTTTTGAATACCATATCAACCACTAAAAGAGTGTGTGCTTTAATTGTAG
+ CCTTTTTTTGTCAAAATATTATTAACAGAAGTGCTAAGAAGGTATAGGAAACATTTTATAGACATTGACG
+ TCAATGCTTCAAAATGGGGTAAAGTGACAGGCAATTGAGCGAGCACTTTTCCACCCATTCGGACGCAGCA
+ TTATTAGCCAAGTTTACAGACACATTTGTCAATTTTATGGTGGCAACAGGGCGATGTATGGCTTTCAAGC
+ TTTTTGGCGAAACGGCAATGCGGCATTTGCAATTATTATGAATCATTTCCGGACAGCTTTGTTGAGGGGG
+ TTCAAGTGGTTGAAACATTTAATTTAGGAGGATTGAATGGAGAGGGGTAAGTTACCGTCGACGCATCGCG
+ ATGAGAAATTGTTTAATTCATTTTGCCAATAGGGCATACATTTTATATTTTTGTATTGAAATATTTTTTA
+ ATGCTTAATACCAATATGTATATGTATAATATACCTTAAATACTTCTTTCTATTTTCAGTTACTTTAAAA
+ ATATATATTGTGCCATATCATTAATAATATCTGAAGCGATTCGATATATAAACTATAATTAATATTTCTG
+ GACATAACTCTTTTATTGACTTACTTTTATGTCAATATAGAATATTTAAAAACGGTATTTTGGTTCTGTC
+ CAGTTGTCTTATGTTTTTGTTTCTATTTGATGATCGATGACGGCATCGGCTTGACCTCTCGGAGTACGTT
+ TGATTTTATAGAACAAGTTTTCTCCTTTCTTATACTATAAGGAAAAATTATAAAAATTGCTGAAAATGAA
+ ACATGGCTAGAATTCGTTTTTTAACATTTTTTCAATCTGAGAAAAAATTTCCGATTAGTCTTAAAATAAC
+ TAAACCAATTCGTATACCCGTTAATCGTAGAAGAAAAATGAAATTCATATAATAAGTAGATGGATTTGCT
+ GACCCGGTGAGGTATATATGTATTCCTGAACATGATCAGTAAACGAGTCGATCTGGCCTTATCCGTATGA
+ ACGTCGAGATCTCGGGAAATACAAAAGCTAGAAGGTTGAGATTAAGTATGCAGATTCTAGAAGAAGACGC
+ AGCGCAAGTTTGCGACTACGCTGAATCTACTGCTAAAAACTGCCACGCCCACACTTCTTAAGAATTTGAT
+ TTATTTTCACAAGCTGAGGAACGGTAGGGTCGAGGAACTCGACTACAACGTTCTGCCTTGTTTATTTCTT
+ AACAAAAACTTAGTAGCCGTTTGGGTTGGAAACCACCTGACCTTAGGTCTGGTAGCAGTTATTTAATTTA
+ TTTTTTTTATTTTATACAACTTGCTCGCTGTTTGTTCCCCCTAGCCCTGAAACACAAGCTGTCAAACGGT
+ GGAGGTGATAAGTCTAATGAATGCGATAAGCTTTATTTCAATTCGCAATTTTCGTGTGGCATTTTGGCAA
+ AAAAAAAAACTCGTCGGACATACATGTTGCCACAAACATAAAGTGAATACATAATGTTGGGTGAACGACT
+ CATACACGATTGTGGCAAATCAAATTCTTTTAACACGGGACGGGGAAAGGCGAGTGAAGATATTTTAGCA
+ TATATTTAGCACATCTGTTAAATCCATTTTTTTACTCTCCGTTTTCGGCCAGATATGGTTAGAAAAGAAA
+ AAAATTAGTACATACCCCCATATATAATAAGAAAAAAAGAGAGAGTCAGCAGAAGTACGGGGAGCTTAAG
+ TGTAGCAATCAGAACATCACAAATAGTAAATAAATTAATAATAATAATAATCATATCCAAAAATATTTTT
+ ATTCCTAACCTATCGCATTGTTACATCGAGGGTGAAATTCAAAATAGACAAAAAGTTGGGGAATAAAATG
+ TGAAAAAAGTGGTAAAATGTTTAATAGTGTGGGCGTTACTGTTTTGTCGGTGTGAGGTGCGTGGCCACCA
+ AAGTGTTTTTGGTATAACGATAGAAATTGGTAAGACAAACAATATTGCGAAGAAAACCCGAAGCATTTTT
+ AAAAAGTGCGAACGTGGCAGTTTTAAGGGTTTGTGGGCGTGGCAATAATTTTTGGCAATTCGATAAAAAT
+ GTACAGGACCAAATATATGAAGAAATATAAAATATTTTTCAAAATGACAGCCAGCAACCATACATATATA
+ TAAATAAATGTCGGAGACCCTTCCTTCTACCTGTAACATACTTTTCCACGAATCTAGTATTGGTTGATAT
+ ATAATTATGCTGTGTATAAGACCAAAATCAGTGTACATTTCCATTGGATTCACCAACCGGATGGTTCCGG
+ ATGGTAATGCAAAATATTCATCTAAGAAACGAAAACACCTAGAATTAAACCTGAACTGATATGACTTATG
+ CACATATCAGTGAGGTGGGCAGTTCAAAGCAATCACGATGCTCCAAGTTATTATCGCAGTGCAGTGAAAA
+ ATTCACAGTCACCGTCGCCAATTGCCAATAAAGATCGGCCATTATACAACAGAACCGCGTTGAAGACGAT
+ CGACGAGGTCGTGGGTCTTATCTTATCACCACCTGAATTGAGGCATGCCTCCAGAATGACGAGGGCATCC
+ GAAGATAATGTGGCCCGCTATTTTCGGCCGGGACTGGACCTATGCGACGACCTATGCTGATGACGGGAGT
+ CTGCCGCTGATATGGTGCAATGCAAGGCTCCAGTCGGGGGTATAAAAGACCCAGTTTCGGTGCAGTCAAG
+ ACAACAGACTTTAGGTGTTGGTCGTTGAGCGAACCAAAGCCGGAGCAGTTGAGGAACCAAAGAATAGCAG
+ CGAGAGGACCAAGGATGAAGTTGACCCTTGTTATATTGGCTCTCGTAGCCTGTGTGACTGCCTTTAGCGT
+ GCCCACGCAGAAGGTAAAGATCGCCGACAAGAACTTCCTGGAGAAGCAGAAGTTCCTCTTCGAGATCGTT
+ CACCGTATTGATGAGCCTCTAATGTTCGAGGAATGGATTAAGATGGGCCAAAAGCTGATCACCGACAAGG
+ CTCAATACGAGGTGAGTGCATTAAGAACATCACTTTCTTCCTGAAACCCTAGCCATTTCCTTGTAATTCC
+ CCACAGACCTTCGATTTCTACATGGAGAAGCTCTGGGAATCCTACAAGCTTGGAGCCCTGCTTCCCAAGG
+ GAGAGTTTTTCGGAGCCCTGGTCAAAACCCACCACAAGCAGGCCTACGGTCTGTTCAACTTCTTCTACTA
+ CGCCAAGGATTGGGAGACCTTCGTCCGGAACGTCGCATGGGCCCGCATCCACGTGAACGAGGGAATGTTC
+ GTCTACGCTCTTACCCTGGCTGTCATCCACAAGCCCGAGTTCGAAGGTCTGATCCTACCACAGATCTACG
+ AAATCTTCCCCCAGTACTTCTTTAACAGCAAGTTCGTGTACGCGGCCGAGAAGTTCGATTATGAGGTCTT
+ CAGCAAGCTGACCATGTACGAGAAGGAGTACAAGGATATCCTTTACAAAGACTACAGTGAGTTCACCGGC
+ AATTTCTATTTCTACACCAAGGACTGGAAGACATGGCAGTGGTACAAAATGATGGGTCTAGACCAGGAGT
+ GGTACGTCGAGGACAAGTACTTCCTACGCGAAAACCTCTCTCAATTTGTGAACGATCCAAAGTACGTTGA
+ TGTTGTCAAGGGCCTAAAAAAATTCTACATGCCTGTGGACTACACCCGCGACATCGATTTTTTCAACGAT
+ GAAACTAAGATGACCTACTTCACCGAAGATCTTGGCTGGAATGCTTACTGGTACTACTTGAACATGGACT
+ ACGCCTTTTTCTTAAACGGAAAGCAGTTCGGATTGGACAAGGACCGTCGTGGCGAGTACTGGATTTACAA
+ TGTGCAGCAGATCCTGGCACGATACTACCAGGAGCGCCTGGCCAACGGTTTTGGCGAGATCCCCGAGTTC
+ TTCTGGTACAAGCAAATAGAGTACGGCTACGATCCCCAGCTGATCTACTACAATGGCATTGGCTACAGCT
+ ACCGAAAGAACTACTATGACTTCTACACCTACGGCAAATTTGAAATGTACAGCCAAATCCAGAACTTCTT
+ CAGTCGCGTCTACAAGGTCCTAGAGACAGGATTTTACAAAACCGCCGACGGTCAGGTGTTCGACCTTCAC
+ AAGCCCGAGGCTATTAAGATTGTGGGCAACTACCTGCAGGGCAATGCTGACACCTTTGACAAGTACTTCT
+ TTAACTACTACTACTTGCTGGCCCATATGTACTTCGCTGATGTAGACTACAACGACATGGAGGTGTTCCC
+ TAACGTTTTCCTGAACTTCGAGACTATGCTGCGCGATCCCTTCTTCTACACCTTCTACAAAAAGTTCACC
+ GATGTGTTTTACACCTTTAAGTACTACCTGAAGCCCTACACCCAAAAGGATCTTTTCTACGAGGGCATTA
+ CCATCAAGGATGTCAGCGTCAGCAAACTGGTAACATACTACGACATTGTGGACTTCGATGTGACCAACTT
+ GCTCAACGACAAGATGACGTTTGTCGACGGCCAGTACATATGGGACAAGGCTCTGTTGGCCCGTCAGGCC
+ CGCCTTAACCACAAACCCTTCAACTTCGAATTCACTATTGATTCCGACAAGGTGCAGAAGGGAGTTGTCC
+ GCGTGTTCCTGGGCCCCAAGTTCGATGAATACGGCCGCGTGATACCACTAGACTACAACCGAAAGAACTT
+ CGTGCAGATTGACAGCTTTGTGTACCCCTTCATTGCCGGCACCAACACTATCAAGCGCAGCTCCAAGGAG
+ TTCAGCTGGACCGCTGAGGACAGGATTACATACACCGAGCTCTACAAGTACGTGATGCTGGCCAGCGAGG
+ GCAAGTACGACTTTCCCCTGGACATTAGCGAGCCGCATAACGCCTTCCCCGACCGCCTGGTGCTGCCCAA
+ GGGATGGGAGCAGGGCATGCCCATGCAGTTCTACTTCTTTGTCTCGCCATTCGCCGAGACGTACGAACAG
+ TTCTCTAACTTTGATTACACCTACTCCTCGGGAGTTGGCTCCGGCACCCGGTTCGTGGACACCAAGCCCT
+ TCGGCTATCCCTTCGACCGCCAGATCGATGAATCCGACTTCTTTGTGCCTAATGGCTTCTTTAAGGACGT
+ CAAGGTCTACTACGTCGACACCTTTGCCAAGTACTTTGAGAAGAAGTACACCCAGTTCGGCACCTTCGAC
+ TACTCCATTGAATACTAAGCCACACTGGATCTAGCTCTTAGCAATGTCGCAGGCAAAAAAACCAATACCA
+ AAAAAATATATAAACGAATTTAAAATAAAGAAATACTGAATAATTAAATATTCATAATCTTGTTGTTCGC
+ ATCATTAACAAGCCTTGCCTTTTCAGATCACCAGAAACACAAAATGTCTTTTGCACTAAAAGCTAAGTAA
+ ACCCGCTTAGTGCCGTAACATGGGCTAATGGCGTTCGGCGGCGCCTGAGTCACATTGAAACCGAAAACTG
+ GACGCTGAAATTTTTTTCTTCTCCTATTCTGCTTGTGGGAAAAGAAATATGTGTAATAAAACGCTGAGCC
+ CTGAAGGCTAGTGGTCAAATACTAAACGCAGAAGGGCGAAGTCCTTGAGCAGGAAACGGCAAGGGTTCGT
+ TAAACTTTCAACGCCAGCTAAGCCCGATACGAGTCCTGATTCCAGTCTCCCTTTTCTGCTTAGCTTCTAG
+ AAGGCGTATGGCGATGGAAGGGAGGCCAGCTCGTGCGTTGCTTTCTGGCTACGCACATAATATCGACGCA
+ CTTTTTAAAAGTCTCTGGTTCCACCATTTGTATTTGGTGCGTCACTCCTGCCAGCTTATGGGTATCGTCT
+ GGCGGTGAGGCGCAGAAAAAAGGAAATGTGAAAAGAAAAAAACGTAAAAAAAACTGCCTGAAGCAACCAC
+ CACATACAACATCAGCATCAAATGGAGTGCAGAGGGGAAGGCTTTAAAGTGGTATAATGTGGTAGCAACC
+ CAGTCAAAGACCTAAACAAAAGAAACCCCAGACGAAATCTCGCCTTTTGCCCATGTGCGTGTGCGCTCCA
+ CTCGTCCCCCCAAGAGATTTGTCTAAAGCTCCTTGGACTTCCTGGTGCGTAACGCGATAGCCTGGCGCAC
+ TTCAATCAATTCAAATTCCTTGAGCTTGTCTTGGCCCCAGCGCTCACATTTTAATTGCCCGGCGGGCGGA
+ GGTAGCTTAACCCATAAATTATAAACATTTGCCTAAACTTCTCACCTATATGGTTTCTTTTAGCTTAACC
+ CATAAATTATAAACATTTGCCTAAACTTCTCACCTATATGTTTTCTTTTTTTCCAAAGTTAAATGTATAT
+ TAATGAAAATATAATTCAAAATAAATATCGCGAAGAAAGGCTGAGTTGAAAAATTGAGTTGACGTAAGCT
+ CTGTCTTGATCTAGTTTAAATTAATAGTCAAATGCCGTATCGTCAATGAAAAATATTTTGGAAGCTTATT
+ AAGTAACTAACGTTTTAACAACGATAAGTGTACACCACATGTGGCTTTTTTCGCCCCTTAACCTGCTTTT
+ ACTTGTTCATCTCGCATTTTTTGTTTTGTTTGCACAAATTAGCAGTCGACGACCCCTATATATATTAGTT
+ TACGACCTGAGAATGGAAAAGCAGCCAGCCACTAGCTCGAAGAGCATGAATCCGGGTTTCAGGGGGGGGG
+ GGGGGTCAGATTGCCGTTTTATTTCACCTTAAGGCTCTTTGGTTAGATGCCTGGCTGTCCAGACACGAAT
+ GAACTTAACTGAAGAGCTCAAAAGCCCCAGAGGGAAGTCCTTCGCTTGTCGCCTTATTGCACGGAAATAT
+ GTTGCCACAGTTTAAACCGCTCGAAATAAATATGCAAGTAATAGTGATGATCGGCTACTTAATTGTGCAT
+ TTAATATTCAATAATTATTTCATTACTCGTATGCCTTTCTTACTAAGGCTTTGTATTCCAACAGCATTTA
+ TAGCCCTATCGAGAGATTGGCCGCTCCTCTTTTTCTCAGGGTCTTCGGATTTCTAGTCAAGAGTTTATCT
+ GAATACGGCTTCTGGCACTTGGCTTTTCACATTCTGATTCGTCTGTTACCCTGTTCCTGTAGCCCTGTTC
+ GTTGACGTTAGTTTTTTTTTTCACTCTTTCCTCGGGTGCGGCACCTTTCGCACTGGGCTGGGCGTCCCCT
+ TCACTACGTCCCTGGCCGAGCTGCTACACTAAATTGGTTCTTGCCCGTTCTGTTTTGGTAGCGAAGCTCA
+ CAACACAGAGAAGTTTTCCCGCCAAATGTCTCGAAATGGGGAAGCGAAAAGCAAAATAATCCAAAGCGAG
+ CAGAACTCAACTCAACCGAGCCGACTTCAGCAGACAATAATACATGGTAAGTCCTAGGTCGGTTACAAAA
+ ACACCTCTGGCAAATGGCAACAAAACTGGCTTGACTCCACCACTAGCATCACCAGAGACCAGACCACAGA
+ ACTTGACGCATGGGAGGACAGAAGTTCGAAACCCGGACCGAGGCAGATGCGGGCCGAGGATGAGGTTGGT
+ CGCTCCGTCATTGTTGTTCTGCTTTCCGCCGTTTCAATATAAAAATCAACAAACGAAAATCATCAGCAAA
+ TTGTGTGCACTGCACAAAATGTAGAATTTGACACATCAGGTTTATATTGTTTAGATGATTTTTAACATAC
+ ATCATATCGAACTGCAAAATAAAAAACAAATTAACGACGATGTAAAACACATAAAATGAAAGTTGTAAAA
+ CACCAAATACAATTTAGATATCAAAAGCATTTATCGCATAAGCTTTATGCTATCGTAGTCTTTGTTTTGC
+ TGTGCCATTCCATTTATTCCATTCTGCCCCAGCACCGAATCCCTCTCATTCCAATGCTCTCGCTCCATTT
+ GAATGTGAATGAACCCGACCAAGGACAATGATCTACGTTAGCTCAGACTTACAATCAGACCATCGGGGTT
+ TATAGCTCAGGTCCACTTCGTGGACCACGCCCCTAACCAGCCAAGATTTTCGCTTTTATTTTCGTGTGCG
+ ATTTATTTGGCCGAGGGTTGATTTTTTACGACTGCGGCAACGGGTAGCAAAAGAAGAGGGAGAAGCCGAC
+ GTCATTGACATTGCAAATTTGACGAGGGCAACGCGGCAGAAGCATAGAAATCAGAACAGCAGACAAAACA
+ AATCGTTAAATTTTTACCACCTATACCGCTCCTCCAGCAAAAGTCTGCCTCGAGCTTAGAAAACATTGGC
+ TGGATGCTGTAGACAGACAGATTGGGCATCCAAAACATAGACAAAAAGCATTGTCAAACTATAGTGAACA
+ ATCTGAGTATTAGCGGTTTACTTTAACTGGTATGGGGTTAGTATAGTATGGTTATGTTACAAAAAGCGTG
+ GGGTTCATTTAAAATCATGACAAATTGAAATAATTCCGTAATTATCTGTTCGCCGTAGCTAGCAGCTGCC
+ TGCAACTGGATACGTTACGTCACTAAATATTTAGTGACAAGGACGAGCCCAATAAAGGACTCCACTCCCA
+ CTGCAATCAAACGAAAGTCTCCCTTAACTCTTAAAAACCGATGTATTTAAACGTAAACGTCTACCCCAAA
+ AGTATGAAAATGAGAACAAAGTCCGCTGTCTGTTGTAAGACCAGTTAGTGGCTCTCCTTCTCGTTGGCCG
+ TATACTTTACTAAAATTTGTGCACCTGCCTTTCATGTGTAGTTTTGCACCTGCTCCACCGTAATCATCAT
+ CATCGACGCAGGCGGTGAAGTTGAAAGCATCTCCGACTGCTTTTTGTTTGTTTATTTGTTTTCCCGTTGT
+ CGGGATTATTTATATGTGTGGCAGGGAAGCCCAATGCAGGTGCAGTTCAATGTCCTTTTTGCCAACGGGA
+ TCAGTAACTCTATCAAGAAAAGCAGAACGAAAGCATTAACTGCTGCTGAAAGAGGACATATTACTGGAAC
+ GTCCTATGATCGCACATAATATCTTTCCAAGTCAAATTTTTTAAATATAAAAAAACAACACTGAATTCAA
+ CTTCGAATAATTCAGAATGAGTTAATATCCCTTATATCACACGTGTGAAGCTGTCGATAACCGGGAAAAA
+ TTATAGTGATTGTTTTACTTATTCAGTGCGCAAACCTAGACATAGAAGACGACGACTGTATTCCACTTCT
+ GTACTAAGTGCTTTGGTTGGGGGCAAAGCCTTTCTGCCAGACGACAGCCATTATTGCTCTTCGGCTCCGT
+ CCGACCCATCCACTCAACAAAAATGTACGTGTCTCTGAACTTTGACCCTCAGACAGTGCTGTTGCTGTTG
+ CGATTAAGAATGTGACATTTGTGAACCTCTCCACCGCCTACATACTATGGCGCCTGTGTGTGTTGCTGGC
+ ATTGGTTGGCACTTTTTATGCGAAATTAATTTAGAAAATTATTTGTTGGAACCGAAACATACCAGCTCTA
+ AAATAGAACGATACGGAATTTACGTTTCTAGTGAAAATGTGAGTGACACTTATCGGTTTAAAGGGTTCAT
+ AAGTGGTTGTGTTTGTGACCCACCAGCGAAAGTCTATATCCACACAAAAAAAAAAATGAACACGAGACGC
+ AATTCTTTTTCCATCTGCTCGCCCTTCCACTGAAGCTTGTTCTGGAGGGGCATGACACCTTGATTCTTTT
+ TTCTTCTTCTTATTGTGTTTCCGTTTCACTTGCTCGCCAACGTTATACATACATACATACACGTTATACA
+ TACATACATACATACATGTATCTAAAAAAAAAAACATGAATAATTACGACTCTCCTAGATCCGACTCCGC
+ GATTCTGAATCTTCCTAGAGTATTTTTCGCACACTTTTTTTGGGCGGCGAAGATATATACCAAGGTTGTT
+ GGAACGAGACGGGGAGACTGGGAACGTGGAATGGAGCACAGGCGCGTAAAAAATACCCAAGCCGCAGACA
+ GTGCAATAACAACAAGCGGGAGAACGCAGTAGGGTTGGAGAATTGGGTGGGGGGGGGGGGGGGGGGCGAA
+ GAGACATGAACAGAAGACCCAAGGCAGAGGTCCAAAAAACAGAAACAGAACCAGATGGAAAATGGAATGG
+ AATCGAAGCACAGTTAAAGGAATTTTGCTGTATACGTTAATGTGTGCTTGTTTTTGTGTCTGGGCACACA
+ CTCATAAACAATGATGAACGGGGTGAATGGACGCAAGGTGACGTCGCAACGCGGTCGAAGCCGCTGCTTC
+ TGCACATTGGGTTGGCGAATTTGGCGCCGACAACATTCCCCTTCTAAAATCGCGCTTTTGAATTTTCCAC
+ CTTAGGGTTAAACCATAAATTTCTAAGTTGCAAGTCCACATAAATTATCTTTTAATCGAAATAATTTACA
+ TTTCACTTTTCTCCAAATCTTTCTAAATGTAAATAAAATTTAAACAGTGACCAGTTGTGTAGAAAACGTC
+ AAACTATCTCGTTTTTGCGAAGTGTTCCCCATCAAGCGCCACAATGGGCGTGGCACTTGGCGGAGAGTGA
+ GAATTGAGGCATAATAAAAGAAGGAGGAGGGAACGAAGAAATCATCGAGAGAAGTTTTGGTTCAATTCAG
+ TTCGTTTCGATTCATTCTCGTCTACTGGCGTCTTTCTGTGCCTCTTCGGTTATTTGTTTATGGCTGTTTT
+ GCTTTGATCCCCTTATTCTGTCTGGGGGCACAATCGTCTTGTTTTTGCGCTTATTGCTATTGCTCTACAC
+ TTTCCCGCTATTTGGCTACTCCACGTCTGGACTCTTGACTATTAAACCCAGCTAAAAGAAGTGCTAGGCA
+ GATATTTTAGAAATCGAGGGATTAAATTAAATTTTGCATTTACTTGCATTTTATTGAAATTTTCTTGCAT
+ TTTTTATTCACATTCCCTCCATCCTTTCCCATTTTATTGAGTGCAGTGTCGTTGATATGTGTAGATATGT
+ ATATATGTAAAATATGAAGATATTCCACAATTATTCAAGTATTTTCATAACTTTTCCCCGTCAATTTTCG
+ GAAACTCCGCTAGGAAACTAGGTACAACATAGTCCATTATCCGATTCAGAATCCGACTCATATTCGTCAG
+ CCGAATCCGTGGGACAAAAGCCTGATAAGGTCGATTGTAGTTCAGTATAAAAGTAGCTCTTCTCGTCCTC
+ TGTGACTTCCATTTCTATATCTCTGTAGCGCCTAGGTGAACCGAAGTTTTGGAGGTGCATGGCTCTATTC
+ ACGAGAACCTTTAAATGGATCTCCTCATGCTCCTGACAGACCCTAAGTTGTTTGTATTCCTGCTTGTCTC
+ TATAAGTCTTGCACTTCTTGAACATCAGTCGATTGGACTTTGCCTTGAGCTCTTTTATAATCCTGTTCTG
+ CGCATCAATAGCGTTGACCACCTCCTGATACTCCTTGTACATTGCCTGTTGCTCTTCATCGTCTTCATCG
+ CTCTCATTGAGGAGCTCAAAGGGATCCTTCTCCTCCACCTCGAACTTATCTTCCTCTTCAACGTCCTGTT
+ CGTCTCCTTCGCCCTCTCCCTCAAAATCTTCAGCAGCTTCTTGTCCTTCATTTTGCTCATTATCAACGTC
+ TCCAGAGGCTTCTTGCTCCACATCAGACATTGCTTCGGATGTTAGGGATAAATTGTATTAAGCGATGCAG
+ GGGTATTAGTTTACATAATTATGAAATACTTTAATAAACCAAATTTTGATATATAAATCAAATACAAATT
+ GTTGTAGTAGATTTATCATGTGATCGACAAACGTAAACATAAAACTCCACACCTTAGAGCCAGTAAAATC
+ TCAGTTTACTGCACACAACAACTACTTTTATTATTTCAGTTCGCCATTTTTTTTAGCACTTCAATAACTT
+ CCGTTTCCGTTTCCCTCGTTATTAGATCTTTTCATATACGATTTATTGTTCTTCTGCCATCATGATAGCT
+ GTTGCGCCGTTAACTTCATTCCTTCTACAATCTCATCTCTCTTATTTCACGCTTTTATTGACTCAGTGAT
+ TTCTTGTGGCTGGATCCGGTGGATTACGTTTCAAAGCGCACCACTCGACGGCATGCGTTCGCATTAATTA
+ TAGAAACTACAGAATGCATTTTAATTTGGCATAATGTTTATCTCGCAGCAGGGTCGTTTCATCGTACTAC
+ CGGTAGTTAAGACGTGAATTCTAACAGATTACAACCTGTAAGCCAGGAAAGAAAGGGTATGTATTTGATA
+ ACTGGCCCAGCGACACAAGTTGCTGTTTTAATATCAAACTGGTGCATTGAATGGCATAATAGGAATGCAC
+ AATATGTACGCAAAATGTACCTGCAAAGTTGTGTGCAATGAAAGACAAAAATGTAGAGAACAATGTTTAG
+ CAAAGAAATTGAATATGTCGATATAGGGATATACAAATTTAAATTTATTTATTTATTTAATTTAATTTAT
+ TTGAATTTACTTAATTAAATAATAAGCACCTTGTTTGGTCCAAGCTTAAGCTTTTATCCTTGATGTTTTC
+ TTGATTACGTCCCTGTTTAATTTTTGGCGTAATTACCAATTGCTTGCGAGTCCCTGAAAGCGACAGTTGC
+ ATTAGAAGCGAACACCCATAGCCAGAGCCTATGGGTTTTATCGTCCGTATCAAGGTGGCTTTTCGATTAG
+ CTCCCCATTCAGATTACGCATACGTCACTTAAGCTCAAAAAGACTGCGCCGCCCATTTTAAATCAAATAA
+ CGGGCAATTTAATTTACAAAGTTGAAAGCAAGCATAGGCCACCCCCTTTAAGTCTCATACATATTTTGAT
+ TTTTATTGGGACATTTTATTCTTTTTTTTTTTTTTTTTTTTTTGATTCCTTTCAGACCATGCAAGTTGCA
+ TCAAGTTTTTCTTCCGCTCAGACTTTTGTTTTCCTTTGTCTTGCATCTTTTTTGTGCTATTGTTACAACG
+ GAATGGGGACTGTTTTTTTGTTTATGCCTCTACTGAATAAAATGGTTTCATTAAAAAAGTTTTAAACTTT
+ TTCATTTAATTTAACTGCAGCAAACAACAAGCATCCTTCATCATGAAGCCTTTCTCCTTCTGCGCTTTTC
+ TTTGCCCACTCTCTTGCCATTTTTCACTGCAACTATTTTGTAGAGAGCATCTGTTTCAGATATAGAGATC
+ CTTAGCATGCTTTGATTGTTTTTTTTTTTTTTTTGAATGAGTTTCAATTAAACTTTTCTATTTCCATTTA
+ TTGTGCATTTTCCTTCCGCAGCGTATGCTGTCGCAGTTTGTTTCAGTGAGTTGCCACCCCGATTATCACC
+ TGAGTGAGAGGTATCTTGTAGTCGAGGCACTCTACTCTCTCTGTCCTGGTAAACTTTTATTTTAAAATGG
+ CCTCTTAAACGTATTGTCAACTCAGTATATTATTTCGTCGCTTGATTTCCTTTTTTGTTATTATTTTAAT
+ CATTCCCATTCACAGAGCATAATTTAAAAGGGGACGTAATAAAAAAGTCGTGTGATGGTGTGAGAATAGG
+ GTTTGTTGAGACCGCCCTTTCTAGTAAGCCGGTCTTCATGTGGCATGACAACATGTCGTATTTGTAATAT
+ TTAAACACAACCGCTCAGCGAAGGTTGACAATCTTTGACATTAGACGGGCGTAATGATGAACTCTGACAC
+ GCTCAAGGGATGGCAGCGAAGGGAGGAGGTGGAAATGTGAGCGGGGCAGACCCAGAAGAAAAATCAATTT
+ TTGCACAAAAAAAGGGCAAACAAAAAAACAAACACATTGCAATACCAATATTAACAACAATAATAAGTGA
+ TGTAAACAAAGTAAATAAATGCGTTGTAATTCCACATGATGAACTGGGGGTAAAAATTGCTGTTAGCATC
+ ACGGGTGGCAATAAACCACTTCGTAACTTTAATGTCAAGGAATGCTGCAGTACCAGTCAACTGGACTCAA
+ TAAGACAAGGCTGCTCACAAAAAAAAAAAAAAACTATCTCGTGTTTAAATCCAAATATATAATTCCGCTT
+ GACATATATATAAAACTCATCAGTTACCACATGTTGAACATTAAAAACAAAGTTTATTTTCTGAGGAACA
+ GAATTAAAAAATGTTCCGGCGTAGGATTTTGGCGAGTGTAAGAGATTAGATGTGTGTCCATGAAAAGTGT
+ CCTGTTGACTGCGTTGAAATGTCACTCTTGCGACATAGTAATGCGTTTTTCTAACGTCAGCGACGCTGCA
+ ATAACTACAGAAATTCACCAGAATGTTGTTACTTTTGTGGCCGACAGAAGTGTAGAAGAAATTACTTTCC
+ TACATTTTTCCCAATAGTCAAAATCATGGGAATATTGAAATACATTTTAATATAAATTAAGATTATCTGT
+ GTAAGAAAACGTTGCATCCATTCCAACAACTTTTTCGACGAAACGTAATATTTTATATTTGCCGAAACAT
+ CGCAACATAGTAAAATATTTAAAAATTTTAATGGCATACCGATACAAATTGCAAAGATAATAAATAAAAT
+ CATAAATTTATAAATTCTATAAATTTTCCAATTGTGGACGTGATAGCCTTTTGGGGTTTGTGTCTTTTTT
+ TTTTGCCGCATCGTTAGAAATATGTCAACGAAGAAAAAAAACAAAACATTTTTCAAAAGTGTGGGCGTGA
+ CAGTTTTTGTGTGTTTGTAGTCAGTTGTGCAACGTTTTGAAGCAATCTTGCACGGTTTAGACGACACTAA
+ AATCTGCATATCTAGTCTCAACAGACTAGCTTTCATATTGTAGTTCACGAGATCAGCGTTCATACAGGCA
+ GACATACCCCGATCGACTCGACTAGTGATCCTGATCAACAATATATGTGCATATCTACTTTATATAGTTG
+ GAAACGCTTCCTTTTAAATCTTACATACATTTTAACGAATCTTGTATACCCTTTTACTTTAAAAATAAAG
+ CGAACATGTTAAATAATACAAATTATTTCTTGGCAAGCCTGAAAGAAAAAAAGGACAGGGAAAGCATATG
+ CTTTTAGTAAAAGATTAAAAAAAAAGTATACTTAGTCGTAACAGGGACCGATAGGAAAGTAAGGAAAACA
+ GGAGGAGAGTAGCAGAGCAACCGTCGAATTATATAATTATATAGTATATTTTTACTATTTACTTCTCCTT
+ TTTTGCTAGAGCGAAACACAGCAATTGAGAGAGAGTGACATAGAAAGCAGCAAGGGTAAAATCGATCGAT
+ TTTTAAATGAATTTGGGTCACAGCAATCTCACAGTCCACACCCCTTCAGCCACACAAGCCCCTTTCCCTG
+ TGGCAACTGCATTCGCCCTCGAGGAACGCAGGTATATAAGTGTGTCAGTAGGGGGTTTGCAGCTGGAGAT
+ ACAGACGGAATACAAGTGTCAGCTGGCTTATGCTCAACTAACTTACCTAATTAACTAAATTCAAATCAAA
+ TATAAAAAATTCGTTATTCTGCAATATCTGGGGTGTGTTGGCTTCTTTCATCACCCTTTCATGATGAAAG
+ GGGCATCAATAGTGCACTTAATATAGGCACAGGATAAATTATTCGAAATGATCATAGACTAGCATAAATT
+ AATCAATAATTAAAATAAAAGCATAATGCAGATTCGAATAAAATTAAACTCCCAGTATTAGTTTTAACCA
+ GTAGACATTTGGATAGTTCCCTTTCATATAACAGTTCTTAAAGTTCATATTACCACACGTGGACATCTAC
+ CCCCACGGATTGGCCATGCAAACGTGCATTTTACGAGCCAAAAAATGACAACGGGGAATCGGAAAAAGGG
+ AGGACACATTGTTGATATCTTGGGAAAAATCTAAAGTATATAACTGAATGACGATTTTACCCAAACCAAG
+ CCTAAGCATTCGTTGCAACTTCTTTTACGTTTTTATTACAGTCCTGCTACGTGACGCGACGGATGCGGAC
+ ATGGGCTTAATCATAAACAGTAGATGCGACTTAATTCAATCACGCATGGCCTATAATATTTTGATTTCGA
+ GTGCAAGATAAGTGCAGTGTCTGGCTAAGTTTAGTAACTTCCTCAAATGAAGTCATTGTTCGTTTAGATT
+ TTTGTCTTTTACCACGACTCCAGTGGTTTTGAAAAGTGTAAGAGGACACAATAATCAGACCTCGAAGAAA
+ AATACTTAAGTTCCGTAATTCCGGAATTTTGGAGCAATAACAACGAAGGTATTTGAGCATTAATCATATC
+ CGTATCTTATACATTTTTAATTAAGAATTTCCGCAATGATTTTGTGCCGACAAATAACTACGTATCAGGG
+ CCACCTACAGTAGTCACCGTTTTTCCATCTTATCCTTCTGATTCCATTATATTTGATTCATATTCTTATT
+ ATGCAGGATCTTTGCTGCATTCGGTAACGGAGTTAACGATAAATTTGAAATGAAACCAGGACCTTGTTAG
+ CGACCTTGCCACTCCCCCGCCTTGACACATCGGAGGCTAGCCGAGTGCATGTGCCAGGCCGAGGTCTGGT
+ TTCATTCGCCACGAAGCGCTAAAAGCTCCCAAAAACAATATAAAGACCAAGGGCATTTCAAAACCAAGAG
+ ATTGGATTACTCTTTTACGAAACGGGTAACGGGAATAATTATAGAAGTCATGCAAAACACTTTTTTAGGA
+ ACAATTATTCACTGTCGAATGAATAATAAACTGAAAGTTAATGGAAAGATTTTGTTGAGTTTTTGCGGTC
+ TATCGACTCGCAGCGCACAGGGTACTGTCACGTTTACGATATTAACTAGATTGTTCGTTGCAAATTGCGA
+ ACGTGTCTATAAACCAGAAGCACATCCCAGTTCCTCTCTCGAGAGCATTCGAATAGGGTAAACCTCACTA
+ ACCTCCCGGTCATAGCAAACAGACCGCCCTGTCGACCTACTTTTCGAAATCAAGTTCTGGCCTTGATTTT
+ CAGCAGTGACCCGCTTGTGTGTTTGTTGCTTTTCATTAAACCCTTGCAGAGCGTACATTGATTTAAGTTA
+ GTAGTTATAAACGCATAAAGGGGACATTTGCGACTATATAACAATATGATTATCATTAACTGCCAAGTCG
+ ACAAAGTCATTTATGTTTCTACGCAAACTAGTCCATCAGTTTTAAAGCTCTTGGTTAATCTGGGTTAACT
+ TTCCCAGCAGTCATTTTTTATTGCATACAAGTATATTGGTCGGAAAGGGTCGCAACAGACCACGATACTG
+ CTGGCATAGAAATAATAGGAACAAATTAAAAAAAAAAATTATATATATACATATATGATATGACATGATA
+ TGATTGTATATTTTAATATATGGCTTAGTCGGTAATCACCAGTTTTTGGACAATATATAATTTCAATTTT
+ AATTTAATAAACAGCAAAAGGCTTTATAATAAAGCTACCGTACGGAAACATTCGGAAATGGGATCTTAAA
+ TAAATAGAAAAAAAAGTATTCTAATTATGTATGCGCCAGTTTTTTGATAATATTTAATAACATTATTTAT
+ TTGATCTAAGTCAGACTTTTTTGTCATATAGTTGCCACAGAAAATTATAAAGTTGTTATTTGCTGTACAA
+ AATAGGATTTGCTCAATTTTATTTAGTAAGTGCTGACTTTCTAATTCTATGAAGAAACAAAATGACTTCT
+ ATTTAGAACAATAAAACTAATGTCAACATCCTCCACCAGTCGAGAACCATTTTTCTTTAGCTTAGGTCCA
+ AAAAATTCAAAGACTACTATAAATACATATTATTTCCATTAAATACTCGATCTGAGCTGACTACAAAGAA
+ ATACAAATGTCAAAATACATTGGAGAGTCAAATTTCTTTCCACACAATTACTTTGATTTCGTTCTTCCTC
+ TGGCTCAGTAAATCAGAAGTTTGATTATCTAATTTCTTGGCTATCTTACTGAGAATTCCTCACACTGCTG
+ CTGGCAATAATGTCCTCGAAAGCAAGGAATGCTTTTTGGCATTGACTGCTTGACGGCTGCGTATGAGTAC
+ TACCCACAGACAGAACAGCAGTAACATAGTTAAAGGGATTTTTTGGGGAGTCGCAAAGCAGGCGGCCGAT
+ TGTAGTTGTCATGAAGTAAATACAACGTCACCGAACGCCAAAGGCATCAACCAATACCCATCTTCATCAT
+ CATTCCAATCATCATCCATATCATCATATCATATCTTTTATATATACGCTACGCTATATATACTATATAC
+ GCTATGTTAGAATGTTAATGCACAAATAAATGGAGTTTATTTTCATTAAGGAAAACCACGCAAAAATGTT
+ TTAACAATATTTATTAAAAACTTGTTTAATTACATAAGGCGACGTTTACCTTTTTGATTGCACTTCTTTT
+ TTGTTTAATTTTTTAAGAAAACAGACATAGTAAGGGCACTGCGCTAAAGCGGGAAACGGCGAAAACGCAA
+ AGTAAATAGTAAGATATGTATTACTTGGCAGTCATTCCGGCTCTGAGCACTCTCCACCCTTAAGCCCCAT
+ CCGCAACCCCATGTTCTCCATCTGTTCCACATTTAGGGAGAGTAATTGCAGCGACAGTTCGGCGCTACTG
+ CACTTACCCCGGCAGAAGAAAAGTCAGCCAGTAACATTAACCCACTCTCCGGCAATGGAAAAAGTCTTTG
+ AATCTCTTTGATGAAATATTGAAATTGTTGGATGCTGATGTCGGGTTACTCAGATGGTCGAAATACTTTG
+ GGGTCCGGCCAACATTTAATCTCGACTAGGGGACTGGACTCGGTTTCCGAGGGGTCTGTCAAGTGGTACC
+ CATCAGAAGGTCCAAACTTTTAGCCCGGCGCTTGTTGTACTTGTCGCCGTCAAGTAGATCGTTATAAATT
+ GCTCAATTTTAGGAGAGCAAAGAAAATGCACTTTTAGTGTTAATAAATAATGACTGCTTACTCTACTCTG
+ ACTGCAAGCGCAACATTAAATTGTGATTTATGGGCAGTGACATCTAAACAGGAATCGGGCTTGAAATGCT
+ GTCAATGACGACAGAACGACAGGTCTTGACATCAGCTAATTGTTTTTGTGGGGCAGCTAAATTTTTGCTG
+ TTTAATATTTTTTGTTGCTTAAAACTAGTTTCAACTAAAAACAATTTGAAAAATAATGTGTTCCGACGAT
+ TTTTACTTCTCATATTAACTTGCCCAAAAATTCGAAGAAAAAAGCCTGACGGGAATTCACACTGAATTGA
+ TGAATACTAATCTTTCACTTTATTTGTCCACTTGCACCCTAGGAATTTTCCGGAACGATTACATTGACAT
+ CTTTAAGCTTATTAGTCACAAAGGAGATTAGTAAATACAAATAGTATTCTCATGAACTATTATTATTATT
+ TTTTTATATTATTATATGTCGTTTTTGCTATTTTCCCCTGGTAAACAGTTATCTCCCAGTTAAACCACAT
+ TGAGGATGTTTTTTTTTGGTTGACTCCTTTATCATTTCCCATCGAGTTTTTATTATACCCGTTAGTCGTA
+ GAGTAAAAGGCATTACAAAATTTGGATACTTGTATTTTAGCTATAATTGCTTTTCATACATTTTTAATTG
+ GAATTGTATCAGATAATTTCCACTGTGTGATATATTGTTAACGTCACCGTTTCTTGGTTCAATTTTTCAG
+ TTTCCATTTTCGTTGTCTTATTGTTTTGCTTTTTCTTACAGATGCTCTTTTTTTAATATTTTGCTGAGCA
+ ACAACGCCAGAGTCCAAAGTCCATAAAGCATTCCATTGTTAGTGTTGGTGATGGTACTTCTTCTGTGCGG
+ CATTAATTTTCTTGTTTTGGATTTAGTTTTTTTCGAAACTGACAGAGCCACAAGACTAAGTTAAGGACCT
+ CTTCTCAAAAGAGTGCTTGCCATTGGATGTTTCACACAAGATAAACGCCGCTAAATGTGCAAGAATAACA
+ GCAACAACAACAGAATAAATAATAAATAGTACAATATGCTTTTTGATCTGCATAGAGTAGTGCGGCCTTG
+ TTTTTGGTCGATATATATTATATATTTTCTTGCACCTGTTCCGCAATCAGGAAGAAATATGACATAACAT
+ AATGATAATAGGAAAAGCATCGATTTTATTGGATTTCTGAGCACAATCCCTTCCATCCCTTCCATCCTTC
+ GTCCAGGTCCAGCTGCACTTAGCTTTAATCGTTCGCCCTACCGGATTTCCGTGGTGTTAACCATTGAAAA
+ ATGCTTGGTTTAAGCTCGGTGGTGTGTGTTGGTAGACCGGCAAAATATCTCGAAAATTGTGTCAGAAAAT
+ GTTTTTCTATCTCACACACACGAAAACATCCACACAGAGGGGTCAAGGAGGCCATATCAAAATTAAAAGG
+ TACTTCCGTTTTGGATTAGTTCGTTTGATTTTTGGTGTTCCTTGTGTGTGTATGGGAAACTACAAAGGTG
+ CCGGAAAGATATGCGAAAAAAAATACTCATAGAACGTTCTGTCAAAAGGTAACCTCCATTGATTTTCGAA
+ CTTTGCAAGGGAGTCGCCTTTTTTGTTTTATTTGTCAGATTATTTCTGTTTATATTTTTGACCATTTTTA
+ AAATTTTTTGTTAATACGGATTGTTATATATAAGATACATTTGACGATAATGAATTGAATTAATGGAATG
+ AATTATATTTTTAATAGCAGCGAAAGTACACTGAACATAACCAGAAGTGGCTTCCATAACCTAAGTATGG
+ CCATTTATGCCTTAATAAATCATTAACGACTATTTTAACGCAAATGTGAGAAAGCTTACATTTTGTTTCA
+ TAATTGTTATATAAAGATTCAACAAAAAAAATTGTTTTTAAAAAACCCTCCAAAACGTCCTCAGCAGTTC
+ AGAAGTTATGGGCGCAAAAAATCACTTATTAATTACTGTTATCCCGTTAAACAATACCTTCAGATTAGAC
+ ATCGGCAGAAATTAATATTTCTTCGTGTATTTTGAACAGTAGCCTTCGAACAATCTTCGAATACGCTTTG
+ ATCTTTTACTATGTGTAGAAACGGACAGTATATATATACATAAGTGTTGAGTCCACGCAAACGTGGGTTT
+ TCCGAAAGTAAGTCTTTGTGCGAGAGCTCCATTTGGCTTAAGTTTAGCCAAATACATAAATATGTATTTG
+ CCGAACAGATCTTAAATCTTCGGTGAAAAGTATGTAACAGGTAAAAGAAAGTGTTTTCGACCATATAAAG
+ TAAATATATTCTTGATCCTATTCAGTATCAATAGCCGGGTCGAACTGGCCATTCCCACCTGTCCTTATGA
+ AAGCTAAAATGTTGTGATTAGGCATGCGGCTTTCAGAGACATAGACGCAGCGCAAATGTTGCCACGTATC
+ TGGTATAGGTATCTGGTATTCAGATATTTGAATATTTGAATCAAGAATGAATAGGTATTAATTATAAACT
+ TTAGCAAATGTAAATAAATAAATCAAAGGGTGCTGGACTTACATAAACCGAGATACCGCTACATTATGAA
+ GAACTGCATTCCAGGCAAATCTGAAAAGAGAGAAGAATTTAGGTCTGTAAGGTCGAGGTACAAAAACAAC
+ GGAACGAAAAATTGTACAATTTTTTAAAATTGGTCAAAAAATAAAAAAAAAAATATACTTTAAAACCTAG
+ AATAATGTATTTAGTTTTTTGACACAACCTAAGAAATTATATTGAAAATATAAATGGGTTACTTACTGTT
+ GCATGTTGAATGTTGCATGTCTCTTTAAACTTTATCTCAGGAAATAAATTTATATGAAACCGATATACAC
+ CAACCTATTTATTTTGCTTCTGTGTAAATCTTTCGGTGTGGATTTAGCTGCTATCAGTCTAACTAGAATC
+ AATATACGCCGTACCGCAAATATATCTTATCGGCTATATAAATGGCATGACTCACCCACACCTCACCCCA
+ CAAACAAACCCGCCTTCAACCTTTGCTTACCCTTTTACACTCGCAATTGATTGCGACGCGTACTTCAGTT
+ CCAGATAAGCGCAAATATTAGCACTGAATATCAACACTGAACCCATCGGCGCACACCCATGCAAACGATG
+ AACCCTCCCATTCCCTGCAATTTATAAATTCCTGTATTTGGGTGCATGAGTAATATGACGACATTAATTT
+ TCACAGTCATTACAACTCTATTAGAAGTTCCGAGGAACTTGGGTTCTGGGGGTGTTTCAATTGGACCTCG
+ GGGTAAATGTTTGTGTCCCGCCCTAAAATTGTGCAAATGGAAAACAAAGAAAAAAACAGACACGAAACTA
+ TATCCGATTGCACGCACAAAACGTGACTCGTCTTCACAAACCACCCTCCAAAAGAAGAATAAGAGTCGAT
+ TTTCTCGACGATTGGGTAAGTACGCAGTGATCCAAGTTTTATCCAAGTTGGCTAGAAAAATTTAAATAGT
+ TTATACAATTGTTAAGGATATAGCATTTTGCGGTTTGTGGGCATGGCCAACTTGTTTTTGACGTATTAAT
+ CAAAATTTTCCAGACAATAATAAAATAGAAAATATACAACAACAAAAAATGAAAGTATGGCCTAGACAGA
+ TCACACTGTTCATACGGACAACCAGATGGGCAACCATGGCCAGATAGACTTTGCTAGTGGTATACATATT
+ TTATAACGTCGGAAACGCTTCCATCTATCTACTCTGTACTTTTTAACGAATCTTGGTTTACTCTACGGTA
+ TGGAAAAAAAATAAGCACAACTTTTTTTCTTGCCCATGAAAGTTTCAACAGAAATTGTACATAGTTCAAA
+ TTCGAGGTCATTACCAATGTGTTACCGGGGTAAAAGTGTAAAAATAACCCAAAAGGGTGGGAAAACATAA
+ AGCTGTGATGTCAAATAGCCATGAAATATGCAATAAAAAAATTACGTTAAAGCAATCTTACACTGGTGGA
+ ATATATGAGGGTAGAGGATTTGCATATTAAAAAAAAAAGAACACAAAAAGATGCGAATAGGTTAATAAAA
+ ATCTGTAGTCAAGAGTTACAGTTGCTTATTGGTACGTGTAACAAATATAAGCTCAAAAATGATACTGAAT
+ AGATTATTTCCTGCCATCGGAAAGTTTTCGTATGCGACCTTTTCAACAATTTCTCTATATATTTAATTGC
+ CAGTCACGGAAGGCCCGGGTGGACAGGTAAAGCCACTGGAATAAGGGAAAAAATCTAGCGGTCGAGGAAC
+ AGCCGACGACAAAGACATATTGGCCATCTCGGTGCATGAATTGGACCATTCCTATCATCCAGAATTCCCA
+ TTTCTTTTTTATGAAATTTGTTGCTTTTTTTGAAATGCAGTCACGTAATTATCGAATTTTCAACAACGGC
+ CGAAAATTTTTCTTTTCCATGGGTGGAGTCTTCGAGTAAGGAGACTGCCCCCTGCGTTTTGGCCAGACAA
+ AGCGACGGTATCAATTTGTATCTGAAAATTAGTACTCCGCTTCAATTTGCCACGAAAAATAAAAACACCA
+ AAAGCACAAACAACAAAAATTCGTTATACCTCGAATCCGGTAATAGGTAATAATGTTGAGTTTGATGATC
+ AATGAAGCGTCAACTTTTTTAGGGATCTATGTTCACCCCGGGGATTCGACTACACGCATATGCCCAGGGG
+ TAACTCCACGATGTCCATCGAATCTCATTTTGCCATTGGGCAAGTATTGCATTAATGAGGCGTTGTTGGC
+ CGCCCCATTTTTGTTTCATTCAATTTAATCTTAACGAAATCGAATGTCAAGACCCGCATGTCATTCGCTC
+ ATATTCACTCTCGTCTATGAAAATTAACAGTTGATTTAAAATATAATTGTCATTATGGTTTTTGTTGCGG
+ CGTTTGTTGGCAGTTCTGGTGTCAACACTTCGCGCCGATATTCTGCTGGTTCGTGTCGAACTAAAATTGT
+ GGTTGTTCGACCAATTTTTGCCCGATTAAAATTCGTTTTAGGTAAGAGCCCTGTTTGCAAGAATTTAAAA
+ TATTTATGGACTTAACTTGGGTTTTTACCAAGCATATTAGTTGGATTCGTTGTGCGACGTAGGCTTTTGG
+ AAAGTTAAGGAGTAAACATATGGACAATTCGTTTTCACAAATCTGACGGTTTAAATTGTTAAACATTGTT
+ TATAAGTACTTAAAGCAATGCTAAAATCAATTAAATCGAACTACTAATCCTAGTTACAGTCATCTTTTAA
+ AACAAACTTGCCACGTTTACAATATTTACTTTACTTAAAACTTACTAACATGTTCCCTCAAAACCCATAT
+ AATATAGATTGTTCCCCAACAATCCCATTTGGTCTAATACCTATCCAAGAAGTTTAAAACAAGGGTGATG
+ CCACTCACTGACCCTACCTACACAAAAATCTGTTCGCTTCTCTAAATATTTGAAGACGGGCACAGTGAAA
+ ATAAAATTAAAATTCCTTCATGGCGACAAAATGGAGAGGGCGCCCATCAGATGGGTGCGAATTATCAGCT
+ TATTTAGTGCCGGTTCAGTTGGCAGTATAATTCCACACTTTTCTTTACAATTTAACACACAGAGACCGCG
+ GAAAAAGGATGAGGAATGTGACATCAATTGACACAAAAGTTTAGCGTAAAAATGTGTCGGGACAAAGAGA
+ TATCCATAAATTCCATTCTCCGAGGAGAGTGAATGAGTGTGTGTAACTATTTAATGCCAAAGAATGAAAA
+ ATAACAAGATGCGTATGTGCGACAAACAAATGGCGACATCGCGGCCAGACTCTAATTGTAAATTCCGATC
+ TAGATGCAACAGCAAATACATATACTCTTTATTTGATTCATTGCATGATCAAACGAATTAGATTCGAATC
+ GTTTTTTCATTCTTCATGGTTATAGACATGTCTATAAGGCAGTGACGGTCGTTGTGGAGCATCTTAAATG
+ TATCGTAAGTGATGTTTTCAAAAACGACCACGATCGTCCACTGAAAAATGTATTATGAAGTACAAGAGTC
+ ACGTTTAATATTCTATATTAAGAAAGTGTAAGATAGGAAACATTAATTGCCCCGCGTAGGTCCATAAAGA
+ TCTTTATACCAAGTTTTCTAGAAACGTAAAACTTGATACAAACTTTTTTGGTATCCTCTTCTGATTACAA
+ TATTTTTTCGAACGTCCTGAATAAGTTAAGTAATAAGGTAAGCTCGCCATCACCTGTATTTCTGCATTTC
+ ATTGTTACTCAAATTTTTATATTCCGAAATGGATTCGACCTATTCAACAATTTAATTCGTCGTTCGCTTT
+ TTGTTTGCAAGTGTGAATGTTTTTGATACCTTTCGCAGTTTATCAACAGCTGCCTCGTATTTTTGCCACA
+ ATCATTTAAATGATGAGAACGGAGGCGGTAATTCGATGCCGTCATTATTATTATATTGTACCGCAACCAA
+ TGCCATACTGAGTCCGAGAAAATTGGGAGGAGGGAGGTCTAGGGAAATCACTTCAGAACCTCCCGCCTGG
+ TACGCGAATTGGAAATTGACGACGTCGCCGCTAAGGGATCATAGCATATACGGGAAAATCGAAGATTGCC
+ GGGTCTAAAACAACAAACAATGCGTTGCGAAAAGTTCGGGTTTCATCAGCGATCGATATGAATGGAGAAT
+ GGCGATCGATTTAATTTATTTATCGACTCCAACCCTTCTTAACCAAAGAAGGAAATGAAATTTGCAAGCC
+ AATGTAATTTCCAAATGGGCCACAACTTTGCGGATAACAATTTAAAAAAAGGGCCACAAAGTAGTCTAAG
+ TAAGTCTACAGATATTAAGTATACATTAGGCCAAATGGGGCAAAGGGTATACGTACATCTATGACTAAAT
+ GCAGAGGAAAAGCAATAAGCTGCATAACTTACTGCAAATGAACTTTCGGCACGCATGTACGCGGATCTGT
+ ATAAAAACAAAGCAAAACAGCATGTGACATGTGCTAAAATCATTAAATCACTATCATTAAATTTCGCGCC
+ ATGAACAGCAAAGGAAATGCTTCCAGCTGCAGCTGCAGCAGCACCAACAACAGACGAAAACTTAGTCAGT
+ CGTGTGTCTGCTCCACCCACTTAAGCCACGGTGGATGGGGTACGTGCGGCTAGCACACATGACATTTTAT
+ TATTACAAAACAAGCATTTACCCGACACATATGACAGTTAATAACATCAGCAACAAAATTCTAAATATCC
+ CAAAACATCCGGTTGAGAGCCGACCAACGGCGAGAGGAACAACACAATAAAAAAAAAAATAAAGTGAAAC
+ TGCACAAATAAAACTCAAAACGAGAACCGACAAACATTTGCGGCACTGTGGTCTAACCGGAATAATGCTT
+ TAACATATCGTCAAAGCCGCACGATACAATTAAATTTAGCTATAATACTCAATAGAAAGTGTGAAGTTGT
+ CCAATTTCCTAAGCGATACTGAGAAGTAGTGACCAGTGGTTTCACTTCGCTTCGGTGGGCGTGAATAGCG
+ CCTGCGGGAGCTGCGAATTTAATCCTAGATATATGGTGGGCTGGCTGACTGTGGCATCATGCTTGCCGAC
+ GCAGGATGCCAAGAGTAGCAGCTGCGTGAGCCAGCTGGCGGGGAATGTGATTGGCATATAAAAAGTCGCA
+ TTCGGACCAGTTTAGCTTGTAAAGAAAAAATACAGCCCAGAAAAAAACACTAAAATGCAGTGACAGTGAA
+ GCAGGTAAGTAATGTTTTTCCAGTTGCAGCGCTAGTGGTGCCAATGCAAACAAGTCGACGCCGGTCAAAA
+ GAGCGTGGTGTGTCATGTGGGTGGGTGTCGCGCCGCCACCAGCTCTTTATCTGGGTTCCCAGTTCACCGG
+ CCATTCCGCCACGTTCCGCCTTGCGCCTGTTTTGATGCTAGCAGCAAGAAGTTTTAGCGATTAAAGTTGC
+ TAGGGTTGTGTACGCACCCACATCCATCAAGACACCAGCACCGAGAAACTTAATCTCAAATGTGGAAACA
+ AATAGTTAATAATCATTTGTTATCTTAAATTCTTTGTAAATTTAAATAATTCTTGCACCATTTAATTTTT
+ TGAATCTGTTGAAGTCAACATATATTCCTCAGATTTCTCCACGTGCCAGTAAGTGAGCAGCAAACATCCA
+ TTTACACTATCATTAATCTTCTCCTGCCCCTATGATGCCATGCGATATTATGCTGCTGCTGGTAGGCAAA
+ AATTAACTCTTAATGATCTGACGACAGCTCCGCGCTTTGTCCGTAAATTAAGAGGTCCAAAGTTTAATCA
+ ATGGTAGGACAAAAAGAAATTGACGTTTTAAAGCGGTAACATTACCTATATATCTACCTTGTTAGATATA
+ CAGAGCTCGATATGTATATATTATTTTCCAAACTCATATGACGCCGTGTGCCACTGTCTAGGATTAATGA
+ TCTCTAAAACAATTACAGATCTGATGGAAACTGAAACAAAGCACCCAGTTCCGGACTCGAACTGCATAGT
+ AACTTCTACAACCATGCATGTTTGCACTTTTAAATGGACTCTCTGATCGGATGATGATGGTTATAATAAC
+ GGCTCAGCTGATGACTATTCTGAATGGAGAAACCCGACCCGGGAGTAGGATAGAGCAGACACACCTAACT
+ CATTCACAATTCGGACAGATGGGGCCTACTAAGCTGCATATAACCGGCAAGCAAGCACAACCAAAAACAA
+ GTGAAAACGTTACAGTCCAGTTTCTGATAGTGAGAGTGCGAGGAGAAAAAAACAAGAATGCTATAATCGA
+ GTTCACCGACTATCAGATACCCGTTACTCAGCTAGTGGAAATGCGAACGCGAAATTTTATCATTTTTGGG
+ ATATCGATAAATATTGGGGAATAAAATGAGATCAAATTGTTTCAAATTCTTCGAAAGTGTGGGAAAGGCA
+ GTTTTGGGCGTTAGAGTGGGCGTGGCATCATTTGGAAACATACGTGCACTGCGCCTATGTCCATGGAAGC
+ TCAATCATTTTTCACCATTCCATCTTTCATAGTTCCTGTGATCGAGGCGTTCATACGGACAGGAGGCCAT
+ GGCCAGTTCGCCTCGGCTATTTATCCTGATCAAGAATATATATACTTTATATTGTCAGCTTCCTTCTGCC
+ TGTTACGTACTTTACAACGAATCCGGCATACCCTTTTACTCTACAAGCAACGGGAATAATTACTCTACGA
+ TTAACGGGTATAATGAGAGTGAAAAATGAGATTTTAGCTTGGTTTTTTTATGGAATCATTATTTTTTGAT
+ GCAAAGAATTGTTTAAAAAAAGTGTGAAGACAAGAATAAATCTTATTACGTTTAAGCTATTTTAAAAAAT
+ TTTGCCCGTGAGCACAAAATATTGATATTTTTTTATAATTTTATTAGTCTTGTAAATTTCTATCGATTTT
+ TGCAAAAACTTTTTGCCACGCCCACTCTAACGCCCTAAAGCCGGTAACGCCCACACCTTTGAACAATTTT
+ TAATTTTTTTCTCATTTTATTCCACAATATCTATCGATTTCTTGCTAGTAAATTTAATCGTGTCTTAAAA
+ TTTTTTTTTGTTTGAAAGAAGCGTAGAGCCCAGCAACTCCCATACCATTACTTCCCTTTCTATATTTTAC
+ GTAACTCAAAAACGAACGATAAAGAGGTAATGATAGAACCCGGGGCCACTGTGGAAAAGAAACGAATGTG
+ TTTGGATGGGCAGACGGAGGAGGAAATTGTCACTTTGTTGAAAAATGAACACGTGCCGCTGATTAGTAAA
+ CTAAGAAGGCCAAACGAGCAACTGAAAGATTGAGAAGTTGAGTTTTTCTTGCTGCTATTTATATGAGTGT
+ GTATATGTCCGTTCGCCAGCCAAGCTCCCCCTTCACCCACCTTGTATGTCGAGCGCTTCATAAAAATTAT
+ TTAACGCTATCGCACATTTGTCATGCCGCGTTTGTTCTTTTACGTGACTTTGCCTTTTGATACAATTTTT
+ GTTGTGGCCTGCATGTTTTTGTTTTTAATTTTTTCTCTGCTTGCGGTTTGGTTTTTACGATTATTTAATA
+ AACGCTAGTCGTTTCTTGACTTTCATATATCCGTTACTCAGCTAGTGGGAGAGCAAACAAGAAATTACAA
+ CATATTTGAAAAGAAATTAAGAAAAAAAACGTTTCCTTCTACCTGTAACATACTTTTCAACGGATCCCGT
+ ATACCCTTTTAATCTACGCGTAACGCGTATAAAAAAACCAAAGAAATTTTTGCCTCTGACGTAATATGAC
+ AGGGAGATATTAGTAAGACGGGTAAGTGATTTCTTTTGATGCTAATATTGCTTTGATTAGGCTAAAAATG
+ CATTAAGATTGGTTTGGCCGGAAGAGATCTTTATATACATACATAATATGAACATAATATATGAAACGCA
+ AGTTCATACAATATCACTTCACTTCAACATTGTTGACTCTGCATTTTATCTAAACCGTCGTCTTTTGTAG
+ CTCTGTTTACTAAACCCAAACAATTAAAAAGCCAACTAACACATTCGATGCGGATATAAACAATCATATT
+ TCCGTGGTTATCAGAAAAAGTATAATTTGGTAAAGTTTTTGGTATGTCACAGTGTTTTTTTTGCAACTAA
+ TAAAATCCCAGAAAAATAATAGCAGTTTTGAAGAATGTTTACACTAACGACAGATTACGAGAAAAAAGAC
+ CGAAAGACAAGGTGACGAAACTCAAAATGATATTATTCAACCATTTTGTCTATTTAAAAGCGATGACAGA
+ CGCTCAACACTTTCGGTTGATTTGGCTTGTCAATATGGAAGAGGTCAATAGTATTTTGAGCGATGGCACG
+ TGTCTGATCGGACTGTAACAAAACCAATATGGAAAACAAAGTAAATGAAACAATAAATAAATGGCAAAAC
+ GGACGATGAAATCAAAAAAGAAATGGTAAACTATTAACGCTTTTGTTTACACCTTACAATACCCACACCA
+ TACATTTTAGCTGAGAACACGGAGAGGAAAAAAAAAAACATGAGGATGACGGGTACTGAAGAGCTCGTCA
+ CAAATTGGCCAAGATCGGTGGCAATAAACTCACTTTTTCAACTTTAACTCTCAGCGCTTTTCAACGGGAA
+ ATGAAAATTCATTTCATCTGTTCACACAGCTCAGGTTCTGATCTCGTATGAATTTTGCTTTTCAAAACTT
+ CCTGACGCTGAAAACCGATTGATGAAATATGTTTCGACTTTAAAGGCAACTTTATCTAAAAATAATTAAA
+ TGGAAATGGCGTGATATCAGAAAATTTTGTAAATAAAGCAGATCACTTTAAAAAAAACAAACTAGTTCAA
+ CTTTTCACCAACTCCGCCGAAATTTATGATGAATGCTTAATAACATTTCTGAAGCCGCGCCAAATTGGCA
+ AAATTGTTGTTGGGATAATCATCACCGATTGTCCGTTCCCTGCACACGACTCCGGCCAGACAAATGTAGA
+ CAAAGTCAGCAAATAAATCAAACAACCTGCACACGCGCTACAGAAAAAAAACACGCTGTTGGCTAAGCAG
+ AATACGATACCTTGTATGCCCAAAAGGGGGCGACGGCCTCCAAACTAGATGTTGCATTGTATTGTATTGG
+ AATGGAATTCGCGAAAGCACCCAATCGCCAGACTGGGACAGCGCACAGTAGTTCAGGAAAATCAGAGTAG
+ TCGAAAGGGAGCAGCATTCTGTATGAAATCTAAAAATGGATCGAAATGCTGTTTTAAACGCCCACCGCTA
+ GCAAAAATCATCATCATCATCGGCAAAGATGCCTTCATCCAGTATCCAACGGATAATCTCCGATTGCACA
+ TGTGCGGCCCATTAATTCGCATGATGTCTTGCATATGGCAGCAAAGTTTTGCGCGTGCGGTCAAACAAAA
+ GTGGGGCAGCACGTGGTAGGAAATCAGCACTCGCAGAAAGATTTTTAATATTTGTGCGAAAATGATGTCA
+ AACCAAATTTTTAAAATTTGGACACTGACCCCTAGTAACGGTATAAAATGGGATTTGTTTGATATCATAA
+ AGTGTCATTTTAATGTGGGCGCGCATTTTGTAGTGTGTGGATCTATATTTTTGTTCACGAGTGTTTATGT
+ CTGCTTATGTTCACATCCGACATCAAAACATATAACCAGCCCTTGTAGCCCACCGTGGTGGGTGGAGGCA
+ GAGTGCGTTGTTGGGTGGTGCATATACAGCCGGTTACTCAGCTTAGGCGTCAGCGTTTGACGCTTTCCAT
+ TGATCAGCAAGCGTCCTACGATATTTGATATGGGAACACACTGATGGACACTTTGAAAGCAAGTCTGCCC
+ GTGCGTCCAACGTGACGTATGAGTGATGCTTGGGGTGCCTTGAATCATGCCACGAGGCGTGCTAGTGATT
+ TTGTCTAACGATTGCGTACTTATGAAAAAATTAAATATAGCTGACTTGTTTTACTTTGCACTTTCGTAGT
+ TTTTATAAAACGGGTACATCACTTTGTGCCTCAAGGAGTCACTAATAGAGACCAAGGTCACAAGGCATAC
+ ATCGTATGCCTTAATAAAATTATACAAAAACATAAAAAAAAAACTTTTGCGTCGACACGTGTAGGAAGTA
+ GCCTTCGAAAATACAAATTTAAAAGATTAGGATCGAGAAGCTGGCATTTTAATACTAACATGAAGGAAAT
+ AACGTAATACTTACAATCAATAAAGTAAAAATAAATAGTTTCAGCAGAAGCAAAAATTATAACAAATGAC
+ AACCCAGAAATACAAATAAATTTTCGTCTGTAATAGCAAAAAACGCTGAGATCTGCGTTGTTGCATTTTA
+ ATGTTTGACTAAGCGCAAACCGAAATGCAATAAAACACCGCACACATGCTGAAAAAAGAGCGCAATACTA
+ TACATCATTGAAAACTCATAAACAAAAAGCCAGTGAGCAGGCAGAAAAGATTTAAGAAAATTTAAAAAGC
+ GACGGGCAACTATTCTATAAAACTTTCTAAAGTGGATTTTCCCCATTTCGCGATTGCGTCGAAGGCGGTT
+ CACGTTCAATCAAGTGATGGCTCTATGTGCCATGTGGCACCGGACAAAACACAGACCATTCCTCCGCTCC
+ ACGACATTTTTTTATTTATTATATTATCATAAAATATTTATTTTTCTAAAATTAAAACTTAAAACTCTTA
+ AAACAACAGAATACTAATATACTATCATTTATTGGAAGAGGGCTGCTTATTTTGGACAGGTATTTATTTG
+ GGTGGTTTTCTAAACGAAGCTTCCCCCACGAAAGAGCGCACCCGCTAAAAGTTCTTTCACCTCGAATTAG
+ TTTCCAGTTTCATGTTTTTGTTTGGTGATCGTAAACGATCGTCAGCGACTTCGGAAAGTTTTAATGCCAG
+ CGATAGATAAGGGCGTTGATAAGTGACGGGGCGCCAAAGCGATTTATAAACAATTTTATTCGCGCGTGTC
+ AATGAGAAAGAGCAAAGCACAAACTCAACAGGTTGCCTTTGGGCGATATTTCATTCATTCTATAACCATT
+ AACAGTCGTTTTAAGCTCTCTTTGTGTCAATACAAATGCATTAGTCACATATTTATAGCATCCCATTTTC
+ GGTCACAAATATTTAAAAATAATTGTTTTGGTTTTGGCTTTTTGCAATCCATGAAGAAGCATGAAGAAAT
+ TATTGATACCCTTGGCCAGTAACTCCTGGACTGTATTTCTTGGGCCCCCGATAATGACATAAGGTCACAT
+ TGATAAGGACTGTCTTTGTCTTTGTTTCCATACATTTTTGAAAAAAAAAAAACCGCTCAATCATATATTC
+ CGCTGAAAACCATTTGGCGAACGATTTATTTCAGACAACCAAAAAAAACAATAAATTTATAAATAAAGAA
+ AATTAATGCAATTATAAATTTGAATAAATGATTAAATTAAGTCTACAAACAGAAGATCAAAATCAAAATA
+ TATTAAATCAATAAGCAATAAATAATTATAACTGTCTAAGCAAACAATTTATTTGTATGCCTATAAACAC
+ ACTGGGTAAGCTAATTCACCTAACTGCGTCGTTGAATAATAATCAAATTTTAAGTAATCCAGCACACAAT
+ AAAATCAATTGTCAAGAACCATCTCAATAGTTCTTAGTTTTGGCCCACTACATAAATTGCCATTCAGTCC
+ TATTCTATCAGTCCTGGACGAGTTTTGTATTCTAGGATTGAATTGCCGCTGCTGCCGAGCTGAAGCTATA
+ AACACAAGAAAATCACTTAGCTTAAAAAAGATTTCAGGTATTTTGTGGTATTTAAAAATAAACATCAAAG
+ TAAGAAGCGGCGACGGAAGCGCGACATAGAGTATCAGGTAAGGGCCATATTGACCAAAAATAAATATAAA
+ GATGGCTATTTTTAAACCAAAAAGCCTCGTATCCGATCTTCAATTGCAAGAGCGCAAATAGAAGTTTATA
+ AATGGGGATCGGATCGTCACATTTTGGACCGCACACTCGCACCGTTAATTGGCACCGCTCGAGCGAATCA
+ CTTCGCGAATAAGTTTGATTCCGATACATGTGAATAACTAATAAACTCACGTAAGAGCGATTTGTGAATG
+ TTTTACTACTGATTTTGAGAGTATATTATGATTTTCTGGGACGGGACTGTACAGAGTCAGTCTATAGCCA
+ ATTGGCGATAGCCCATTGAAGGTATTAAGGCCTGTAAATCCCAAGTTCCTTCTTTATGTAGCTATATATA
+ GCAGTATGTATGCGCAAAATCAGGAAGACAGGAAACGAGCACAGCACAGAGGGTAGACAGGTGAAGGAAT
+ TTCTATCTTAAAGGGCGTGTGGCCAGACAGGTAAGTCACCCAACGAGGCTCGTGTCGAGGACAATTTTTT
+ ATGCAGGGTAAAGTTCTGTTTCCACGTTTAAGGGGAACACACTTCCCAAGTCTTACACAAGTGCTGGGTA
+ GCTTATGTTAAATTAAAAAGAGCAAAGAACAATGCTTTTTTGAAATATATGTATAAGAAGCGTGCCCTTG
+ ACCGAATTGGTAACAAGAAAAAATGCTGTTATTAAATAAAAGGTTATTTATTCTTATCTGCAAACTCTCA
+ CAGATTGTCTCGTGCCATCACTCAATCACTCAAACCCTTTACCTACGCAGCATGGGCAATCAAAAGCAAG
+ CAAACCCCATTTTTCACTTGCTGTCCATTTTGAAATTGCTGTTCTTGCTGAGGATGGTGATTTATTTATT
+ TATTGATCACTTGATTTAAGTAGAAATTCTTTTGATATTATTAGCATTCGCTTATGAGATTTCTATTTTT
+ GTTTCTGCCTCAAGGCACATCCACACACCTGCGCATGCGATAGAATCTGTAGATTTCGAGGTATATTTCA
+ TAAAAGGGCATAAAATGAAATTTAAACTGCCAAAGCGGTTTGTATTTGATTTGTTTCGCATTTATTTAAA
+ GTGAGTGTCGAGTGCGTGTGACCCATTACGTTGCGGAGCACCGCTATTTCGAATCAATTATGACACTGAG
+ CTCCCGGAAAAAAATCTGGCGCCGACAAGTGTGCGGAGTGTGCGATAAACAAATTTTGACATTTTTTAAC
+ AAAGCAGCGGTAATTAATTAAAGCTCTGTACTGTCGGCTTTCTTCTTCTAGGAGGTATTTCCAATGCACA
+ AGTGTAAGTGTAAGAACAAATAGAAAAACAAGTTTATGAAATGTCTGACATAAGAGACGTCCCTAGCGTC
+ TACGTCCAGCGCCTCCGGCACGAGCACTCCCACCCACCTCGGCGCCCGCTCCAATGCCGACGTCCATCCC
+ AGCTCCAGGTCCGTCCTCAACGGCTTTAGCCGCTCCGCCGCCGTGAGCTCCAAATTGTCCGCCCGCCCCC
+ GCCGCTGCGCCCAAGCCCCCTTGGGCGGCACCCATAGCCTCGGGTTGATCTGGAACTTGAGCCTCTGCGA
+ TGCTCTAATTGAACAAGGCTTGGTTAATAGACAATAAATCATTGGATATTTACATAAGTAAGTCCCAAGA
+ GGATCAGCTATAGCCAAAAAGTTCTACTTGCTCTACTCCTCTCGGAAAACTTAATCGCAGATTTCAGATC
+ TCACCCGAAGCATCACCCAAGTAATCCAGGACAACATTGCCAGTTTCATTGTTAGTACAGTTCCACTCCA
+ ATGCAGGTTTAAACCAACTATAGATGGGTTTCGGCTACCGTTTTATCAATTTATACTATTATAACGCTCA
+ CAAAAAATCGTGGAAATGCCTGCTTAGTATTATCCAAACACAAATCTTTAGCGGCCTTGTCCAGATAGCA
+ TCTATCGTAGTCGCTTTGTTGTTAGCCATCAATTATATATTATTAATCAATTGTATTGTTGACAATCGCT
+ TAATTGCTCCCGTGCTTAATTCATGCTTCTGGCGTGAGTCTATTAAAAAATAACTAAATAATTACCAACC
+ GTCGTAAACCAAGTAGTGATATGATGACATGGCGACCAATACAGTTGTTATTGCTGCAAAATTATTGAGT
+ AATAGCGCGCACTACAAGGTCAATATTAAACAAAACCAAAAGCTTGGTATAAAGTTAAAGCTAAATACAA
+ ATATATATTTATTTAATTTAAAGGAAATAACGAAATAATTTAAACAAAATGAATAGAATATATATTTTAA
+ GTTTATTTTATAAATTTTCCAATTTTTAAAAATGCATTTAGCGGATCAAGAGTGACCGATATAGTCGAAT
+ TCCTTGGCTTTCAGATACCCGTTAATCAGCTGGTGACGAAAAGGAAATTTATAACCTTCTTCGGCAGATC
+ ATTAGAAATTAGCAAAAAAAAAAAAATAATGAAATCATATTTGAACATTTTGAGGAGTGACTGGCTTTTT
+ CTTGAATTTTCAAATAATAAAATAGAAACATTTTTCAAAAGTATTTACGAATCAAGTATACCTCTAAAGA
+ GTACCATGTAAAAAAATATAGCACCTAAATAACATTAATAATTTTACACATATACCCCACGTATTGTTTT
+ TTGCTCATCTGTGGGTGGCCGCAGTAATAGCTACTTTTCCTGATTCTCACGTACATATGTGGACTACTAC
+ ACTTAACCATGAAATCTTGTTCTGCTATCATAAAAATTAAATCAAAATTAATGATAATCAAATGCAATAA
+ TGTATTTTAATACACATAGTTGTGGTTTGTACACGTGCATTTTGGTTTATCATAGATATGTACATATGTA
+ CACATATTTAAGTATGTCTATGCATTTTCATACGCATAGCCGTTTTTACCCTATTGCTGTTTTGAGGAAG
+ TTTATTTGAGGTTTCGAAACAATTAAATTTATGATTTTTTTTACTCGATTTGAATGTGGCGTAAACAATA
+ TTGTATTTTCATTCAATAAAAACCAACGGCTTTAAATAGTTTTTAAATAAATATTGTATTCGATCATGAA
+ ATTGGAGGTTGTTGTTTGCTTATATCTTCAAAATTATTGTAATTTAAATTGCTTGGCCCTCAAGGCCGTG
+ CAATATCGCATAACCGCCCATCCGTGTTATAGTATCATATCATGCTGATTTTGCGGTTTATTTTTTCAGA
+ AATTTTTGACGCTTACGTGTGACCTACATATTTTCTCGAGGCGCCGCCGATAAGACGCTTTAGACGACAG
+ TAATAACAACATCCCACAAATACATACATATATGTATACAACACATAATACAAAACATAGATTATACAAA
+ TGGAGGGTTCACGTAGGTAACACATACGTTCTTATACATAAGAGTTGCTTTGCCGCCACCACTTTGGCAT
+ TAAACTCGTCTCTTTAACACAATCTTTAATATAAATAATCACAACGAATTAAAAAAAGACACAAATTTTG
+ ACTAATAACTTCGGACGCTAACCCATTTTGAGGCATTCATAATTTACAAGGCTAATTCAATTACTATAGT
+ AATATGATCCTTAAAAAGTTAGAAATATACTTGTTGCAAGGGCCTACTTAATTTTACCGAAAACAAGAGA
+ AAATGCTATGGTCGAGTTCCCCGACTGTAAGATACCCGTTACGAAGCTAGTGTGAATGCAAAGATATTTT
+ GGAATAAAAAAAATAAAAAAAAATTTTTTAATTGTTCAAAAGTGGCGTGACCGTTTTGTAGGTGTAAAGT
+ GTTTTTGGTATACCTGTAGAAATTGGCAAGACAACCAATAAAACGAAGAAAAATCAAAAAATTTGTTTTG
+ TTTGCATGGCAACATGAGTCAAGACTCTTGCGTTGCGTCTATGTTTCTAGGATCTGTAGGCCTAATCTCA
+ ACCTTCTAGCTTTTATAGTTCCTGAGATCTCGACGTTCATACGGACGGACAGGGCCAGATCGACTCAGCT
+ ATGATCAAGAACATATATACTTCATCGTTGGAAACACTGTCTTCTACTATTCAATGAATATACAATAGTA
+ TAACCTTATACTCCATGAGTAATGGGTATAAAAACATTCGATTATCGACAACCAAGTATTGCTTGATTTA
+ TTTGTCGGTTGTTGGACCTCAATGAAGCCGGCCAAAGGTCTATTCCGCATGTATACCACTCTCGCCTTAA
+ CGGATAATTAAGTTTCTCTCAGTCAAAAAGAGTACGCAAAAGGGAGGGGCAATGTGAAGTTTGTGTACAT
+ AAAGCGTAAAATTAAATTATCACCGCACTTAATAAATTATCCTGTAGTAAAGTGCGGCTGAGGTCATTGA
+ ACTCCGTATACCCGATGATACGTAGCAGATGTTGTCCCAGGTCGCTTACGACGTTATTCGACGAGCAGAT
+ TGACCCGACTGCCACAAAATATTATTTAATGAGCTGGAATGTCGCTTAATACATTAGAGCCGAACATTAC
+ ACATCTATTTTTGACGCATTTAATTTGATTGAATTAATATTCTTTATGAAATATATACATACATACATAT
+ TGTATGTAGTTGTTTTTAAAAGAATCGCAAGCAATAGACATGAGACCAAAATGCTTTTTCTGAAATCGGA
+ AAAGCAGTACCAAAATATTTATATATTTTATACCATACAAAACAGCACAAATAACATTACAAAGCTCTGT
+ TTAAGACCCTTTCAGTTCTTATTTACATATGTGTGTATCTATTTATAATGAAATTACTCTTCTGAACACA
+ ACTGTATGATGTATGATCGCTTATTCAACTCTCAGATTTACATACACACATACTAGGATACGAAAGTGGA
+ ATTGGTGAGTCCAAGCAATGCTCTGATAAAATGCGAAAACAAAATGTTTAAAATATAATTAAAACTTACA
+ TACTTCGATGAATATCCGGATGCAACAAATTTCCTGTACTACTATATACACTTTTCCCGACTTTGTAGTT
+ ATTTTCCCGAACTAAAGCCACGAAAAACAGTTCTTTTCTTTTTCGACGAAAGGAAGACGCGAGGTGGCTT
+ GACTGAACTGTTATCGATATTTGATAGTTTTCTCACTCTCTTTTGCCGATAGGTCGGTGACCCTTCAGAA
+ AGCTAGAAGCTGGGAAACTAAGCGTAATTCAACTAAAACGACAAAAATTAAAATATCGCTTTTAAATGCA
+ TATACATTAAAATATTAAAATATAATGTATTAACCATTATACGTCAATTCAAAAATTTAACTTCATTAAG
+ TTTTCTTTACCCGTCTTTGACGTTGTTTTATGTTTTCTTAGCTTATTCACCTTTGCGGGCTGATTTTATT
+ ATCGTAACGGATTCCACATATCCGTAATTCAGAATTAGCTCTAAGTGTCTTCATCGCGTATGTATGTAGT
+ ACATATGTATTTACATACAAATCGAAAAAAAAGATACATATACGAATATATGTTGTATATTAAACGATGC
+ ATTAGGGAAGGTTAGTTCAGTCGGTCTTTATGAAATTATTATTATGAAATTTCTCTTCTGAACACAACTG
+ TATGAACGCTTATTCAACTCTCAGATTTACACACACACATACTAGGATACGAAAGTGGAATTGGTGTGTT
+ AAGCAATGCTCTGATAAAACGCGAAAACAAAATGTTTACAAATATAATTAAAACTTACATACTTCGATGA
+ ATATCCGGATGCAACAAGTTTCCTGTACTACTATACACACTTTTCCCGACTTTGTAGTTATTTTCCTGAA
+ CTAAGCCACGAAAAACAATTCTTTTCTTTTTCGTCGAAAGGAAGACGCGAGGTGGCTTGACTGAACTGTT
+ ATCGATATTTGATAGTTTTCTCACTCTCTTTTGCCGATAGGTCGGTGACCCTTCAGAAAGCTAGAAGCTG
+ GGAAACTAAGCGTAATTCAACTAAAACGACAAAAATTAAAATATCGCTTTTAAATGCATATACATTAAAA
+ TATTAAAATATAATGTATTAACCATTATACGTCAATTCAAAAATTTAACTTCATTAAGTTTTCTTTACCC
+ GTCTTTGACGTTGTTTTATGTTTTCTTAGCTTATTCACCTTTGCGGGCTGATTTTATTATCGTAACGGAT
+ TCCACATAACCGTAATTCAAAATTAGCTCTAAGTGTCTTCATCGCGTATGTATGTAGTACATATGTATTT
+ ACATACAAATCGAAAATAAATGATACATATACGAATATATGTTATATATTAAACGATGCATTAGGGAAGG
+ TTAGTTCAGTCGGTCTTTATGAAATTATTATTATGAAATTTCTCTTCTGAACACAACTGTATGAACGCTT
+ ATTCAACTCTCAGATTTACACACACACATACTAGGATACGAAAGTGGAATTGGTGTGTCAAGCAATGCTC
+ TGATAAAACGCGAAAACAAAATGTTTACAAATATAATTAAAACTTACATACTTCGATGAATATCCGGATG
+ CAACAAGTTTCCTGTACTACTATACACACTTTTCCCGACTTTGTAGTTATTTTCCTGAACTAAGCCACGA
+ AAAACAATTCTTTTCTTTTTCGTCGAAAGGAAGACGCGAGGTGGCTTGACTGAACTGTTATCGATATTTG
+ ATAGTTTTCTCACTCTCTTTTGCCGATAGGTCGGTGACCCTTCAGAAAGCTAGAAGCTGGGAAACTAAGC
+ GTAATTCAACTAAAACGACAAAAATTAAAATATCGCTTTTAAATGCATATACATTAAAATATTAAAATAT
+ AATGTATTAACCATTATACGTCAATTCAAAAATTTAACTTCATTAAGTTTTCTTTACCTGTCTTTGACGT
+ TGTTTTATGTTTTCTTAGCTTATTCACCTTTGCGGGCTGATTTTATTATCGTAACGGATTCCACATATCC
+ GTAATTCAGAATTAGCTCTAAGTGTCTTCATCGCGTATGTATGTAGTACATATGTATTTACATACTAATC
+ GAAAATAAATGATACATATACGAATATATGTTGTAGATATGTACATATATATGTATACCCAACTGTTTTA
+ TTAGGTTTCAGCGGGTAACCCCATTAAACGATGCATTAGGGAAGGCTAGTTCAGTCGGTCATTTCTCGCC
+ ACCGCACTCCCTTAATTTATCCCAACCCTACCCTGGTCATTCCACCGATGCGTCTGCCCTGTCTAGACGC
+ TTTTAATTTGCGTAATCAAAACACAAAGAGCAACGGCGACTGTCAATGAGAGCAGAGCTAAAACCAAAAC
+ AGAAACTATTACGCCTTACACAATTAACGTGTTGTTAATGATATACAAAAATTTCAAAGCTCCCTTTTAT
+ TTTTATTTTTTAATAAAAACCCCTAGGCCATAGGCTAGGCTGTAAATGAATCGAATGTTAAAGAAAACAT
+ AAAGTTTCATTAAATTGGTGACCCTCCCATAGGCCATTCTGATTTTTATATTATAAATTATAAATTTATT
+ TTACTTTAAGCAACCAATTAAATGGCTTTTAATCGTTGGAACTAACAGTGGGAACGAACATAACATGGAA
+ ACATAACAGCAATGATTTATTACAATTTTAAAAAATAATTTAGATTAGCTAATAGTTTTGGCAATTGGTG
+ AAGCCCATTTTGTATAAAATCAGAGAGCTCCTCTAGGACTTACTCAAATATCAGCTTCAAAAGCATATTA
+ TTTGTCTATATCGCGCAACGAATAAAATGCAGTTCCTTAATTATTTCTGGTATTTCTGTTTTGCGGCAGG
+ GCGCTATTTTTACCCGTATCGCTGTATTGTTCTCGGAAGTGGCCGACGTCGAATAATTCGTCATCGGTAC
+ AAGTCGCAAGTCTACGACGCCACGATATCGCAATTGGGTTCAGTCGGAGCTCTAGCTCTCATTAGAAGCA
+ GACAAGCATCAAAGATATTTACATATGCACATATGTATGTGTTTTTTTTACCCAAATAGTTTTGGTTTCC
+ TCATTTGTCAGCGTACTTCGCTAAAATTGTATCTATGTATATATGCGGCCAAAGTTGGATCTTGCACCTT
+ GGCACGAATCGCAGTCAAAAACATAGTTAACTTCATTAACGAGTGCACTGCGAATTGCTCTTTACCTCTT
+ TTGAGGTAGCCGGAATTTGCTGGACTTGATTGCATTTTATTTTAACGGCTGACGACTCAATTATGATCTG
+ TCAAATTGCCTTAAATTAATTCGTAATTTATGAGCTTTTTTCCGAGGCAGCACCGATTTTTTGTAAGAGA
+ ACGCGAAGGTAATATACACGGCGAATATACATACATATTTAACTGTTTCTTTACACTGACCCTTTGCCGA
+ AATAAATATGTTTTTAAATAACCTAGAATTGATTTATTCCACATTTTTGTCGAGTTGCACATTCCAATAT
+ TATATTGAAACGCAATTTATAAAGCCGGCGCAGAAATGTGTTTGTATGCGCTGAATCGAGTGTATTATTC
+ CGAAACTTACGGATAGCTCTGTATCGGGTTGCACATGACAGCCAAATTAATGTGTTGATCCCAGATTAAT
+ CAGATTTACAAGAGATGGTGGAATTTAAACGTTTGTTTAAAGTGTTACCGTACTGCAATAAAGATTTTAT
+ AATATGGAACATAATAATACTGTTATTGTAAATATTGTTATTAGCAGTAATGCACCGATGTACATACCAC
+ TGATAAAGAGTAAAAATGCCCACGATGTGTGCACAATGCGTGTGGAATCTCGTACAGCTAGAAATGCTGC
+ CGATCTGTGAGTCAAACAGTTGGAATGGCACTACGATGGGTTGGGCTGGCAATCAATAGTCCCAACTGTT
+ AATTGCAAAATCAAAGTGAGCTGCCACAATGTTGCTGTCGGAGAAGATTACCTCATCATCGAAAAGACGA
+ AAAGTGTTGGCGGCGAAATCATCAGCGTCTCCCAAAATGGCAATGAGCAAATGTTTCCTGGAAGAACGAA
+ GGGGCCACGCATCGCGAGTCTGACTCTCCCCTGGCTAATTACACGCAAACGCATTTTAATTTTCATAAAA
+ ATAATCATAACATGTGCCGCGCACATAACTCTTGCTCTCATTTCCTTTGGCACTAGATAAAATAAACTGG
+ CTGCGGAACCATTTGAAGCACGGCAACAAAATTTTCGATTGTGATAAATGAATTCCGCGAATCTGTCGAG
+ GCCAACAGCTACAAAATTCGCAATTTCAGGTGTATAAATAGATCGACCACTGCAAATAAAACAAACCGAA
+ TAATAACGCCTAACAATCTAAACTGAGATCAACAAACGAATCGATCACCCAAACTCCTTTCTTTTCAAAT
+ ATTCGTTTCGAAAACTACCTCAAATTGAGGTCAAGCGAGTATGAGGAGTATGTATGAAGCGCCAACTCCG
+ CAGTTGGCGAAGTCTTATTAATAAATCTAATATTCCGGTTAACTGGCTGGCATACATGTAGATATTGTAG
+ AACCCCACACCAACCTGGAAAGTCGTCAAAGTCATTAACTTTCAAAAGTATTAAACCATACGACCTACAG
+ GTGTTACTATTTAAAACAAAGGCGAGCCGAAAATATCTTTCAAGTCTACATAATGTGTAAAACTTAAAGA
+ AAGGAAATGCCTTGCAGTACAGAAAATACGTCTAACCAGGCTCCGCACTTGTGCCCTGAAAGACATAAAC
+ CTAAGACATAAACATAAACCAATGTTTAACTAATCGGTTTGACAATGCTTTGTAATTGATTCAAAATATC
+ AGCAAATAATGTTAGACCTGAACACATATGCATTCTTAAACCGTCTGGACTTATCGCATCCGTTTTGATA
+ CCGATATGTGCATGGTAGAAATGTAAACAAATATTTCTTCCCAGACCTCGGAACATTGCTGCAATGTGTT
+ AGTTGAGCAGTCCGATAAATCGGCACCAGATATCTGATATTTGAGTATTAACACCAAACGTTGGTCAGCA
+ CTGAGTGTACATTTCCCCCTTAGTCATTTGGGGAGAAACTGCATAACCGCATGTCAAGTGGATGTATCCC
+ TCAGCTCTATTTATCGTATCCCAGGAATATTACTTAAAACAAACAATGCTTACTTTCATAAAGTATTCCT
+ TATATGTGATTTTAATAAACATTGCCGACATTATACTTGGTTCTTAGATTAGATTTAATAAAATTTCTTT
+ CTGAGATCTTAAGTGAATGCAGTACCCATCAATAAGCCGTACCGTATTCGGAGGTAGCGATCGTCGCGCG
+ TGCCGTGCGCTAATAAAATTCGCCCTATTTCAAAGCTTATTTCCCATACGCCCCGTTTCCTGAATTGAGT
+ CGCTGCTATTCGTATTAAAATGTTAATTTAGCATGGCCAAAAGTCAGCAAGATATTAACAGTCTACACTC
+ AGTGAGGTAATTATGCCTCCATTGACCCTCTGAACATGACATTCATCGTTCTCCTCCCTAGCTCGCTTAT
+ CTAAAGTGCACTTAGCCAATTGCAAATGCAAAATAAACGTAATGTCCAGAGAAATAATTTAATGTCAGTC
+ GCAGCAAAAGTGGCAACCAAATGAGCCGGAAGAGGCAAGCGAAAATTAATAAAACCAGAGCTAAAGTAAA
+ AAAGAGAATAAAAACATGAGACAAAGTTATTGCTTCGAACTCGCAGGTTTGGTCAATAAAACAAACAACA
+ AAAAATAAAAGTGTGCGAGTGGCTGTACGCAAATCAGGGCATATATGGATACACATACATAAAAACATAC
+ ATAAGTATGCTTGGAACACATTCCCATAATTAATGCAGAGCACTTTCCGAGAACGATCATAGCCTTGGTC
+ ATTGCTTATCCACGTAACAAAAATAAATTGGTAATAAAACATGAAAAATAGCGTCGTTTAAAATATTTGA
+ ATGACCTACATGAATGCAATATATATATATGTAAAATAATAATGCGGAAGGCAAGAGTCACATATGTAAG
+ TATGAGTTGTGGGATATAATTCATCGTAATTCGCTTAATAAGATTTTGAAAGGATAAATAAAACCAGTTT
+ CTAAGGAATTTGGAATTCATTCAAACAAACAAATAAATTGACCACATCCCCAGTTAGAAATAATTGCATT
+ TTTGTAATGTTTAAAAATAATTAAATAAAAATGCAGAAATATATTTTCTTAATATTTTGTATTCCTTTTT
+ GTATTCATCGACAAAGGTGGACAACTTTCGGGTGTGGAATATTTAAACAGATAGAAGCTCAACTTATGCC
+ TTGCCTAAAGCAATAAATTAAGACACTTAGTCGAAGGTTATTATAAATGTCTCCCACTATTAGACTGTCT
+ GCTCTATTTCGCTACTACAACTTCGTCATCATCGGCACACATTTAATTCGTAATTGTAGCAATTTAGACG
+ TCTTCCCAGGTTCTCTCATTCAATCCCATTATCACCTTCGCGATAGTGGGCGTTTCGGAAGGAATGCCAA
+ CAGACTCGTGCCTTTAGATTCACACGCATCCAGGTTTAATGAGATTGTTAGCGGCATAAAGTATATGTAT
+ ATATGCCCAGGAATGAGGGAATACCCCTGGGGAACCACCCTTAGAGGAAAAAAAGGTTTCTCAACCGAGT
+ ATCGAGTGAAATGCGTGTAACCCACGCAACCACAATACAGTTATTATTCTAACGGAAGAAGTGTAACATG
+ GCATTAAAGGATGTTGGTTAAGCACCTTAATAGGGGCAGGTCAAATTTGGCGGATTTGATAAGACATTTA
+ AAAGTTTCAAAATCATCTTTGTTTTCTTATGGAAAGAATATGGATGAAAATTGTCTCATGTATTATTTAA
+ ATATCAATAGAACCAATACAACCCGAATATAATTTTTCGGGCAAATGAATTAATTTGACCTAATCAAAGC
+ TATACTAAGACAAAGAAAAATTCGATCTCCGCCTACCCGCTCATCAGGAAAACTGTGTTACTGGGCTTAG
+ CTATGGGCCCCTCGCCAGACCTTCGTAGATGTAAAATCAAATCATTACGAATTTCAACAACGCTTAATTG
+ TCGGAACTAAAATTTCCATTTGGGCCAATGCAAGAGCTACACCCACGGCAAATATATTAGCTTTCGAAAA
+ CATGTCAATGAATTTTCAAGAGAAAGCTTTTTCTAATCATTGGTTATAATAAAATACTATTGGTTAAGTA
+ CCAAGACAACAATTTTTGAATAAGTAAGAACGTAATGTAAAAGCTAATAAATATGAAACATTCATGTGTT
+ ATTAATAAGGTTGAAGAAATGTCGTCTTTGTCGGCAGTGTAGTCACCTACGGTGACTGCAGAGCAAAATT
+ GATAAATTAATAATTAATGAAATAATGAATAGCAAAGGGGACTTTAATTAGCATTACACGACGTTCAGCA
+ CAAATAATAAGAGATATAAACAGAGAACAGAGAAAGAAAAGTGGCTTGAATTAAATCCGAATCTTCAAAT
+ ACCCTTACCCACAGCAGTGGACAAATTTAATTAGAAATGGGTTGGAAATAACATTCACATATATATCGCC
+ AAAAATTACCTAGGTCGCAATAAATTATAAATAATTCAATGTACATATATACAAAATCCACTTCCATCTT
+ TCTTATGCCCCTAGTAATCCATTGGATCGTAGATGTCAATGATATGTCAGCGACAATGCAGCAATGGGGG
+ TCGAGGTTGGGACTGTAGGCAGTCGAAGGGGAGCAAAAGTTACAACAACATTCGTCGCTTCACAAACGTG
+ GGACCTTTATACAAGTTTCCCCCATCAAATCCACACGGCTGCATTTGACACGACACAAAACGTGGGCTTT
+ CGCAGTGGAAATGTGCAGAGGATGGTTTCTGGGAGCGGTGGGCGGTAGTTGGTGCTGCGGCAGAGAAGCT
+ GTGCCGTTGTACCCATAGGCAGCTGTTGCCGCCAATTGATTGAAATGCCGCCCCTTCATTCGACTGGGAG
+ GTCATCTGTCCGCCTCGTTCCGCCGCTCCGAGACCCTTCCCTTCCCTAAAGTAGTTATGGTTGTTTTTGT
+ TGTTTCAGATCTTCAAGGGTGCTCTCAAAATACTTTTCTATATTTTTCTGGTCTGCTGGTTTTTTTTACT
+ GTCCGGATAGGGTAAACAATTTTTTTTTTGAGCATTTTTGTCGCTCGAAAAACTTTCTGTTTCGTATTAA
+ TTAAAAAAATACTGTTTGCAATGCGCACTGTTAGAAAATGGAAATTTCGTTAATACGAATACGGCAGTAA
+ AGGGGTCGAATAGCAGATAAAGCCATTTTTAGGAAATTATTAGGAAATTTTAATCTTAGTAGGATAAGAA
+ TCGATGAAATTGAGTAATGTTTAAACTGGACTACATCGGATTAAAAAGTTATATGAGCACCAAACCAAAC
+ CCTCCTCTCCTCTGAAAAAGCATCCCTATCTTCGAAATATTCTGCAATTTTTCGCTTTCGATTTGCAATT
+ TTGTCGATTGCTGTCAGTCGGCTGATGGCTTGCTGTTATGGTGGCTACAGTTGCTGCATTATCGCCGTGC
+ AACAACAAAAACACGCCCCTAGTGCTTTCTCATTATGCTGATCCCCCGCCATCTAAGCACGGTCCCTTGT
+ GACTTATCACATCGGGCGCATGCAGAACTATTTTTAGTCCCAAACACTTGCAGATGTTTCCTACCCTCAC
+ CGAGAAATATCTTAGTTAAAGCACACCTTTTCCGTCTTGGGCAGCACTAAAAAAAAATTAATCGCTCGTC
+ CAATTTATTTAAATATTTTTATTTATTATTCATGTTTAAAGCACTGAAGAGAAAATATTTGGAAACTATG
+ TTTAACTTAATATATAAAAGTGGTCAGGAGATACTTAATCTCTACTATCCATTTGAAAATCCTATCTACA
+ GATTTATAATCTAAACTGTAAAATCCCAAATAAGAAGACTTTACTCGTTGAGTTTTTGTAAGAAACTGAT
+ TTTATTTGGAAATATCTTCGGTTTAAATAGGTGACATGAGAATCGCATCTTAAAGTAAATGGCCTACGCA
+ GAGGCCTAAGTAAATAGTCCCCGCCTTATCGAGGTCCCACGCTCGGGCACATCTGCCTATCTTGAGCGGC
+ GAGGACCTTATCTGTGGTCTCCCACTAAGGGACTATTTTAGGAGGCGGGGAACGATCTCAAGTGACTGAC
+ TCATGTAGTGTGCACTTAAATTACATGTTTTTGAGCAATGCACCCATGTCGCCTTAGATAACAAAATCCT
+ AAATATAATTTATCGCTCTCGATTCATTTACATAAGATATGAACGGAGCCCAAAATTGTAAGTCTTTAAA
+ TATATTCGTGTTCATGTGTGAACATTCTGCCAAAGGGCCAGCAAGCTGAGATGTACATTAGTATATTAGT
+ TGCATTTATAACAGTAGTGGACTGTATTTATTTGATATATGTTCATTTATTTTGCAACTAAGATTTCAAT
+ GGGCCTAGTTTTTCTGGCTTTTAATTTTATTGGATTACAATTATGGTTTATATTATTTTTAATTCAACAA
+ TTTGTACTCAATTAACTTATTTTAAACATTTTGCTTTTTCTATGTAGAAGTACATTTTCTATTAAACAAC
+ GATATAGTGGACTGTATATTTTTATTTGTTATATTATTTTATTGTTTATTTACTATTGATATTTATAGTA
+ CTGGCAACGGACCTGCAAAGGTTATTGCTTGCATTCTTTGTTGCACAGCACATTTCCGTATGAAATATAT
+ TATTAATACTATCATTAGTATTAAAGCAATAATTAATCCAGCATGTCCGGAAATATGATGGAAATGTAAA
+ TCTTTCAATTTTTGATGGTTCTCTTTCATAAATTTAATTTCATTATTCAATCGTTCAAATTCCTCAGTAT
+ GATTTAATATTGATAGTTTCAGCGGATCCCAAATAATCTTCGGCGCTTCACTAACTTCTCCTATATAAGG
+ TGTTGATAATAATTCTTCACTTTCGGACTGAATGTTATGGTGGGCAACTAGAATTTTATCGTCGGTTCTT
+ GCCGTACAATATGGCGCAATGCTTAAAACTCCTTGCTGAGGCAAATCAAACAATTCAATTTGAGAGCCAG
+ TACATTGCAGACGGACTTTTGAATTCGCAGGAACCTTAAACAACCAACTACTTTTCTTTTCTAACTCTAC
+ CCAGTAACTTTTAGAGTCGACTACTGTTTTATAGATGCAGTTCGCCGCTTTATCTGGCTTTAGAGGCTGA
+ ATCTCACATGCATTATCATTCGCTGAATTCCAGGGCCAACTTCCTTTGCATATTCTCTTATTTAGTTGCC
+ ATTTCTGACATTGATTTAATGTGGCTTCCGTCATTATGTGATAGGAATCTATCTCAAAATTATAAATTAA
+ ATATTCGGACGTTGTATGCACCATTATTATCCGATCTTCATTTCGAATTGGCACCGGAATAAGCCTGAAC
+ AATTTGGATGGATGCCTGCTAAACAGAGGCACTTTTGCACTAATGATCAATTTATCGTCGATGAATAAAC
+ CCCTGGCTGTTAACAGTGTATACACCTCCTTAAGTTCCGTACCTGACCGTTTTCCTGGAATTACTAGGTT
+ CTCCGAAAGACTCTGCTGAATTTTGGCAATTTCTTTTTTAAGCTGATTTGGCCTGAGAATATTTGTATTT
+ AGCCTACCGTGATTAATATCAATCAACAGGCTTATAATGCCTGCTTGAATTTTTTCGCCTTCTTCAATCA
+ ATGAGTGTAGCTGTTTCGTAATCATAAAGAATTTTATTGATTCCTTATAAACATAATAATTTTCTTTAAG
+ AACTTCTGTCATGTTCTCAATTCTTATTTGCATACTTCTAAAATTGGAGTTAACATCTTCTGTTGTTCTC
+ TTTAATAGATTAGAAGTTGAATCAACCACAGATGTTTGTTTTTGAATTAGTTTATCAAGGTTGTTCTGGT
+ TATCTAACAAATTCTTCATATTTTCTTCTAATTGCTCTCTATCATCTTCATCCATTATACCAAATAAAAT
+ ATGATACAAGGAACCCATAAATTCGAAAGGAGCACGCTTGCTTCTAGATCTAGACTGTATCATAAACAAT
+ TTATTGTTTTCTTCAAGTTCCGATAACTGACTTTGCATATTATCTAAGACTAGACTACATTGCTCTTCAA
+ AGCTATGAAGTCTTTCGCAAACTTTCCTCATACTTTGTATAAGCGCATTACCCTTTGTTAACATTTTAAA
+ ATATGGATCCATTTTATAATAGATAACCAAATTCCAAGAAGTACTCACAATCTCAACATCTCCTAGCGGG
+ TCTAGATATATTGCTGAGGTTTTATTTATTTTGTCTATAGAATATCTTGGTGCTATATCTTTAGGTAATG
+ CGCTAGAAACTTGACAACTTAACACAAACAACAACATTGCCATAATGATTCCGATCTTGGACATTCCCGA
+ TGTCGCTCTAGTTCGTCTTTTTGGCTCTTGGTCAGCCTCATTTTTGTCAACAGACTTTATTCCTTCCAAG
+ GGACAAATTTTAGTAATGGGTCTAGTGATATATCCTTCCTGCATCTTTACTTTAGCCACTCGGACCTTAT
+ CATCATTCCCCTTATGCACCTTTTCCACCTTTCCTAAAGGCCATCTTGCAGGATGACAATTCTCATCCTT
+ TAATAAAACTATTTGCCCTTCTTCTATATTAGGAATTTCCTTTTTCCATTTATTCCTTTGCTGGAGCGTA
+ TGCAAATATTCACTTTTCCACTTAACCCAGAAATCTTTCTTCATTTTTTGGATAAGTCTCCACCTATCCA
+ AATTTCCGATTTTTTCATCTTCCATTGGTTCGACTATTTCTAAAGGTGGTCTTCCAATTAAAAAATGACC
+ TGGTGTTAAAACTTCTTGTTGGTCCTTCTCACTAACTATAGTGTATAATGGCCTTGAATTTAAGCATGCT
+ TCTATTTGACATAAAAGAGTTGACATTTCTTCATAAGTCAAAATAGTGTCGCCGATTATACGCTTTAAAT
+ GGTATTTCATTGACTTAACTCCAGCTTCCCAAATACCTCCGAAGTGAGGTCCTGCCGGGGGAATAAAATG
+ CCAATCAATCCTGTCCTTTTCAAGCTGCGCTGCAATCGTTATATTTTCTTGTATTGCATTAAATAACTCT
+ TGATCTAATTTTCTTGCAGCTCCTACAAAATTTGTTCCGTTGTCTGAATAGATATTGGAACATTTTCCCC
+ GTCTAGCAATAAATCTTCTGAGTGCTGCTAAAAATGCGTCTGAAGTTAGATCGCTTACCATTTCTAAGTG
+ TATGGCTTTGGTGGCCATGCAAACGAATACAGCAACGTATCCTTTAAATGTTTTTTGGCCACGATTTTTT
+ GAACATTTAACATAATAAGGACCTGCGTAATCTATTCCAGTATTAAGAAACGGGAATGTCATCGTCACTC
+ TATATTTTGGCAAGTTACCCATTATTTGCTGAGCTGTATTTTGTTTATACCTTGCACACGTTACACATTC
+ TCTTAAATACTTTTTCAATGAATTTTTCAACCCGAAAATCCAATACTTTCTTTGGATATAGTTTCGCATT
+ AGGTTTATCCCTCCATGCAATGTTTCCTTATGAGCATTTTTTATTAATAAGCTTGTTAGGTGGCATTTTT
+ CTAAAATGATTGGATGTTTAACATTAAATTCTGCATTGGAATTTTGCAATCTTCCTCCAACTCTTAGAAC
+ CCCATCCTTGTCCAAAAATGGATTCAATGACAATATTTTATTATTTGTCTTGATTTCCTTTTTGATTTTA
+ AGGCACTTTATCTCTTGCCTAAACTGGTATTCTTGTTGTTTCTTAATAACAACTGTTTCCGCTATTCTTA
+ TCTCCTTTACTGAAATAATTGATGAATAGGCTTTATTTCTTGTTTTCATCTGCACGAATCTATTTATGTA
+ TGCTATTATACGTATAAGTTTTTCTATACTGGAATACCTTTCTATTAATTCGTAAATAGGATCATCTATT
+ TTGTCATTTAATACCGTATTTATTAAGACAGGTTCTTCTACAGACTGCTGCCGAGGCCAAAGTTCTTTTG
+ GGTCTGCTAGCCATTTCGGACCTTTCCACCAAAAATCACAGTTGATCAACTGGTTAGAATCCACTCCCCT
+ GGATGCTAAATCTGCTGGATTATCCTCTGACTTAACATGATTCCATTCAGTATTTTTTAATTTCCGAATG
+ TCATCCGTTCTTCTTTTTATAAATTTGATCTTACTTTGACCACTGTTAATCCATGCTAAGGTAATCGTGG
+ AATCACTCCAAGCATAGATCTCCATTATATTGTCAATTGATCCTTTTAGTCTTTGGATTAATTCACTAAG
+ CAGGTGAGCTGCACACAGCTCGAGTTTGGGAATTGTCTTCCTATTTTTTATAGGGTTGACTCTACTTTTG
+ CTAGCTATTATATTAACATGAGGTCCTACTTTAGCATAGACTACTGCAGCATATGCTTTTTCGGAGGCGT
+ CCGCAAATCCGTGAATCTGAATGACTGAAGAACTGTTTGAATTAATCCACCTTGGGATTCGAATATTCTC
+ TAACAATAATAAATTTTCTTTATATTTTTCCCAATAATTTTTATCTTCTATGGATAATTCCTGATCCCAT
+ TCACTTTTATTTATCCAAAGTTTTTGAATAAAAAGTTTTCCTGAAACCGTGACTGGTGCCAACCATCCTA
+ ACGGATCAAATATTTTTGCTAGCGTTGATAACACAACGCGCTTATTTATATTTTTTGATTCATCATTACA
+ ATTTACGCTGAACTTAAATAAATCCTTTTGAGGTTCCCATTTTAGTCCTAAAGTTTTAACACATTCATTT
+ TCGATAATATTGAGAACCTTATTGTCCCCTGTGTCCTCCACAGTGGTTAATATTTTGGAATTGTTGGAAA
+ TCCATTTCCTTAAGTTGAATCCAACTTTCTGCAATTCATGGGGAATTAATGTTATTAATTTATTAGCTTC
+ TTCTACCGAATCAGCTCCAGTCATTAGGTCATCCATATAGAAATCATTCCTAATTATTGCACTAATAACT
+ TGGTTTTTACATTTATCTGCAATATCTACCAGAACCCTGGTAGCCAAATATGGTGCAGATGCAGTTCCGT
+ AAGTGACTGTGGTTAATTTATATGTTTTAATTTTTTCTTTTGGAGAATTTCTCCATAAAATATATTGATA
+ TTTTTGATCATTATTATCTATTTTAATTTGTCGGTACATCTTTTCAATGTCTGCCGAAACAACAAATTCC
+ CATTTTCTCCATTTAATAATAATGTCAAAAATATCTTTTTGAACTCGTGGCCCAACCCACATTATGTCGT
+ TCAAACTTTTGTTATTCGTAGTTTTTGCTGAAGCATCAAAAACTACTCTCAATTTGGTCGTAAGGCTTGA
+ ATCTCTAATCACTGCCTGGTGCGGTAAAAAATATTTGCCTTCATCACTCACTTCAATCATGTGTCCTAAA
+ TCCATGTATTCATTCATGAATTTAGTGTAGTCAACCTTAAGTTTTTCATTTCTTTTTAGTTTTTTCTCCA
+ GATTCATGTAACGAGCTATCGCTTGTTTCTTTGAATCTCCTAAGGTGACATCCTCCTTGAATGGAATTGA
+ CACAATGTATCGCCCATCTGAATCTTTTTTTGTCGTTTTGATAAATTTATTTTCACAGATTTCAGACTCG
+ ATATCATCTTTTTCTTCTTCTTCCACTTCCCAGTAGCGATCTAACTCTTTTATTTCTATTGTTGTGGCTA
+ CAATGGTTTCTTTTCCTTTGGATTTTTTACATCCAGAAACTATCCACCCGAAATCAGTTTTTTGCCCAAG
+ GAGACCGTCTATTTTTATAACTCCATTTTGCAGAATGTGAGTATATACGTCTGCTCCAATGATTAAATCA
+ ATGCGACCCGGTTTATTAAAATCGGGGTCGGCTAATTTAAAGTTCTTCCATTTTTTCTGATCAACATTAA
+ TCGTGTTGACTGGAAGTGCCTTCATAAGTTTTGGGAGAATAATTGCTTCAATTTCTAAATTTTTCGGAGA
+ ATTTCTTATCGAAATAACCGCTTTGTGCTTGGAGATGCACGTTCCTGTGGAAGATACTCCACTTATTTCA
+ GTATGAGACCGAAATTTTTTCAATTTTAGAATCTGTGCAGACTCTTCTGAAATAATTGTGCTTTGAGAGC
+ CACTATCAATCAATGCTCTTAATTGTTCAAAGCCTCCATACCTCGACTTTACTTGAATCAAGGCCGTGGC
+ CAACAAGGCTTGACCTGTTGTTCTACACGTATTCACTTTTTCTGGATTATGACCTGCAAAGTGAAGTAAC
+ GTGTGGTGAGGTTTACGACAAGTCGAACAAAGCTGCTCGCTTATACATTTTTTACCAAACGGATGCCTCA
+ GACATCTTAGGCAAATCCCATTTTTTCTTACCCAGTCAGACCGTTCTGCTGGATTCATTATTTTAAATTT
+ ATGGCATTGAATTAAATAATGCCCTGGTAGTTTGCAATATGCACAATTGTCACTATAATTTTTATTCTTG
+ TTATTATTAATCATTTTCTTTACAGGTTTTACTTCCTGTGAGAATGATGATATAGAATTGAGCCTTTGCT
+ CTAAAAAGTCCATGACATCAGAAAGTGCCTGTATTTCTTTTGTCTTTTTAACATGGCTTTCATATAAATT
+ GAGTGATTCTTTATTGAATTTCCGAAGAATTATGTGAGCGAAAATTGCATCCACATCTTCTGGTAATTGT
+ GCCTTTAATTTTATAATATAAATTGACTCGTTAATCGTGTCAATAAATGTCTTTATTTGCTTATTGGATT
+ CTAAATTTAAATTTGGCATATCCATAAGCCTATTCATATGATCTGAGAATATGTTTCTTTTATTCTCATA
+ TCGCTTGGTCAAAAACTCCCAAGTGGCTTCATAATTTTCTCCAGAGCCGAGCAGTAAATGAGTAACCACA
+ TTTCTGGCTTCTCCTTTTAATGCTGACTTTAGATAATTAAATTTGAGAGAAGGACTGAGATCCTCTCTCA
+ CATGTATGAGCTCTGTAAAGAGTTCATTAAAAAGATCCCATTCTTTGGAATCACCAAAGAAAGTGGGAAT
+ CTGTATTTTAGGCAGGGTTGGTAACTCCTCCGCCTTAACAACCGTCGACATTTCAGCTTTATTTATTGTG
+ CCACTGAGTCGACTATTAATGGCTGTAAGAATATTTTGTTTGTCAAATTCAAGTTCGCTAATTTCTTCTT
+ CGAATAGCGAACTCTCAAAATGACTATTCACCTGTTCAATCAGGTTATCTATTTTATGCCATAAAAATTC
+ AATTTTATTTTTCCTTATTTTAAGGAAATCTGGACTACTGTCTATTAGTTTAGACGTATCTTCTAGATAT
+ ACTCGAAATTGGCCAACATTATTACGAAATGCCTGCTCTACTTTTAAAGCGTTGTTTTGTGCTATACCCT
+ CTTTTTCAGGGTGACCACGCATTTCAAGGTTTAATGTAGGGGGAGGGTTTGATTTAGGGACAGTGTTTGA
+ TTTAGGGAAAGTGTTTTCTACCGACTCGCCCTTAATTTTTTCATTTTTATTTTTAATTTTTTCTAACACC
+ ATCATTATTAAATCATACTGCTTCGCGTTAAAATATTCATGATCGACAACGCCGATCTTTAACAAATTGC
+ TATGATTAGCAATGAAACATTTTTGAAGCTCATTTAATTTTAGAATTTCTACATCTGTTAATGTTGGTTT
+ TACTTCCAACTTTCTAATTTCCAAAATAATTTCGGACTGCTTCTTAAGGAATTGAATAGTCTTTTCTGAC
+ ATCATTTTGAAAATTTTTTGTAATTTCTTAATATATATAGTACGTGTATATGTATTTTATATGTATTTAT
+ ATATATATGTGTGTTTGGATAAACAGAAAATTCTTGTTTTGACTTAGCTGATGTCGTTGTTGTTGCTGCT
+ GCTGTTGCTGCTGTTGTTGCTGCTGTTGCTACTGCTGTTGCTGCTTCTGCTGCTGCTGTTGTTGCTGCTT
+ CTGCTGCTGGTAGAGGCTCCTTTGAATTTGACTTCCTTCTCTTCTTTAAGGCTCCGTCGATGTTTAAAGA
+ TGATTTTTTTTTTGTTTGGCACGTTTTATTATTTTTGTAGTCCAGTCAGATTTTTTGTTTTTTAGCCATT
+ TATTTTGGCATTTATGCTCTTTTGGCATATACACTGCACTCTCTTTATGAGCTGATTTAATGCTATTAGA
+ GCATTTATAAGGCACTGTTTTCAGGCACTTTTTATTTAATTAATGCTCTTTTGGCATATACACTGCACTC
+ TCTTTTTGAGCTGATTTAATGCTATTACAGCATTTATAAGGCACGTTATGCACTTTTTAATTTCACAATT
+ GCTGATGTATGGCCTCAAGCACGCCTTACCACAATTTATAATGGTACACAAAGCAACCTTTAGCTATAGA
+ CTATAAGGTGCTTGTTTTAAAACATAAAAGATTCTTTTGTATCTTTTTGCTTTTTATATTTATACTCTGT
+ TCCTTACCTTTGGTAGGGGGAAACAAGAGTCACTTATTTTTGCTACCTTTAGCTGCAAGATTAACTTAGC
+ AATGCTTAAAGGAGCTGGCCTTTCTCTGAGTCCCTTACCTTTGGTAGGGGGAAACTGCAGAGTCGATTAA
+ AGGCTCGATTGACCAAATGTAAAATCCCAAATAAGAAGACTTTACTCGTTGAGTTTTTGTAAGAAACTGA
+ TTTTATTTGGAAATATCTTCGGTTTAAATAGGTGACATGAGAATCGCATCTTAAAGTAAATGGCCTACGC
+ AGAGGCCTAAGTAAATAGTCCCCGCCTTATCGAGGTCCCACGCTCGGGCACATCTGCCTATCTTGAGCGG
+ CGAGGACCTTATCTGTGGTCTCCCACTAAGGGACTATTTTAGGAGGCGGGGAACGATCTCAAGTGACTGA
+ CTCATGTAGTGTGCACTTAAATTACATGTTTTTGAGCAATGCACCCATGTCGCCTTAGATAACAAAATCC
+ TAAATATAATTTATCGCTCTCGATTCATTTACATAAGATATGAACGGAGCCCAAAATTGTAAGTCTTTAA
+ ATATATTCGTGTTCATGTGTGAACATAAACTGATCCCGATTTCTTGCCGTGCTGCTATAATGACAAGTCA
+ TGCTACGCTCGTGTGATTTATAAGGTCTTTGGCTCTCTTCCCATCTGCCCCCAATTATAGTTCTTGTTTT
+ CGTTTGCCAGACTGTCTGCCTCTCTTCTTTGTTTTGGTTACCTTCTTCTGCGTCGTTTGTGGTATCATTT
+ TGAAGGCGTAAACAAATATAAATATAGATATGGGAAGATGGAGGCGGGACAGCTGCTAAATATTCCGATG
+ TATCTTTGTAGACGAGGCCAAGAAGCCGGATAGAAGATGCTAATTTTGCGCAGCGCCATTTCGGCATTTT
+ GATTCGGGACTGACCCAGATTCTTGGTTTCCCAGGGGGTGTGTGTTCCCCTGAAACAAACATTTCCACTT
+ CATTATCGTTGGACTGCGTCGCAATTGATCAGCACTCTGAACAACATCACTTGCATGTCCTCCTTAACTG
+ CGCACTGCACTTTTAATTGCTGATCAAATATTTTCGACAAATACTGCTATCAGATAATGGTTCATGCGAG
+ GGACGGGCTAGGGAGCTTGGCGCCACTTAAGTTGATAAGTACTATGATTAGGAAATTGTTAAAAAAAAAA
+ TCATAATAAAATTAAGCTCATGCGAGAAGGAACTCCAAACTTTTTATAATAGTCCTTAGATATAATTACA
+ GAGATAAATATGCATGCCTACTTAATACTGTTTCGACATTATCCCTCACAGTCTCATGAATTATCAATCA
+ TTAAATTACATTTAGTGCTAAGTGTCCCACAAAAAATGAAGAAAATATTGCTTATTTGAAGGCTAATCAG
+ ACTGGCTAGACATATTTGCCAATCCATTGGGGAAATTAACCATTAACTGGCAGCTAATTAAGAAGGCGTA
+ TTCTGAAACAGCCCTACAACACCCAACCCACTTTTCGCCATCTGCATTGGGGGACAGAAGTCAAGGGCCA
+ TCTATCCTATCAAACAATAGGTCAAAGCGCCACAGAAGTTGTGTTGTTTTGATTTCCATGGTAGTTGTAT
+ TGTTTTCATTTCTAAACGTCCGGACAGACCATCACTTATAGGCGGAGAATTGTTTATCGACGTATCATAT
+ CGAAGGGTAGAACGAGTTAGAGCAGAGCATAAGCAAGAGCATGCAGAAACTGTTTTAATAACAGTGGTAA
+ ATCTTAAACGAATTAAGTATTAACAAGCATGCATAGTTGCCTTCTTAGGTAATCAACACAAAAGATTTTC
+ CAACCCAGTAAACATGAATCTTACATACTTTTCATTCCGAAGGTCGCGCAAGCATTTGACCCGAGTCCTC
+ AAAATAGTCAATCAAGATTTATTTCTGAAAATTTTGGGAATGCTCACTCAGCAATTCGTGCGAATAAACT
+ GTTTGGTTTTTTTTTTTTTTTTTTTTTTTTTGAGTCTACCAAATACAGTAAAGTTTTGACAAAAATCAAG
+ CTTAAGCCAAATTAAATGATTTTTTCCTGGAAGAAAGGGCAGATATATAATCTTTAATTTTATAACTTCT
+ TACCAGAGTTCTAAAAAATTCGACTTGTAATTTCCAATGAATTGAATATGAATATGAATATTTTGCATAC
+ GATTTTATATACATATACATAATTATTTCATTATATATGTGCGCATTTTTGTGGAATGACAACAGAGCGG
+ AGCGTAATAGCTTTGTTGCGTCGAGAGAGCCTTTCATTCATATAATCATTATAATTCCATTCATTGATTC
+ GCATGGTTTAGGGCAGGTAGTCGCCCTAATTTATACACAGAAATTTGTCCATATAGGTCCACAATCATCA
+ TTTAATGTTTGCATCGGTTTAATTTGTTTGTTTTATTGTTCATGATCACTAAACCGCCGTTTGGCTCTTT
+ TTAGATTTTAAATGCTTATGCGATATATGCGAGTACGACACGTGCCCCGGGAGTAATGAACCCCCCCAAT
+ GATCGACTAACCAGCCCCATAACGGATAATATATGTGCGCGCAGTAGTTGATTTACGATCCACTGTGGGC
+ CGGTTAGAACACACAAGATGGGGACAATCTGTCTCAGAGCTTACTTGAGTCCAGTTCGGTTTGGTCCGGT
+ TTGTTCTGGGGCTTTGACATTGCGGAAGGTCCAATTGTTGTACCTGACGTGGGCTCATCAGATTGTGGCC
+ ATATTGAAGAATGAGATCAGCGGAAGGTTTTAGCGTTAGATAAAACGATCCAGATTATCACTCAGTATAA
+ GTGAGTTCATTTGAACACGATTTCACCATGTCAGGTTAAAAATTCGAAAAGCTCGCTTTAAACACACATA
+ ATTTAACTATATTAACTATAAGGCGGATTGTTTTTAGAAAAAATGACGTTCGAACCAACATTACTGTTTT
+ TCCCCTCGCTATTCCGATTATAACAATGCCATTTTATGATGTTAGGCTTATCGACGGAACCACATGAGGA
+ CCACCAGAGATCCACCCCTCAATTTGAAACAGTTATTTGATTATCGATCCCTTATCGTCTCTACGCGAAA
+ GCGTGCGAAAAGGAAGATAAGTCTGAGACTGATTCTGCTTATCCTGTTCATCATTAACCAATCCACACCC
+ TGTAGCTGTGGCTTTCTTGGTAAATTACGTGACTGACTTCGGCTCCCTTCTGTGCGAGTGTGACGGTAAT
+ AACCGCAACAGTTTGTCACAAAATGCATCAATGTCAAGTCGCCCATAATGCCCGACATTGGAGTTAACCA
+ TTTAATCGGAGCAGAAGAACAGAAAAGCTGCTTGATGGAATTTGATAGATTCGCAGCCATCAAGCTTGTT
+ CATTTTGCATCCCGAACTGAAAATAATGAGCTGCTGCCTCGCCCACAACGACATCACATCCGGACTGATT
+ GCAGACTGCGGATTTGTTTTCGCTCCCTGTCCGCCGCCAGCCGATGACTTTTTAGTCCTATTTATAGAAC
+ CCACAAAAGCCCACACACATGGCAGGGCGGCATTGAACAGCTGGAGCAGCCAACGTCACCGAAACACAAG
+ CCGGAAAAAGAAGAGTCGTGGGTCGTGGGTGGCGGAGTCAGCGTCAGGATAACTGGGACATCCAGCGTGG
+ GCGAAATTGGTATTTACATGCCATAAACGTATTGCCTTTTGCACTTTCTGCTCTAAGAGCCGTATCGTGG
+ CAAAAGCCAATAAATATTTTTTAAAATACCAAATTAAAGAAAATGACAGGATATAAGTAAGGAAAGTCGG
+ TGAGATTATAAATGTTTGGGCGGCTTGTGCGTTGGGTTCTTGTGGACCTCATCCCACCTACCCTATAAAT
+ ATCCCACTGCACTTATATGGGCAATCTATGGAGCTCATCAAGTACCTTCTTCACGTCAAGTTTTAAAAGC
+ GGATGAAGCCCACCGGGATAGACAGACCGGCGGGGGCAAGGAATAGCCGCCCATTGAAGTAGATAGGGAT
+ AGTATGATTCAGCTAATTTGCTGGGCTTACATCGAGTGATGCCTTCACAAGTAAGCGCTTTTAAATTTAA
+ CGAGTCGCTGCAGCGACTAGATGGCTATCAGAGCTGCTAAATGGGTTGCAAATGGCCGGAACAGGTATGC
+ GTGCCATTGGCCTGGCCTATATAGGCTCCGGGTACAGTCTGTCATGTCCTTTTCCACTGCCACTTCCAGT
+ TGCATTGTTCCACATTCGCCGGAGCCGAAGCTGCCACGAGAGCCTTCGTTTATACATATGTATATGTATA
+ TATACCAATCGGGTAAATACCCTTGTATATGTATACTGCCCCACATCTGTGCGTCGTCGGTATACAAACC
+ ACAGAAAGTACACAGGACTCTGGGCGGTTGAGTTGAGTCCAGTGTATCGCCGTATACATTGTGCAATAAA
+ ATATTTAGAAGACACATTTAAGCCGTTGCCATTCTGAGGAATACTTGACCTGGCATCTACGGCATCAAAA
+ GCAGTAACTGAATTCCGCACGTACGATGACCTTGCGCCCCTGCATTTCTTATCATGGATACAGAACAAAG
+ CCCTGCTGGCGGTTTGACCGTAGAGTACACAGTAGTAGTTTAGTTTATCGAAACTCGATAAAAGAATACA
+ ATTCATTTTTAGATTAAGATTAAGATTAGATGTAGATTAAAAAATTCTTTTGAACTTGTTTTTAAGATTT
+ ACGATTGACGGATACTGTGACTATCCATTTGGCCACTCAATCGTACCTTCCACGGATACCTCAACCTATT
+ TTCCCCTGGAATCCCAAACTGTCCTTTTTCTCCTCCTTGAGGCGTCTGTGACTTCCGTTTATTGCAGTTG
+ CCAAGCTAAGTCTAAACGGCCCATCTAGGCGTAGCACTTGTTACCACCCCTGCAAACGCCCAGCTTCATT
+ CAATGCAAAATTCATTTAAGTTGTCCTGTTTCACGATTTACGTTACGCTACGCGTCCCATATACAGGAAT
+ ATACGAACCTATGTATCTGTACATATGTAAAGAGGGACGCCGAGTGCAGAGCGCGAAGCCATGTGCCCGT
+ CATCGTCATTTTACGATGAATTCAACTACGAGTCGAGTGACGAGTCCAGTGACGTAAGAATCCAAGCGTG
+ AGTGAGCAAGAGGGCGCAGTTGGCGCGGCAGTGAGAAGCAGGATACGCCCACGCTAGCGTAAAACTTCGG
+ GCGTAGTAACCTATTTACCAAACGAGCTTCTTCGCACACACACAGTATTATAAATGTGTATGTACATATT
+ TACTACAGCTGTGGACCGAGTACCTCCCTCTCTTTCTCGCCTGTTGCAGGGTTATTCCTTTTCTACCGGG
+ TCGACTTAAAGGAGTGACGTCACATATTACACATACGTCTGTAGCTCATCACCGAGGGCCTCCAACGACG
+ TGAACGCGCGTCTGGCAAAATGGTGACTCTGTGACCAGGAAATTAGCGTGTCCGTCACTGGCGTCATTGG
+ TGGCGATTCGAATCGGCTCGATGCGTCTCGAATTGGAACAACACGTGTCGGGCCTGCCGCCATTACTTGA
+ CACTGGGCCATCGGTAATCGTTAGTCCGTATCCGATAAGTGTGTTCATAGGTACCGGTGTATATCTATAT
+ GTCGGCAAGGGCAGAAAAGTTGTTAGCAATCGGCACCACATCATCTTTTGCACTTGAACATTTCAAAAGC
+ GAACCATCGTTAGTATATATTGCAAAAAATCGAATATTGGTTGTCGTACATATAGCAAAGTATATAAGAG
+ TAGGTTAACCCATGACGAAGTATAATCCGTGATCCACCACCACGGGACAAATCTGTAAAGGCAAAATCGT
+ CATGTGGCTCTATTTCATAATTATTGGCGCAATTTTCAAGTGTTGGGAGGTATTTACAGTTGCGGGTATG
+ AAAGTCGTTACAAATGCGTGGGTGGGGGGCGTGGCGATTGCGAAGTCAAAGTGCCTTCGCCTGTGATTAA
+ AGTATTTGGGTTACCAGGACAGCACCGTCGTCTCAGTTGTAACAGCATGTTTGTGGGCGTTTTTGGTGTG
+ GGAGTGCCGGTGGACGAATACAGTTAACGGCTCTCAGCCACAGTTAGTGTCACATCTGACAGCTTGATAT
+ TTGCAATTGAATCAGCTAGAAGGATGCAGGAAGAACTCAGCAAAGCATTACATCAAATTGTTGTTGAACC
+ CATAACCCGGCATAACCTTTTGATTGCAGAAAGGCTGAGTTAAAACAAATGTATTTTTAATTTCCACTCT
+ TTATTGTATGTATGCTTACAATTACAATCGCTCTATATTGAGAGGTTTTAAACTCTGCTTCTCCAGGGGA
+ ATCATTTATTACATATTATTTATTTTTATTTTCTATATCCAGTCAGCGATGACAGTCCACCCCCACCGTT
+ ATGTGTATGTATATATGTATGTATGAATAACAACCTCCTGGGTCGACGACTGTATGCATAAGGAACCTTC
+ TCGACCGCCGGGAACAGAATCCATTAGTCAGCCTCCCACGTATGTATGTATGTGGCTTCACCAGGTCCCG
+ ATACCCAGTGCACACGTCTTCATTTAGTTCCATCTCCCGTTTCCTTTCTTCCGGATTTGTTTTGGTTTTG
+ GTTTCAGCTATTCAGCTCCGTTATTTAAGCGGTGACCGCAGGGCAAGTGCAACTCAGTCGTCTTCGGTCA
+ GCGGCCGCTGCACTTGAACATGAAACAGCCGCAAAAAGCTTAAAAGCTAAACCAAAACCAAATCCAAATA
+ CGAATCAAAAAACCAAACCCAATATAAAAGCAAAGTTCTGTGTATGTCAATTTCCAAGCCGTGATACGTT
+ GTCACCTGATTGGTACGGGTCGCACTTGCTACAAGCGACTCTGGCTATGCGAAAGGTAAGTGGGTATCTA
+ GTATTCATAGGCGGAAAGGACAGAGGTGAGCGACAGAACAACAAAGCACATGGCATCGCCCACTCGCGCC
+ CACAAAGAAAGGTCGTATGTTGTCTGCATTGGGGCCGCTGTTTTGCGCTTATGCTATTGCTCTTCCTAGC
+ GCTGAACTTGAACAATAGCGTCGCACCACGCAATACCGTGCACCAAAAAAGCACAGGTGTAGCAAAATGT
+ TCCCCAAAAATGGGAAAATGCAAAATGTTATAAAGGCCTTTGAAAATAATATAAACAACATTTTTGCTTT
+ CGCTTAAATTCAATAAATTTTCAATAATAATATATTACAAAATTATATTAGGGCCAGGTTCTGGGACGCC
+ TTTTTTCATAGCACGCACAAATGAATAAGAAGACGCCATACAAAAGTCTGCCTCTTAAGTACCTAGGGGC
+ ACCCACTGCACTCCTTTCTCTCTTTGCTGCGACGCAATTGGAAAACATATTCATGCAATCATCAATTGCG
+ CTTTTGCCGACGAAACAAAAAAACACAGAAATTTACGAAGGGAAAACTACGAACTGGAAATGCCCTTAAA
+ GGGGGCAAAAAATTAAAAAACTTAATTCATTACTAAATTCCGAGCGTAGGACTATGCAAGGGGCATTTTG
+ AAAAGAGGAGAGTACTTTAAAATAATAATGCTAAGCTACACCGATAAGAATTCTAATTTCCAATTAAACT
+ GTCAATAACGCCAAACTAATGCATATGCAAATGTCATTATTGTGCGAAGCTTTTATGACGAAAGCCAGGT
+ GCATTGATTCGTTCTCGGAGAATTGGCTTATTTTCACCTGGCATCTGGTGGCCCTGACACACGCCCCATT
+ AAATAGCCACTCGAGCCGGGCTGAAAGAAGAGTGCCTGAACTACTGTAAGGCGCACTTGTCGTGTTGCAC
+ GTGAATCGAGAACGTGGGAACGGAAAAGTCGAGTATCGCCGTTGAGGCGCCATCCGAAAATTATTCATTG
+ TTTTAGCTGCAGTCACCTGTTTGTCCTCCTGACCGCCTGTGCCCCTTCCTCCTCTTCCACGAAAGCAAAA
+ TAATTTATAGAAAACGACCGTTTAGAGTTTTAAATAAACCGTTTGAGGTAAGTTGGTGGTCGCATTGCTT
+ CTGCTCCTTTTTAATTGACCATTGCGAATTCGTTTGGCGCCAATTTTATTTTCACGCCGCCTGGCGCCAC
+ ACGCGGCGTTTGCGCAATGTACACCGGGCGAAAAATGGGAAAAGTGAGTGGTATGTGTGAAACTCTCATT
+ GATTTGTTTTCTGTCACTCCTATTCATTTTTGCTTTGGTTGTTGTGTCGGGCACTCGACTGGACGGGTGT
+ TAATTAAATTATGGCTTTTAATTTAATTGTTTCTGTTCGACATGCGCATTCATTTATAATCGAATTGGAT
+ CAAAATTCAAAGGGGAAACGAACAGAACTTTATTATTTTATCGTCCCGTGGGAAAATGAGCGAATGGAAA
+ CTCAAAAAGCAAAATAATAGCGGTTCTGTTGCTTTATATTTGGCAAATATTTAAATATTAAAGCCTTTCA
+ TGTTGAGATGTTCATGTTCAGTTTGGATTGCACTTACATTTAGGATCTTCACTTCCCCTTTTTAATTTCA
+ TAAATTTTCACATGTCAAATGGTGGCTTGGTGTGGAAATGAAAAGCTAAGTGAAGAAAATGGTCTTGGCT
+ GGTCCCAAGCATTTTTTAAATTTATTTCATAAGGCAACAGAAAAAAAATTTCCCCAGCCCATTTTGATGA
+ TTAAAACGACATATTGCGCTGCCCTAACACGCTATCACAAAACCGTACCCCACACCACTATTTGCTAATA
+ AATTAAACAAATTGAGGACGAATCGGCGGGTCCATTGATGTGTAACTCTGGGATACCGACGGGTTTAATA
+ ATGGGCAACTAAATGAGAGCTCCGAGGGTTCCGAACCGGTTCGTCTGCCAAGCTTAGCTTCCAAGCGGGG
+ GGAAGTCCAGCAATTAGAAAGAAACTGGTGCACAGCCCACCGTTGATGACTAAATCAGCTGGGATTTCGT
+ GAAATTAGCTTTTTATACTAAGCGCTTGGCTGAAAATATATGCAAATGGGATTTTAAAAATATTTTTCAG
+ GCGACATTGTGTCTCGCCGAACCTCGATTGCTGCCCATTAAAAATGCTAATTTCAAATATTTTTTAGCAG
+ AAAGCAAGAAATAAATTAGCCACAAAATGCTAAAAGCAGAGGCCAAATAAAAACGATTTTAACTAAGCCA
+ CCGAACTCGCTAAGGGTGAGACAAATTAAATTGAATTTGATTATTATATAAAATAAAATAGGTAAGAAGA
+ AAATTCGCGACCATTTCTAAAATATGCAGTCAAAGTTCATTCGATGAAGACGAATTGTAATTTTCATAGA
+ TTTATTTGAGCCTAAACGCCGTTCAGTTTGAATGAGTGCTTATCACAAGTACACAAAAACTAAAGAAATA
+ TTACTTATATTGCTAATTGATAAGGTCTTTGAATATTAAATGTGTTTATTAAACTGTGTTATTTAAACTA
+ CGCAGCAATTCACAAGTAAGTCTTTAAACAAATTAAGCTAGGAAATTTAAATAATACATAAATGGAAACT
+ CAACCAAATATAGAAAATAACAGGAATAGAACTAATATTTACAATATTTCTTAACAAGATAAAAAACCAT
+ AACAGGAACAGAACTAATATTTACAATATTTCTTAAAGAGAAAAAAAAACAAAGTGAGAGAAAAACTTGA
+ TGACGAAAGCGTCGGCATCCACGTCAGCAAAGCCAAAGCAACTGCAGTTTCCGCTTCCCCTTAATTTTGT
+ TTTGTTTTCGCTTCGTAGTAAAACGTAAAAACGAGAATAAAACCGTGAGCGGGAGCGGGAGCAGCAAGTG
+ AATTTTTTCACGCTGGGTGGAAAAGGCGCGCGAACGTGACGGAACGCCGGAAAGTTGTGGAACAGGCGAT
+ GTGAATGAATTGTGGAACGCGTTTGTGTAGAAGGCCTTACACTTATGCTAATGTGGAACCCAGAGTGCGG
+ ATCAACGAACGATCCGTGCGCGAAGAGAGCGGGAATAGTTTAAATTCCAGAAAATGCACATTTGTACACA
+ TACATACATACATAATTGCCTTGGAAGTTTACGACAGCGACGTTGTCCACAATTTCATTTTATAGATGGG
+ GGCGTGGCACTGATGCATGATCTTGATGGAATTATGTACCTATGTATGTATGTATGTAAATGTAAGCAAG
+ ATTCGTTGCAGTAACAACAAATAAGTGGATGAAAACAAGTGCGTCACTTACTCATTAATAAATAAATAAT
+ TAATGGGCGGCGCATTCGAAATGTAAAAGAAAACGCAAATAGCTTGCCCACTCGCGGCAATAACGGAACC
+ GTGACTTGCAAATCGGTGAAATGAATAGGATATGCATAACTGTTTTTTCGAAAGACCTGCAAATAATTCA
+ AGAAAGTTCCAGAAATACCCAAATTTAATAGCTATCCAACATTAGGGTGACAATAACGTGTTTCAACAGA
+ TGCAATATATACGCAAAATCAAAGAAAAACAAACAAAACCCGTTAAAAACTAATTATTTAAAAAAGAATA
+ CAAAAATATAAATTTAAAGCTAACTTAATAAAAAATAACATAATTTTCCCATTATTCATGTGTCGATTAA
+ AACTCAAATGAAAATTCTTACACTTCTCCGCACTCTTTTTTACCCCATAACTCTCTATCTCTCTTCCAGT
+ TCTCCGCGCTCACGATTTGGTAACTGTGGCCCAATGCCGCCGTTCCCAGTTTAGCGCGCTCTCCTTGCCT
+ TTTCTTTCGCCTTTTCGACTCATTTCGAATCGGAAATTTGACGGGTTCGGTCGTAATCACGGATACAAAT
+ TTGACGCCCTGTTGGAAAAACCACAACGTCCAATTTTCCTTTTATCGCGCCAAAAAGAAATGCGAGTAAG
+ ACCCGAGTCTTCGTGTATACGTATAATTACCATTTGCAATCACAAAGGTTTTGCAACTGTCGCCGGGCGG
+ TGAAAACTCAAGTGAATAAATATCGCAAAGTGAAGCAAATAAAAAAATATTACAAAAACCGGTAAAACGA
+ AATGAAACTGAAATGAGTGAGGGCAGCAACTTCAAGTGACGAAAGCAATCCGTTTACCGTTGTCTTTGCC
+ TCTTCATCCTCCCCGAGAACGGCGGAGAACGCGAAAAATATCATGAAATGTAAAAGCTGGTCCAACAAAA
+ TTAACAACTACGTTGTGCGCAAAATAAAGTCTATCAAGGTAAATAGTGTCTTAAAAAGGTGCGGTGTTTG
+ GCCCTGATACATATATACTTATATTTATTTAAATTTTGATTAAGTGAATATATCTTATGAGGCTTATGAG
+ ACTTGTTAAGGTGTTAAAAAATAAGTTTATAGCATAGATATGGGGTAATGCGAAAGTACAATTTGTTAAA
+ GTTGTTTTTAATTAAAATAATTTAGTAAAACTTTTTTTACAAACTACAAGTAATGCTTTCGAGAAAATAC
+ CTCCCATCAATTTTATCGTTAAATTACACAAAATTGTTCTTGGAAAAAAAAATTGAATTGGTTGTACAAA
+ TTTTTGTTTACAAAATACAAAAGCTGCAAAATAATTTATTGACATGAAATAATGAAATACTCATAAAGCT
+ GTGAAATTTAATGTTTGAGCTATATAGCAAAAAAAAAAAGTATTTTTACTTTTTGCAATTCTTGTTACCA
+ ATAAATTTAAATATTTCCGTACATTTCATCTAAAAAATTTCCATTGACAACACATGCTGGTATAATATAT
+ AAAGATCAAAGCCATAAACTCCTCACTAAGTGGGCAATAAAATAAGATAATTCAACGACTGTCTGTATAA
+ CAACCACTTTAAAAGCTATCTAGATGGAGTTGATTATGAATACATTTTCAGATGCTTATATTACTCGACA
+ TAAATAGGCAGTGGATGTGTATAATTATTTTGCAGGCACCCGACAACGAAAATAAAATGCATAAAAAAGT
+ TTAATGAAGCCGCAGGGGTTGACTAAATTTATTTAACAACTGCAGTTCATTGCCTCGCAAATTGCTTGAT
+ ACTTTAAAAACAACAACAAAAATTCACAGCAAAAAAACACAATGATTCCAGCTGGTTTCTAAACAACAAT
+ TTATTGTGGTTTCTTTTACTTTTAATTGCTATCTATTAGCAGCAACCAATAAATGAATTATTTATTTTAT
+ TTTCTCTTGCAAGCAGCCAAAAGTAAAATTATGCCCCTCTCTCTCCCGATCCGAGTTCATCACTTTGTCT
+ TCTTTTAGCTGTTTTTATTTTGCAAATAACTTGAGTAGTGGATGGGAAACAACGCAAAGGCCTTTCACTT
+ GCATGTCTGTTGCTCGGTTTGTTGTCATTAGGTTTACTGTTGTTGTTGCACACACTCATCCGCTTACATA
+ CCTCGTTTATATACTTATTTACATTTGAAGTTGCCGTCGTTGGTATGTTTTACTACGTATCAGCTTGTCC
+ GCTTTGAGCTGCCCCTTCGCTTTTCAAGCATTTTGTTTTGTCCGCTCTGTTTTTCAGCTATTCCAATTCT
+ CTTCCTTCGTTGCCCTGTGTATGTATTCGTAATCGGGTTCGGATTCTTGTTTATTTTTACACCACTTCTC
+ TTTCTCTTTCGCACGAAAATTCCTCGAATTCTTTTTTATCCATATTTTCCTTTTCCAGCGGGAAAAACGA
+ GTTTTTCCAGCAGCGCCGCATTCTTAGCCTGTCGCCTTGTCTCTTTCCCACTTTTATAGTGTCTCCGCTT
+ CTTGCTTGTTTACAGTTAGGAATGCGGTCGTCTCCCCTCTCTCTCTCTCTCTCTCTCTCTCTCTCACTCT
+ CTCTCTTCAAAAAGAGCGTGCGCTCTCTTTGGCCTTATGTAGTTGTGTGGATTTCGACTGAAACTTGTTT
+ TCGCTTTGCCCCGTCGTGTTTATTTATAAAAAGTCACTGGCAAACAATTACAGTGCAACAATTACGCTCT
+ CAAAAGTGGCGCGCAACTTGTTCGCCTTGTAAAAAAAATTGTGACGCCAGCGGCGACACGACTGCGCTGC
+ TTTGGCCCCATTTAACTGAGAGCGCCGAGGGTTAGCTTGGCGGGGGCGGCAACGCCAAAGAGAGTTCTCT
+ CGGGTGGCGCTCGTCTCCCATCGGTTTCGCTGCTCGAGCCAAATGCTTGGAAGTCAAAGTCTCGCCCGAC
+ CATAGTTTCTTATTGGATTTCAAACCAGTCGCTTCGTGCACGCGGCGTTCGACTACGCACACACACACAC
+ CCATAGCGCGCTGGCATTGATATACATACACAGGCAAATACACGACGCCCCAAGTTCGTGTGATGTAGTG
+ CTGTAGTGGTGCGATTAAATAATACTCCACAAAAGGCCAAATAAATTACATAAAATCTAAATCGGAATAA
+ AAATAAGTGTATTCTCCCTCCGTGTTGTGTTCAAAGTATTTAACCGATTGTTTTCATTAGTCAAATTAAT
+ GTAGTACAACGTATGAGTGTGAGCCAGTTCCTAGAAAAATAAGAGGGCATAAAAAATAACAGACACATAC
+ AGCGTCTCGTTTCTTATAAATTTTCCTACTGCGTCGGAATTATTGTCTTGATTATTGTTGTTTCTGGCGA
+ ACTTTTGTGATTTGTTTCGAGAAACATACTGCGGCGGTTTCATAATTGTGCAAATCAAGGGAAGCACAAT
+ ACGAATGTTAAGAATCAAAGCTAAGAATTAAATAAAATTAAAGCCGCACACATACATATACACAGGCACG
+ CGCAGAGTCGAAAAAATACGCGCGCTCGCTCTGTACAGTGTGTGCGTGTACGCGGTGGCTGGCTCTTCTT
+ CTTCATTCGTGTGCCCATTGGAATTTGTACCCCAAATCGAAATTACAACATAGACAAACAAAGAGCGCCC
+ GTCTGCCCCAGCACCTAAACGTAAGTGTGTGCGTGCGAGAGTCGTTTCATTTGCATTCTTGTTTAGCGCA
+ CTCCCGCTCTCTCTTCGTGCGTTTTTCATTCATAAGCACATTTTTACTATTTGGAACTGCAATTTTTTAC
+ ACTAAGCTTGAGGACAGACAAGAATACTGTGAAAATCCAATGTAGATGAAAGCAGGCCGTGCTTTTTCCA
+ TCAAAGTAATCGCAAAAAGTCGAGATTAACACAAGTTCAAAATTATTCGTTAAATTTTAGAACAGAATTT
+ TGAAATGAACATAATTCAGGTACTGTGTCATCCACATATAAAGAACTTTTATTCTAAAAACAAATAATCG
+ TCCGATCGGTGTGGTCTGTCCAATAAAAATTCACGGCAAAGGCGTTGGCTAAAAATACAAAGACAAACGA
+ GTCGGGTAAAAAACAAATAAATGATAAAAAAGACTAAACAAATTTCGCGAATTTTGTATTACTGTGAATT
+ GTATGCTTGGTGATGCACACTGCTATCTAGCAGCATTATAAACTTTTCGACCAAAAGCTGTTGAAACGCA
+ ACGATAAAGATATTATAGCAATCGCATAAGTATACATACATACGCAGTTCAACAAAATATTTTTGTCATA
+ TACAATAGTTCTTGAATTAGTCTTAGAGGCTCGTTTGCCATTTAATAAATGACAAGCTAGAAAAAACGCT
+ AATGATAGCTTAACCTTTTTTTTTTTTTTCTTTTTTGTGTGGCCTCGACAAAAGATTTATAATTTTAATG
+ TGTCAAAACAAAAATATTTTGTGTAAATTTATCGTGTACGGTTTTGGTGTTTCTTTCGTAATAAACTTTG
+ GTCACATACCTTGAGATAGACATCGCTACCCACCGTTTTCTGGCTATTTCTAATCAAACGTCCTCTTTGT
+ GCTGCATTTTTTGCTTTCAATTGGCTGCATTCTGTAGACGAAAATCTTATTTATAAATATAAATTGAACA
+ TGGACGCAGGGGCAGAGGCAGTGTCAAGACGCGCAGAAGGGGGATCGGTTGGGTGGCTGCAAAACGTTCA
+ TCGGCGTTGGCCTGGCAATAAAATAGATTAATTTAAATGTCATTTTTGTCTAGACGCCGCAGACGACGCC
+ GACAACGAGACGTCGAGCTACTCTGCTCTATGTTTATAGATCGGTTACATATATCCCCGACATCCCCATC
+ CCAATTCGCATCCCCCACGTGATATAGCGGATCTTCAGTTTTTTTTTTCTCTCTGCATTTTCTTTTTCCC
+ CAATACACGCCCACTCTAGGTACACTTTCTCGATTCTTCGAAATTTTTCCACAGCATCTTTATGGACGTG
+ GATCTTCTTCATATCGCCATTTCAACGCTCGTTTCGATGCAAATGAGCTTTTCGGGTTTTGGGTGACGTG
+ GAAATCTGGTTAAACCCATGTAATGGACAACAATACAATTCGGAATTTTGGGTATTTCCTGTTTTGTTAT
+ CGCTGTCAGTGCCATTCACCAATTGCTTGACTAGTTTCAGCCGCTGACGCAGATCGTCGTCTTAATTAGC
+ GTCGCAGACGACAAAAATCTCAATAAAGTGGGTAGGCAACTTTTTTTCAAATGTTTCTTTTTTTTATTTT
+ AATACGTTAAAGCGGCAGAGTTCAAATATCTGAAAATTGTATGTTTATTTTGTTTGGATTGACTAGTGGG
+ TGTATCACAGCGCGCTGTTGAGGTCATGTTTTAACATAGAAAGAAAAGAGACGGCTTTTTCTGATTGCCA
+ ATAGTGTCGCGGGAGCTGCGGGTATAAAAAGTAAACCAACCGCATTCCAATCCGAGTGACGCACATTGGA
+ CCCCTCATGACGACAATTACTATTGAGGGCTTCTTGTTGGCCGTAGATAATACACCTGTTTTAGGGACTT
+ GGGGACGGGGCTTCTTGGGGCCTTCCCAGACAAAACGATCAATTTTTAAATCGATCGGATTTTTTCGAAA
+ TGAAGCTTCTTTTTTGTCTTTTGTTCGTCTGGGTTCCCACGTCAGGGTCCAAATCCCCAACTCCAAAGCC
+ TAGTTCCATTCGTATCTTAATCTTTCGCTCGTTGTTGCTCTAAAATTAGCCACCAGCTGAAACTTTCATT
+ GACGCATTTGCTCACCTTGTTTTTATGGTTTTTTGATTTTTATTCACATTTTGAGTTTGTGTGTCTGAGT
+ TTTATGGTTTGTCCGTTGCATAATTAATAATCTGGGCTGAAACTGATTTCTTTCTTATCTGAGTTGGGCT
+ TTTGCCGAATAATGTGATGTACACCGTACGCTATAGTTGCGCTCACTTGATTTACTTATGTGGTCATCAC
+ TTTAGCCTGTGGGCTGCTGCTGATTTTGTAGCTAAAGGCTTCCCTCGAGCTTTTAATTCCTTAAGAAATC
+ ACGCCACAAAATTTATTTTTCGCTAATGGTAAACTGGCGAATAAAGAAACACAAACGAACCAATAAACGA
+ GAAGCGAACGAAAACAAAGCCAAAGTCCAGCAGCATAAACTTCTAATAGAAATGTAAACAGGTGGCAATG
+ AACTTTATTATATTTTTATGCTCCAAGTCCTTGAACCCGCCAAAATCAAAGTCACACAAAGTAAAACGCA
+ AAGCAAAAACAACACGGCAATGAACTTGACGTCAATGGCGGACCATTGGGCCGCCTGTTGTCGTTCTGCC
+ TTTTGTGGACCTGTTCTTGAGTTCCGCTTTGGAGCATCGGCTTCGAGGCTTTGCGGTTGTTCAGCAGAAA
+ ATTAGTTTATAGCATGTCAAATTTCTCGTTTAATATAAGTCTGGAAAAATCATGAAAAGTTAGTGAGTTT
+ CAGAGGAAGTTACGACCATTTGGAATTCAAGCAGTACTGAGCAAAATATCCAAACATTTAATCGAAACAA
+ GAAGGTGGAGGCAAATTATATTTTATATTAAATTAAATATTGTTTTAATCGCAAATACTTTGCATATATT
+ TTTCCAGATCAACGGTACACAGCAACAGCTCCAATTGCCAGGCAGCGGCGCTAGCGGAATCGCAGCGGCA
+ GCCGTAATCACGGTAGCATCGGATTGCGGCGAAAACTGCAGCAGTAACGGCACCGAGCATCAGCAGCACT
+ TCAACATTGCTACCACCACAGCAACTTCGGCGACAGAGGCAACAATGCCGGCTATGGCCAAGGAGAAAGC
+ ATCAGCAACAGTGTCCTTGGGCGAGTCGAATTTCAGAGATATCAACCTAAAAGACTTGGCCGTGGTCGTC
+ GAAGCGGCATCGCGGCTGCACCACCAGCAAAACGTATGCGGCTGCGGAGCGGTATCGTCTACTGAGAACA
+ ACAACAACAGTCGCTACGGCAGCAGCAAGTATCTGACAAACGGTAAGCTTAATTCTGAGTTACTCAAATA
+ GAGTATGTTTCAAGTTGTTCTTAAAACACTGAACATTGTCCGTTTGCAACATGTTTTTGCTTCGACGCTA
+ ACACAATCTCTGCTTTTCTCTGGCAGGCCACACGTCGCCTTTGGCGGCAGCGGTTGCTAGCAACAGTTCG
+ TCGGTGGCCACGACACCGCATTGCAGAATGTTGCACAACTGCAGTCTGCAGCAGTACCAGAATGACATAA
+ GGCAGCAGACGGAGATATTGGACATGTTGCGGCAGCAGCATCAGCAGGGCTACCAGTCGCAGCAACAGCA
+ ACAACAGCCGCAGCAGCAGCAGGAACAACAGCAGCAGCAGGAGCAATCGCAGCAGCAGCAACAGCTACAG
+ AATCCTGCGCCCAGGAGGTCTCCGAATGATTTCATTTTCGGTCGTTACATAGGCGAGGGCAGCTATAGCA
+ TAGTTTATCTGGCCGTGGATATACACTCTCGCCGCGAGTATGCAAGTAAGTCCTTTTTAGTTTTCAGTGG
+ GTACGATAACTAGTTAGTAGGTCGGCGCATCATTCGACCGATGCCCGCCCACGGTATTTCAACGGCACTT
+ GTATGGCCTCTGCTTGGCGCCAGCGCGAGAATGCGGTCGCAATGTAGACGCGGCGCTTTTGTTGCCACTC
+ CGCTTAGTTTGTCACCTGCATCGCTTATTTTCAATATTGGGATGAGCCCCAATACAAACGCGGGCCGCTG
+ CGTCTTCGGCGTCTTTCCTTGGGAGTGTTTGCACGATTATCTCATATTCAAACTGGTCAACATGGGCATA
+ CGATTTCTTGCGCTCCTTGCTTTCAAACAGCATTTTCTACCTGCTGGGCACAAAATGAGGAAAAATTTTG
+ GGGACGCTCACGTGACCCTTTTGTTATTGGTAATTTCATCAGTCAGTCTATCAAACTTGCTCGAAAACGA
+ CACGGGCTGTTATCAGAGTGATAAGCCAAATTTCGTTCTGTAGCTCCTTGCTTTTGTTTTGCTTGTTTAT
+ CGATTAAAGCCAAAGCTGACGTTGGCGACTATCTGGCGTCGGGCTCGCGCGCACCATCAGCTGTTTAGTT
+ TTTTTAATGCAATTTAAATTAACGGCAAATAAACCAGTCTGAAAACGAGCTGAAAAGCAGCTTTTAGGTG
+ TTCACTAGATTTCTAGAGCCATTGTTTTAAAAGGCTATGCATTGCCACACACCACTAGAGTGCATTTATA
+ CTGACATATTTTTCCACCTTGTGTTTATTTGTGCTAAGCCAATTTGCTTAAAGATTTTCAGTTGTGCTTT
+ TCAGTGGGCGTGTACGCCGTGAGTGGCGGAATAATTTTGCCTCGCCAGCAGCTAATCAATACCGTCACAA
+ GAGGAGGGAGGCACGTGTTGCATAAATGCAAATGCAAACACAATGACGCACACAAGCACGCACAGAACAA
+ TGGGAGCTGAGAAGGAGCACAACGGCACGTTGTCAGCAGAACGCATTTGCAGTGAGGGGCGAAGACTTTG
+ GGGGCATTTGGTAAAACTAAATAATTGGAATTTCTTTTGTTGAAAAAAAAAATTCCGATGCGATGCCCCT
+ GCCTAAAGCTGTTATTACTGCTCTGGCCGCTTTAATTGCATGTAAAGATGAAGGCAATAATAACAAAGTC
+ TAGTTATGTATGTATTTAAAAATAGGAAGCGCACTCACACAAGTCGTAAACAGTTTCCCCAAGGCGTGTC
+ GCTCCGTTAAATTAATAAACATATTATTCATACTTTTGACATTGAATCCGATGCAGCTGGTGCACTAAAT
+ ATTGGCAAACTATGGTTGTGCAATCGGGAGCAGAGTCGACGCTTGTTTGAAGGTCAGTGTTCGTTTTTCG
+ GCAGGTTTGTGTGTAGTTGCCCTCAACCTAATGGGTTTCATAGTCAGCAACATTTCCTCCAACCACGTAC
+ ACATCGCAGCACCCACTGGTGCAGACGCCTCCCACGCACGAGAAATGAACACGCACGCAAATTCACGATG
+ AACGCAGCAGTTTTCGTTTTCATGCGCCCCATCTCTTTCTTGCCTACCCACTTTACCGGCGTCATTGTTG
+ TTGTTTTCCCTGTTCGATGACGACAACGGCGTCTATTTGACGCCATACGAATTTCAGTTTAGGCTTTTCA
+ CATTTCCTGCGCAGCTATGTATGTATTTCACCATCTTTGGCAACAACATATGCCACATTCTTGGGGTTCC
+ TTCATTTTCCGCTCGCTTACCTGTATTTCGAATTTTTAGATTCTTGCGATGGAAGATTTTAACAATGCGT
+ GCTCGTGCAGATAATCCTGATTTGAGCAAGGGATAAGGAGAGGCGGAGGGAGAGTCAACAGCAGCTGTTG
+ GTTTCCTGAGTTGCTTACACTTACCATGCAGTCGTGTACAGTTATGTAAGCTAGTTTTAGTCGGGAAAGC
+ TGAGAACTTCCAAAATACTGGTCTGCTAGTCGGATATATGTACTATATAAACATTTTCAAAGTACTCCAC
+ TTTCTCCACCTCTGTTTTTGACCATTGAACTTGTACGCGCAATCCTTGCCTCGAACCCGTTTGCTTCCAT
+ ATCGGGCAACGTTCGGATTTACCATCAAGTTTTTCATCTCCTCGACTCCATATTCTTTATTGGGGGTTGC
+ TGTCTGGTACTTTCTTAGCAGTCACCTATGTTCCAGCTCCACTGCGTTATTTTTAATTACACGTTTATTT
+ TTGGACAGCAGCTGGTTCTGCGCAGCCGCAGCTGCCTGAGGCCGGGGGTATTCAACTGAAATAGTCACTT
+ GCTTGGCTGCCTAGGGGGTTCTGTTTTGGCTCCGTAACGAGATATTGGATCGGAGAACTGGGACGTTCAA
+ CCCATGACTCGACTCCTGTCGGTAAAATCCTTTCCAGCTTACTATCAGGCTTATTCATAATATTCTGTCT
+ TACACCTTGCCTTATCTTTCTTTTTTATGTGGTTGCGACATCTGTCGTCGTCGGTAGAAGGTAAAGGGGT
+ TTGTGTGGTAAGGTGTCTCCTGCACGTGTCAAGGACATTTGGTGGGCTATTGGTCCGCCCGACGCTTTAG
+ GGCCAAAATTAAATAGCTTTTTTTATTGCACTCGCACACACTCGCTTTTCGTTGTTTCTCGTCGGTATAC
+ CGAAAAATCCTCCCAAAGGGTCAATACACTTTTGTTAGCCTGGAGCAAGAGAAGCATCACACAATAATAA
+ TAATAAAAAATTTGCAAGAGTACACATAATAAGCCAACTCGAAAACTCCGCACCCAGATTACTGTGAAAG
+ CTGCTAAATTAAAACGCGGCGTGGGAGTTTTACCATGTCGATCGGTGAGGTGCACTTAGGGAATGACGAG
+ AGTATTATGCTAACTGTAGGTGAGTTCTTTAAGAATGGCGAGTAGTAGCCCAGTCATAGAACACCAAAGC
+ AAGAGACAACCGTATTTGCAGGCTCTAAGCTCTCTGTCCCACTATCGAGTCCTCGTAGTCTATTTTTTTT
+ TTATACTTTCATCCACTTCTTTTTAAGGACTACAGAAGTTGAGCTTCCGCATTTTGGCGGGCGCTTTCCC
+ ATCCTCAAAGGTAAAAATCGTGTTCCGTCTTTTGAAAAGCCGGATTTTAGACGTTGTCTTCCAGTAGCAA
+ AAACAACGTGCAACCACGAGAAGGTTGCTCAATCTTTATTTTGATTTATTTATAGAATATGTATTCGTGT
+ CCTGCTCACGCGCGGCACTGCTTTATCGACGAGTTCACACTAGCTTTCTGGTCGGTGTAGTCAATCTGTG
+ TAGCTCTATCTCGCTCTGTCATTCTAAAACTCGTTGGATTGCATTCCTTGCAGCAACAAGTTGCAGTCTT
+ GGTATTTTCATTGTTCGCCTTGTTTTTGATTTCTGCATTTTATTTGTGACTTGATTAACCAGCCTATGAT
+ ACGATTTTTGTGCTATATGTATATTAGAGTTGTTGTGGCCAAAATAAGGCAGTTGAAAATTTGGCACTGT
+ GACCAAAAACCCAAAACAAGGAGGATGATGGTAAAATGTTAAAAAACAAGTACTTCTGATTTAGCGGGAT
+ AAACCGAGGTGGCAACTCTAAGACCTCAAGAGCAAGCTTCGGGCAAATATTTATGCTTAGACGGCGAATT
+ GGGACGTTTTTTTTTTTTACTGCTTTGCAGCTGTTTGTTGGGTTTTTACTTATGTGTTTACTTTCGGTGA
+ TGTTTGTGTTGTTGTTGCACATGCTACACGGCAGCGGAAAAGAGAAACGGAGAACGGCAGCAAGTTCAAG
+ GCTAAGATTATCAGGAGGTCAATAAACCTAACCAATCGGGAAAAAACACAGAATATCAGAGTAGAGCCGC
+ AAGTGAATTAATAATGTGACTTTTTTTAAATTAAGGTGAAGAAAAAGGCCAGGCATGCGAAAGCATCCAG
+ AAAAAAGAAGGTGAAATAGGTAATGTGTTTATTGCATAGGATCGGAATGATAATCATCGTTTTTTTGTTA
+ CATTTTGCTGCGCAACAAATTTTTGAAGGTCAATTCTGTTTTTACGCACCCATTTGTGCTGCTCTATCGC
+ TTGGGAAATTTAAAACGCGTAAAAAACATTTTCGTTCGGTTCTTTTTGATTTCTCGATTATTGATTGTTG
+ TTGCTACCGCTGTGCTGTGTTAATCTTTTAATTGCTGTATTTTGTTTTTCTTCTTTGTGTTTATTTTGTT
+ GCTACTCGACCGACGACTTATCGCCCCCGATGTTTTTTAGACAGGATTCCGATTCAATTTCGTATTCTAT
+ TGGATTTTTCCCTGTTCTGTTTGCCCTCTTTTGCCGCGAATAGTTGTTTTGATCTTGATAGAGGGACCTC
+ CAAAAAATAAATGCAAATTTATCTTGAACTTTATTTTTGGCAATAGACTTATAATAGTATGAAAAGTTGA
+ CAGATATGGTTGGGGCTAATTTATTATTTTTAGCATTATTTTCAACAGATTTGTGATTTTCCGTTGCGAT
+ TGTCAGCCAAAGGCTGGCTATTCGTGATTGGAAAATAAAATAAGGGCGGGCAGAAACAAAAGGGAAACTA
+ CTGATAAGCGGTCAAAACTCTCTCACAATCATTATAACCGTTAACCCCGCACGGGAGGGTGTGGGATGCA
+ AGTTTGAAACACCGTTTCATACGGCCCAACTGTGTAGTTCCTCTTGCGCCTTTGGATCTCTCACTCTCCG
+ TCTCTCCCACTAACTCTCCCTCTTTACTCTCTCTCCTTCCCTCTCTCTCTTTTCGCGAATTCCAGTTCAA
+ TAACCAGTTTTAAATTTATTTAGCTCTGAACGAGATGGAGTTCATAAGTTCTGTGCTTGCTGTGGTTTTC
+ TGGGGGACCGGAAAGCGGAAAAGGGGCGGAAGTCAAAAACAAGTTTCTCTAAGGGCGCTCGCTTTCATTT
+ GTCTCGCTGTTAATTAAACAATTTGATCTGAGTTCTGACATCAAAATTCCACTCTCGTCTCTTTATTGTT
+ TCACCGTCTTTCTTTCATAATAGAAGTCTGTCCGCACTAAAACCTTTCTATTTCAACAGGTCATAAAAGG
+ GTCGCAAGAAATTTCTGATTGGACCACAAAAATTTAGGGGGAAGTCCATCAGACTGAAAATTTGGTCGCA
+ TTTTGCCAAAAAAAAAAAAAAAAATGTGTGCTGCTAGCTGGTTTGTGTGCTGTTTTATTATTCTCACGCG
+ TTCACTTTGTGTGCTTATACCTACATATATAGCATTTTTAAATTCAATTATTTAATCACTTGCATTGGTA
+ TACGTATATCTATGCCTTTGCAGTTGCCAAGAGCTGTTTCCGCAAGCAAAATGTGGTTTGCCCGCAACTC
+ TGACTTACCGATAGTTGCCTGCACTAAGTAAAAATATTGTGGATACTAGGTTCTAGAAACATGAATTCTT
+ CAATTAAATATGTATGTAATTTCATCTACACTTGTAGATACCATATTAACTCCAATCTGACCCTATCGTT
+ TTCGATCTTCTCCTTGCAGTTAAAGTATGCGAGAAGCGGCTGATCCTGCGCGAACGGAAGCAGGACTACA
+ TCAAGCGTGAACGCGAGGTGATGCACCAGATGACCAACGTTCCCGGCTTCGTAAACCTGTCGTGCACCTT
+ CCAGGACCAGCGTTCTCTTTACTTTGTGATGACGTACGCGCGAAAGGGCGACATGTTGCCATACATCAAC
+ CGCGTGGGTAGCTTTGACGTGGCCTGCACGCGCCACTACGCTGCCGAGCTTCTGCTGGCCTGCGAGCACA
+ TGCACCGCCGTAATGTGGTGCACCGCGACCTCAAGCCCGAGAACATCCTGCTCGACGAGGACATGCACAC
+ GCTAATCGCCGACTTCGGTTCCGCCAAGGTGATGACAGCCCACGAAAGGGCTCTGGCCACGGAGCACTGT
+ TCGGAGCAGCGGCGCAGCAACTCCGATGAAGACGATGAAGACAGCGACCGCCTGGAAAACGAAGACGAAG
+ ACTTCTACGATCGCGATTCGGAGGAGTTGGACGACGGCGACGACGAACAGCAGCAGGAAGAGATGGACTC
+ CCCACGCCATCGTCAAAGGCGTTACAACCGTCACCGAAAGGCAAGCTTTGTGGGCACTGCCCAGTACGTT
+ TCACCGGAAGTGCTCCAAAATGGACCTATAACCCCGGCGGCGGACCTGTGGGCACTGGGATGTATAGTTT
+ ATCAGATGATCGCCGGCCTACCGCCATTCCGTGGCAGCAACGATTATGTCATTTTTAAAGAGATTCTTGA
+ CTGCGCCGTGGACTTCCCGCAAGGCTTTGATAAGGACGCCGAGGACCTGGTGCGCAAGCTGCTCCGTGTC
+ GATCCGCGAGACCGCCTGGGTGCTCAGGACGAGTTTGGATATTACGAATCCATTCGGGCGCACCCATTCT
+ TCGCCGGCATTGACTGGCAGACGCTCCGTCAACAAACCCCTCCCCCCATCTACCCATACTTACCGGGCGT
+ AAGTCAGGATGAGGACTTCAGGTCCAGCTATACTGTGCCCGGGGATTTGGAGCCTGGCCTTGACGAACGG
+ CAGATATCGCGACTGCTTAGTGCAGAATTAGGCGTTGGCAGCAGCGTGGCCATGCCCGTCAAGCGATCGA
+ CCGCAAAGAGTAAGTGTCCACGTGGTGCCCCAGAAAAATACGTTGGCTAATGAATGTATTGTTTTTCTTC
+ AGACTCTTTCGACCTGAACGATGCCGAGAAGCTGCAGCGTCTCGAGCAACAAAAGACTGACAAGTGGCAC
+ GTTTTTGCCGACGGCGAAGTGATCCTCAAGAAGGGGTTTGTCAACAAGCGCAAGGGTCTGTTTGCCCGCA
+ AGCGAATGCTCCTTCTGACCACGGGACCGCGACTCATCTATATCGATCCCGTGCAGATGATCAAAAAAGG
+ AGAAATTCCGTGGAGCCCAGATCTCCGAGCGGAGTACAAAAACTTCAAAATTTTTTTTGTCCATACGGTA
+ AGTGTTTACCTATGGTGGGATAAGGATGCACGAGGCGCAACTCGGAAAACCGAGAAAGCATAAGTTTGTT
+ GAACCGATGACATCACAGCTTATAGTTCGTAGCCAGTCACACGCCTACTGAAAAGCAATTTGAGCGTTAG
+ TTTATGTCCCGGGCACGTGTTGGCTATGAAAGCAAATTAAATGCGGCATTGAAAACTGCACACGCAAGGC
+ AGATAAAAACTCAAACTTGTTTGGTGAATGGGTTTAAAATTAGCGTTGCGCTCAACTAATTTTACTCTTT
+ TGGTTTCATTGCAGCCAAATCGAACCTATTACCTGGATGATCCCGAAGGCTATGCTATCCACTGGTCGGA
+ AGCTATTGAGAACATGCGCAAGTTGGCCTACGGAGATCCCTCCTCCACATCTGCAGTGTCCTGCTCCAGC
+ GGCAGCAGTAATAGCCTGGCTGTCATCTCAAATTCATCCGCCGCCTCCTCAAGCAATTCGCCCACGGTGA
+ AACGCAGTTCCCCCGTAAACGCTCCTCAAGCTTCGACGGCGTCTGACAACCGGACATTGGGTAGCACCAG
+ AACGGGGACGTCACCTAGCAAGAAGACGGCGTCTAAGTAAACGTAGTCCTATTTATAGCAATGTGAAATT
+ AATTTAGTTGAAATTTAGTGCAAACGAAGCGATGGCGTAGAAGAGGGCGGGAATAGAAGTAAGCTTAGAA
+ GTAGAAGTAAGTGATGAAGGGGAAATAATGATCGTGTCTCTAGTGCTAATTAGAACCAAATTTCTGTTTT
+ CCGATTTGTATTGTGCTTAGGGCGAAAATATAACACTAGAATAAACTTATCTAAAGTAAAATACATCTAT
+ AACGACTAAGTAAATTCAATTTAAAATTTAAATTAAATATTTATATACAGCATACATAAATACAAATATA
+ TTCGTATTTAGCGCGTAGTTAGTCGCAATTGAAATGAATTACACACGGAGGCAAGGTGGCATTGTAGGCT
+ TAAATTAAAAGTAATTTCGTGAAGCAAACTAAAATCCGTATTTAAATGGTATAATACTAGGAAATTATCT
+ GGAAACTGTAATATACATAATATGTGTATGTACGTCGGAGAAATAATTTTTGTTTCTGTTATCGTGGGAA
+ GATCACATATATGTTAATATAAATTTTGTAAACAGTGTAACTATGTACAGAACTATGTGAGCTATATGCA
+ CACGGCAAAAAGACCCTAAGTCGTGGGGAAGGAGATGGGAATGAGCCGGAAAACCATCGATGTCACAAAA
+ TCGGTGTTTTTCCAGCTTCACGCTCAACTGTTTAGGTAATTCTAATATACAGTTTAACGCTAATTATCAT
+ TATTTATCATTCTCATTATGCTTTTCGTTTACCTATTTGCCCTATAATGAAATGTATAAGACTTGAGCTA
+ CCCTAATAAAAGAACGAATTTTAAATTATATTTTTATTTTGTAAGGGCTACCACTAAAAACTCAACAGTC
+ GTTCAAAGATTGTCAAGATTGGCGGTCGTTGTCTCTCCAACTGACTCCAATTGAATGTGTGTAAAACAAG
+ TCTTATACAAAGATATATGTAATAGATGTAAGACAGACTGCAAAGTTTCTTGAAACAAATTAGTTAAATG
+ TTGTAAATGTCTAAGTTGCTACCACTGCTACTACTAGAACGCGCCCATCCCCTCCCATATTTACCTTTAA
+ GCTACAGTAATTAAGTGATGAGCAGAGGTGTAGAGTAAGGAGTCGAAGTTGAAAGAAAGCAAAAAATACA
+ TTTTGTACATACATATCGCCGTTGGTCGATATACATCTAAACATAATTTAATTTTTTGTTACTTTTAAGT
+ AAATTATTTTTGGCGACCTAAGTAAATTAAAATTAACGCAATATGCAACAACACACATAAGTATACAATT
+ AATTAAATTAAACGAAAATTACGATTTATTAAACGATGTCATAGAACGGAGAGCCACTGATAGTGAGAGA
+ AATCTGTAAAATAAATATTTAAACAAATTATATATTATCTATATATGAGTACCAGAACAAGAATGTCAAA
+ AAAGAGAAGCATGTAAAAATAAAAAATATATTACGAGTAAAACAAAAAAAGATAATCGAGCGAAAGGAAC
+ GTATCATTAACAGGAAAAATTAAAGAAAAATACAAAAACATTTCAAAGTAACAAAATTACGATAAAATTT
+ GTTTTTATTTTGGTTCGTTTGGTTATTACAATTGGCAATATCTAACTGATTGGGTAATAAGTGCGCGTAT
+ CCCAGTATCCAACGTTGCAAAATGATACAACATTTCAATAGGTTTCAAAATCTACGTAAGATACACATAA
+ AACGACCTGACTACTTTGTTCTACCCTACGCTTGTGCTGCAGTACCTAAAATCGAAGAAAGAGTACAGTG
+ AACAGGGCTAAGATATAGAAAGACAGCTCTATTTCTGCAATCCAAAAAGGGCTTGCCCTAATTAAAATAA
+ TTGCAAATGCATTGCGCTTCAAATCCAGAAGCCTTTTTTACCTTTTATAGCCTACAGGAAAAAAGAAAAA
+ AGAGGAGATAACGGAAAGACCCATAAAATCGAAAAGTGCATAGGTAAACCTGTAGGACGATTAGTGGAAT
+ ACTAAAATCATCATATGTTTTAATCAATAAGTATTCCAATTTTACCAGGGGCAAGTGTATGCGAATTCTT
+ TCAGTACGAGTATTTAATATATTTATTTTTATCATAATTGTATAAAAACCTGAAGCTCCAAAATAACTTG
+ ATCATTTTGAGAAAAATATTAATAAAAATTATTTTTTTGTTTATTTTCTTATTATTTAGTTACATATAAT
+ TTTATTTTATGTTTATGTTTTTATAATTTTTATTTTATTATTCATTATATTATAATAAATAGATTCGTTG
+ AATAGTATTAATATTGGATTTGAATGCAGCGATGCGTTTTACGCATTTCAAATCCGAAACTCGCTTAGAT
+ CACACGACGTAACTTTATAAGATATATAAATCAAAAATAACTGTTATTTTGAAAGAGAAAAAATGATGTT
+ GTTTGAAATAAAGGAACAAAAAAGCGAAAAACAGAAAAAGCAATCGGTTAAGTTTTAAATTCTTTTTGGG
+ CGCCAAAAATGAATCGGATAAGCCAAAAACAACAAACAATAGGCTTTTCGATTTTAAGAAGGGTCACATT
+ TCCGATAACAATGAAAACTCACATTTAAATTGGTCACACTAAGTGGGGCGCCAAGAGAAAATATCGATAT
+ CGATTCCGACTGTTGTGTTAGACTTTACAAATAAATTACAAAGAAATCGATCAAAATAAAATCATGGAAG
+ AAAGTCAGCCAAGGTATGGCGCTATGTGGACATTCAAGCTGGTGGCACCATACGTAATTGGCGGCTACCT
+ ATGCGGCCTCGCGGTAACGCTCGCATGGAACTGGTGGCAGCTGGGCCACTTGGTTCTGGGTCTTAATCTC
+ ACCTTCGCGATTCCGGTGGCGCTTGTTCTGGCGGTCTTTTACAGCAGGCCCGTAAGGTAAGAACTACCTG
+ AAAAAGCCCAAAACGATTTGTGTCTAACAGTGTTCCCTCACTGGCTGCCAGGTGCATTGTGACTTTGGCC
+ CTTCCCTCGCTGTGCAGCTCTCGGGGAAGGGCGTTCCTCATCAGCCTTGCCTTTGTTATTGCCGCAGTTG
+ GGCCTACGGCGAACATTCTAGCCAATTTGAAGGTGATGCTCCGCAGCCTCGCTTGCGGACAGGAGCTATT
+ GCGTCAGGCGCTTGGCCAGATGTTGGACGTAATACTGGAGCCGGTGAATGCCATCCAGCTAGCGGTGGAT
+ CTCTTGATGCGGGAAGTGCGTCGGGTGCTCAAGCTGGCCATGGTAGTGCTGTTACGCATTCAGGACCAAT
+ TGATCGCAATTAGTGAGTATCTGTATTAAAAAGTGCTGCAGTTTTCTCTGCTGATTCATTTTTGTAGTTA
+ AAACCCTGAAGAACTGCGCCGCTTGGCTGAAATCCATCGTAGACCTGTGCAACACAGAAATGGGCACTCC
+ CTGGGCACGTTGCAAAAAGACGGCGCATCACGCAATGATCAGGTGCCAGTCAAAGATGGGCGTATTCAAG
+ GCGCTATGCCATGCTGCAAAGCTGTTTCTGGCCCTCTGCTATCCAGCCAAGATCATCGATGTGTTTTGCA
+ GCGGTTACTGGGATCTCAGCTGGGGTCTTCTTGATAAAATCGCAGAACGTGAGAGTGTAAACAACGATCG
+ GTACTTTGGTTATTAGTTATACGATCTCGCAGGCTACCGTGAATTTGTGCGGCACATCGAGGAAATGTTT
+ GATGCCAATATCACTTTTGAGCACGAATTTTTCTTCGATACAAACTCTTCAAAGAGCCTGACGGACGTGG
+ GGGAGGAAATTTTACAGGATATTAACAAGCGTCTGTCGTCGTTTATCTTCTTGAGCAGCTTTGTGGACAT
+ TCTCTGCTGGGTCATGGTGGTTACTGTATTTTTTAAGTAGGCAAGAGCTTAATCATCTTATTAATTTAGT
+ GTTGGTGATGCCTCAATTGTTCCCATCAGAGCCACCATCTTCTACCTTCGATATATGCACAGCCGGCAAT
+ TTCAGAATGTGTTCTTGACAAAGATACTAAGTGATATCGACCGGCGGCACGAAAAGCACGGTTACGATCC
+ ACTGCTACCCCTTCATCAGCTTGAAAGGGCAAAGTATATGAAGGTAAGGTTTCCCTACGTTTCCCTGACA
+ TAATATTACAATGATTTCATTGCAGCTTACTAGCTTGCGTTTGACTTTGTTTGAGTTCGTGTCCATTGTT
+ GAGAACGCCTGTTTCATGGCCACAACCTGCTTGCAGTTGTTTGCGATTTGCTTTCTGGATTACGGGCTGT
+ TCTGGCTGTTGGCAACTATATCCCTCCATGGCCACCAAGAGACTGGGCTGGAGGTGCCCGCTTACGTCGA
+ TCTAGAGATTAAGGGTGGGGGCTTTGTGGCGGATGTCATGCGGGGAATCGCTAATGCCTTTCGACCCTTG
+ ACGCAAAAAAGCATTTTAGACGTGAATCCTTGCCTCCCGCTGCCCGTGAAACCTGATTATGCGGAGTATC
+ TAATTATATTATTACTCTGTCTGCTCGCTTGGCTGATCCTTTTGGCCGAGCCGTATATTTTGCGTACTCG
+ CCATCTTATAATGGCCCACTTTTATCCAAAACGCGCCAAGGAAAGAGGCATGTTTCTGTACAACATGATT
+ TCCGAAGATAGAAGTAAGAAAGTACATACCTTTTAAAGTTGTTCTAATGTATTCTCTCCAGCAAGCATTT
+ TTAAGTTTATCCGCCGCAGAAAGCGTAATGAGTTTAACCACACACGGAATGTGAAGCACACCAGAAACTA
+ CACTTGGCTGAACAATAGATTCTCCTGTTTAATGTGCATGTGCTCCTGCTGCTCATCCTGTCAAAGCACT
+ GAGAGGTGCACCATATGTGGCCGATCTCTGACTCTGTAAGTAACTCCAATCGTTAAACACACTCCGGGTT
+ ACAGTTGGATGTCCCCTTTTTAGTTCAAATCGTAACCCCTGCGACACTCCTGGATGCAAAGGGGTTTATT
+ GCGGTAAATGCTTTGAAAAGTCACACAATAAGTGTTGTCTGTGCAATCGACCAGTGGATTATGGTGATTT
+ TTCCGACGTTACTGAAGTAGAGTGAGTAAAAACCAGGGTTTAATCGACTATTCTTAATGGTTTTGTTTGT
+ GCAGCGACTCTTCGGACTATTCTGAAAAAGAGTCTTTTAGCGAAAGGCAGTACAGGAAGACCTGTGGAGG
+ ACAACGCTAGCAACGAGGGAAAAACAGTTAAACATAGAGGTTGTGAGCGCATACACGTTATGCAGATAGC
+ TCAGAAATATAATATTTCCACCTATTAAATACCTGATATTCCAACAATTTAATATATGGTTATAGGTGAG
+ TTATTCAATAAAAATAACTCTTGTTATTGCTGATCTGATGTCAGTGCAATTCCTACCCTTCACCGCCCAT
+ GGAAGTCGCAATACGGGGACTGCGTTGTTTGGCGAGCTTCTGGGCTGAAATTATTATTTAATTAAATACT
+ ACAGCGACAAATGGCTACACAGCAATTCAGAAAATAACCTTGTTCTCACCCCTGTTTTCGATTTTTTCTT
+ TTTTATCAAAGGCTTGTTTGCTTGATACCTATTTTTATTTCTTCTTGGGCTATGACTGTAACGTGCTGTT
+ GAACATCTTCTCATTATTGTTGACTTTCTCTTTACGACTGTTTAATAAATTCTGCTCTTCCCCCACATGC
+ GGCTTCCATTTACCAAGCTTATACGAGCATTTATTATATAACACCCGTCGACTTGCACCGATCCCTCTAG
+ ACCCTATATCGACCCCTATCCACTTGACCACCATCGTTGACAGTCAACCACACACACTCGAAAAACAATG
+ GAGCTCATCTTTTCGAACGGATTTTTGTGCTTGTGCAAGGTAATGCCCGGTCCGTTCGGATGATATCAAG
+ TTACTATTGGGTAGTTTTGTTTGACACTCGATCGATCGCCGTTGTGTCTCTTAGATAGCTGATGCGTGAA
+ CATTTCATCAGTGCCATCCAGATTCGCTTTCAGGCCGACGAATTATTTTGTTTTATTGAGAATACCATTT
+ TTCCTATCTAAAAAACTGCTTTTTTGTTTGGGTACCCAAAGAAACCAATGCTTTTAAGCTCCATAAGAAG
+ CTCGTGGTCGTTGCCAATTGCCTTGAAAATGGCTTTCTCTAACTCGTCGTATTGGAAGTGTGGCGAAAAG
+ GGCATGTCGTTCAGGGCGTTGAAGAGCGTGTTCCCGCGCTCGTTGCCAATAACCAATGTGCGACCACAGT
+ GGGAAAACCTAAGAATTGGTAAAGGAAATTCCTATTCAATTGGCCATTTTTGCGGAAAGCAATAAAAGCT
+ TACCTGGCCACAGTATTAAAAGAAGAGTCCATCTTGTGCTTGGACATGGGTCTTAGCAAATTTCGGCGAA
+ AGTCCCAGACGTTAGCGGTTTCCCGGTTCACCGTCACAATAATCGTAGAGTGGGTGGGGCTCCACTTGGC
+ CCAATGCACTGGGGTCATCTCGTCTAGCAGTTCGAGAAGAGGTCGCGTGATGCCATCGACCCAAATGCGT
+ ACGAACCTGCAGAATAGATACTATCTTTAGCTACCCTTGATAGAGGGCCACTTCCTACCAATCGTTGCCG
+ CAGGTGAGGAAGAGTTTGGGAGACCAAGGCGAGAACTCCATTACGGTGACACCCCCGTCGTGACAACGCA
+ GGACTTCCAAGTACTGATGCTGATAATTGATTGAGCACTTGTGGATGCAGCCCTCATCTGTCAGCACGTA
+ GTAAATGTCCTTGTGCAGAGGATGTGTAGTGATGCTTAAGCCTTGCGGGTGGCGGTTAGACTCGCAGGGG
+ ATACGCGACGATGGGTGAACGAAAATGCCCTCAGGATGCCCCTCGACTCGCTCCAGAATCATTTGGGTAA
+ AACCAAGCAGGAAGGGACTTTTGATAATCCGGAAGCGGGTGACCGAGCCATCCTGGGAGAGGCTCAGGAA
+ TGGATCGATGTCTGTTTCATGATCGTCGTCTGAAACTTGTTTGATCCAGCGGATGGCAACCACCGGCGAG
+ GAGCCTGGCGAAGTGCTGCGCTGCGAGACCGCAACGGGTGTGTCCTGCAAACTGCTCACATCTCGCACTT
+ CCACGCTGCCGTCGTACAGACCAATGGCGAGCAAGGATGGCAAGAATGGCGAGAAGTTTATTGCCGTTAC
+ TGGCACATCGTAGTAGTATGCGCGCTCCGGCTCGCCTGGATTTTTAATGCTCCACAGGAAAACGCTGCCG
+ GAGGTCGGTACGTGCTGTGAGGAAAATGAGTACAGTCCGTAGGCTACAGCCAGGATGTCACCATTGCTGC
+ GGCAGAAATCAATGTCGCTTACGGCCTTGCGCTCGTCTTTGCTGGGCTCCGGTACCAGCCGAAAGAGCAA
+ GTTCATCGAGTAGACGTACTCGGCCTCCGCGTTCCAGCGTTCCACCTGGTCAAAGTTACGGAAGCGTCGT
+ AACCCCGCCTCGTTTGTGTTGCTCGAGAGCGTGCGGCCCATGTACATGATGGCGTTGCGAAACTCGGGGC
+ TCCGGAACAGGCGCTCTATCTGGCTGCTGACCTTGTCTTTTTCGGCAACGGCCTCGTCGTCCTCAAAGGT
+ ATCCGCATCCTCCGTCTGCGCTAGAGCCGAGGTCAGGTCCTTTACCGAACTCATAGTGGCTGTTGCGAAC
+ TCCTTGGTGATATTGTTCAGCGTGTCGTACATCTCAAAGTTGGAAACGTAAGAGCTGACGGTGGCCTTGG
+ TTATGAGGATGGTGTTGACTGCCCGAGTGGTGAAGAGCAGAGTATCTGTCTGAGCGTCATTGTCTGAGCG
+ CCGGCGAATTTTGCCTTTCCCTATTGTCAGATACTCGTAGTTTCGGTTGTCTCGCTCCGCATCGTCGCCC
+ TCGGGCGATCCCTTGGCCACCGTCGTCTGCGTCTGGCTGTGAATTTCGAAGAAGTCAGACTTGCGTAAGG
+ TGATCTTTAAAAAGGACTTGGTATACGGCTTTGGCTCGTACGCCTCTTCGAGAGCCTCAACAGTGCTGTA
+ CGGTTCCCAGTTAATAGTTTCATAAAGTATCTAGTGGAGAATGACGATTCCCGCTGGGATGATACAAAAA
+ AGTTTATATAAACTTACCCCGTTCATCAGGTCGTCAATGGACTGCTTATTGCCGCCTATTCCGGCCCGAA
+ CACTAGACCGCGTGCGGGATCTGGTCGTGCTCTTCGCTACCATTGTAGTGAAGTTAGTCATTTGGTGCAT
+ GACATTTAGGTTGTACTTCATGAACTGCTCCACATAGGTGTCATCTTGGATCGACTTAGGTGTCATATCA
+ ACCTCCTCGCCATAGATCTTTTCCAAAACCTAAGGGGAGTTTGCAATTAGTGGTGGTGAGTTTGTAAGTC
+ CTTTGGGTTCACCTTTATCTGAGATCGATACTGCAGGTCGGCAAGTGTTTCCACACTGTAATAGTGCGTA
+ GTATCTTTCTTCTTAGCCTTAGACTCTTCGGCTTGTGTCTGATTAACCACCACGGACTTCTTTTTGAGTT
+ CGTTGTCTAAGTTACTGGACCGCTTTTTGACGCGTGGGGAACGGTGTTCTATGTAAGAAGTGCAAATTAG
+ ATCTTCCAGTAATTACTTACTTTAAAGATACTCCCATTTTCTTGGCTAGTGACTGTATTTCTTACTGACG
+ CGGACATGACTTGTATTTTGTTATGTACTCCTCTTGATTTCGTCCAAATTTTTAATGAGTATTTTGTTAT
+ TTTATTATTTTGAGGGCACTGGTTTCTGGTAATACATATGTTTTAACTGCTGATATAACTTTTTTTTACC
+ AAACATTAGTTTCATAGTGTACTTATCTTTCTTTAAAGATTTAAAATGTAATCAAAAACTGAAATGCTTG
+ GAAATCAATTTAAAAAATTAATATTGTGTAATATTAAATTTGAAGTTTAAAAACTCCGAATACCACGAAT
+ TTTTACCGTACGGTAACGAAAGGGCTTTGTGCTACTTAACAGGAGCACTCTCTTACTCTCCGTTTCCGTG
+ AGCGTTTTTTACCGAGCTCCCCCTGCGCCTGCTCGTTAGATAATACCGAAATAAAGTTGTCAACCAAGCC
+ ACCCTCTGTGGGCGAAGGACGACCGGCTGCCTTTTGAGGTTGCATATGGTTGAGTTAGTTAGATTCGGAG
+ TCGCCAGCCATGCAAACCTGGTTCACACTCGCGTCCGTAATCGTGCTTTTGTTTGGGATGTATTCCAATG
+ TGTAGAGATTCGATTTCTCAATGTAGGTCTGCTTATTTTTTGGTACGCTCCTGATATGAAAAAAACTTGC
+ GGCAGCATCAAAATCTAAAAGGCATCTAACCTAACAAGAGCTAACAATTAATGGAGTGTCAAAGTGAAAA
+ CCGAGTACCAGAAAACTCAATTAGTAATGTTGCAACGTACCATACTCTGCCCGAATCCCAAACCTCATCG
+ GTTTTGGCCAAGCATCAGCAGCGACAGCTGAAAGAACCGCAACAGCCGCCGCAGTACGTTATAAATTCAG
+ TGGCAATGCACGCCAAGACGACCACGGCGAACTCCATCACGGGCGGCACACTGCATCGGGCAAAAAGTGC
+ GCAGGTACGTCCAGAATGTTATAAATTAAATGGATAGTATCCGAGGAAGTGGATCGAAGTAAAGCGATGT
+ GATCGCGATGCTTATTGGAGGTAAACCTATTTGACAGGAATTGATATTGACTGCCAACTAGGTGCGCTTA
+ ATCGGTGGGGAAACTGGATTTATATATTTGTCCATGGATAATTCAAATCATTCATATTGTTTTTCGGTAT
+ CTCAAATCGTTCCGTTAAAAACTTTTGTGCTCTGTACAGGTGTAACAAACTCTTACTATTTTTTACATTT
+ ACTACATTTCGGCAAGTAAAATCTGTTACAGCCAAATTCATCGAACGACCCTCTTCCACACGCCATTGCC
+ TGGTTCGACGCGAGTGCAAAAACGAATTTTACTCAGCGAAGCTACACAGATACATACAGATTATGGATAC
+ GCAGGGTGCGTAACGTAAACTAACGCTGTAATACTGTTTCTGCCGGCTAACCAAGCTGGGACGGCTAAGT
+ GGCTAAATGGCTACAGGACCATCGGGCCTAAATGCAGCTTCATGGAGGCCGCATGCGTGCAGAGAGAATC
+ GGGCGATGTGCCCATGTTATGTAAACATATTCGGCAGGAAGATAGGGCAGGGTGGACCTCGAGTCGTGAC
+ GAAGCAAAAGTCAGGGATCTGGCTAAGGCTGCTGGCTGACTGATTCCCGTGGAGAGTAAGGGTCGTCAGG
+ TGGTGGTGGCTTCTGTGCGTCGCGTCATTCATCAGACGCTCCATGATGTGAAACAAATTCGCCTGGGGAG
+ GCATTGGATGCTTAAGTGAGGTGCTAAAGTTAAGCTGCCAACTTCAATGATGTGGTACTTGACCAGCTAC
+ CGATTCAGAAATGTATCTTTTGATTTCGCTGTCAGTTCTACCCTTGTATATATGTATGTATGTATGCTTT
+ CAATTTTATTTGCTCGCGAAAGTTGCTATACGATTTTTCAATGCCAATATGAGAACTGCTATCGACCTTG
+ CCGGGGGTATGAACTTTCCGCAATTAAACCTCACCGGGGTGGTTGTTCTCTGTTCTTTTTCCCGCCACCG
+ AACCACGCTTCGTTCTTTTCCTTAAGCAACATGTTTGGTTACTGAGAGCACTTTTTGCTGAATTTTTCCG
+ AGTGCCGTGCTCCAAGAGCAAGTTGCTCGGAAACATCTGGAGGGTTTAATCAATCTTTGGTGTCCTGACG
+ AGCCGCGAACAATGTTTTGTCAAGTACAAAGGAAGGGAAGATTCTTCTGATCTGATCTGTCATGATAATG
+ GGATGCATTGAAAATGGCCCCAAAAAAAAACTGTTAAAGCAGAAGTTCGTAATTCTAAATCATTTTATGA
+ CGATATTGATATATATTAATATATATTTAAATTGCAAAAAGCCCCTAATCAACGTTTTGATGTCTTTTAT
+ CTGGCTACTGTGGCTGCCTGTACACAATTTAAAATTTTTGCTGGCACATTTTATTATTACAAATGGCACT
+ TTGGAGAATTGTGTACCACGGATTTTGTAAGCGGCGCTCTAATGATTTATGAATTTATTCAATGACAATT
+ GGCAAGTTGAGCCAAAGTGCTTTTAGCTGGTGAAGCGGACCGGTCATTGAGCCTCGGAACCACTTCATTC
+ GTGGCTGGGAATTGAAATGCACAGAGGAAGAGTTTGAGTTCGCAGTAGTTCACAGTTAGTTCACTGGTGG
+ CCGTCATAGGCGCCAACATATTTTGTTCTTGCATTTAAATTATGAGCTCTGCCATTATGCATCAATCGTT
+ AATCCAGCGGCGGTTAAAAGCAGCACAAAAAGAAAAGACAGTATCTATAACCAACACAGAATAAACAACA
+ ATAAAGAAAGTGGAAAGCCGGGAAAAACGTGCGCTGAAAAGTGAAGAATTTAAGTGTACGTGTTGAAAAT
+ TCCTCAATTTGTTGTCTGAGAATGAGTATAATTATTTGTGTGTTTCCAGCGGTGGCTTTATTCACCGCGT
+ TCTTTTCCCTGCTAAGACATATTCTTTGGTAACGTGACGGTAGCGAAACTATCTGTTATATGCACACAAA
+ AATAACATTGTGCATCCTCAGTTTTAAGAACTACGTTTTCATGCGAAAATGGTTTTTGATTAAATAACTC
+ CTTAAGTTTTATAGGACTTAAATTGGCAAGTCCAAGAAAAATCATGAAATCACACGCGGTTTCAAAAATC
+ ACTTAACCCTGTTGACGTAAATATTTTTCCAGTCCCAGCACTGGATATATCTTCTTTTGCAACATTCGTG
+ CTGCACATGGCAAATATGTATATGATTATTGGTGTCTCGAAGAGATATATCCACTCATTCTAGTCGCCCG
+ GTTTCCCACTCCTCTGAACTTAAAATAATTTATGCAGTTTGGGGACAGCTTTTCCTGGGCAGACTAAAGC
+ GTTGCGGCATTCAATAAATTGCTCTTAAATTATGGAAATGCAGAGCAGCCGAGATTTATTGAGAAGTTTC
+ TAGAGGTGGGGAAAATGTGTATTTTTGGATAGGCTGTATATACGTATTGAGTAAATTCCGATAAACTTAA
+ TGTGTATGTCTTAAACCGAAAGCATCGTCATTTTGAGATTATCATCGATCTATGAATACTATGAATTTTT
+ CACATCCCAAATTCTGCCTTTATTGCTGACCCATTAATCCAAATATATCAGATGGCGTCGTTTATATCTC
+ ATTGCAGATCAATTGGGCTATTTGGTCGGAATCTTTTTGGTTTCGGGGTCGCCCACGTTTGGCCCCGTAT
+ TTCAATTTGACGTTTCTTCAGGTTTGGTAACTGCATTGTCTTAGATCACGCTTTGACCTTATAAACTGGA
+ GGAGCAGGGGTCGCTGGAGAGAGATGATGGACAAAGAGAACACACCAAATATGTTAGATTCATAAATTTT
+ CCAAAAACCTAAACACAATGTTTTGAATTAAGCAACGCTGGGAAGTAGACTGCGGAAATAATTCGTAAAT
+ TTATCAGACTAATTTGGTCTCGACATATTGAACTTAGCAGCTCGGGCGCTAAGACTTTTCGAGTGTTCTG
+ GTGAAGTGGGGTAAACCGTTCTCAAATCATTTTCATTCAATTATGCTCAAAAACTTGATTAGCCTTCAAA
+ GCTAAGGAATTAAATTTTAATCTTTTGTGCAACAATTCTATAACATAGGTCAAATGTATGATAAATTCTT
+ TTAGAATGCATCAGTGAGATATCTGAGAACTTCCATATTTGATTCTCTTCTCATCTGATGACCTATGTGC
+ ACATGTGTATTTTCGTAAATATATAGTTAATAAATGCCCTAACAACATTTATTGATATATTCTTCGAAAA
+ AATCGCAACACCAACAATCGCAACGCAACTATCGTTGTCAGGCAACGAATGGGGAGTTGAGTACAAGTAT
+ CCAGTGTTGAGGTAACCGAAATAAAATTTAATCTTATCTAATCTTATCGCTTTTAGACGTATTTTGCTGG
+ CTTTCCCCTCCTTCCTACCTCCTTGCCCAGATATTTGCAAATAAAATGTCAACATGCCGAGCACACTCGA
+ TAAGATAAAGCCATCAAGCTATTCCTCCTGCAGTCTTTGTTTTTAGCTGTTTTTCCGTGGAATTATTCGC
+ AGAAAATTGTGCAATCCGCTAAATTTAGATTGTCGGATTGTTTACTAAGAGCCAAGTAGTACCGAAATCA
+ GAAATGAATTTCCCGAAAATATCTACGAGGAGCATGCTAATGGATAATAGCGCCAATAGCATGGGATGAT
+ GCCCTGTTGATTGATTTATTTACACGCTGATGATGCTGCCCCATCATCGACCTAGCAAGACAAGAGTTCT
+ TTTTCTGTGACTGACAAATAAGTCGTTAGCTTACGAAACCAGAAACTGGCAACAACCATTGGCCCCAGTG
+ TGGCTCAGTAATTCGATTTTCACCGGACTGATAAGGCGAAAAGAGGGGGACCTTCACCCCGACATACCTT
+ ATTCCAGAACTTCCGCCATCTACTTTGACGTCAATGCTTGGTATTGTACTTTCAATTGTACCATCAATTT
+ GATTTCCAAATCAACTGTGCTGCTTTTCGAGTTGCGTTCGTTACCAATGCTAAATATTGCAAATGCTTGA
+ TCAAAATCATTGATCAATACGTAAGGTGCATGGAATTTAAACTATTTTCTCATAGGTTGGATAAATAAAA
+ CAATTACAATTAGTGCTCTTAGCTCTTTTTTCTTCGAAAGCTTTGTTATTTATCTGTAAACGTTCTACCT
+ CGTCGTTAGCTTGGTTAAATCGCAGACCAAACATTATCTCCGCTTACCGTTTTAATTACCATTTTATAGC
+ AACGCATTCTTTTGGCTTATGACAAAGCCGAAAATTTTCTTTTTTGTTTAACAAGATTTCGCAGTCATGA
+ AAATGAGACAGTGTGTATCGAATGGAAACCGGAGAGATAAGTCTATGTATATCTTCCTTCGGTTTGTTAT
+ TCTTGCGACTGGGCAGGCAAAGTATCTGTCTGCCTAAGCTTTCTGAGAATCACTACACTGGGTAACCCGA
+ AATGAATCCCCAGTAAACACTCTTACATGCAAGCCATAAAATCATTCTTTCTCTTGTTTATTTCGCAAAG
+ TGAATCGGAATTGGGTTAGCATTAAGTGCCACATCAGCGGAAAGTACAAACGGAGGAAGTCAGCATAAGG
+ TTGCAATGTGTGTGCGCTTCATCCACTTGGCCCCTGGCCATCAATGAGTGTTTATGAGACCTCCTCACAC
+ TGCCTTCATCCCGAAGTAAATGACAGACGGCACGGATTTTATTACATGCCGAGTTAGGTTCTTGCGGTAA
+ TTGTGTTGGGCATTCTTGGGACCAACTACTCCGCAGGAGGTTTCATTCCGCACTTCGAGATCCTCGCGTA
+ AGAACCAAATGATTCGGCTACTGTTACGCAAATTCATTATACAATATTATGGAATCGAAAGTTCATTTTA
+ GTGTTATGCCGCTCACCCACCAATCGGAATTTTTGAGAAAAAGCTGAAAACATGGCATTTTGAGCTAAGC
+ ACTTCAAGTGACAAACATGGATACATGTACACTTGGCCACTTCCCCTCTTCACTTGATTCTGGCTTACAT
+ TATTTGATTGGGCGTATTTGTATCTCACGGATGCCATGTGTGCAGCAATTATTGCGATTCTTTTTGTGCC
+ GATGCTGGCCCTGAAATGACTTTTGTATATGTTAGGTAGACATATGTATATCCTGTCATATGAAATTTTG
+ TATATTATTTATATTTCAATTTACTTTTAATAAAAATGGGTACTAATAACAGGTAGAAGAAAGACTACAA
+ ATTTGGTGTTTCGTTCAACATCATTTACTGAGCCGATCACGACATGTCCGTCTGCCGGTGGTGTGCCGCC
+ TGTTTGTCAGTATAAATGTAAAGATCATTTGTCTTGCCAATTGCTCACTTTAATGCTCACTAAAGAAGTA
+ AAACTTAAATATATATTTTTTTTAGAAACCCAACGAAGTTTCCACTCGAGGCGCCTCTCACCAACAAAGC
+ CGCTCTGCATGTCACATTAAAAATCCACATTTAGCTTTTGAACCTGACTCTTTTAGCTTAGGCAATATCA
+ AGGGTCCAAGAAGGCGGAGGAGGCCATAATTCATGCTGCCCATATATGATTTGAGCTCCCTTTGTTTTCT
+ TCTTCTGCTTCTCAATTTTGAGTGTAATGTAAAGAACGGAACAATGTGGGTGTATCTTGCAACCGGCTTC
+ CATTGGGACCCGTCTGCTCATGAATAATGGAAACACTTGTATAACAGAGGCCTAGGAAAGACTGACCATT
+ GACAGCTGTAAATCTGTATTAAACTATTAAAACTAGCTCACTCTATTCACAGGGTTTAGTTACCATGAAG
+ CTATACCTTCTATATTCCTCTCTTTCGCCCACTTCGGATCAAACATGTCCACAAACTCTGCCCCCTCATC
+ CGCTGACAGTGAACAAAAAACCACCAATAGTTGACGAATTTATGACATGAAGTGCCACAAGTCGCTGAAT
+ GACTTTTACCGAATTATGGCGTTCATCCAGTTACTGGCGCTTGCTATTCTAATTGGATGTCGCAGGGATG
+ GCTTAAAATGGCAAGGAATTTCGGAAATCGGTGCCAATGCTATTTGAAGATAAAATATTACGAATTTGTT
+ TAGAATAAGTGCAAATTCATTCATTTGCCTAGTTATCGATAATGAGCCATTATACAAATGTTTTAAAATT
+ GGTCATATTCTTTATTCATATTCGTTTTGTTTGGATTACATATTTTTTCAACCCTAAGCACACAAATGTC
+ CGAAATTGCCGACTAATTCTATGGATGCGGGTGGGTTTTCAAAATCATCCTATTTCACATCGAATTGTTT
+ GTGTAGTCAGAAACCGGTTGCTAAAGAAATAAATGCCAAGCGTGACAACAACAAAGATTCACTGAGGACG
+ GGGCTCCGTTTTCAAAAACTCATACGCAGGGGTAATGGACAAACGACAGATATGAAATTTGAGAAACCCA
+ CGCTCAGAGTTGCTTCATACTTTTTTACGACTCCTTAGTATTGATAAGAACACATATTGATGGAAAGTCG
+ CTATTAATTTGGCACTTCCCTCTAGTGTTGAAAATTTCATCAAATCGAGCAAACTAAATTAAATCAACGA
+ CAGCGAAAGTGACAGTAAAACTCAACGACTGTCGGAGTTTTTTATATTTCCAGCGGAAGGGGGTTCTGCA
+ CTTTTTGTGTTTCCTTGGCCTGTCTTTACCCCGACTTCGGTCTTGACGTGACTGAAGTGGGTGTGGCACT
+ CGGCATGCAAATCATGTCAAATGTCGCACTCTGCTCAGCTCAGATCAGTTCTGTTCGAAACTGCAGCTCC
+ AAAGACATCGGGGGCTTCCCGGCCCGGTTGTCTGTTCGCGTATGCATTTGGAGTGGGTAATGACTTCCTT
+ TTTGTGCGGAACGGGTGTCTGACCTTCAGCACTGACTTATTAAGGAGTACGTTCTGTTCCTGCCCTTTTC
+ GGTGCCCACAATTCCCCACGCCTCCGAGGTGTATAAAATGTGTTTGGACAGCTGCCGAGTCGCTGGTTGA
+ GCTTTGTAGGAGGTCGGCTTCTGTATTCAACTGTATCTTTCAAGGGTAACTTGAGCTTGTGCGCGTTCGC
+ ATCTCCTGTTTAATTGAGCTTTCAGGGGTGAATATCCCGCTTTATAGAGAACATCTGCACTTGATTCGTG
+ CTAGGGAGTAATGGATCGAATATAATCGAATCGGGTTGAATTGGCTGCCTCGCATAACGATTGTGTGTCA
+ TATCCCAATAAGGGCAGTCAACATGAGCACTCAAGAATCATAATACGGAATGTTGTTATTCGAACTCTGG
+ AGCATGGTTCGTTTTCCTGTGTTTTCGAATTATCGAAATAATTTTAAGCCGACCTACTATTTGTCTTAGC
+ ATCGGTATAAAATTAAGAACAAATTCGGTTTTGTTACCAACATCTACATCTGCGATAAAGACGGCAATAT
+ AGGCCGTTAACAGAGCGGCTAACATTTACGACATTTGAAATGTTTGTAACAGTAACAGCCCCTACGCCGC
+ GTTTGATGTCGATTCAGTCTACAGAGTTGCTTGCTGCGGTGCAGACCTCGTTCGGATTTAAGCGCTTCGT
+ ACATAAAATACGAAATCCGATTCGTGGCAACCTAACTAAAAATACAAACGAGAGATATACGGGAAGCGGC
+ GATTTGCTACATTTGTGGTTTGGCAACGTCTTTTGTTTTCGAATTCGGTTTTTTCGGTGGCCCGCGGTTA
+ AACTTGAAAATAAGCTGACTCAGCAAAGCCAGATACAAGATACTTATGCAGATGCGAGCTCAGAGCTGCA
+ GATAGACAACAGTGAAATGAGATAAGAGTGGCCATATACACATCGATAAGCTTTATTTATATTGCCCTGG
+ ATTAAATATATCTAAAGACATCTCGATTGTGGCCGTCAACATGTCGTGCTAAGCTGCGACTAATCAGCTG
+ AACCCAGATCGCATATCACCTATCAGACCTACAAACCAAAGATGCTGGACAAGACGACCAGCTCATCCGT
+ GTCGGTGTCCACCTCCTGCTGCAGTTCGAATGCCATCAATGCGGACCTGGACTACGATGTGCCCGTCTCC
+ CGCCGCATCCTCATCAAATCGGTTAGTAAAACCTAGCGATAAGCCCTATCATAAACCGCCGCACATTATG
+ CTGCGGAGATTGGACCATCCTGCATATAATGCAACTATCTTCGCGTCATCTACTGTTGTGAGACTTCTGC
+ TGCTGGGAAACCGGATCGGCTTTCTCAACGTGTATCTTTGGCAGCTCTCAGGCGAAAAAGTGTCTACGAT
+ TTTAGGCTTTGTTATCACCTCTCAGGTAAACCGTTTGATGTGCCAGTTTGCGAAGTAGGTGAGATATCAC
+ AATGTTGTAGTACTCGTAGCTCATTTGAAGCCTGGCAGTGCTTAAAACTTCTAGTCTTTGATCGAAAACA
+ ATATGAGCTCCCCAAAATAAACCATATAGTAGTTATTACCTCCAGATATTTTCGGTTCTTAGTTTACAGA
+ GCTTTTGATAAGCTTTTGTTTAAGCTTAGAAGTATAAATTAAGATCTGCGACAACTGTGATCTAGTGCGA
+ TCGGTAGATTTTTGCTGCTATATACTTTCATCAGAGGTCCGAGAGTCACTCAATCAACATCAGTCGCAGG
+ CTGGCGAAATGAAAAACGGTTGACGCCACACGCGGACATTAATTCTCATAAATTTCCATTCGACCCAGAC
+ CGGAGTCAGAAGTGGCACTTAAAATTATTGTGTCGAAGCAGACATATGTTCTGTCTAGACGGGAACGGTG
+ GGGTGCCCACTTAATCAGCGTGCGATAACCGATAGATCGGAGATGTCCCTTAGGGAATCTGTACTGCGGT
+ TATCCTAGAAGATAGTCATTGAGCCCTGACACAATCTAAATTAATAATATTGCCCGTTTATGGAAGAATC
+ TGCTTGTTTTTTCGGTTAGTTATCAGGTTCTCTTTAAATTTTCCTGACCATTTCGAGTTTTTCGTTTTGC
+ TGCTCAATAAAGTCTGATTAGATTTGGAAGTGGAATTGTTTCGGCGATAAATGCAATGTACTTGCTCTAT
+ CGAATTGCCTCTCCTTAGGTTTTGTTTATTTCTGCTGTCCGATAAGAACCGACCACCGAGGCACCACTGG
+ TCACCACTATTAATAACTGATTTCTATTCTATGCACTCAGTCCCGGTGGGGTTATCATCCTGCCCCTCAA
+ TTAGTCCCCCCTTAATTGCCGGTCTTGAGGATGCGAAGGAGTCTAGAGAAACTAGTATTAATTTCCATCA
+ GTCTTCGGTGTGCTGAAAAAGCTTTTTCCCCGTTGTGTTCCAATCCTAGAGAAGCTATGGGTTGAACTAA
+ TCACAAACTCCATGAAATTGCGTAAACGGTCTCCTGAAGAAGACTCCTTAGTCTTCGCCTATTAGTCCGA
+ GCCTCTATATACTAACCCATCTCTACTGCCAAGTCATTCACAGACCCATCTGCGGTCGTTTTTCGCTGTT
+ TGCGTTTTGAAATCTAAGCTGAGAAGCTCGTGGGACCATATGCCTCCTCCAGAGCCTCACAGCCAGTCTA
+ GGTGAGCGTCAATTACTTGTCGCATTTGGAGCACATTTATTTTAATCTCACCTGCGCCTCTTTTGCTGTG
+ AGTCTAAGCCCATGATGGATGCATCTGGTCCACCTGCCTCACGGCACTCCATCAATTACGTGATACTTTG
+ TGTCACCGACTGTTAGTCCAAGAACGAGTATCCTCCGTCTTTGGGACCGTAGGATCTGCCTATTTTAGTG
+ CCAGTGACCATGTCTGAGACACGACTCTTGTAATTAGCAGTTGTTGTTTATTTAATTTTAAGCTTAATAA
+ CAATTACAGCACCAGAACATTAGGTGTCACGGGGAGGGGAAAGTCTTAAGTGTTTTGTGAGTGCATTTGC
+ ATTAATATCTATTCGCCAGACACTTACACCGCAGTAGTGTAAGACTCGTTAGTTCGTAAACCAGCTTATT
+ TATTTTACCGCTCAGTTGGTGCAAACATTTTTGAATTCAAATTTGTCCAACAGGTTCCGATGGATGTTGA
+ CGAATGTCGCCGTAGAGGGCGGCTATAGGTGACTGATTGGACAAAGCTTAAGAAAATAATTTTCAGAGGG
+ AAAACTTCAAGAAAGGTATGGCAGAAGAATACGCCATGCAAATCATATCGACTGTAAATACACAGCCAGC
+ AGATAAGAAAACTTTCGCTTTTGTGCATTTAATTTTTTTTTTGTTTCGATCGGCATTCGAGTTGAGTTGC
+ ATTCAGTTGAGTTTACGCAGACTATTATTATGTTACCATTCCGAAATGTCATTCCTCGTCCCACTTTCGA
+ TCGTTGGACTGCGCGCGCCACATCCACTGAAGAAGGCCTAGCAATAATCCATACCGTAATCCATCATAAG
+ TTGTTTTAAGAATGAGTATAGGCACTAATGTGTACGATACACTTTCCGAAAGCTGACACAAAAAACGAAA
+ AGTTCAAGGCACCAACAAAAGTTCTCGAGGGGATGCCCCTCTTAAAACTGGTTAGAAGAAAAGTGGAATT
+ TAGTAATAGTCGCCAGACATCGAACCAAATTCCTCAGTCATGAGTCACGTCCGGAGTATTTCTCCGACTT
+ TGTTGTTAGTTAATTTGGGAAGTTCCTAAAATACATACAATTTGTTGAGAGGCGACCGGAATTAAATTTG
+ TGAATGAACAAATAAATGACATTTTTGCCATATATTATTTATAATATATAATATATATACATATTATTTA
+ TCCTTCATCGCCGGGGACATTTTTTTACCCGTTACTCGTGGAGTAAAAGAGTAGACAAGATTCGTTGAAA
+ AGTATGTAACAGGTAGAAGGTAACGTTTCCGACCATATGAAGTATATATATTCTTGATCAGGATCAATAC
+ TCGGCTATTTATACTTTTAGCTTTTATTTTCAAAGAGGTACATATATATGCAACAATTCATTAAATACAA
+ ATTCTGAGCCATTAAAATATATGTACAAAGCTACAACAGCAAATTAGATGTTTTTCGTTTGTTCTGCTGA
+ TTAATTTTTTTTATTGAATGCTAACTGCTCGGGCTTTATATCTTTCCCTGTGGAAGTAATTTTGCAAGGT
+ TTTTTCGTATTCCACTTTAAATGGCTGCGAAGGTCGACAATACCTTGTGTGGATTCCGTGTTATTTGTTC
+ TTTAAAAAATAAAGTCAACAGTTCATATTTTGTTTCAACGTATTTTTCTTTGTTGCGTTATATCGCTTTA
+ TATTCGGCATTTATTTTACCTACAGTCGTTGGTTAAAAAATATCTTAAGGGGGAAATTTGCCTTTCACAC
+ ATAGTTTGTGACTCAGATTTCGCTGTCGAATTTGCTGAAAAATTGTATGTTTTGTATTTACGGTTAGAAA
+ TACCGAAAATGCATCTTTTTTATTCTCTATAAGTCGTTTAGATTCTGAATTGACTTAACTCTTGTACTAT
+ ATCACTAAAACTAAACTAAACTTTAGTGCAGAACCATAAATTTCCCCAAATTGCGGACATAATGTTCAAA
+ TCGCACTGGAGTTACTCATATTGAGAACTGCAATTGAACAATCTGCTAAACCAGAGTGACATGTGGCGGG
+ TGGGCTACATTGAGTCGCCCATCGTGCACTTGTCAATGCAACTCTCCGTCAATGGCACACCGATTTCGAC
+ CCAATCTCCATCCGGAACGTGTTTCCCTGCCCATGTTGGCCGGCTCTGAGTTTTTATTATCACACCGCAC
+ TTCATGCTGTTTTTTTATTGCTTTGCTTTAATTTTCAGTATTTTCTTGGCACACAAAACTTTAAATTATT
+ TTTTTGGCACACAACGAGCTGATGAAATGTGTCGAAAAGGCCGCCGCGAGAGCAGTAAAAATTTTGTTTG
+ TTTTCGCAAACGGAAACCAGTTCAACGCGGCATAATGCGTTTTATTACAGACCAAGAAAAATGTGTAATA
+ TTCTCCGCTGGCTGAAACTCCCCGTTTCTTAGAAAACCTTCAGCCAGTCATAACCCTAGTAAAAATCAAA
+ AGTCCCTTTGTCAGAGTTAAACAATGACACAACTAGATAACTGGGCGATTAGAAGTGAAGTTCCTATGGC
+ ATTTTTCCAGAACTGTTCAATTCTTCCAATAATTAAACTCCAAGACCTTACATAGTCTTCACCTTCAAAA
+ TATTCAGGATTGCCCTAGAGGTCCGGTGGTGCTCCTCTTTATTTAAACAAATTTTGTTAATTAAAATTGA
+ TAAAAGTATTATCTGTCACGCAAGCCAATGGTTGACTTAAGAGTATTGTCACTTTATCAGCATTTGGAGG
+ GCTGGGTCGAATGCCGAAAACGGAACGCATTTCCATTGGAAATATTACCAAGCCATCGTCATTAATTGGA
+ TAAACAGTACTATAGAATCACATTTCCCCTAATGTGGTCAATGGTCTTTTGAGAGCGTAGAATGAAAACA
+ AATTGTCATCTTGTCAGTAAAGGGGGCGAAATGCGAATTTTTTTTCTTTTTAGATCTCTGCTGAGACTTA
+ TACTGATATGTGCCCCAACGAAATGTGGAAAAGGCTTGAATGTTCCCTAGCGTGGATCGGAGCTAATCGT
+ GGAATACATAAAGCATTAAACTTAAGTTTGTTTGGCCAACTTTGATTATTCTTTAAAGCATCGAATTAAG
+ TCCGTCATGCAGACTGTCAAAACATTTATGACAATAAACAATATTTCATATCTTTTAATTTAATGTCTTA
+ CATGTCTAGGGAATGGATCTGTTTTATTTCCATTGCCGAGAAATTCCACAAACAATTAAAGGTGCTAGAC
+ AAACAACTGTAAAAAGGCCCCTAATTCTTGTTACCCACAAGAAACAAAATATAAAGGGGCTTTATGTGCA
+ GGCGGAACTTGAATCTTTCAATTGTGTACTCAGACTATTTGCCTCTTCAATTAGCGCTGTGTCAAATGTC
+ GAGTAAAATGGCAGCCAAGAGAGCACAGACTGCTATGCCGTTTTCGATCCTAACATTTGGATTCGTAAAT
+ GTGAAGCTGTCTGCTCCAGCCCACAAAGCATTGCACTTGGTTTTGTATTGTTTGGCCAAGACATCGCGTT
+ CCAGTGTCACTCCGACGGTGCGCTATTTTCCTTTTGACATTTGAACGCATCCATAGCGCTTTCGAAATAG
+ AAAAGTAGAATATCCGTCGCCTCGTAAAACGGGTTTTAAAACTACCTAACCACATACATACATATGTACG
+ ACAACAGAAGTGCCGGTACACACGGACACGGACAAGCATTCATATCGTACCTGAGCAGCGGGTTGAAAGT
+ TCAGCGGCTATTGAACGCTCGATATTGTAATTGCTGGCTCCCTCGCCCTCTTTCACTTCTTCTACACAGG
+ AAAAAATTGGGGAATCGCTTTGGCTGTTTAATTTGTATGGGGGTTGCAAAAACTTTCATCTAGAGTCTAA
+ TTGAATCGGTCTATGGATGTCCACAGAAAATGGGATTGTTTTCTATGTGTACGGATTTAAGATGAACTTG
+ AAGCGGGAGGCAGCAGCATGGCTCTTTTGTTTTCTTTAGTTGTTTTCAGAGTTCATACGTTCGTTTTGTA
+ TTTTCGTATATTGCAGTGGCGAAATGAAAAGTAACTTGCCAAACCCGCAACAAACACAGATACGTGCACT
+ CACACAGAGGCAAGTACACACATTCATTGAGCTAAAAGTTTATCTGAAAGGAACAGTCGTGTTCAGCAAT
+ TTAGGGCCAATAGCAAATTGGAAGAAAGATATCTTGTGATTCTGGGAGGCTAGTATTATCTTTTTACGAC
+ CTTGATTCCTTCTCAGCCACGGCTGTCAAATCGCAACCCCAAATCCGGACAAAGACTAACCAGCAAAAGG
+ TTGACCTGAAATTCCAACTAACCCAAATTCCAAAAAAAAACCAAATCGCATTGTTTCTGCCTTTCCTTTT
+ GCGGGTTATCTGTACTTTTGGCGTTCATTTTAAACGTGGTAGCAGCAAAAAATTTGCAAATTTTATGGAA
+ AAAGAAACACGAAAATCATGCAAAAAACGGCGATCAGGAGAAGAGGTTCTTATGAATAATGACAGCCAGC
+ GTCAAGTTTGGCCTGCTGAAAGGGTCATTGGCTGGACGATTCTGCGTCTTTGAAATTACGTTGAAAGTGT
+ TTAGCTAACGACTTTATTTGGATAGAACGCAGAACAAAATCCACCGAATTGTGCCCCCATTAGTACCCTT
+ CTTAAATATTTAATATTCCGCTGATTTATTTGCAGAAACTTTACGCCAAGGCCATTTACGATAATTATGC
+ GGACACGTCGGACGAGCTGCCCTTCAAGAAGGGTGATATTCTCACAGTCCTTGAGCAGGACACGGAGGGC
+ TTCCAGGGTTGGTGGCTCTGCTCTCTGCGCAACCGACAGGTGAGTTGGGTCCTATGATTTCATGATTTGT
+ TATTAGTTTGGGTCTACACGAGCCCAGGTAATGGTACTGCATGCAAAATAGTCGCTAATAGAACAATTAT
+ GAACCATTCGATCCTAAGTCATTACCCAGTCTATCAAACGTTTTCGGATATACAAGACTTTGTTTTGATT
+ TGAAAACAAAGTTGTGGAAAATTTTAAATTTTCTGCACGTCGATCGACGGCAATTTTTAATTAACAACTG
+ AATTGGCGCCACTTAAAAAATCTCGTTTGTGTAGGGGCCGGCCGGCGATGGTGTCAAAACATATATCAAA
+ GTGGAAATTAGAAGTGCTGGGTGAGATATGGAAACATGAACGCGATAGCGGTACGTTATACATATGTCGG
+ GCAATTGTCGCTAATTAAAAAGTAGCCGAGCCTTTTAATGGAAACAATTAACCCAAAAACGGTCAATTGA
+ GTGCCGACAAGAGCAACAACGTGTGGCATAAATATTAACAGCAACATAAATAACTGTGTCAAAAAGCGAA
+ ATCAACTTTCGGCACACACTTTTAGCTAAAACAGATGTTGACAAGATTTTCTGTTGACTTCGAGTTTTAA
+ GGAGAATCGCACGAATTTCTGTCAAAACTTGCATTGAGATGGTGAATTGGGCGAGTATAAAAAATGAGCC
+ GTCCAATTAAAAGCACGCACGACATTCTTTTTACAACATTTTTTTTTTAACATATTGTGTCCATTTATTT
+ GTATACGCAGAAATAAATAATTCATACGTCGTCGGTTGATAAAAAAACAATCAAAATCAATTGGCATCAT
+ ACAAAAGCGTATTAATGTTTTGTTATGAGAAAACTAAAAAATGGGGTTGCTATCTTGTGGTTATAGGAAA
+ CTTTTAGTTTAATATTTTAATTTGCTTTCCCTACTTAATGTCGATTTATATTCAACAAAACATATTCTCA
+ TTGCTCTATATATATTTCAGGGTCTTTGCCCGGGCAACCGGTTGCGCGTCTTGAACTCGTACGACTCGGG
+ ATGCTTCTCTCCTTCGCCGGCCAGTTCTCCAGTTCCGTCCCTGGCGGCCAGCACGGCCACGCTGGATAGC
+ TCCATCTGCTCGGCGGAGATATACGAGAACGGTTCCGTCATCAGTGCGGTATCGTCCTCAAACTCAAATT
+ CGGGAGGGGCTAGTAGTGGACTCGGATCGGAGTCGGTGTCTCGTGTCTCGAGGAGATCGTGGCACGCCTC
+ GCCGACAAAGGTATGTTTCTCGTCCTCATACCGAATGACTCGTCCATTTACCGCTCCGTTAGACTTTTTG
+ ATGGAAAGCAGGCAGTCGAGAGGAAATGCATCTTAATTGATTTCGTTTCCTTGCAAATTTTACGTCCTCT
+ TGCTTAATTATGATATTTGTCAGGAAAGTAAAAGAAAGTAATTTCTCAGCTCCTGCGGCTCCATCTGCAT
+ CTCCACGAGTGCGATGCCCTGCTTTTTCCACGACAACTGCGTGTCGTAATTGTGCAATAAATAAGAGTTG
+ CGAGAGCCGATCCTTGGCTCACGGGGATAACCTCGTCCGCAGGGGTCTGCAGCTGTCCAACTGGTTTCCT
+ CTTTGCACTCGACTCGAAATTTGACAATTTGTCAGCTGGACATGCGTTTTATTTGCATTTCTTTCACTTT
+ GATTCCATTTGATTAGCAAATTGAAGGAAACAAACAATTTAGCATAGAAGAAGCACGACTACAGACTTGA
+ GGTGTTCGGTGTTGTCCATTAAAATCTCAGTACAGGAAGTGATTATCTGTTAAATGGGCATAATAAACTA
+ ATTGGCCGATGTGACCAATAGCATCCAAAGAGCTCCACGACCCTTGGAAACCTCAAAAGACGCCCACATC
+ CATGGGAGATAATACTCTTGGAGAAACTTTCGCTTTCTCAGCATACTCGCTGAATGATCGACTCGCAGGC
+ AAATCAAATAAAATGAAATTCAAATTACAGTCATAAACCTTTTCTCGTATTATCGGCAGCTATCAATCTT
+ AACTGGAGGCAAGTAAAACCATAAATTCAAAATCGGTCTGAAGGAGAGCCAGCGATTCGAACGCCCCACT
+ GTACATTGCGCCGGTAGATTTGCTGGCGGATGCATAGATTTGGAGAAACCTTTTGCCCATAAAAGTTTTG
+ CACTAAATACCCAAAGCCCCCTATTGTTCGATTTGTGTTCAATTTTATCGAGTTCAAAAAATCTCATCAC
+ GCGAGTCTGTCACTTGAAGGCGTCGAGAGTTATGTGGAGGATAGCTGCAAACATGCACTTGACCGATAAT
+ GCGGTCGATTGTAGAGGCAGACATTCCTAGTTGGAGTGATGTACCGTTGACGTGTTTCAGAGGGTTTGAC
+ AAGACTTTAGGAATAAGCAAACATCGATAAAGGTGAATTTGTAAAGTGTGAATTACGCAAACAAAACTTT
+ ATCGACATTCCTCGAGTAAATCGAGAACGGAAATTTCTCGCGCGGAGCGTTGCACAATCGTTGGGCAGTG
+ TTGGTCAGATTCTTCAACCGCGGACATCCCACATACTCGTAGTTACACTTCATGGCTGGCATGGAAACTC
+ GCTTGAACCGTTAGATGGCGGCCGTCGTCAGACTGTGTGACAATTTCGAGTTCCTTGAGCCCACATACCG
+ CCAGCTCTGCCGCTCCAAAGCTCCATCGCTCCGTCTATCCCCTAAAATTTTATCCATCTCTATCACGCAC
+ CGAGCATAAAGCCAAACGAAGCCGAATCAGGTTGCCAAATGCACTGGTACGGGCAATGGCCAATGAAGAT
+ TTATGGTCAGATCCAAAACAAGCACAAAAGAGACTTTACCTTTGAGCAAAACATGTCATTTTGTTTTACT
+ GCCCAAAAATGGTTAAAAATGCAGTCAAAGCGACAGCAAAAAAATTTTTTTTTCAAATTCTGTGGAGATT
+ TGTGCGTGACCAAAGTCGGGGAAACTCGAAGACTACCGATTGCTTCGATTGGCAAACCGGATTGATTGCA
+ AAAGCGGAAAAATAACCTCCACCGGTTAGCTTCCAAACAAGGTCGATTCTCACCTGAGACGGACGGTGTA
+ GTTTTCCCTTGCTTATCCCTTCGGAAAAAATAACCCGCTGTCTAATTGTCATTCGGTGAAGAAATTCTTT
+ GTTTCGTTCTATACGTGACAAAATGATACGATTTGGATTGAACCGCGACGGGAGCAGGAAAAATGGGATG
+ ATCAGCCGAGAACTCAAAATATACTAAGGGAACATTGAAATGCAAGGAATAAGCGTGGAGATGATAATCT
+ CGAGCTCGCTACTGTATTCAGGTTTGGAATTTAAACAACAACATAAAACATGACACTTTTTACACTCCCA
+ GTATCTGGAATTACGCATAGCACGCGAATTATTCGAACTGCAGGCCATCAAAGTTGAACGAAAGACGAAA
+ AGAAGACCGCCTAGCGGCCGGACTTTAATGCGATGTCTGTGTCGGACAGCCCAACCCAAACGGCTACCCA
+ AATGCGCTAGTTATATTGAAAACTCTGATGCTTGCCGTGCCAAAGTTGTTTATTTGGCACAACAATCACA
+ TAGGCACAACAGAGAGGAAAAGGCACTCAAACGGCAGGGGAAAAGATTCCCAAAACGTGGGTCATATAAA
+ CCCAATACTTAGCTCCTGCTGAGCCACGTTCGCTTTCAGTTTTTGAGGTAGGCCTACTTATAGGTGGTCT
+ AGTTGTCTTTCTAAATTCTGCTAGACGACTAGCTTGGTCTCAGCTGCCCGGACCGTTACCCGCTGATTAC
+ ATAGTGGTATCCTTTCGGATCCTTATCCTGGACTGTAGCTGCAGCTCTTTGAATTTATTTCGGTATGTAA
+ CAGGACATTTTGTTGGACTATTGGTTCAACCGAATCGAATCACGTTAAGGACGTAGGACTTTGGGGTAAG
+ GTCCTGTCTCATCAAAGTTATGAAAATTAATAAAGCAAAATAAAAGTTGTATGCGGAATTGCTTTATGTT
+ ACTTTGTTTTTAATCTTGGACATTTCGGACTTACCGTCCATTGCCTTGACACTGAACAGCTTGAAGTGTT
+ CCTGTATATCCTAAACGGCCATTGCGCATGCCCGAAAAAATTTCCCTGCCATTTTCCCGACTTTCACATT
+ CCTACTCAGTCATCTTTGGTCCGCAATCGCAGTCAAATTTTCGTCTTTCGGCGACAAGGTTTTCCAATTG
+ GGAATTTTCAATTGTGCAGACCATTTTTGATAATAGTACATTTAAGCAAGATGTGAAAGCAAAAGAGACG
+ GAGGAAGGGCCCAAAATAGTGAGTGCCACACCCGATTGTATTCTACGACTGCCTCTGTATTTTTTTTAAA
+ TTGCCACATGCATAGTAGAGGAAAATCAATAAACCACTTAGCTGCAGGCAGTGTGTTGTGTGTGTACTTA
+ CAGTCTGTTAACTGAATTAAACCACGTAAAGGGAGTAAAACCAAATTATACTAATGCTCTTCATTTGCAG
+ GTAATCACACCACAGCGACACGGTGATGTATACATCTACAATTACTCGCCAGGATCAGCGACTGGATCTG
+ GAGCAAGAGCCGCGCCCAGCACGCCGCAGCAGCAGATCTATAGCAACCAAAGCATCTACCAGAACTTTGC
+ AATGATGTCCAGTCCTCGCCAAAACGCAAGTGGCAGCGAGTTTGAGACCTATGACATACCCAAGCCGGCC
+ ACGCCCGTTCCGCTGAACTACGACAGTCCCAGAAGCGGTCTTCCGAAGGCTTCTAACTCTACAACGACCT
+ CCAGCTCCAGCCTAGGCACCCGGTTTGAGACACTCAAGAGCGTGGCCGCATCCATTGCGGAGGAGTCTTA
+ CGATGTGCCACGACCCCTGATCTTAGGCAGCAACCAGCTCCAGCAGCAAATGTCACAGATGACGCCAAGC
+ AGTTCCGCCTCCTCACTGCTGACCAGCGACAGCCTCTCCCTGAGCTTTTCCAGCTCGAACCGTTCATCGC
+ TGGCCAACATGCCGGATTACGACATCCCTCGACGAAATCCGCTTCCTGTGCGCCGTCAACAAAGTGGGCT
+ GACCTACGACTTTCCGCTGCCTCCGTTGCAGGAGCAGGTTCCGCGGGTGCTGTGCACACCCTCTACCGTC
+ ACCACTACCAAAGAACTGCCTCTAGAGCTCTCCTCCGCACTAGAAACACTCGCAAAGCTGCAACTGCAGA
+ CTACTGCGGCCATTAATCGATTGCTAAGTTTCGTAGTACCCAATTGGCGCACCCGCGCTCAACTCGAGCC
+ GGCCATCATGGATCTGAAGCTGGCCGCCCTGCGTCTGCGCACAACACTCCACGACCTGGCAGAGTTCGGG
+ GAGGGAGCCCTGGGAAACGCCACGCGTTCGGAGGACCGAAACCTGGCCCTCAAGCTGCGGCCCTTGGTGC
+ GGGCTTTGCGAGATGCCAACAAGCTGATTCACGACTCTTCCGAATCCCTCGATGCCCAGGGAGCCTGGTC
+ TATAGATCAGCTGGCCAGAAGCGACGAGAAGCACGGCTGCCGACCCCCGGACGCACTGGACCAACTGATG
+ GTTTGTGCCCAGACGCTCACTGAGGACGTGCGCTCAACCACCAGTTTCATACAGGGCAACGCCTCGCTAC
+ TTTTTAAGCGGCAGCTGACGGTGGGTCACAACGGAGGATCAGGAACGGGAGTGTTAGAGGGCAGTCGGGG
+ CAGCGCTGAATGGTTGGAGGACTACGACTATGTGGCCTTTGAGTCCAAGGATGCAGCTGCCAGGAAAAAC
+ GAGGCGCTACGTGAGGCTATTCCCGCCGACCTGAAAACGCAGTTCGATACGGTTATCCGGACTGCTGAGA
+ GTTCAGCCATGGGCGCTGGGTCTGGATCAATTCCAACCACGCCCACGGCACGCACGACACCTACTACGCC
+ CTGCAAGTCGCCAGAGATGACCGACAAAGACAAGAAGCTGGTGCGCTACTATGCCCAACAGATCTCTACT
+ CATATGGGAAACTTGATGCAGGCCATTGATTCCTTCCTGGAGACAGTAGAAAAGAACCAGCCGCCCAAGT
+ TCTTCATTGCATACGGAAAGTTTGTGGTCGTGAGCGCCCACAACTTGGTGACCATAGGCGACAACGTTTA
+ CCGAAATATTTCGAAGGAGGCACTGCGGGAGAAAATCCTGCGCTGCACCAACGCCCTCTCCGATGCCCTA
+ AAAACGTGCGTCTTGAAGTCAAAGAAGGCGGCAGCCCACTTCCCCAGCGGTAGTGCAGTCCAGGAAATGG
+ TCGATTCGGTGGTCCACATCAACAACCTAGCCCGGGACCTCAAGTCGGTCATGCTGCAGGCAGTTCATCT
+ GTCAACGGCGGCAGGAGTGGGTGCATGAATGGATTTCAGACAACCAGTATTAGTTGAGAGGCGTGTAGCC
+ AGGTCTTCCAGCATTGTCCGCGGTTTGGTAGATGTAGCACATGCATTGCATGTGTATCTGACATCGACAT
+ ATCCTGGCATCAGCAACCGAGCGCCAATTGCCGCTTATATTTTGCATTGTGATATTTTGAGCAAAACATC
+ TGAAAATGCACAGCACCACAGCCACAATCGCCCGATCGCCATCCCGGCCAGAACTCAGGTTCGGGCAAGC
+ ATAAGTTACGATATTGTACATAGGACGATGTAAATTAGCGTATTCCCAAACCCCTGTCATGTCCGCTAGC
+ AATATTGTATTAGTGAAGCATTTCAACATAGTTTTGTATACTTATATACTCTATACTCTAGAGCATAAAC
+ TTAGCCGTACCACCACATAAACATCTGCCTAAGTTAAGCACGCATTATTATACTTGCATAGTCAGAATCT
+ GAAAGATTTACCCCCAACATTTTGAATAACGCGCCTTGGCGCTACTACAGTCAGCGATATACAAGCATAT
+ ATATATAAATTGTAAACAACCAAGAAATTAGTATGTAATATGAACAATAAACTAAAGACTTCGAATAAAA
+ TAACAATAAACCTTAAAATATTGAAATCTGAACGCATCAATTTGGTTACATTTTATATACATACCTGACT
+ TTTTTCTTGAGACTACTGATCCAACAGAAAGATCTTTAACTTAAAAGCATTTCTTACAAGGTAATTTCAG
+ CGCCGACTTTTATAAAAAAGCCATCGATGGCTTAGTATGTATCGATAGTAATCGATAGCTCTTTTTGCTC
+ TTTTCTTTAAACAATTGACATTCCCAATTTTTCCTTGAGCTAAAAACTTAATAATCGACAGTTTCAGTTC
+ AAAATGTACGGATTTAAAGTAATTCCTAATTTGTGACGTTTTTATTTAAAAAATTGTAATAGAAAAATCA
+ GTATTGAATGAAATTTCAGTTATTCAAATGAAGCCCTATTGCCTTATTTAAATTTATGTTGTAAGATGTG
+ TGTCCCATGGCTGAACATAAAACTGATTTGTAATTAATGTTCATATAAACTTCCCAGTAGATGACAGCCG
+ GTTCCGCCTAATAGAGAAACGACGACTTCTCTCGTCTTCAGTTTATCCCAAGTACCAGAATGTGGAGGAC
+ TTCGCACATATGTATTACGCGAAGCGACAAGACGTACATTTCGAATGAAAGTCTTTATATTTGGTTAATT
+ TGTTGTATTTGTAAAAATAAAAGAGTTGTGAGGAATTTCCCACGATGACAACTCACGCATTCTTGGCGCA
+ CCGAAAACCCAGGTTACCGGCTGAACTGTCTTCTGTGTTCTGCGAGCGTGCCGCGCACCTGTACCTGTAG
+ CAGTAGGACTTGTGACACAGATAAGAACCGCCCTTCTTGACCCGATTTGGATTATCGCTAACGTCATTTA
+ CGTCCCACAGATCTGCCGTCCACTCCCAGACGTTGCCCACCATGTTGTGCAGGTCGTAAATATTCTGTCG
+ GAAGGCATCCACGGGGCTGGTGTACTCAAACCCATCTTCAGCCAGGTTGCCATCGGGAAAGTCTCCCTGC
+ CAGATGTTCAGCCAATGTTCATTCCTTGGCATCAGCTTGTTGCCCCAGGGAAACAGTTTGCGCTCCTTGC
+ CGCCCCTGCAAGCCGCCTCCCACTCCGCCTCGCTGGGCAACCGCTTGCCGGCCCACTTACAGTACTCCAC
+ AGCGTCGCGCCACGATACGTGCACTACCGGGTGTCGGCCTAAGTGGTCTATATCGCTGTCCACGCCATTT
+ GGATGTCGCCAGTTCACGCCGGCCACTTTGTACCACCAGACAGCGCTCGCCACTCGGAAGTCCTCTAGGT
+ TCTTCTGCTCCAATGGGCTCAAAAGGCTCTTAAACAGAAAACTGTCGCCATATCGCTCAGCCTCCGTGGT
+ GTAGTTAGTGTGCAGAACAAACTTCGCAAAGGCTTCGTTGGAAACCTCATACTTGTCGATGTAGAAGTCA
+ TTCAGCTTCACCTGCCGTTCCGGAGCCTCGCGGTCGGCCGGAAAGTGCGGTTTGTCAGTACCCATGTAAA
+ CCGTGCCTCCCGGAAGCAGTGACATGTCCGCAATATTTGGCTCCAGTTCGCCATAGTAATCCCGGTAGTG
+ GCTGTGTGCACCCTGTGCTCGTTGCTGGCACACTTGTCCGGAAATGGACGGCATATCCGGGGCCTTCCGG
+ TCGAGCTTTTGGCAGCCACAGTCGCTGGATACGTCATTGAATAAAACTATCCAAATAAAGAGGACTAATA
+ TAATTGTTGTCATCTTAACGTGCAGTGTGGCCCTTTTTAGTTTTGGAATCAATACTTAATTTCGCGAATT
+ TAAATTCCGAACAAGCCAGCTTTTTAATAGCATACTTTAGGCTGTAACGTTTTAAACAATTTATTTCAAT
+ TTCAACAACCATACTTTTGGGATTATTATTATTATTATAACCATTTAGTAGTAGTTAGAAGGTTAATGAG
+ TGCAGTTTTACCATTTTAATAATATATAACCTACAATATTTAGGTTTTATAAAAAGTTATGTATATGAGC
+ TAATTATAATTTATCAAAGTCTGGTCTTTATGTTAACTTTCGTTTGTATTTGTTATAAATTCTTCAATCA
+ TGAACAAATTTTTGGGAACGGAAGACCTACAAATGCAAAGACCAGAAACATTAAAAAACGTTAAGTATAA
+ GTTAAATAAGTTTAAATTGTTGTATGGCGCAAATCGGTCTTAACAAGTTGTGATACACAGCAATCCTAAA
+ AGCTGCGGGCTATGCCTCGATAGGCTTCTCGTGCAGCCAGGGCCGGAATATGGGTAGTGTGGACGGATAG
+ TGGGTGTGCGTGTCCGGCTTAAGCACCGATTCCGGCCAGGTGTTGGCATTGACCGCATCACCGGAGTGTC
+ GAAAGGGGTACGTCGCAAGCACGATAGGAAGCTGTAGCTTAATCTCCTTCTCCATGGACTTGGGTTCGAT
+ CACGAAGAAGACGTCGTAGGATATTTTGATCAGGTGGCAGCCATGAAGATTGGTCGGCGGCAGGGGTGGA
+ ACGTAAAGCTCGTTGTGCCACTCGTCTTTGGCCCCCGGACGGATCTTGCCACGAACTAAAACAGCCAGCT
+ CCCGTTTTTCCGTTTGCACCACCTTCCCCCGCGCCAAATACTCGATGGTCTAAATAAAATCCAAATAAGA
+ TCAAAATGGATGAATTGTAACTAGCCACTTGAAAGCGATACCGACCTCAGTGAGGGATGCCTTAGTCCGT
+ TTAATGGACACATTACTGTAGTTGGATATAAATGCGGTGACCAGAATATTCTCGCCGGGCACATACCCAC
+ CGCGATCAAGGGACACTCTGCACTTTATCTGACCTCCACCAACACAGACGACGCCTAGCTTGTGCTCAAC
+ TTCGCAGGTGAACGGTTGCTGAGTCAGGCGAAAGGTTAGTTTTTTTAAACAGGGTTTTTAAAGCTACTTA
+ CTGCTAAGATGGGCTTTTCAAGGTTTAGGTCGATGGGATTCATCACAATGAAGACCTGGTGGTTCTTATG
+ GATAATGCCATTGTTCTCGCGGAGCGCCGCCTTGCAGTAGAACTGAATCCAGCCGTACCGACCGAGAAAT
+ GTAGATGGAAGACCCAGTGGCAAGCCGAGTTTGAAGGGGAAGCTGTGAATTCCTGGCGAGAGTATAGCTG
+ GACCTCCTTGGTCTACGTCCCCCAGAAGTCGCATCCGAAAGTCGATATAGTTCTCCTTATCGTATGTCCG
+ CTCCTGTCGCCGCCCGTTGCGCACGACCCCTTCGCCTACCACATGGAAATGAAGTCCCAAAGCAGGCGTC
+ TCATCCTGCAATTCGATTAGAACCCGTCCGGAGAGAAACTGGCCCGGGAAGTACAGGAGGGAAGTGTTGT
+ CGAAGATGATAAGGAATTTAAGCAACTTGCGCGGCATCGTGCCTCTGTTTTGTTGCCGATTTCATTCGTA
+ CGCCTAAGGAAAAACCAACGAAATTCGTTAGAACACGGTTGCCAAATATTTGACCCGCTCCGCACGCGTC
+ ATTATGGTTAATGACAACTTATCCGTCATAGCTGGCTAGGTCTGAGACCATGTACTACGGACTACGGTCT
+ CACATACATACGGCGCTTGTTTGCATATTTATGTGGGTAGCATCTAGGCGGGCAAAGGAAACAAAACCAG
+ TTTCGTACGGCCAAGAGATGGCTGCGTGCACAACTATGCAGCACGAAAGCCCCGAACACTTAAGCATCAA
+ CTGCAAGGTCGGCGCATGAAGCATGTCGGGCGTGTCACGCCCGCGCCTACAAATTTGGGCAAAACTCCAG
+ TATGTACATCTTTACCAAAAGCGTAAGCTGCAACTGCGACTGTCGGCAAGCCTGTTTGGTGCACTGGTGA
+ CAATGTTGATGATTCCTGATTGGGAAACAGAAACCGAAAAGAAAACTGACGTAATTTCCTAGTGGAAAGC
+ GGATTCCCAACCGTACACTGCCATTGGAATGATTACATTCAAATTGTTCAACATTTTTGTTTTTATCCAC
+ AACAGATCAATTGTTTTCTCTTCATCCCTGTGGGCGCACTTGAAATAATGATCGCTTTTCAAATACCTGT
+ ACACACAAAGGTGTTTTTTGGCCAGATCGGAACACCAGTCCAAACCGAACCGATTTAACCCGTTCTGCCT
+ TTGAGCGATATTCGTTTGGCAAGATCTCGTCCACGCTCTCGAGCGTTTGTTTGGCAACTGATCACCGTCG
+ TCGTCATCGTCGTCGTCGTTATGCATCAGTTTGCGGACGAGAGCTCGACTGAAAAACTTGTTTTGAGCGC
+ GTTTTTGCGAGGGATCGTTTGAGAGAGGCCCAGCCGGAGCCAGCTGATGTCGTAATGCCAATAAGTAGCC
+ CGCTTTTGTTTTTACTATCTTTTGCATTCATGTAATACATGGCTGAATTTACCTTTCCAGCGGGCTTACA
+ GGATACGCAAAGCGCGTATCTTCTTGAATAAATTCAAACGGAAAAAACTGGAACGGCACCACAGACAACA
+ GAAGACCAAACGAGCATGAGAACCAAATTGTCACCTCAACGGTTAGCTAAGCTGTTCAAACTGAATCGAT
+ TATAGGAGCAATTTGCTAATAATATGGCAATGCTCGCAGAGTCGCCCCGCTATAGCTCAGCAGGTGTATC
+ TTGTGTTACTCGGTTGCACCTAGAAAATAAATCTGTATTTCCAACACCAAGCCCATATTTTACAGGTATT
+ TATCCATAGTCGACAAATCGTGTGCAGACTAAAATGGATAAAGTGGCACACATTTATGCATTATGCATGC
+ ATTTAATACCGGTTATTTGTTGTTTTAAGGTACCCAAATCGAAGAACCTCAACTGTAGCTCATGAAAATG
+ AAAGGCCAAAAGCCAAGCAAACTATCACTGGCTGCGAAAACCGAATCGGTGAATGGCTCGGCAGCCTGTG
+ GCAAGCTGTGGCAAGCTATGGCTATACCCTGAAAATTAGTCAAAAAATGAGTCCTGTGGCAGATACCTTG
+ AAAACTTTATTAAAAGGAATCTGTAGGTTATCCTTATGATCGACAAAGTATAAGATAATATTAGAAAGAG
+ TAGAGATGCAACGATGGTCAAACTATATATGGACTGAAGAAATCAATCGTTTTGAAGACTATGCTGGCTA
+ TAAGAGAAAACAAATCACTTTCGTATTTAACTTTTCCAGCTTTTCATATTTCTTCCAACGGCATTAGTGA
+ CATTTAGTAGCAATGGCTAGGCTATAGTTTTCCATTTCAATGTTTCTCGGCTTAATTGCTGGGAGTTGTT
+ GTTTTATAATGACCCAAGTCTTTACCGCGAAGAGAGATTTCAACGAGACTCCAAAGATTTCCCGTTTGTG
+ GCCTCGACGTATAGAGTATCTGAAAATTAGGTTGTTTCGAATAGAGACGTCTATACTAGTTTGGTTCAAA
+ ATGATAATCGCTTGAGCTCGAAGTTTCGTGGAGCCCACAACTAAGTATTCTTGAGTTAAAGTCAGTGTGG
+ TTTCAAAGCTGCTCCGCGCACCACCGAACCGATCTCCGAATCTCAGCTCTGTTTATCATTTTTCTGAAAG
+ TCCGGCGCTGAGGAACCTATAGTAAGCCTATCTCCATCTCTTATAATAATAGCGAAAGCCAGACGTGAAG
+ GCAGAGAATATCTTGGTGTAACATCAATCACCAAGGGGGAGTGGCTGGTCCACTCCATAAACTTACCAAC
+ GATACCGTAAAGTCTCAAAGAGAAAAACAAGAGGTGTAGCAGAGCTACACCTGCAAAACTTTCTCATGCC
+ CAACTGGCTGGGCGCATTGGCCACTGTTTTCGTTGCTCTTGCCTTGTTTCACCTCTCTGGCACGCTCTCC
+ CTTAAATCGAGCTGCTTCTATGTCCGACTTGGGGCAGTGGCTCAGTTGTGGCGAAGATACCGAGCGCGCT
+ GGTAAGGCACGGTTCGCATCGAAAACTTTAAACTGTCTTCGGTCGGGCCAGTGGAACGCGAGAAAGTTAA
+ AATTGTAACAATAAAGACACTCATAATAGCGCTCCGTGAGTAACTTAGTGTTTACATGAAGAAGGCTGAT
+ TCTAGTTCATCACTGGTCCAATCGAAGCGCCATACACAAGTTACCACAGATTTTCATAACTAGCTAATGA
+ CCGAAATTGACACGTTCTGACGGCCGCAGCCGATGAGAGGACCTTATTCTAAAGAAGAACTGTTAACTAA
+ TTGTCAGCTCTGCTTACAAGCGGTTAGGTTGCATAAATTACACCAAATGGTTTGTTCGCCACGCTTCTTA
+ TACCATATCTGTATTAGCATATCTAAGGTTCTCTTTTGGCTAACCCCTTCCTTTGTGATGCCTCCATAGA
+ GCACTAGCTTACACAATAACCAGTAAAGGCTTCGGGATGCAGAGCCTACCACTACCAGGAGATGAAGCCA
+ TAGGCTTGCTACCCTCTCAGTCAGAAAGCTTTTCCATTTGGGTCAACGGCGAGGAGCACTGGATATCCGG
+ TGCGGACTCAAGCACCACCTGCGCAGATCTAATATGCGCGTTAATCAGCTACCAAATAGACCAGAAACAT
+ GTGCTCAGCAAGGAAGAAATACTCGCTCCACAGCAATTTGCTATTGTCCAAAAGCAGCGTCACTACGAGG
+ AGTATTTGGATAGTAGTGCCAGGCTCCTTGATGTTATAACCAGCCCTCACGCAATGCCGAAAGAGGAAGT
+ AAATAATTTCACGAGAAAAACGATTCTCAACATTTCAAATTACCTTATTCCACACAGTACCAGCTACATC
+ TTCGTCACTTGGCCACTTCAAGTCGAAAGCAAGTCCCGACGACCGATAAGGACAGTGGAATGGGCAGTCC
+ AGTAGATAGTTCGCGGAGCATGCGCATCCGGCGGAGGGGCAAGCTTCTCTCCACTAAGACCACAGACAAT
+ ATCAACACTAAGCAGTCGAAGAGAAGCCGGAAGCAGCAGCAGAGGAACCACCACTTAACTCCGAACGAGA
+ GCCTGCTTACCATTATCCTTGCCCAAGATGAAACCATTCTGCAGCAAATGACCATGTTGCAGTAAGTTTC
+ GCCTTTATCTGTCCGAGTATCTCCGATTTTCATTGGCGCCATTCTGTAGCGAAAAGGATCGACAGATTTT
+ TAAAATCGAGGAGGAGAAGCACCAGGTGAGGGAGCGAGAGCTGGGTAAAAACTACCTCCTTGAGACGTAC
+ TTAAAGGACTTGGATGAGCCCCAAGAAAAGGGCGAAGACCTGGAACTGTTTGAAGAAATGACACACATAG
+ ACGTAGATCGAGACTTTGGTATAATGTCAGGTATGAATGAAGATAAAGCTGGTAGTCTTATCAATTTGCT
+ ATTGCAACGCTTGTCATCCTAGATAGTACCGTCCAAACTGCGTTAAATAGTGGCACTATGCAGGACGACA
+ TCCGGCTTTACTGGCTGGAAAAGATTCACGAGGTAAACAAAGAGCTGCAATGTGAAGAGGAACTTTTACT
+ CAGCCTGCACTCCAAGGTACGTAGACACCAGGTGAAGCGGGCGTACCAAACGAAGAGCGAGGTGCTACTA
+ CAAATCGAAAGACTCGATACAGAGTTGGCTACTCAGGTGGCGGATATCCACCATGTGGAACGAAAACTTT
+ TCACGGCCAATGAACAGCTTAAAGCCAAACTGGCTGTTCTTGAATGTTTGAGTCGTGAATTTGAGACTAC
+ AGTATCTGGAGGCGTTCAAGAAGGTGATGTTGCCACTGGCAGCAATGCAAGTGCAAAGGTTCAGCAAAGC
+ CAATCAGATGATCTCCAACACGCTGGGAACTGGCTGCACGTTGTTAAGAGACTCTTTGCGGCAGATCATC
+ TTAATCGGCGATTAACGCAACAGGCACTAAGTGAAAAGAACTTAACGGATCGACTAATACCCAGCAAAGG
+ AATATCCAAGCAGATGTTCGAAGTTCTAAGATCCCCAGATCCTTCTACCTCGAACAGCGTAAACAAAAAA
+ GAGTTGAGTACTAGGCAAGCAATTTCTTTAGAAAGGGATATTCAACACCTCGGCACCCTTGTTTAATGCA
+ AAGATCAAGCAGTTGACTTAATCCAAGTATCTCATGTAACGTATTTTGAACATCCGTACCAAATTTGTGT
+ CAATTAACCAAATAGAGATTAAATTTTTGTTATGTTTAAAACTTGAGAGTTTAGTGGATAATATCGTTGT
+ GTTGTACAACAAATGTGGATTAGTAACTAAAACCCACAAACAAAAAACAGAACAACATTCATAATTACTT
+ ATCATATGCAGTATCATAAACTATTAATCAGACCTCTTTAACTGTTGTATGAATCCCGCATTGGGCTGAA
+ TACACGGTCTCCATGATTTTACCAGATTGTATGCATCTTCGTAGCACATGTCACGGCGCTGCATTAAATA
+ ACCGATTACCACAGAGGGGGATCGCGAAACGCCTGCGTTGCAGTGGACGAGCACGCAACCCTGCGATCTG
+ TGCGCATCTTCAATAAACTCCATTGACGCGGGCAAGATGTAGTTCATCAGGTTGGTTTCCGGCAGATCCA
+ GGCAGGGCAAAAATGTACAATTTACGGGTAAGGGCCACTCCACCTCGGGCGTCTGTATGCCGACACTCAG
+ GATGTGAGTTATCTTATATTTTATGATGTTATCCGCGCTAACTGCATCCTGCGAGCCCAGGTAGAGAAAG
+ TCGCTCAGAATGCAGGCGGGCACAGAGTCCGGCTTGGTATCCACGACAAAGCCGTATTCACGCGGATCCA
+ GTTGCTGGGAGCAGTGCGCAATGTCCTCCACGCAGACGGATGAAGTGCTTCGCTCAATGTAGCGTACACC
+ GGTGGGGGTGGTCACAACCGTGGCGGTGGGTCTCAGGTTGCCCATTCGCCTTTGCAGCTCATACAGCAGT
+ ATCATAGCGGTATTAAATGTCCGTTTCTCGGTAGTGCACTCTGCAAAGGTAAAGCCCACAGGCTGGAGCC
+ AGGAGCACACGGTGATCCCAAGAATTCTTCGAGGGAACGGTGAGCATCTGATATAGGCACCTCTCGTCGA
+ TACGTCCGTTACCCAAAGCGATTAGCGCGCCGACAATGCGCCTTACTTGTTTGTAAAGAAATGATTTAGC
+ CCTGATCTCGATGTCCCAATAATTATATGTTTCAGCGGCCTGAATAGCGTTCGAAGACAATGCACGTGTT
+ TCACCAGGACGAATATTAATCTCGTCGATTTTGCGCACTGTAAACATTGGGTGATCCCGACAAACTTTCT
+ GTCGGCTAACACTCATGAAAGTTCGAAAGTCGTGGACGCCGATAAACATTCGAGCTGCAGCCTGGACTCT
+ TTTGATATCGAAGCTAGAAGATCTATGGTGGATCAAGTGGTTACTAATATCATTTAAGGGTTGCCGGAGT
+ TTCTTACTGCAGAAAGTAACAACGATCGATTTCTTCAACTGGTATAAAGGTCTCGAACGACCTATTCCGG
+ AGACTGCAATCTCCCAGGGTTGGTACCTTTGCCACGGCAAAGCGATAGAGATAGGTTCGTCCAATGGCGT
+ CGTAGCGGCAGTGGAAGGAGTTGGCCACCAACTTACTGCTGAGCACTCGGATGGGAAGACGCTGTTTGTT
+ AAGGGTTCGGTTGAGCACACCAGTTAATATAGTTGTATCATAGGGCTGCCCATTAGGCCGCTCCAAGTCC
+ ACCTGCACCGTGGAGTGCAGGGCGTGTACACCGGCGTCTGTTCTGAAAGTTACGGTTACTATATGACTGT
+ ATAGATGTTGTGTATATTGTCTTGCACCAACCGACTGGACAGCACGGTGTGTATTTCGTTTGTTGGGTGA
+ AAAACCTGCAACGCCAGCTCCAAACAGCCTTGTATGGACTTTGTGTCCAGGCGGGACTGCTCCAGCTTGT
+ TCACCGTCTTTTGAATACCACTGTAGGGGTGGTAAGTCTTGCTTCAACAATTAATTTCCACAATTCGACG
+ CACTTACCGAAAAGTCGTGCCGATGTAAGAAATGTTCAACAAATACCTATACATGTTATAGAGCACGACC
+ CACAACCACCATCCATATCGCTAGAGATGGGCTTGGGCAGCTGGTTGATCTACACTCCTAGAGGTGGGAT
+ TGTAAATTATGTGTTGAATAATCAAAAAAGCAACATTTAAAATAATTAAAAAAGCTGTATATCAAGAAAG
+ CAACTATTTTTTATGCAACTCCCTGCAAAAACACTTTCTACGGCCAAGCTCTTTTTGGGCCAGAGAATGA
+ GAAGATATCGATTAATCGATGACGAATCGGTTCACGGCATTAGGCAACAACAAAGTACCCGGCCACATTG
+ CTGTCAGAAGTATATTGTTTTGTAATAAAAAAATATAATTTTGCAACTTGCCAAAGCCTTGCAACCCTGT
+ AAGAGACGGCCAACGGTCTAATACTTTTTCTGTCTTTTGCACAGCAGTCCTCCAAATTAAAGGCTACAGA
+ GTTGGGCCCTCGGTATAAGCAGTCACCAGACCACCCAGTCACTCCACCCACCACGTAACTAGAATGGCCG
+ GCTTTCCCGAGCACGCCCGCGCAGAGGATACGGAGGTTAATGTTTGGATCCGCTTTGGTCTTAGGCTGGG
+ CGTCAGCGCCGCCCTTCATCCGTTCGAATATTCCAAAACCCTCATCCAGCTGGGTTACGAACCAATCGCT
+ CCTCTGCCCGGCAAGTCGATACTGGGCAAGCCGATCATGAAGTTGCCGAACATCTTTCAGTACGGTAGGT
+ ACAAAGTTCCTTTTTGCCGAAACATAACTAATATTTCCGCTGCGGCTCCTGCAGCTGGCCACATTCGGCG
+ GATCGACGGCTTCTACGGTTGCTACCGCGGTCTAGCTCCTAAATTGGTGGGTTCTCTGGTGGCCATGGTG
+ GTAAGCGACCGAGTGGCCGATCAACTGGGCCTGGAGCAGCCAGAGGAGAATAAGGACGACTCGCAGCTTA
+ GTGATGAGGAATTGCAAGTCTTTGATTTTCAAGTGCCCAAGAATCTCCGTACAACTCCTGATTTGTTTTC
+ TTACAGGTACGTCCAGTTCAAGAAAAGTCTGAAGCGGGATATTGTTTTGATGGTGAGCGGAGTCGTGGCC
+ TCGCATCCTTTTCACGTAATCTCGTTGCGCATGATGGCGCAGTTTGTCGGCCGCGAGACCTTGTACACCT
+ CTATTGTGGGCTCCGTGGCCGAGATTTGGAAGTCTGAGGGAATAGCGGGATTTTTCGCCGGTCTTGTGCC
+ AAAGCTGCTGGGCGATTTGGCCTGCCTAGTGCTCAGCAGCTCCACGATCTACATCCTTAACAAATATATC
+ ATCAAGGACAAGTTAGGCAGGCAATACAATTCCGGATTCACACAGTTTGCCGTATCTAGTTTACTGTATC
+ CACTGCAAGTGGTGTCCACCTGCTCAGCGGTAAGTGGCTCACGCCTGATGGCTGCCCAACCGCCAATTAT
+ GCCGGCCTACAGGAACTGGGTAGACTGTTGGAATGATTTGCAGGTTCGCGGGGAGCTTAAGCGCGGCAGC
+ TCCCTTTTCTGGCGGTGGGTGTTACAGTGAACTTTATGTTTAAATTAGTAACTACAAAAAACGTCGACTT
+ TCCAGGTCACAATCCATCAGTTCTCCAGTAATAGCCACCTCATTCGCGCCCTTGCCTAAGCTGGCGCGTT
+ ACCAGTAGCCGTCAACAACGAGGCTGGACGACCACGGACGGGCTCCGGTATGACAAGCTTCAATCCAAGG
+ CAACTGCATTTTTCTACTGTCTCCAAGCCCAGCCATAATTCTGTTAATACAAGTTTAGATCTACATTGAA
+ GTGGATTTTCATCGTGGTCCGTTAGTCTTGCGCGATGTTTTCTTTTCTTTCAGCAACTACGAGCACTGAA
+ ATCGTGAAAAAATCTTTCCCAATCTTGTGCAGACTCCGATATAATTGTTGTTATTGTTTACTGCAAAATT
+ TTGGAAATAAATCGTTTTGCCCTACTAGTGGAACTTTTCCATATATATGTTTTTTTAATTATAATGGTCT
+ ACTGGTAACGCTCTTATCGTTACCTTATTTTATTTTTAAGTAACACGTATTAAAGCTCAGGAGTTAAATA
+ AGACATATGGTTTCATTGAAACCCCACTTTTTTAAAGTAGATTTTATATTTACTTTGAATAGTTTTGTTG
+ CGCAATTTATATAGTACTGAAAAAAATATTTTCCTGTTGGAGCCATTAAAAACAAATTCAATTGACAATC
+ TTTATTCAGTTAAGGTTTAATTTCTGCTATATTTTTATGTATATAATACAAATTATCTTATTGATTGTTG
+ ATTGATCCTTACACGATTTTTGCAGCCCAATAAAAGCTTAATTAATTAATTTGTCCTGTGCTAACTATAA
+ TGCACTCTAGTATCATTTTTTGTAATATTTATACTTTGCTGTTACTACATCTCCAGTACCACCAAGCAAA
+ CAAATTTTGCATCTACAACAAATTCTTATTTGTAATTGGTCTGCAAACTGTAGTGAATAAAAATAAATAA
+ TTTACATCTACGAAAATTATTTTTTGTAGTTGGTCTGCAACCAGCATTTCGAATTCACATCACCAAGTTA
+ TGTTTCTAGAAATAGCATTTGCTTTGTGCAAGCATCCTGCAGTTGTACCCCCACATAAATCCCCTTAATA
+ TCCATCCTTTCGAGTCCTTTTGCTTCTGCAGTAATTGACAAGTAGCTAGGCGTCGAGTATATGAACATTT
+ ATAATAAGTACAGATTAAAAAGGAAAAGAAAAGGTCAGGCAGTTCTGAAGAATGTTGTTTTTAAATAAGG
+ CTTTTTGCTTTTATTAAATTTTCGCTAAAAACTAGAATTAAAATTAATAATCATAATCATTAATTAATCA
+ TTAGAGTTAACGTAATAGTATTAATTAAAAACATTTTTTGCGCACAAATATTTACAATTACAGAAGTGTC
+ GTTAACTTCTAAATTTATTTCTTGCTTGGTTCTTTACACAATTATATTAGTTATTCTCTATTTTTGCCTT
+ TTCGCGGATTTATTTTAGAATAAATATTTGTTGCTGGGTTCCTTAAATGATTTTTTATTTAATTTTGTAT
+ TGCCCCTTTAATCGAGATACGCCCAATGCTAATTGAAAACTAAATGGGAAGTAATTTCTTGAACTATTGG
+ CGACAAAAGAATACAGAAAGTCTAGGTGGACCGGGGCGTTGTGTATCGTTCCGCGATCGGAATCTGGAAT
+ GCAATCACACCTACCAAACAGTACTGTTTTAGATGGCATCTTGCTTCGGCCTGTTTTGTGTGATTTCGCT
+ CGAGGCTGCAGGCACCTTTGCTTATAGAAAACCAGTGTTCTTTTGCCTACGTTACTATTGCTTTAACATC
+ ATACAACGCAAAACAATCATTAACTTTCCTCTGGAGTTCTTCGATACGTTGCATTCTTAAACGCTAAAAT
+ ACAAACAATTCCCTTTCGGAAATGATAGGGAATTTAGTTATTCAATTTTTGTTTTTCTCTCTACGCACAT
+ GTTTGGGAACAGGGACTATTATATGCACTTAGATTGCGGTCAGGGTCAACCGACTTTGATTTTCGCTAAG
+ AACTACAATTAATGACTATAGCTACAATTGTTGAAATTGTTGTTACTTTTTGCACGCATTTAACACTTTT
+ TGCTAATATTTTACGATTATTTTACACATTTTATTAAATAATTATTAATAAATAGTGTTTATTATATATG
+ CTGGGGTTTATCAATCATGCTTAGTGAGTAGGAGGCGTGGAAGGATTTTTAGGTGAATGGAAACTTTATA
+ AACCTAAACCGAGAGCATTTTTGGATTTTTTTTAGGCTAGACAACACAACTGTGTCTGCTTTTTTGTTTC
+ TTTTATATCTTTAATACAATATTTTACAAAGCCTTAAATGTACAATCTGCTTCTAAAAATGTACAATTTA
+ TATTTTTTGTTTCTCGCATAATGTGCTATATGCATATTAATATTATATAGGTGTGTAGAGATAATATCTT
+ CTTTACGCTGATGCGATTACAACAAACCAGTTACAGACAGATAGAAGAATGGTTAAGGGGCTTACAAGCT
+ AACTGTACACTTTAAAGTTCGATTAAGGACCTGCAGTTCGCTCATGTACTATAAAAGCTAACACTTTAAT
+ AGGGGCGAGGGCAAGGAACCAAATCACAAAGGGAGGGGATTATCGAAAGCTTGAATGAACGAAGTTACAG
+ GATACGCTTACATGCGACGTTTTCGCGTTCTCCGATTATCATCTAACCTCACAGTCTTTTTTCAATGGAA
+ GTAAGCCGCCTTCCCCGCTGGCGCGTCCTCCTCCACTGCCGTTGTTGTTGATCGAGTTGCTATTGCAGGA
+ GTTGCTGGAAGCCGATCCGGTGCCACTGGCTGATGGCAATGAGTTGTTGCTATTCTCGTAGTTTCCCACG
+ TTGACGCACAAAGGTGTGGTCGCATTCACAAGGGACGACTGCACGCCCATCGCAGCCTCCCCGCTCTCGG
+ GCAGGGATGTGGAGTCGTGCACGTCTGCACTTTTGCTAGAGTCTATCACCAAGCATGGCGGGGATGGGGT
+ ACCCGTGTCCTTACCAAGCAGGGCTGGTGACGTATTAGCGTTCTGGGAGTGCGGTGTAAAACTGTTGAGC
+ AGTCTGCCCTGTGGTGACGCCTCTCTGAGAGGTGATATAAGTGGCAGCTCCGTAATCGGAGACGTGTTGT
+ CTGCCGTAGACTCATCCTTTTTTTCCGCCTTCGTGCCGATTATGTATCCGCCGCCAGATGAGTTCCGGGC
+ TATTTTAAATCGCAGGGGTGCTGGAGCCTCCAAGGTAGGAGGTTGCTCCAGACTGGCGGTTCTTGTCGTG
+ GTCTCCGCCTTTCGTTTGCCAAAACGTAGGATCAGCTTAGGCTTATCACCTGGCGACGCACTGGCCGTGT
+ TCTCAATTAACGTAGTGGTCATGGTGGTTGTACTGCTGCTTAAGATAAGCTGTTGCTGTTTTTGGCGTTT
+ CTTTTCCTTCTTCTCCTTTTTCGGCTTGGAAGACTTAGGTCGTTTTGTGGGAGGCTGGGGCATTATGAGC
+ GACTCGCCATCTTTGACAACTACCCCTCTCTTGTTGCTGTCCTCGCCCTTGACAAAGTCCTGCATGACTT
+ TCTTGCGGTAATTCATCGAGTCCCTCTTGATTTCCTCTAGTGTAAGAGTGCTAAAATTACTTGTCAAACG
+ CTTTTTAGGTGGACAAGCCCTTCGGGTCATTTCATAACTGTAGTTTTGGCCCTCGTCAACGCTTGAAACA
+ CCTGAAGGTGTCTCGTTGGCCGTCAAACCCCTGATTTTGATCTTCAGCTTAGGGGCCTGGTGGTCATCCT
+ CGCTGCTTTCGAGAGTCTTACTGCGTCCTCGCCTCTTACCTGCACTACTAGCTGCTCCAGTCTTCCCGTT
+ GTTGTCGTTATTGCTACCTGAGCTACAAGCGCTACGCCGTCTGCCGTCACCCGATGATCCTCCTCCACAG
+ GCTCCTGCACCGCTTGAAAGCAATTGTTCCTCCACAAGGGCTAAGTTCGCATCAAGAGCACGCAATTCCC
+ TGCTACTAGAGTTCTTCTTAAACCTTTTCGTACCGTTGCCACCTGAAAGTTCGTCTTCCTCCTCAGACTT
+ TCGCAAATTCTCAAGGGGCAAAGTGTCGGATGCGGCTGGCAGTCCGCATGAGCTATCGTCATTGTGATTA
+ TCTTTCTGTACCACATAAAGACTAAGAAGTTCCTTCTTTCGCATGCGACGAGAGTTGCCGCTAACGGCTG
+ ATGACGCACTGACTACAGTCGACGTGGATACGGTGGTTTGCACTACATTTGACGACTGCACCAGAGTGCT
+ GGTAAGAGTCAGACTGCTGCTGTTCGTCATGGCGTTATAGTGTTCTGGATAGGCCATCGGGCTCTTGATC
+ TTAAGTTTAATCTGACTTCGGGCATCTGAAGTCGAGGTCTTGGAGTGTGGTATCGTGCTGTCTGAGTCAA
+ TCGATACCTCCTCTGAAGTGGCCTCTAGAGATGCTTCAACCAGCGAGCCTTCGACCAAATGCGTAGCAGC
+ ACCTGTAGCAGCCACATTGGGTGCCATTTGGTTTGCTTCCGTGCAATGTAGAAGAAGATTTGGTGCAGGT
+ GTGGGATTGGGACCAGTTGGAGGTGCAACTAGTGCCGTTGGTCCTGAATGCTGTTTGCTGGGCGAGGTTC
+ CAGTGCCAGTTGCTCGCAGTGCCGACTGGAACTGGCGTTCGTCCTCCTCGTTGAACTCGCTGAGTGTCTG
+ ATCGGCGGTTCCCGAGTCAAACGCACCCAGAAGATTATTCTGGTAGGCCTCTTGAGATGCTGTACTGTGC
+ GGTGCCTCAAATCCGAGATTGTATGTTCTCATGTCCACAGGTCCCGGCAGCACTGGATGGAGGAGAGGAT
+ TTGTGGTTGTTGCAGTTGTCGGTGTAGTGGTTGGCTTGTTTTGAACTCGTGGAGCTCGAAGCTCAAAACT
+ TCTTCGCCGATCCCTTAGCGATTGCAGATTCTCCACACCAGGTCCTGCCATGTCGTCAAACTCGTTGTTG
+ AACTCAAAGGGAGTTCCGACCAAATTATTGACTATATGAGTATTGCTCCCGTAATCTGACATTGGCGGTG
+ GCAGTACCATAGCCATCCCACTGGTAACTCCTCCTCCACGTCCTCTACCCCTTCCTCGTCCCCTGCCCCT
+ GCCTGGTGCTCCAGAGCCGCCGCTACCGCGCGGTGCACGCTGGCGCGGCTTTCCCTGTAATGTGTGCGTC
+ TGGGGGTCATATTTAGTCGGCGGCAATGCCACCACGGGAACTGGTGCAGGAGGCGTTGGTGGCTGCAGAG
+ GCTGTCTGGGCGACTTTCCTGGCGATTTTCCTTGCGGAAGTTGGGGCGATTTGTGCGTCTGTTTTTTAGA
+ TAAGTTACTACCGCTGACGCTTGTTCTCTTGCTTGGCGAGTCCTTTGCTGTAGCTGTAACCGGTGGGGTT
+ GGTGGCATCATCGACGCAACGACTGCTTCTGCACAGCTGCTTAGAAGCTGAGCCGGATATGTCGGCATTT
+ TTCCATCAATCGGCGAAGTCAGAGTAAACGGATTATTGGGTGTAGTTGCAGTTTGAACGGGAACTGTTGA
+ AAGCGCAGGCTGTTGTACAGAAATCATACCCAAAGTAGTCGCGGAATAAGGTGTTCCGGGGTACTGGTTG
+ ACCTGAGCCGGTGGAGGTAGTGTAGTGGACTGCACAGCGCCTCCAACTCCCCCATTGCCGTATAAGCTTG
+ AAGGCGGTTCTGTAGGAGTTGTCTGTGGATGCATGATACCCGCTAGTTGGGGGTAGATAGTTCCGTTGTA
+ CTGATTGTTTGGAGTTCTCTGCTGTTGCTGTTGATGAGCTGGCGTCGTCGGTTGATGCTGAGTCGTATTA
+ GTATTGTTGAACATTGGTATGGAATCAATACCGTTCACCATTGGAGGATGGTTAAAGGGCGCTGTAGCGT
+ TTGCTGCAGTGCCAGGCCCGGCATTACCGCTTGGATAGCTGTTGAAAAAGTTTTTACAGCTCTCAAGCTG
+ AGCGAGGGATCGAGCCGTTGTTGCTGTTGCCGTAACGACTGGAGGTGGCTGAGGAGGATCATTGGATTCG
+ GACACTGAACTAGGCGAGCTGCTTCTTCTCTCAGCGATAAGATCGCTTTCGTTCCACGGCATTCCCCCGA
+ ACGGCGACTGCATTCGTGTGCTCTCATCGTAGTCGTTGATCTTCGCATTGACTCCCGTTCCGGATTGCGT
+ GGGAACGGTTGCTGCTCCGCGAAAGCTTCCGAGAGTGTTCTTTACCGCTGCTGCTGCCAAGTCTACAAAG
+ TCAGGAGTGGGTGCAGGTTGCCCTACATTAGCTCCTCCGTTGCTGGATAGGGGACAAGCCCCTTTTTGGT
+ GGGGTGATTTTTCCAGGAAGAGACCTAACGTTGGAGGTGGCTGAGAGTTCGGAAAATTTACTTGATACCC
+ AAGATTGTTCATTGTTGCGTTGGTGGGTGTAGCATTTGGAGTGTTGGTGAGACTGTTTGCATAGCTTCCA
+ CTGTTGGCTGTCATAGGAGAATCCTTGATAGTCAATGATGCAACAGAGTTAGGTCCTGATGAGTTTCCAT
+ AAATACATGTTTGAGATGATTGCAGCTGTTGTTGCTGTTGGTGCTGCTGTTCTTTTTGCGCATGAATGAT
+ ATCCTCTGGGTCCGCCGCATTGTGAAAAGGAAAAACCGATGGGATGGCTGGAGTTGGAGGTAATAGATCG
+ ACCGCCTCCTTGCTACTGCAGTCATCCTGCGCCTTGCGCTTTGTTTTGCGCAGTTTCTCTAAGAGATTTC
+ GGGTTGCTTGGATGCTATCCTCCTCACTTATTTGCTTACTCCTGTCTATACTAGACCCGATTAGACTCAT
+ CTGATTGGGAGGATTTAACACACTGGCTAAGTTTGACGCGAAGTTGTTAGCAAACTTACTGTCCTCCATC
+ TCAAGTATTGTCTCAACGATGGGTAAGTGCTCGACAGGCAGTTGCTCGATTAGAGGCCGTTGTGAGGGCA
+ GCAGCTGTTGCTGCATAACTGTTGGTACAACATCTGCAGCAGGGGATTGTACAACAAGCGGAGGCGGCAG
+ GGGTTGGTCATGTAGATGCTGCTGTTGCTGCTCTGCAGAATTCGAGTCCAGTTCAATTATTTCCGGCGGA
+ TCGGGCGGAATCACAGTGACTGCTGGAGAGGATGTAGACGCCGAGTACTTACTCGCATTTGCAAGCAGCT
+ CGTTTTTACGTTCCTCTTCCAGCTCCCTAGCCATTTCCATCTCGTTGAGGAGATGTTGGGTGTGATGAGT
+ GTGTTCCTCGTCTGGCTCGTGACTACGTCTCCTTCTTCTCCGTCGGGATCGCCAGCGCATACGCCGCCGT
+ TCGCTGAGATCACTTCCAGCGTCAGACATCTCGTCATTAGAGGTAGGGGTAGGAGTGGGCGAGGCGGGAA
+ GCGGAGCCGCCGGTGGACGCTCATCATCGATTATGTCTGCCAGTTTACTCGCGCTCGCAGATAGTTGGGT
+ TCGCGTTGGAGCAGTGGTAAGCTCCTCATCAATATCCATTGGTAGTTCACCAGCTTCTGCCGCAGACTCT
+ GGGTCCAGATCGGGTTCGGGTTGCGCATCTGCTCCCAAGTTAATCTGTTGGATGGACACCTCATCGGGTT
+ TAAGATCACATTGATCTTTTACGATACGTGTTTCAGAAGCAGGTGGAGTTGGTGAAATTGGTGGGGGTGT
+ AGCTTGAGCAGAATGGTTCATCTGCTGCTGTTTCTTATTTAACAGCTTGTCCAACGAACTAGTCCCTTTT
+ CCGCTAGCTACTTTTCTCTGGCTTATTTCTTGTTCCAAATTTGCAACCTTCTTAGGAGATTCTTCCGCTC
+ GAGATTTACATCTGGATACTGTCTTTTCTGGAGACGATTTAGCAGTAGGCGAGGGCGGTCGCGACTTGGA
+ ACCGCGAGTCGCTCTTTTGGTAGCCTGTTCCAACTGGACCTGCTTTCCACATTCGTCCATAGAGCCCTGC
+ AGACGATTTGTTTTCGGCGTACATTTGACGTCATCCTCAACTGATTGCACTGCCTTCTGCAGTGCTACCT
+ TTGTCGATTTTGTTGTAGAGTTCTGACGAGACCGCGTAGACGGTATGTTCAATACATTGACCGATGCTGG
+ CGCAATAGTTAATGCTGAAGGCTTATCCATAGACTTGCGGGGTGAACGTTTTGGCACAAGAGAGGAATCA
+ GATGGCACTTTCGCAGGGGCTACAGGAGGCTCCCTACTAGATGGGTTTTCCGAATTGCTGGCCTGAGACT
+ CGCTGTCCGAGTCGCTGCCGCCACTGCTGGAACTACTTCCTGAGCTGCTAGAGGAGCTGGAACTTTCACT
+ GTCGCCAGAACTAGAACTTGAAAGATTTGGGACAACTACGCGGCGCTTAACCAGGGGAGTTGTTTTTATA
+ GGTGTCGCCAGCAAATCTTCTTTTGATTTTCTTCTGCCACTTAAGGGTTCCTTTGGAGTAATTGGTGCTT
+ CTTTAATTGAGGACCGTCTGGTAGGCTTAACTGGCGTGCTAGCCGCTGGAACAGATGATCCTGATCCGGA
+ TATCGTTGCCGACGTCACTGTTTCTTTGTCCGAAATGTCGTTCCCCGTTGAGAAAGATTCTAGAACGGGT
+ TTGCTACTCTTTAATTGCTCCGCTGCCTTCTTAGCCGCTTGCCGTTGAGGAACCAATGAGACTGCAAAGT
+ TCGACTTGGCTGAGACTGGGGTAGCGACGACAGATGGGGGCTTGCTTTGAGTATGCGTTGGGAGGGCAGG
+ CTTGTCATTTTCCGTAATAGATGGCGGACGTGCATCCTTTGGGACCTTTGGTGGCCTTCCGCGCTTTCCA
+ CGTTCAGCAGGTGCGCTTTCGGACGTTTTTCCAACAGTCTTCTGTAAGTGTTCTTTTGGTCGTACTTTTT
+ CAAGACTTGATTTATCCGCTTCATTCGACACACGAGAGCTTGAATCCTTCACCTTGCTCTTTGCAGTTCC
+ TGAAATGGAGTTTATGTCTGGCTCTCTGACTCTGTCGGACACATCTGGCTGTAGCGTCGTGGCGAGATTT
+ GTGGATCGCATGTTCTCAGAAGCCTTTTTGGCTGCCTGGCGCTGTGGCACCACCAAAAGATCTGCCGGAT
+ ACAACTTGGCATTCGGGTTCGGTTTGGTTTTTGTACTGTTGCCGATACTGGCAGCCCCTTCCTTTCCTTC
+ CCGCGTGTTCTTCGCTTTACTAGTTGAGGACGCTGCTTGGGAAGTAGAGGATGTTGTGGCTGCTGTTCCT
+ GGCACAAACTCTTTCATAGCTGCCTTTGTTCTAATCGTCTGTTGGTTTTGTGAGTCACTAACATTACTTT
+ CCACGGTGGCCTGCTCCTCCTGGTCTTTTTCTTGTTCAGAGGAACTGCTCTCAGAGTCGGAGTAGATATG
+ CTGTCCCAAGTTTCTACCAATGGCCGAACCAGTCGTGGCTAGTCCGGAAGTCGTTGTGCTCTCACGCTGT
+ CGTTCCCCTCTTAGAGGCAACAATTCCTCACTTTCGTCGCTCGATACGCTCTCATCGGCATCTTTATCCA
+ TTTGGGCAAGTCCTCGTGTTGTCGTAGACAACTTTCGTCTTGCAGAGGCTCCAGTTCCCTCTCCAACGTC
+ TGCTTCCGTTGTAGGTTTTGACCTACTTGCCTGGCTCCTATTAGGTACTGATTTGCTTTGAATTGGCCCC
+ CGTCTCGCACCGCGCTCTGGTTCTTGGCGGTTTCTACATCGCTCGTCTTCACCGTCGCTGGAGCTGCTTG
+ CAGACCTGGAATCCGGATACGTTGCAGACGCACCCGCAACTGCTTCATTTTGACGTCGCTGTCGCTGTTT
+ TTGCCGCTGCTCAACGGACCGAGCGTAGCTTTGCTTTTTAAGGGGACTTCCTGAGGAAGACTTTCGCTTG
+ GAGACTCCGCTACCCGCGCTAGAGCTACCGCTTTCACTACCCGAATCACTTCCTGAGGAACTATCGGAGC
+ TGCTGGTACCATTCGCCGAGCTGGAATTACCTGATGATATAGTGCCGCTTGACGAATGGGAGGTCGTGCT
+ ACTGCGGATATTTGAGTGGAATTGACTTTTGTTGTGGGTCGACGTCGCCGCCGCCGCGCTGCTCTTCGAG
+ GCACGCCTCCCTGTAGGATTCTTCCCTGGCGGAGACCGTACCTTGGATGTAGTCGTTCCCACCTTACTCC
+ CTGCCACAGTCTTCTCAGGCGATGACGTGCGTGAACTAAGAATGCCATTATTAAGCTTCTTGTTTGGCGA
+ AGCTTTAGCAGGCTGCTTGCGTTTGTTAGGAGACTGCGAGGCACGGCCACGGCCCTGTTTACCACTCTGC
+ AGCTTACCCATAAGCTGTTCAAGGATGTATTTCAAATCCTGGTACTGCGCCGGCACAGTTTGTCCTCCCA
+ CAGAGCTGTAGAAACGGTCATACAAAGTAGGTCCGTCGTTGGCGTAGATTACAGCGTTCAGATCCATCAC
+ AGGTTGTTGCTGCTCTTGTTTGGTCTGCTGCTTCTCCAAGCGCATCTCATCCAGAACTCCCAGCTGCTTG
+ TAGAATACCTGCTCACGTAGCTTAAAGAGAGAGCGCGAAAGCTTTTCTCTTCGACTAACCATATAGCAGA
+ GATTACGAACTCGCTCCAAATCCTGTCGCAAATGCACCACCAACTTATGATTTTCCATGTCCTGTTGCTC
+ CTGCTTGCGGGCTATCATCTCCACATCTTCGGACTTGGGCGGGATAAGCTCGCGATTGTGTCGAGACTTT
+ CTCTTAAGCTTCCAATAATTGTATATGGCAACAATAGCATCGTCGTCGACATCAAATAGATGGCAACTGA
+ TGTCATTAAAGTTAACATGCTTATCGAACTCAGCTTCCACCTCCTGAAAATCAATGGGAAAAGTTAGCAA
+ CCGAATGCATGCAGAAGGCACAACGGAAAAGAAACTACTAACCTGGAGGCGCTGAGCTCTGGCTTGGTTA
+ CGTTCCTCGGAGGTCAGTTCGGTTTTACGGTGATTTTTCCGCCTGCGTGGATCCTCTCCAGTTGTCCCGC
+ ACGCGTTGTTGCCGTCGTCGGCTCCTCCACCAGCCCCACTGCCGTATCTGTTTGCTTTCTGCATGGCGCT
+ TGCGACTGAGGCACTGCCTCCCCCATGACTACCAGCATTTTCCTTCTTACCCTTGCTCATACTGTGTTTC
+ TGACAATAAGAGCGCAGCTTCACGCCGTCCTCAGCATTACCTTCCTCTATGATTGCACGCATTTCCAGGC
+ CATGCTGAAACGCGCAAGTCACATGGTATGCTGTTTTGCAGGGCTTTACTGAGCACTGGATGCAGCTGCC
+ AACTCGCTTTCGGCAGAGTACACAGATCAGGGACCAACGCGACTGAGGAATGCTAGAGATTTTCGTGATG
+ GGTTCCATGCGATCCACACACCCAATGCTGACCTCGGGTATCCACAGAGCGCAAGAGACGTGTGCCCAGT
+ GCTTACCCGACTTGTTGGATTTCATAGCGCCGCCCTTATTTGGACAGAGGACACAGTCCGGCTTAATTCC
+ CATCGAACAAGTGCGGCATAGCCATTGTCCTGAAACAAAAGTTTACATGAGCACACTAACATTTCCACTC
+ CACTAGGTGCTGCTTACCTGATGGAATTGCTGTAATGCCATAACACGCCTGGTGCACACAGATATTGCAA
+ TTATCACAGAATACCATTTCGTTCGCCTCCTCGGAGTCGGGCGATCGGCAAACATCGCAGATGACATTCT
+ CATCGAATTCGATGCCCAAGCCTTCTTCCAGTTTAAGTATGACTTGAATCTGTTCCCAGCAACGAACCTA
+ GAACGCAAAAGTCAATATATTGGTTCAGCATGGGGTCTAGTGAGCTTACCTCTAGCTCCTCAATGACGCG
+ CTCAAACTGCGTCGCGTTTATGGGAAAAGCACCACATTGGGCACGATCGCTGTTGTAGAGACGCAACCAG
+ GCCTCGTCAATAGGATCTATATCATAGGCACATGTGTTCTCCGCCAAGGCAACAACATTCGTCAGGTAAT
+ GCAGATCCGGCGAGTAGTGCTCGTCTTTGGTAATGCGCAGATAGCGATTTTTCGGGCTGTAAACGAGAGC
+ CGCAGTTCAGTACAGAAATTCACAAGTACGAAAAAAAAATATGCTAGGTATTAACTTACAGCTTAAAGTC
+ GTGCGCTGGAGACACAACAGGCTCGGGCAGAACATAGACGCATGGCTCAGGAAGGGAGTCTGGGTTAACG
+ GGCACTTGCACACCCTTTTCCCATTCCTGCTTCCATGGGTCTGTTACTATTAAATACTCGTAGTTGGCCA
+ ACGGCTCAGAGTCTGGCAATTTCATTGCGCTAATGAGATCCTTGCTGCAATTAAAATTTGAATATTATTG
+ AATCGTTTCTAATTGGTTTGCTGGTCTGTTAATACCGGTAAAGTTCAGCTGGAGCTTCCGTTGAGCTTCG
+ ATTGTAGATGCTCGACATCTTGATGTCCGCTACAGACCGCGCCTGCCAGGAGCTACTAGAACTCGCCCCC
+ TGCGACTTGCACTTGCTTGCCGACTTTGCCAGTTTCGTTGACTTCGATTTGCTAGTGCTGGTAGCGCCTG
+ CCGCGGCTCTTCCTTGTCCTCCTCCCCCCGCTTCCGCCCCTGGCTCTTCATGTTTGCTTTTGCACAAAGG
+ CAGAACTGGCACACGCTCCGATCCTGTAGCTGGACCCGATCCAGTCACTTCAGCTACTGCTGCCGTAGTG
+ GCTCCATTAGGTGGCCTACCTTTGCGCCGCTTGGTGGGCGGCGGCTGCGGCTCAACATCCTTGCGCTGAT
+ GCTGTTGCGGCGGCGGATGGTGCGACTGGTGATGCTGCTGATTACCGCGCTTACCTCTTTGTGACATTTT
+ TCATTGGTGTTGATTGGATATTTGTGTGTTTTTGCTTCGATTGGTACCTTGTCCCTTGTGTCTTGTGCTT
+ GTTAGAGAACGGGTTCTTTGCTGCAAGACCTAGAAGTAAGAAGGCAAAAGCAGCTTCAATACGTATTTCA
+ CGCGATTTATTTACTAACCAAATTTACTTACTACATGCTTAAGGCCACAGTTGGCGACACCACACCGGCT
+ GCTGCTGCTGCGCTCTCCTGGATGTGGTGCGGTCGTGATTCTTGGTGGTCCACCCTTTGTGCCCCGTGGA
+ CATGGACGCCGCTGCTGCCCCAGCCCTAATATCCAGTAGCGACGCCACTTTGCAGTCCTGTGTGCTCCGC
+ ACTTCTCCACGGGCGAGTTAGTCCACTTCCACTGCCACCTTCCGCTTGCTGCCTTTTGTTATTGTTCGTT
+ GTTTATCCACAGACTTTTGCAAGTTTTTCTTTGGCGTTTGGCTCACTGGTTTGGATTCTCGACGAGCATT
+ CGCTAGTCTGGTGGGAGAGAAGGCATATGTTTGTGGGTTATTCGCTTATATTAGGAGCGTTCCCAGTAAG
+ TGTCCACATTTTCTATGCTTTCCGAAAATACACAAAAAATATAGAAAAACGTTCAAGCTGCCAATAGGTG
+ ACTGGTGCAAAACCCACAGGCGCCCTCCCGCTCGCACATAGCACGCTCGTTTAAGGGCGCGCTTACTATG
+ CGCGTGAGTGCAAGCAGGAGGCAAGCAGGTGGCGTTCGTGTTGCATCCGCCAGCTTATACACGGCACCCA
+ GCATACCCCTCCGACACTTCACTACTCAGAAGCAATCAAAGTTTTTGCACTTTTTTTTACACTTTTATTA
+ TAACAACTTATTTGTTATTGCTATCCGCAAACCTAGACAGCCACTCTGCTCGTCGCTAGCGCTTCCGCAC
+ GCGACACGCCCACTCAGGGCGCCACTTTCGCACTGCCCATTCTTGGGGGAGTTGGGATTTTGTTATATAT
+ TTTACATTTGGGTTTTTTGCCGCCGCAGACACACACGCCAAGCACTTGTTACTGACCGAAGACCGCTCAC
+ AGTCTTCGCATTTCGTGAAGCGTCCGTATCAAACTCACGTTTCCCAAAATCGCATTTGCGTTCGCAGGAA
+ TTACAATTCTTTTGATTATTTATTTTATTTTTGAGCAAAAATTATTTTTCTCAGATCGCCATGATGAACG
+ GTTGCAAATTTAAACTATCGAGTGCATTTAGTCGGTGGTCGGTATCGATACACAGCTTGGGTATATACAG
+ AGTTGCATTCGGCCCAACGCTGTATTTTGTTTTAACAACATTTAATTAATTTCCACAGAATTTTCATATT
+ AATTTGTATTTGAAAAAAAAAGTTATTTCCATTAAGTTAAGATATGTTAATTAAGAATTTTCTTATTATT
+ ACCTCTAAATATTATAGATTTTCTTAACTTAATAGAAGTTAATAATTATGTAACAAACAATGTCGAAATG
+ ATGAAATTACAATCTTTTTATTTTTTTAGAGAGGAATTTTTTATTCGTTAAAAAAAACCCGATAAGCTGA
+ AAACAAACATCGCGATTGAAGATAAATATCGGTTAAAAATATGTTATTGTGATTACAGAGGAAAACTATC
+ GACTGAGCGCACCCAGGAGCCCATCTCCAGCACCAACAAGAAAAAATATGTATATTTATAACTATATGTA
+ AAAAGGAAAAAGTCGCGTCGCACAAAGGTAACGTGAATACTATTTAATCGGACCTCTGATGCAGCGATAA
+ GCAGGCTTTTTTTCAACGGAGCCTCGCTAATTTGACCGCCCTCTGCCAGATTGTCTTTGTCTCTCTCGAA
+ AAGTCGGTGGAACGGTGTTGTACTGGAATATTTGAAGAGTGGCTCATCAAACGCAACAAACATGTCAAAC
+ ACTCCAAGTCTGAACAGTAGTAGTAGCAATATCAGTAGCAAGGCGCCCCTTGCCCAGAAGCAGGACACGT
+ ACAGTAGCGACAGCAGCGAGGAAGTTCTCGAAACAGCCGAGGAGCGGAGGAGGCGCATCCTGAAGGAGCG
+ CAGCCGGCTGAACCGTCCGCAGCACAATATGTCAGGCGGAGGTGCTGTGCCCAAGCACGACATAAAATCC
+ CCTTGCGGAGCATCTCCCAGCTGCCAGGCAACTGGTTCCGGAATGGGCCGCCTGCCGCTCCCTCCCGAAA
+ GGATCACCATGCTGGTGGACGGTGTGCGCTTCACGGTGGAGCAATCACTGCTTACAGCACATCCCACCAC
+ AATGCTTGGCACGATGTTCGGCTCCGGCTTCCAGTTCGCTCATACCAACGAGCGCGGCGAGTACGACGTT
+ GCCGACGGCATTTCGCACTTAGTGTTCAGAGCCATTCTGGAGTACTACAAAAGCGGTGTTATCCGCTGCC
+ CGCCCACTGTTTCGGTACCGGAACTAAAAGAAGCCTGTGATTATCTGCTCATTCCCTTCGACGCAACCAC
+ GGTGCGCTGCCAGAACCTAAGTGAGTATAACGCGAACTATTCCTGCCAGGGCGAACCTTAGTTGTGGCCA
+ CCTCTGCTTGTTTTCCGTCTCTTTCCTTGTAACATGCCCTCTGTTATGTTTGACATAAAGGAGGCCTTCT
+ CCACGAGCTTAGCAACGAAGGAGCGCGACAACAATTTGAACTCTTTCTTGAGGACCTAATTCTGCCCCTC
+ ATGGTGGCCTCGGCGCAGCGCGGGGATCGAGAGTGTCACGTTGTGGTGCTCCTTGAAGACGATATGGTCG
+ AGTGGGATGAAGAGTTTCCGCCTCAGATGGGCGAGGAGTATTGTCAGAGTGAGTGTATTTAAAAAATGTG
+ TTTGCATTAGTATCACGGAAGTGGAAGCAACACTAACATTTCTAACGCAGCCGTGCACAGCACTGCCATG
+ CACCGATTCTTCAAGTACATCGAGAACCGCGATGTGGCCAAACAGGTGATGAAGGATCGCGGTCTGAAGA
+ AGATACGCTGTGGCATAGAGGGATACCCCACCCACAAAGAGAAGATCCGAAGGCGTCCCGGTGGACGGGC
+ TGAAGTCATCTACAGCTATGTGCAGCGACCTTTCATCCACATGTCCTGGGAGAAGGAGGAAGCAAAGAGT
+ CGCCATGTTGATTTCCAATGTGTAAAATCCAAGTCTGTAACGAATCTAGCGGAAGCAAATGCAGATCCGC
+ CACTGGAATTGGACGCAAGTGCGTAAGGCTCGAAACGGAGAGTAACAGCTCCCTTAAAGCCCAAATTCGT
+ TTTCAGGTGGAAATCCGATTCCCCCTATAGCAGTGGCTAATCCGCATCCCAATAACGCTGAGCTCGCTGC
+ CGGTATGGCCGTCGCACCCGCAGCTATAGGCGTGGCTGGTCCAGCAGTCGTGGTAGCCGTCGACGAGGCG
+ GCCGGGGGCGTTGTAATGCTCAACGAGTTGGACCAGGCAGCGATCGCTGTTGCCGTCGGAATAGTTGATG
+ AAAATATGTAGATCAACTGACCGGCTGGTAGTCGGAACACACTGCCAGAGCATCACAGCGCACAGAAAAA
+ CACTTTACGTTTTTAATTAACATTTTTATATGTATATGTAATAAATGGAAATTTCGAATACGAAAAACCA
+ AGCAATTGATTTACGAATAGAAGAACATGAACGTTACCAGACATTAGCTGTGATCACGCTCCGTCAAAGG
+ CCTCCCGTTCGCCCTGTGGAAGCGTCGAAGTCTCCCAGTTCAGTGAACGATCGATAGCCATTTTCCACTT
+ TTGGTAGCGCAGGTTGCGATCGGTGGCACTGATCGATGGCTTTATGGCTTCTCGGGGGCCAGATTTAGAG
+ AGTGGAGCCTCCATTTGGTATCGGTTTTCAACGGCTTTGTAGGCTGCCATTGCAGCTCCCTAAAGCATTT
+ TTGAAGCATTATTGAAGCTGCATTTACATCACAAGTTAAAGTACTAACCAGCGCTGTTGTCTCTGCGATC
+ TTCGCCCGGAGTACTTGAATTCCTACTAGGTCGGATTGAAGCTGCAGGAACAGATTATTCACAGTCATGC
+ CCCCGTCTACCATAAGCTTGGCCAGTGGAATCTTGCAGTCCTTGTGCATCGAATCGAGAATATCACGGAC
+ CTGGAAACAAACTGCTTCCAGGGTGGCTCTTACTATGTGCTCACTTGTTGTTTCTTCACTCAGTCCACAA
+ ATGACACCGCGAGCGTCCTGATTCCAGTAGGGGGCGTAGAGTCCATTGAAAGCTGGTACGAAGTATACGT
+ CAAGAGAGTTGTCCACAGTGCTAGCCATGGTTTCGATCTGCCCCGAGTTTTGAATAAGGTTCATGTTGTC
+ GCGCAGCCAGTTGAATGCTGCACCGGCAATGGACACGCTTCCCTCAAGGGCGTAAAATGGGACTGCCTTC
+ CGTCCTAGTTGGTAGCCAACAGTCGTTAGTAATCCGTGCGTTGAGTGTACAATTGAAGGTCCTGTGTTAT
+ AAAGCAGAAAACATCCAGTGCCATAAGTGGCTTTGGCCTGACCTTTGGCCAGGCATTGTTGACCCACTAG
+ AGCGGCTTGCTGGTCGCCCAGAACCGATGTTATGCCTATGCCTTGCAGAACGCCCTGCGCAATGCTGCCA
+ TAGAACTCTGAGCTCGAGCAGATCTCCGGCAAAATGGTCTTGGGCAGCCCAAAGAACTTTAGCAAGTTGG
+ CATCCCACTGAAGGGTCTCGATGTTCATGAGCATAGTGCGCGAAGCGTTGGTCACATCCGTCTTGTGGAC
+ ACCACAGTCCTTCCCGCCCGTAAGATTATACATTAGCCAGGTGTCGATGGTGCCAAACATGGCCGTGCCC
+ TTCTCCATAGCCTGGCTGACAACCGGCACGTTGTCTCGAAGCCAGCGTAGTTTCACGCCCGAAAAGTACG
+ GAGACAGAGGAAGTCCGCACAATGGGCGCAGGTAGTTGATGTTCCTGGCATTGTTCGGAATAGTCTCCAA
+ AAGCTCCTCCACCGTGCTGGTGGTACGATTGTCTAGCCAGATGATAGCGTTCACCAGCGGTTGGCCGGAG
+ TTTCTATCCCATACGACTGTGGACTCGCGTTGGTTTGTTATTCCAATCGTGATTATTTCCTGAAACGAGG
+ CGAAAGCTTAGGATTCTATTTCAAATATTCGAATTAAGTTAAAACGGTCAACTCTTGTATATTCTTTCCT
+ TGGTTGTGTGTGTACACACTTGTTTGCCATTCTCTGGGAAACGCCGTAAGCTAGGGGAATGGTAAAGAGA
+ GCAGCGCAGTAAACAACTAGGTAAAAATAATTGATAACATCTTACGACGTAACGATTCGAAAATTTTCCA
+ CAGCCGGCGACCCGTTTCAATGTCAACTCTAGTTAATACCACGAGACGCAGCATTGTGATCGCCATTCAT
+ CAGCAGCTACGCAGGATGTCCGTCCAAAAGAGGAAGGATCAAAGTGCGACCATTGCTGTGGGTCAGATGC
+ GCTCTACCAGCGACAAGGCGGCTAATCTTAGCCAAGTGATAGAGCTAGTGGATAGGGCCAAGTCACAGAA
+ CGCCTGCATGCTCTTTCTGCCTGAGTGCTGTGACTTTGTGGGCGAGAGCCGGACCCAAACTATTGAGCTC
+ TCCGAGGGCTTGGACGGCGAGTTAATGGCGCAGTACCGGGAATTGGCGAAGTGCAACAAAATTTGGATTT
+ CCCTGGGTGGCGTGCACGAGCGGAACGATCAAAAAATCTTCAACGCTCATGTTTTGCTCAACGAGAAAGG
+ GGAACTAGCAGCAGTATACAGAAAGCTGCACATGTTTGATGTTACGACTAAAGAGGTTCGCCTACGCGAA
+ TCAGATACAGTTACGCCGGGATACTGCCTTGAGCGCCCAGTGAGCACTCCAGTTGGCCAGATAGGGCTTC
+ AGATTTGCTACGACCTGCGTTTTGCTGAGCCGGCGGTGCTGCTCAGGAAGCTGGGTGCCAATTTGTTAAC
+ ATACCCATCCGCATTCACATACGCAACCGGTAAGGCGCACTGGGAAATCCTCCTGCGGGCCAGAGCCATA
+ GAGACTCAATGCTTTGTGGTCGCTGCGGCTCAGATAGGTTGGCACAACCAGAAGCGACAGAGTTGGGGCC
+ ACAGCATGATCGTTAGCCCCTGGGGAAACGTACTGGCTGACTGCAGCGAGCAGGAGCTTGATATAGGCAC
+ GGCCGAGGTGGACCTTTCCGTGCTTCAATCTCTGTATCAGACCATGCCCTGCTTCGAACATCGTCGAAAC
+ GACATCTACGCCTTAACAGCCTACAACCTTCGTAGCAAAGAACCAACCCAGGATCGACCATTTGCCACTA
+ ATATCGTGGACAAGCGCACAATTTTTTATGAGTCTGAGCACTGCTTTGCATTCACCAACCTGCGCTGTGT
+ TGTAAAGGGTCACGTCCTTGTGTCCACTAAGCGAGTGACTCCGCGCCTTTGTGGCCTCGACTGTGCCGAA
+ ATGGCGGATATGTTCACCACTGTGTGTCTGGTGCAAAGATTGCTTGAGAAGATTTACCAGACAACTTCCG
+ CCACCGTCACTGTGCAAGATGGTGCACAGGCGGGACAAACTGTTCCCCATGTACACTTTCATATAATGCC
+ CCGCCGTCTGGGAGACTTCGGGCACAATGACCAGATCTACGTGAAACTAGATGAGCGCGCCGAGGAGAAG
+ CCTCCGCGTACCATCGAGGAAAGGATCGAGGAGGCGCAAATTTATCGCAAATTTCTGACGGACATAAGCT
+ AGCTTTTTACCCCACCCCTTTTCCTGCCATGTGATTTATGAAGAACATATAATAAAGAGATAGATTTTCA
+ ATCGGCCATTTCGGAATAGATCAGATGAGGGAATCGATTCATCTGAAATTGACGTACCTCAACCTTCCCG
+ CCCACGGCCACAAGTTTCTTGCAGGCACCGGTGATGCACTCGTTGACCGTATTCACTATGGCCATGGGAT
+ CCTGCTCGCACCATCCCTCCTTCTGGAAAATAGACTCCACTTCAATCTGATGAAAGCACACAATTTCGTC
+ AGTGCCCGCACGAAATATAATAAATCGCGCGGAAGTGGTTCCCTCGTCAATAGCCCCAACGAATGGACCA
+ GATAGCGTGGGTGGAGGCGGTGTCGTTTCGGTTGTGGGAGAATCCATTTTTTTTACGTGGTGTCCAGAGT
+ TCACCTTTACAGTCAATAAATGCCAGCACGCTTTCTCGCGAGATTGTTTCACACTAAAATTAGTTATTGG
+ AATCTTGTCGACATATTCGACGGAAATTATGCGATAAGAGATAAGGTGAGCGAGCCTTCTCTTTGCAAAT
+ CGTTACGATAGCGGTGTGTGCAAGCTAAAAACCCGTCGGATAGTAAATATTTACTGCGAATGGGCGCGAC
+ ATAACGTTTATGCATCATAAAGAACGTGATTTTTGCTATCGGGAACAAACCTTAAAATTATAAATCATTT
+ ATTTCTTCATTAAGTGCATTATAATTTAATATTTACATATTAAAATTTTGTTATAGGTAATTTTTCACAA
+ AATACACCTATATATAAAACGTATTGCGCATAAACGAACATTCACAACGAAATAATGTGTCTGGTAAGTG
+ GGGTAACACTTTTGCACGCAGGCTAAAGAGTATCAGCTGATCTGAACGCCAAACTGGATAATAACAAAAA
+ TATCCAGTTTGTTACCGCCAAGTAAACTAGTATATTCCGACATGATGATTTCAGACAGTCAGAAGAAAGG
+ ACTGCGGGAGTTACTTCTAAATGACAAGAACTTAACTGTTCTGCTACAGTTGGCCAAAGGGGCCACCAAA
+ AATATGTGCAAAACCGAAGACCCGGAGGGTAAGATTTAATTTTGGAATTTGCACAACCAATAAGTATTTT
+ GTATTTAACTTGCAGAGGCCCTTCGTCTGATCACTACACACATTCCAGACATTTACGTACTGCTTTCCAA
+ GCGCGCTATAAAAAAGGAACTCCTCTTTACGTATTTGAGCAATCGACGCGCTGACGCAGCCACAGACTTT
+ AGCAAGGCAGACCTCATAGCCAAGGTTATACAGTATTGGAAGCAGGAGCATAAATCAAGCATAGAGCTTT
+ CCGGAGACCAGACTTCCAGCTCACTTCATATTCAGAGCGAAGAGGATTATCCCATTCACACGATTGCCCG
+ CAAGTTCGGCGAGTGGTTCTTCGAACGCTTCAACGCAGACGCCCTTAGTCTGGTGGATTTATGGGCAGAT
+ GCGGCTCTACATCTCACGATCATAGCCAGTGATGGAATCAATGAGTGGGAGTGTACGACGGCTGCCGAGG
+ TGTTATCGGCACTAACGAGCGCTAAGCAGCAGTTTGACTTTTACTTTAATCCAAACCTGACGCACGCCGG
+ AATTCAGGGTCGAATGGACTCGTACGGACATTTCTTAGTGATCTGCTGCGGCACTCTGCACTCCCGTGAT
+ AGCTGCGTCGGAATCTTTGAATGTGCCTTCGGGCTTTTTCGGGACCCCTTGGCTGACAACAACTGGAAAC
+ CCAAAAAAGTGAAGTGCTTCCTTAAAAGTGAAGCTCAGCCCCCAGAGCTGCACTATCTGTGCTCGAGCGA
+ AACTCTGCAGACAGCTCTGGAGCTGTCAGTACCCTCTGATGACTTGAACTAGCGGACTGTTATGTATCAG
+ CCCGTCCACATGAAGTATAATTTCAAAAAGAACTGAATACTTACTTGGACAGAACTATATTAATCAATTT
+ GCTCTATGAATGTTCTACTTAATATACTCACGAGTTGAAACTGCAAGGCGTGGAACAAATGTGTTGACTG
+ CACAAACTGCAAAATTAAAGAAAACAAATTTATTAAAGAAGTGTGGGTTAAAAAATATGAGCTGAATCTG
+ ACAGTTAGTCACTCAGATTTGAGCTTATATGCCTGATACTTTCTTCGACCAACCGAAGATACGATTTTCT
+ ATTTTACCAACTAAATTCTTTTTGTTTACTATTTAACAAATTCATATTATAATCATTGAGATACTTTTAG
+ GACATCCAATTTACGCAAGAAACTATATACATTAAAAAATTGTTATTAATAGTGTTAGTTATTGGTAATA
+ TTAGGTAAATCGGAGGGACATACAGCGTTTGAATTGTGTTAGGTATCCTCTGCTAAATCGTGAGTGTAAA
+ TTATTACCAGTTCAGCCAGCCACAAGGCCAAAGAAGGCTCGCCCGTAACAAGCGGCACACTGAAATTTTA
+ GTACACATAAATACGATTCACAAAACAGGTTGAAACTGTACTTATGTGTATTTATATATACATACACACA
+ TATATACATATGTATACATATATATATATATGTATACACATATATAATAGAACTATATAGTGTTTGGCGA
+ ATCCGTTACATGCATTTTATACAGTAGCATAAACATTTACACACGCAGGAAACATTAATTGAATACCAAT
+ ATTTTGTATAATTCGGTTCTCAAAACGCCATAGAGCTTAAAACCACAGAACATATTTAGATCGCTTGTGT
+ AGATGTAATGATCTAGTGATTTTTGGTTGAGCAGATGTATCTAAAATAACAAACGATAACTAGTAGCTAA
+ CGGCTGAGTTAGGGAATTGTTGTCTTAGAACTATGCGAAATTAAATTACGTTTCATTAACTTCGTCGGTC
+ GATTTACATCTTCTCCTGTATGAATGGATGAACTAGTGCCTGGTTAAGGGAGATCCGTTTAGCCGGATCT
+ AAGGCAAACATGTTCTCTAGAAGATCCTTGAGCTGGGTGACCTTGCGATGTTGATCGTCGGGTAAGTTCT
+ GGTCAGCAATTAGTTCCTGCTGCAGGCTACGCGAAGGTTTGACTACAGGCATTACAACAATTTTTTCCTG
+ TGGATATACAAAATTGGCATTAGATTCTCACTTTATCCCAAAAACACTTACCCTCTCAGTGAGCTTATCT
+ ATTTCATGGTAGAGAAAGTTGCAGCTTTGGTCAAAATGCTGCTCTCTAAACTGACCTTTTCTGATAATTC
+ GGTTTGGTATCTTGCCTTTTACGTCCATGAAAAACTTAAGCATCTGATTGTTACTTTTCCCGCTAAACAG
+ AATCTTTCCCGTGTATAACTCATAAATTGTGCAGCCCGCAGACCAGGTGTCGATTCCGTAGTCATAGGGA
+ ATACCCAAAATTATCTCAGGCGAACGGTAGAACCGCGATACCAAGTACGGTGTTATTTCGTTGTCGCTGA
+ TTGCCGAAGCAGAACCAAAATCACACAATTTTAGTATCAGATTATTTTCGTTTACCAAAATGTTATCCGG
+ CTTAATGTCAGCATGCAAAATGCCCGTCTTTTTTAACAATTTGAGCGCTAAGAATAGCTGCTGCGTGTAG
+ CTACGCACTGCTTTGATGTGGAGTCCCACATTCTTGCCATACTTTTTAAGTACTTCCCGCAAATTCATTG
+ CTAATGGCTCAAACACCATACAAAGATGCTATAGTGGAAATATAAAGATTGCAATTCAGTCGACACTAAG
+ TTGTACAAACGATGAATTACCTGCTTGTGAAAGAAGTGACGATACAGTCGCAGGCAGTGGAAACGATCCT
+ CTGGATCGGCATCGTTCAGCTTTTTTAATATTTCTAGTTCCCGCAAGCCAGTTTTGTGCCTAATAAAAGA
+ AACAAACGGCATAAATAGGCATACAAATACAAAAAATTACAAAATACATACATTATTTCGTTGTTCCGTA
+ TGATCTTAATGGCTACATTAGCTTGCCCACGAGCTTGGTCTCTGCCACGCACTACGTTGCTGAAGACACC
+ CTGGCCTGTGTATCCATTCACTAGGTAGCGATTGTCCAAAACTTCACCGATACGAACTCGGTAATAACCT
+ TCAGCGTCGTCCCAATTGTCTGTGAGAGCGGGATTTTCGTGTTGATGCTTATTTTGGACGATTGTGTTGG
+ GTGACTGGTGGGATTTGAACTCGGAATTAATAAATGGAATGAAGAATTTGAGTTTGAAATTTACAATTTT
+ GCGACTCACATCGAAATTAGAGTCCACGTCTTGGTCAGCGAACATATCCCACTCGTTTCGTTTTTCCTTC
+ GCGGAGCAAGTCTTTTGGCTAGTCGAGTTATCCATATCTTCGCGATCCTTTGGAATTTCCGAGATAAGTG
+ GATTCGGGCACGGCATCGTGGGCGACGGCGTTCTTAAAGGTCTTTCGCGTTGGGATGACCCTTGTGAGGT
+ ACTCCGAGACTCGTACGAGACCGAGTTATGAGGCGCTGGCGATTCTTGCCCAGTGCCCAGCTTCTGATTA
+ CAGTTATAGGAGAAAAACAATAAGTTTACACTAACAAATATTAAAAACAAAATGTTTCCCTACCTTGAGT
+ AGCTCCTCGCGCTTCTTTCTACGTAGCTCAATGATACGTTCTTCGTCATCTTCCTCCAAAATGTCAATGT
+ TTACGTTCACCTCCTCATCACTGCTCTCCTTGTCGAGCTTATTTTGCCCCTCGCTCAGCGAACCCTTGTA
+ CCGATCTCTATCCCCGTTGTCTGTCCCGCTGCGAGCTCCTACGCGCCCGCCACCACGATCCCGGTCCTTT
+ TGCCGCTCCCGCTCTCGTCGCCTGTCTGATTCAAACTTACTGCGGCTGTGCGACCGCTGCATACGACTCG
+ GCCGAACGTCTCGCTCCCGTGCACGACCTGGTCTCATATCAGTGGGTGGCGGCGGCCTATCCAATCCTCG
+ CCGATCCCGGTCTCGACTATGGTCCCGTCTTTCCCTTTGCTTGTCGCGATTTATTTCCTGTCGTAGGTCC
+ TCCATGTTGCGGTTGCGGCTCCGCGGGCGAACCTGGGTCTGCTGATCTGATGCTCGCCGACGTGGGGGTG
+ AACGGTCGCGATCCCTCGAACGACGATCCCTACGGCAACGGCTTCTCGGAGCCGCTGGGAGCGGGGATGC
+ GTGGCGCCTTCGTTTCTCGGGTGTAGGCGAGGGGGTTCGCTGGCCTCCGCTAGAATCATCCAACAATATA
+ ACATCGGATTCATTTGAGTTATGCGTGGTAGACTTTTTAATATTAGCATGTTTACTGGTTGCAGTAGCCA
+ ACGGCGCTGCAGACTTGCTGGGTTGGGGCTGCGGTACGGATGTGACAGCTTTGAGCACTGATTTGGTGTG
+ GACAACCAGCTGCTGCGAGTGTGTGTGTGGGAGGAGATCGCCCTTATCCTCAGCCTCGGGATCCGACATA
+ TAGGCGCCCAGGCGCGCCTGCAGAAGGGCCTTCTGCCGCATCAATTCCTCCAAATTAAGCTCGTCTTCAA
+ TAATAGACAAAATAATAGGACTGGCGGCATCGGCGGGCCTAAAATCAAGAAAGATAAGTGCGAACACCAT
+ ATGAATTACGAAATCGCTCCCCTATTTTATTCCACAATACTTACACATCGCTTTCGCTGCTTGAACTGGC
+ CACCTCCAGGACAGGCAGCATCTTATTCTGAATAGTTTTGGTGATTTCTTCAACAAGGCTGCTCGGATCC
+ GTCGGAAGCAGGGGTTTGCCGACACGGAAATCGGCTCCATTCCGGCTGGCCTTCTGCATGATTTCTGTGA
+ ACTTGCTGCTCAGCCCGCAATTTTGTGATAGCTTTAACTTTGCGTTTTCCGGGGCGTCCGATTCGTTTGT
+ GGATTCGCTTGTTCGGTGGGGGCGCTTTTTTGCCTTCTTCTGCTTCTTGTGGACATGCCTGTCCTTCTCG
+ GTCTTGCCAGTCGAGGATTTTTTATGTTTTTTGTGCTTTTTAGCCTTTTTGTGCTTGGCCCGACGCTCTT
+ CGGTCTCGCTGTTGTTGCTGGAGTCGTAGCTATTCGGTACAAGAGGGGAGCAGCCCAGGTCAATACACAC
+ ACGTGCGGTCGGCTTAGTAAAATTAACCTACCTTTTGTCGTCAGCCATTATTTGATTGTTTAACAATGTA
+ AACTGCAGATGCGCGCACACTGTGCGTTCATAAGGTGTGCGGTAATTCTGCAGATGGCTAATGAAACTTG
+ TAATTTTCCTCTTATTGTATTCTTCCTCTTCGTAGCTTTTTTAGTGTGACTGCACGCCGGACAAAAGTAA
+ ATACGTTTTAAAAATACCTCCTGGGATTTCGGAATTATTTCTAGTATATATGCAAGTAAAATAAAAATAT
+ ATTAAAATTAAATTTTATAACCCTTAAATATCGTCTTTGGCGCAAGTCTAAATTGGAAATAAAAACGAAG
+ GAATTTCGAAACAACAGTTGAATTTGTATATTATAGTTCATGACATTTTATTTTTTTGTTTTTATTGTAC
+ ATGCTAGCGCTTCTAACCTAATTGGCAACAGCTACATCCACGTCGTGCTCATCTTTGTCGATGCTTAGCT
+ CAAGCACCGTGTCCTCTTCTACGGACATGGCTTTAGAGTCCTCAGTAGAGACTGAGTGATATTTGGGCTC
+ GCCGCGGGCTCCGTCGAACTTTGTGGGAGTGCTATTGTTGAGATCGTCGTCTTCATCGCTTACCTCCATG
+ ATCCCATTGTCGTCTAGGTCCGGCTCAGAGCGGGCATCGCAATCGCTGGACGAGGAGGATGCCGAGGATG
+ AGCTGTCCTGGTCCAGCTGCTGTTCCAGCTCGTGAATCGTGTACATCAGCAAAGTGAAGTCATTGCGTCG
+ TTTCTGAAACTTGCGCTCCATCTTTAGCTTCTTTTGCACCAAGTCGTCAATCTCCCTCCTAATGGTCTCA
+ ATATGTCGCTGTGTTTCACTGCGGTCCGGTTGGTCCTGGATGAGCGAGGCCAGCAGGTCGTACTCCATCT
+ TGTTCTTGCGAATCTGCTTGGCAGTGATTAGCTCTTTTTTACTGGATTCGATTTCCGCTTTAGCCAAAAC
+ AATACTTTCTTCGTGGTGTTCAACTAGTTGTGTGTAGTTGTCACGCTCACCGGCGATCATCTGCAGAGTT
+ TGTACATTCTTTAACGCAGTGAGCTTGCACTGGGCGAATTGGGCCATCAGTCGGTCGTACATGATGGGAC
+ TGTAATTCGGAAAAGAGGAGATATGTACACCATGTTTTGAATACACACATATCCAATTTCTTACTTGCTG
+ TCCAGCGAGTCACTGGCCCACTTCAAGAACTGTTTCAGCAACACTACTATTCTCCGATCCTCTCCAGTTC
+ CATCCCCGTCAATCAGCAGGCGCTGCTTTATGATTTCTTCTGGAAGATCAGTTTAAATATCTATTCCCAA
+ ATGCGAAAATAAACAAAAACAACTTACCGTCATTCATCTCCACTAATTTCCGAACTAGCGTATCGGAGTG
+ TGGCCGAAGCTGACACTGCTCCGACATACCACGCAGTACGGTCCTACTGTACTTGTCCTATCATTTTAAT
+ TTGGAGAAAGTATTGAATTATGCCTTACCCTTTATATCCCGCCCATAGCCAAGTGTAGTGCCGTACACTT
+ TCGGACATCAGCGAATCCCATTAACTAAGTGCACTTCTTGCAGAATGTCGGAAACGTCAAGCGTCAACGT
+ GGATGCGGACCGAGATTGCAGAAGGATTGAGGGCCTCCGACAGCGCTCACAACGCCTTGCTGCCCGCCTC
+ CAGCAGATGCAGAGGGAAATGGAGTCTAATGCATCCAGCAAAGACCTATCGGCCAACAATGCCGTTATTC
+ CGCTGCAGCCACTAATGCGCTGGGCGGAACCACGGCCACATCCCAACCAATCCCAACCATCTGCTCGGAG
+ CAACAGCAGGCAGGCCATTCCTTACGGTGTGCCAGTATCCACGCCAGCGCCGGTAGCTATGCAATTGCCC
+ TACCACGTAGCATTCGCCTCCTACCAGGCGACCATGCAGATTCCCTGCCTTCAGCCACTTTCGCATTTGC
+ ACGTCGTGTCTAGTCCCAGCCATCGGTTAATAGCGAAAAAGAAGTCGAAGCGGGCTCTTCGAAATGAGGT
+ GGAAGCTCTTCAGGATATGGTCAAACATCTTTCACACCTCTCCCCAGATGTTAACGCGTATGCCTGCCAG
+ CTGATACGTAAAAACGAGATCCTTTCTCAGCTCGAGTGGAGTCAGACCAGGTCAGAAGCACATCCGCAAC
+ AGGTTGGTTACCAGGGGCGGCATCGCCACGATTCTGAGGTCTCTGCTACAAACAATGGAAGTCATGTACA
+ GCAGCAACCGAAACTAGGACGAAGGCAACGCAATAGCAAGAAAAACGATGGATCCGGTAGCAATGGGACC
+ CAATCGCAAAAAACCGAACTAGAGGCCATGCGGTCGTACATAAACAAGATTGTCCAACGTCACGTGGGTA
+ TGGATCACCAGTTGTCGGAAGACTTGATTTTCAAAGGTAACTTCTCCGACCTGGAAGCGCATGCGCAGAG
+ ACTAGTTGCGGCGGGTTATGGGCGCATTGTAGAAGAGGAAATCCGGGTTAACCGCAAGAACAACAGACAG
+ GCCTTTATAATCATGTCCACTGATCGAGAAGCACTCGAACGAGATGGCATCGTGCTCTTGCCAGTGGCTA
+ GGCGCTATGCCTTCGATGGTGACAAAGTACGTGCATTCGTGCTAAACCCTGGTGCTCAGGGTAGTTCAAA
+ GACAGCTGAGCCCTCGTCTGGTGAAATCTCTGGTGGGAAGCCCTCATTATCTCTTGGTAAGTTTATCGGC
+ AAACTTATAATACTTTCGACTGATGATAATATCCTATAAAGCGGATGGTGAGGAGCTTTCGGACGATACC
+ GAGTCCCAGGGCTCTGAGTCCGATACCGACAACGTGGTCGTGATATCGTCGGACAACTGCCCTAAAGCGT
+ TCGTCATAGCAATAACTAAACGAACTGAGCTCCGCCAGATCGTGGGAACCATATCGTTTACGAACCCAAC
+ CAAACTCTGTGACGACCAGCTATTCTACAAATTCCGACCGTACGATTTGCGTGTCCCCATGGTCTACGTT
+ CCGAAGGATGCCTGTGCCGCCCACATCGGAAACAAGCAGCAAATAGACGTGTCCGGCCTCTTATACCTTG
+ CCCATATACTCGAGACAGATTGCAATGGGCACTGCATCGCTGAACTAATCCAGCCGGTTGGCCGCGTGGG
+ TAATTTGGATGACGAACTTAAGGCAATTCTGTTTCATAACGGTCTCCGGGATATAAAGCCATTTGAGCAA
+ CGATTTATCGACATTTACTCCCAGCCGCCACCTCCGATAAGCCAAGAGGATCTGCGTCAACGAAAAGACT
+ TAAGAAAGATGTGCATATTTACTATAGATCCGATGACTGCTCGCGATTTGGATGACGCCGTTTCTATAGA
+ GAAGCTAGGCGACAACGAATATGAGATTGGCGTCCATATATCCGATGTTTCGCACTTCCTGATAGAGGAC
+ AATGAACTGGATAACATAGTGAAGGAACGCTCTACGTCTATTTATTTAGCCAACGAGGTAATCCACATGC
+ TGCCTCAGTCTCTATGCATGCGATGTTCCCTGCTCCCTGGGCAAGACAAGTTTGCTTTTTCCGTCTTCTG
+ GCGGATGAACGGGAAGGGAGTCATGCTGCAAAAGAAGCCAGAATTTTGCCGCACAGTCATTAACTCTTGC
+ TCGCAATTTGCTTATGAACACGCTCAAAAGATCATCGACAACCCTAATGAACGGTTTACCGAGAACGACT
+ TTCCGACCATCCTGAATGGATTTAATCCCGATGATATCAGAAATAGGGTGCTATGGCTGCACGACATTGC
+ AAGCTCCATCCGTAAGACACGTTTAGACAATGGCGCACTCACAATTAACAATGCCAAGCTACGCTTCCTG
+ CTCGATCCAATTACTGGCGAGCCGTTGTCTTTTGAAGTGGAGAAACAGCGAGAGGCTAACCGGCTGATTG
+ AAGAGTTTATGCTCCTGGCCAACCAGGCAGTCGCCCGCTTTATACACGACTCCTTTCCGGATATCGCTGT
+ ACTGCGTAACCACCCTCCGCCACTTATTAAGTCCCTTAAGGCTTTAAGGGAAAAGCTGCTTGCTCTGGGA
+ TTCGAATTGGACTATAGCTCGTCTAAGGCGCTCCAGGAGAGCATGGTGCGGTTGTGCAATGAGGCGCCCA
+ ATCCTGTCGCAATGAATGCCTGCCTAAGTCAGCTTTTGATGAAACCAATGGCCCGTGCAACGTGAGTGTC
+ TCAGTTTTCAAATAATTACTCTTCCCACAATTTCCCCCCTTTAGATATTTTTGTAGCGAGGGTAAATCGG
+ AACCGGCTGACCTGTGGCACTACGCCTTGTCCATACCCATATACACTCACTTTACTAGCCCAATCCGTCG
+ GTATCCTGATATTTTGGTGCACCGGTAACTGTCACTTACCTTGGAAGTTCGCCTCCCGTACTTAAAATTT
+ CCTCCACTCTAGACTTTTGGCGGCCGCACTTAAATATTGTACACCGCCTAAACGTACCCCAGATGATTTG
+ CACACCTTAACGAAATTAGCGAATGAGCGCAAGTACAATGCGAAAAAGGCCGGAGAGGACTCTGGTAACT
+ TGTACTTCAAACGATATGTTCACAACAAGCAGGGCATATACATGCGAGCTGTGGTCATTGAAATATTTCA
+ GCATATGATGAACGTAGTTACTCTGGAGTCGGGCCACGTTATAAGCATTAACTACAAAATGCAAAAGGTC
+ CTCGTAGACACACACGGCGTACCCAATTACATTCTTATTGCCGAGCGCAACTTAAAGCAGTCACCTAGGA
+ AGTTGCAGCTGCTTTCCGTGGTCCCCATATGTCTGATCATTTGGGACCAAAAACTAACTGGATTTTTAAA
+ GATGGAAGAACAAATTTAGGAAAAAAAGGAGCAGACGAGCAGATGTAATTCTTCGCATAGGAACAACCCA
+ AAGCAACTGCACCGTATTTTTTCAATAAGCCAAAAAAGTTTATAACTACACACAGAGGGAACATCAATTT
+ TGTTTAAGAGATTCCTTCTGTTTCAGTGTCGTTAAATGAAAAATCAAAAAAATCGAAAAATACTTGTTAG
+ TCCAAACTCACTTTTTTGAACCACATTGTGGGTCCGAGCTTTATGCTTGACAAAAATTGACTCTGTGATG
+ CTTCCTTTTTCGGTTTGCATATCATAATAAGCTTGTAAAAATGTATGTACATATGTGCTATGTAAAATCA
+ AGGCTTAACTGCTTATCAATAAAACAATCAAGTTAACCGAAAATGATTTGGATCATGCTGACAAATGTTA
+ ATCGAAAATAAAGGTCAATTGGGGTCATTGGCGATAATGTTAACGGCGAAAGTTTAAAGCATGAGGTTTT
+ TTAAATTAAATTTGCATTGACGCAGAAGTATCGTCTGAAATGTCTAGATTCGGAATATTTGTTAGGCTGT
+ CCAGGTCGTATAATCACCGATTGCAGCTGACGATTTTTTTAAGGCATTTTCCTGCTGTTAGTTGGACTTA
+ TTCAAAGCCACCCTCATCCGATAATATAAGAAAACTACAGTCTAGGCTCCAATGCACGCAATCCTGCCTA
+ ACCACCCCTGAGTACAATCCCGTCTGGAGTAGTGATATGGTGAGCTACGACAATAAAAGCAAATTGAACT
+ GCGCAATCAAGTGCGGGTTAAGTAAGTACACACACAATATCTGCACAAGTCTCCAGATCGGATCGTTCTA
+ AAACTACATCCACTTGTATCGTTGTAAAACTACATCCATGTCTAATCTAAACCGGCCCGGACGAGTACGC
+ TAGTTATCCTGATTTGGAATATATGTATATATACAAGCCGTAAAGAAAGCACTTGCCTTACTTTTAGTAA
+ GTTAAATTTGGAGCTGCACATATGTATTCTCCTGAACATGTAAGTACCTCAGGTACAATTCGCACTAAAT
+ GTTAACATAAAGACATGTATGTATGTATGTGCATGGATAAATATGCATGTGCATATTTTTTTTAAAACAT
+ TGTTCACAGAATGCGTGTACTGGTTTTAAATTCCAATTCCTGAATTTACGGATTTTGCTAACAGTCGAAA
+ GCGAAAGGCGCTTTCAAGTTTCAAAGAATCAATTGCGTTAATCTGGTAGGCAACCGGCCTATAAATAGGC
+ GTCACTGGGTTTCCGGGGACCTCAGAAGTGCCTGGTAGCTCAAGCGAAGCGGAACCAACAAACTCCCGAA
+ ATGGATTGGATCAAAATATTTGGTAGATGTTGTGACGACTTGAGATCAGCGATATTAACTTAGACTCTAG
+ TTTCAGGTCTTGCCCTGCTATTGATTGGGATGGCGCAGTGCTACCCGCAGTTCGATAGCGAAAACCCCTG
+ GTTGAGGCCTCGGCAACCCACTGAACCTACGATATCTCCGAATGCGGGGGGCAGTACCCCGGCCAACGCT
+ GCTCCACCAACCACCCAGTCACCGCGCTATTTCGCCTGTTTCCATTCATGCCCGGCCACCAGCGAGTACA
+ ATCCAATCTGCGGCAGTGATAACGTGAACTACTACAATGAAAACAAGTTCAACTGCGCCTTGAACTGCGG
+ CCTAAGTGAGTATATAGGCTGCGTGCCTCCCCAGATTCCTTTCTAAAACGATGTATGTACACATGGATGC
+ CTTCTTCATTATAGACATCCGGAAGGTGCACAAGGGAATTTGTCAGACTTAGTCTAGATCGCTTGAATTC
+ AGTTCACTTGTGTATGTAAGCATGAACGTATTGCAAATACTCTATTCATCGTCTGATCGATGACATCAGC
+ GAATATAAATATGTATATATGTACGTACATAAATAAAAACTTAGCGCTGTTACTGGTATATGGACGGTGT
+ ATGACCCCAAAAAACTCAGAATCTCTTGCTTCCAATCAGTCACAGTCGGGTTGCTTGTCTGTTCGCCTGT
+ AGCGCTAAAGTCTCCATCATCTATTACCTATTTATTGAGGCTTTGTAAAATTAAAGAAAATGGTTTACAT
+ ATGCAGTAAGTCGAGGCCATACATTAATATATACATAAGATGTATATGTACATATTGCATATATACGTAC
+ CTTGCGTTCATCCCACTAGCAGCTCTTGTGGTGTTGATCTTTCCCGTCTTGTTGTTGGGTGCACCATGGG
+ AAGGGTCGCATCCTAAGTCTCAGGTGGAATACATCAGCAACGACAAGAGAGTTGATTCTGGCTTCGCCAA
+ CCCCAATATCGTGCCCATCACCCAGCCGTCGGTCGTAACGCAAACAGCTCCTCCTCCGCCGCCAAATTCC
+ AAAAACTTTGCATATAGTCCGATGACGCAGAGCTGGACCCTCATTGCGCCAGGCGATCCGCTGCCCAATA
+ ATGACACCCTCGTCTGGAACCAGAGCAATGACAAATGGCTCACTCGCTAAGCAATGCAACCATCGATGGC
+ TTTGCTTTAATCATTGTGTATTACTATTGAAATAAATATAACTAATTCACTGTAGGACTTAGCGGTGGCG
+ ACGGATGTGGCTGGAGGCCACAGACTGACCCTGCTGCCGCAGCCGGCACAACTCGTCGGTACTGTAGTTC
+ AGCTTGCGGGTTGCGTTTTCTGAGAAACGCTCGAACTTGGCCACTAGGTCCACCAGTTGCGTCTTGATCG
+ CCTGCACCTCGGCGAGCACTGCGCTTAGGACATTAGCCTGATTCTTCATCTGTACTGTTCCCTCCGCCTC
+ CTGGCGGAACTGCTGCGGCACATTTGTAGCGGATCGGGGGCGCAAAAGCTCGTGCATGTGAAATAAATTC
+ TGTGGAGTCTTCTTTGTGGTCCCCGTGGCAGGTTCTGGCTTGAGGAAATCCGTGTGGAGCGGCTGCTGCT
+ GACGCTGTAGACTGCGGCTGAAAATGTTGTAGTTGTTTTCGAACTGGCGCCGTCGGAGGCTCTGGTTTCT
+ GTCGCGCCGTTCAGCCACTAGCTTATAGACATTTAACTTAATATCCTCAGGCAACTGATTGTCCCGGGGG
+ TCGTTGGGCCGTATAGTGAACTGAAGTTTGTCCCGGGACGTGCGCAAAAGAGCACTCCTCTTACACAGCT
+ GAATGAGGTTAGTGGGCGCACTTCGCAGTAGGCGGGAGAAAAATAGGCTTTCCAAGCGTGACACCAGCTC
+ CGCTTGGCGCACGAGACGATCGAGCGTGGCGCTCACTTGCAATCCTTGTATGTCGCTTACGGCCAATCCC
+ ACCATGAGATTGGTTAAAATTACCGTAACAAGAAGCACGAAGGAGAGAAATATGATGTGAGCGGTGACAG
+ GGAATTTGACGGCATAGTCCCCATAGAATATGTCTTCAAACTCCAGTTCCCCAGACATCATCGTGATGGA
+ CTTCAAAAAGGACCATGTGATGTTCTCAAAGGCAGGATAATCATTGAAGAGCACGGCAAAGCTGAGGCCA
+ AAAGCCACCAGCAGGCATATGTAGGCAAGCAAGAATTTCGCAAAGTTAACGGCCACTAAATATATACAGA
+ AGTAATAGCATTTTACAGAATATCTTTCCAACCTATGATCCAGCATATTTACCCTTTGTGAACATTTGAA
+ CATATACGCCAAATATGGGGAATCGTCCCACCAACATCATTAGTTCCAGCCAGACGAGCAATATCACTAT
+ AGCTGCCACGTGATGTTGCCACACCGGCACTGCCGTTAAATCGTCAGTTCGCACGGTCTCCGGTGTTACA
+ CATAGGAGCACACCGGTTCCAATGGTCCATTGCAGCCAGTTCTCCCAATATTTTGCGTAGCCACGAAGTC
+ CGTGTGCCATTTGAAAGACCTCTTTCCCCAGCAGAATGAGGTTTAGTATGATCACCAGATATCCAATAGT
+ TGAAACGTAACCTGGAGCCACGCACAACTCCTCCTTCTTGCAGCAGCGGACATACACCCAAATTACATAG
+ AAAGTGAAAAGGATCACGAAAAGCGTATGATACGCAAGGCTCATAAGGAAGAATTTCCGAATGCGACGCC
+ ACTTAAGAAAGAGGAAAGTTTCGCAAAGCGGGTGCATGAGAATGCGCTTCTGTCCCACTTCTATAAGGGA
+ AAGTAGTAGCTCGGTTTCTCCCCGATCCATCGAGGAACTGGGTACCAAAAGCCGGAAGTCTAGCTTTATC
+ TGACAGTCAACGTCGCCGATTTCCTGGTCGTTCGCCTTTATCGAAGAGTCCAGCTTTTGCATTAATTTGG
+ GTATAATCTCAGGAGTGCGCCTTACTATAAATGATAGTGCCGATACACGCCCGTCCGTCCTGGCGGTAAT
+ ATCCGCCCCGTGTTCTGCGAAAAAAATGGCCATTTAGCAATGCAGACATCGTTGAAAAGATGATACATGT
+ CCTTGCCTATGAACGTGTACACACAACTGCTGAATTCATTCAGTGCTGCAATGTGCAGTGGTGTATATCC
+ ATAGTTGTCTGCCTGTAAGTAATAATCATACATTATTCTAATCGTAAGTAAAAAAAACGTTATGGCTTTA
+ CTTTTGTAAAACTTTACAAAGAAGGCTCCATGTTTGTTAAGATTTTAGTTTAGTTTTAGTTTAGGTTTCA
+ CTCTAAGAATGACGTAAAGAGCCACTGGAGCCCTACACAAATGTATGTATGCAACGTATTCTCACTAAAG
+ TTACTGTATTGTATTATTTGATTTACAACATTTAATGAATGTTATAACATGGTATGCTCGAATTGAACCG
+ ATCTTCCCGTATGCATTCACTTTAGTTGATGAGCTAGGAGCTTACGTTTATAAAAGTTTATAAAATTATA
+ TTTTATGTAGGATATAAGCGTATGGTAAGTAGCCAGATAAAGATCAATATAAGCCTTTATATAAAATTCT
+ TGTCGTTGTCTCACAAACTGAATGCCTCGGCTGCTATTGCTCCTAGTTCTCAGTTTGGTTATAGTTTTAT
+ TAAAATAAAATTCCGAAATAACGTTTTTGACGATTAAGTAATTTAATTAATTTCGTTGACCCTTCCTCAT
+ TAAGAAAAGCGAAGCGGTTTATACTAATATCTTCATTATCATTTACAATACTTTTTAGTAGAAAAAGCAC
+ ATTATATTAAATAATGGTTTTTTGTGATCAGCTCTCATAGTGATCTGCCGCCTACCTTGTTAACATCCGC
+ TCCCGCCTTTAGCAAGGCATTGCAGCAGTCCAAACTCCGCGACTGCTTAACGATGGCGGCGTGCAACGCG
+ GTTCTACCATCTCGGTAAACGGCATTCACATTGGCTCCGTAAGATATCAGTAAATCCACGGTGCCGATTG
+ ACTGCGAAAGGCAGGCGAGGTGCAAGGGCGTTTGATGGCTGGCGTTACGGCAGTCCACCTCAGCACGGTG
+ TTCCAGGAGCAAGCGAGCACATTCTACATAGTCGTTTTCGGCAGCTGCAATTTGTGGATTTACCAATCTA
+ TTTTGCAAAGCACTTGTAAACCCCTTGCCACTACTCACCCAAGTGCAGGGCCGTAACCTTTCCCTCGCCA
+ AACTGCGATCGCACGTCGGCGTTGTGACTGAGAAGAAGCTGGACGCATTTGGCGAATCCTGCGGCGCTGG
+ CGGTGTGCAGTGGAGTTTCAGTGTACACCTGCGGTGTGTTTGGGTCGGCTCCGTACTTCAGCAGGATCTC
+ AACGCAATCCACGGCATTCACATCGATGGCATAGTGCAGAGCGGAACGCTTTTCGATCCCAATGTTGATG
+ CTCGCTTTTCGCCGCAGCAACAGCAGGATGCATTCAACGCTTTTTGAGCTAATAGGGAGTCGCTTGATTA
+ AAACTACGTGTCTAGTGCTGTGCACATGTGGGAAGCGCAATCAAATGAATGGCCTTTTACCTGGCCGCAC
+ AGTGCAGCGACGTGACCTCCTTCCTGGCATCCCAGCGATTGGGGTCAGCGCCGAAGTCGAGGAGAACCTT
+ AGCTATGGGAGCGTTTGCCCGACAGCAGGCGAAATGCAGTGGGGTCCGACCCCGACTGTCCGCCACATTC
+ GGATCCGCGTTGTAGTGTTTTAGTAGGAAGAGAGTATTCTCTACGCTCCCGAATACCGAGCAGCAGATCA
+ GCGCCAGATTGCAGTCAGCAGAGTCGGTCATTAGTTCTATGTGGGGGTTAGTCTGGGATATGTTAGGTAC
+ CGTGCTGTGAGGTACTCACCCAGGAAACAGCCAGATTGAACCATGTCCACGACATGCTTTCCGCCTGGAG
+ ACTCGGTCAGGGTTTCCTTAACCTCGTCGAGGTCCCAGAGGATCTGGTTCTGCTGTTGGCGCGCAAATAT
+ CTCGTGCGCCTCGTCGCTAAAAACTCCGGCGCTGTTGGCCTCACTGGATATGCTCCGCTTGTCCAAGAGC
+ AAGTCTACATCCGCCGTCGGATCGCTTTCCGAGTTCCACTTCAAGTCGTTTTCCTTCCAAAAAGAAACAA
+ AGAATTGCAGGCGGCTGAAAGCGCGAGGCATGTAGGCCAAGTCGTTTTACTTACAATAATTGAAAAGCGC
+ ACGTTCTCCATCTTAACGCCGCCACTTCTGTCTGCGCCGATTTGTTTACACTCCCGTGGACCAAACAACA
+ ATAAACTTTTGGATGCGGCCGAGTCGGGCGACTGTTCAGCTGGCTCCGGCTGCTGTTCGGGTCGGCCCAC
+ CCTTCTTGTTGGGGTCGACTACTTACACTTATTCGCGGAGATAGGCTGCGATCGCTAATAAGTCATGACA
+ CGCAAATAATTATCCCCAGGCCAATATGTGCGGACACTCAAAATCTCTTGTGCCCCTAATTTGTGTGATA
+ TTGCTGCATGTGTGGCGACGTTCTCTTGTGCGATCGGTTTACTTCGATATTTGTTGGAATATCTGGATGT
+ CTGGCGGATTCTTCGCACCGCTGGCAATGGCAATCTGTGCTAATTTTTCACGTTCGCAGCTGCTCCCCCC
+ ACTTTCCACCTTCGCAGTTGCCACTGATCCGCCACTGGATATGTTAATTGTGTGCACGACCGACGGCAGC
+ TAAGTTGTACGTCGAACTGAACCGATCGTTCCAGATCTCGGCCTCCAGTGCCTCCAACACTTCGCACTTG
+ TTCATCGTAGGTCTACTTGCGGTACGGACGAGTGAGCGGCTAGCAAGGTGCGTAGGAATATAAAACATAC
+ TGTTAAATAGCCCGCCAACCAATCTCTAGACGCCAGCCCTGGCATTTTGCCATATTCAACTCGAAATACA
+ CTACATGTAAGTTAGGGGTAGTATTTTGTTGAGGATGTCCCATACTTCGACATATATCGCTGCCTTTTCA
+ TAATTATAGGGATTTTTTGCAGTGTACTAGGTCCGTTGAAAAGTACCTACAAGGTATACAGTTTATATTA
+ GGCAGCAGATGTGGCAACGCCCATTCTAAAAATCTATGAAGCCGGCCAAAACTGCAACACCTCCACTTAT
+ GAAAAGTGTTTTGGTTTTATTCTTCTCATTATTTTATTTTTATTTTATTAGTCTATTTCCAATTTCTACC
+ GGTATACCATCTAATGCACAGCAACTCTCCAAAATGTTTTATATATTTTTTTTCCTGGGTAACGGGTATA
+ TCATAGTCGAGAAACTGGACCTTATCGTTCTCTTCTGCTCTTATATGCAAAACAGATCAACAGATCAATG
+ TAGAGCGCAGATTATAGTTACAATTTCATAGAAGACATCAATCACCCCTCGTTAGACTGTCCCAACCAAT
+ ATACTGAGTCAGTATACTTTTGCGGTATTTTTTAGGATTTTTTGTACATACAAAATGGACGACTCATTAA
+ AATTAAGTTAAAAACCACTACTTTGAATTGAAGTTTTTTGCCATGCCCATGAAGACCACTAAAATATGAC
+ GTCGGACATCGATTTTCAAGAAACGAGACCGTGTTCTTGTGTGGTTATCACGATCCGTAGGGCCAGCATT
+ CGAGCAGAAATCGTCCCCAAAAAACAGTTTCCCTGCTGGCTGAGACAAGAAAAACGCGTAGATTTGCGAG
+ CAGAGCTATAAAAGGGCGCGCAGACAACGCGCTCTACCCAGTTAAAAAGAGTGCGTTGTGTAGAACAGTC
+ ATAAGCAGTCCGCTAAGAGATTAGTAGCAACTACGAAGTGAAGGTGTGTGTATACCAAATTCTCAATTTT
+ CTCTTCGAGTCGTCGCAAACAAAAACCCTGTGAGATCATCGAAATGGTGGCGTACTACGACGAGTGCGAC
+ GCAGCCGAGAACCCCAAGACCCTAACCGACTGGGTCCGTAACTTCCGCGTTAAGCGCCAGAAAATGCGTC
+ GCAAGCTAAGAGGCGCTGGCAGCGACCTACGCGTGAACGCCATTTTGTCGACGGCCCTGCTCCACGCAGA
+ GCACGAGCTGCGTAGAAAGCAGCAGGAGCGCTTCAGTCGCTGGCTGGACATTCAAACACGGTTTGTGCCC
+ CACGGCAGAACGCACTGCGCCAGTGACGCGTACTCTGCAGTGGCGACCTCGACCACCAAGGCTGCCGCAG
+ AAGCAGAGGCGGAAAGCAATTTATGGAGCAGCGAGCTTAGTAGCCTCGACAGTTTTATGCGTAGCTTAAG
+ CAGCAACAATGGCAACCAAGACACATGCAACAACAATAACAATGGGAGCAACAGTTACACGGGCGCCAGC
+ AATAACAATAACAGCAACAATGAGCAGCACAGCTGCGCCATTGCCGTGGCCAGTTAGTTAGACAGAGACG
+ ACCGTATGGTGCGTACTTTATGTGTATGCGTGGCTGACACACACATCTATATAAACAAAATGGCGTCAGG
+ ATGGAAGGAACCGTTTAGTTTTCAGCTGCCCGTTCGAATCAAACCGTATACCATTGTTCAAATACGTAGC
+ TTTAGCCCTATTTGTCTTCTGTTAAAATAGTTTTATTACGACAACCAATTTCTCATTTGCAGTCGCAAAC
+ ATGTGCAAGGCTGTTGTAGATTGTAAAGAAAGAATGAAGGATTGGAAGAGTGTGAGGAGACGCTGAGCAA
+ ACGGCCTTCAAATCGAAAGTGGTGTGAGTCATGGGCGCTGCCACCATCTATGCGAAAAGCCCACCAAGCA
+ TTGGTCACGGAGCACACTCGGTTTGTAAATAAGTATATTTTTTTTAGTTAAATTACGTAGCTTAATGAGT
+ GTGGCGAAATAAGACGTCGCTTACAGGCATCCCAAACGTCACGAAATCGGTCAGACAAAGAAAAAAAAAA
+ CTCGATATACTTACACAATGCATACACATTAACACATCTACATGTCGCGATGGTGTGTGAGCATGAACGC
+ TCGTGCTATTTTTGTGTACACCAAGTTGAGCTACTTTTGTTGTCCGATGTGTCGAGAAATTCGATTTCGA
+ ATTAAATTCGAACGTTCGTCATCGCCACTTCTGCGAGTTACATACGGTTCATATTGAATCACTAGCGCTA
+ GAAAACGGGCAATATTGCAAAGTAAACGAGTGAAAGTCGAAAACCCAACTATTAACTGTAAATGTACTTA
+ AAGTAAGCATACAGAACTGATATTTGATAAAACCTAAAATAAAACTATTATAATTAATAACTGTTAAAAT
+ CAACGTTGCCTTTATTTATTATTCACCCAGACCAGACTCAGATTTGTTGCTAAGCAAGCACCAACCCTCT
+ CCCCGTTTGACATAACCCGCACCTATAATCAATTTTGTTTTGCAGTTTCCTGCTCCTCGCACGTTAATGG
+ CAACGATGATGAGGAACGGAACACAAACAAGAAACTACGTCGCAGTGGGTCACTGAATGAATCCGCGTCC
+ CGGTAGCAACAATAGTTCGACTATGGCTGGTACTGGTAAAGAAGAATCCCGAACACGATCGTCGCAGTGA
+ CGATGACGTTGCGTTGTAGAATTACTGAGTGAGTCTCAACGTCTGTCCGAGTCCCCCCACGTCCACCGCC
+ AGGCACTGAGTTCCGCAAACCAGCCGATGGCCGATTCTACACAGATCGCCGGAGCAGGGAGCAGCAGCAG
+ CAAACACCACCGAGTCTCCTCTGCATGCCAATGCCCATGCAATTCAGTCGCAGCGGACAGAACATTGGGG
+ ACAAGGCGGAATGCGCGCGGCAGCAGCTCCAGCTCGCATCAGCTTACCTGCGTTTGAAGCTCTCGTGCTG
+ TTGCCAACCACCGACAATCACCACCTATTCTGCATTGAACGCTTCGCAGCTGCTGATCACCACCCACCCA
+ TCCGCACAGATACACGGTATTTGGTATATCAGCTGCGAACAAAATATTGCTTTTTAAACAAAATTCCAGA
+ GAAAAGAACAGCGGAGCATTCATTTATCATCGAAACGACATTGAGGAACTGCTGTAATCCTTTCGGGTGA
+ ACACCGTGTGCGATTGTTATTGTGATATACAATTGAAAGGCAGTCGTCGAGTTTTTATCTTTCTGTCTTC
+ GCTCGGTACACTTTTCTGGACTTCTCTTTCACCGTTTGTGATTTTGGCAAGCGATTATTGGACCCCTTTC
+ CATTCAAACTCCCCATCTTCCTAATCAATAGGCTAGATAAGGCCGCTTAAATCTTTGTAGCTGCATGTCA
+ CAGTTGATCGGTTCCTGTGGGTGCTTTTGTTTGATGGGATTGCTTTGCGGTCTTCAAGTATTCACGGTCT
+ TGAGGGCTCCAGACGAGGATCTTTCCAGCAAATCTATGCGCAAGCAGGCGTCAAAGAGTTTGTAGACTAG
+ GCACGACCATCACATTTCGTTTTTTTTTTTTTTTTATAGCGTTGCATCGCAGTTGATCGGTGCCTGCGGG
+ CATGTATAAATGGAATCTAGCGAGGCGGAAGATTGAGGTCTTCAATTCTATGGCCCCAAACAACGCTCCT
+ GCGACATCAATCCCTCAATTAGAATATGTGCAAAGAAGCATAACTAATCAACTGAACAAGCGTAAAAGCT
+ AAGATATATGCAACCGATATCTTTTCTTTCGTATTTTGTAGAAATACATTTTCATGGACTGATAATCTAC
+ AGAGAATACCAACTCGGCGCTATGGGCCCGCCCAATACATGTAAATTTGTGATTTTATGTCCAAAATATT
+ TTTTGTCTTGTAGCATTATGGGTGCAGTTGAATGTACCTGCCCATAATTAAAGCCTGCAAATCAAGAGTT
+ ATTGTTAAACGCAAGAGGGAACATTTTGAACAGACTCAAATCTGTACACGGCCTCTGTAAGGAATGTGCA
+ ATCGATACCCTTTTCTCTCGTATTTTATAGAAATACATGTTGTGGAACAGTTTAGATGCTATGGAATTGT
+ ACCACGTAGTTGGACCACCACACAAATTTAATTAAAGTATGGAGAAAAACTTTTTTCTGTTTTCAAGCTG
+ TTCCCGTTGAATGTGCCTGCCCACATCTCATCTATAGCTTCTGAGTAAATCCAACAGCGAACCGTCTATT
+ CTTGGGACTTTAACAGCGTTTGAGAAATGGTTGGATCTTTACATTGCTCATTTAATACTAAAGTTAATCT
+ TCTTTCCCAATACCTAGACGCTTATTTATGAATTCATTGCAGTGTTTATACAGAGACATCGGTTTCAAGC
+ AACCAGTCTTATCAATCACATAGTTGACATACCAGTGCACATTTGCCTGTATTAAAACCAACCGAGAACA
+ TGTAGCAAAATTTCTTGAGGCAATGGGAATCAAATGCCAACTTGAAAGCAATAACACCAACACTAAGTCG
+ TCGCAGTCCAACATCCATACTACACGGCGAATTCGAATTGAAGACGCTGGTCAGGTCTGAACCCAACTAG
+ AACCCGCTTACACCTGTTTTTCAGCAATTTTTCTGGTCAGGATGTGGATTATCTGTCACAGAAACTTCGT
+ TTGTCTTGAGCGTCGCTAAGATTGGCCGTTTGACCCTCCCAAAAGTGAGATTCTAAGCAGCCTTAAATTT
+ ATTTTACAATTCTTACAGCGGTGCCGCACAGTTGAGTGTGCCTGTGGGCATCGACTAAGCAATATTTGAA
+ CCGAAGGGCAGGGCAGTGGACCGTTCCGTTGATGATGATGTGCACCGCTCCGAGCTGGCTAAGTCTACTG
+ CTGTGCTGCTGCAAATCGTTAAAGGGAACCCAAAACGATGCATCAAGTCCATCCAGTTAGGCTTCTCTTC
+ CAAAGCACAGCTCACCTGCGCTACAACGACAACCAATTCAATCGCACCTGCTTCTGCAAGCGATCACAAT
+ ACGTCAAATGAGCATCGAGCACAGAAAGCAAGCAAACAACCAGGTTAATGGCTTCCTCTGCTGACTATGA
+ AACTATACGCCTTTACATTGCAGCCAAGAAGCCTCTTAGTGCATATTCAACTACCAGCACAGAGCTTCTC
+ AATGACTGGAGTAAGCATTGTTCTGACCGCATCGGACCCTGACCGAGTCCGACTTGGGTGCCTCTGGTCG
+ CAAGATCTACATTAGGACAGAGCCAGAATAGGAGCGCTTATCTAGCGCCATGATGTGCTGAGCTGAACCT
+ AAGCACGTACTGCATTGCACCGCACAGATATGTGCGTTCGGTCCACGCTAAAGGGAATCAAATGCGTTTG
+ GACCGAGAGCCGATACACCGCACCATCACCAGTATTCGCTGTGAAGTGAGCTGATGTGTTGTCGTTGTTA
+ CAGGGCTGCTGCTGCAACTGCTCCACAGGTATCCTCGCCTAGCGTCGGTAACTATCATTTGTCAATTTTA
+ GCGGCCGGCAGTGTACATCAAACATTGAAGTCCGGAGTCCGGAGTGGCATGTAATTAACGGCAGATGTGA
+ AACCAGCAAATGGTGCTCAAGCATTCCATTTTAAATCTGAAGATTGTCAGCAGTAACAGTTAAAGACTAT
+ CGACGCAGACTTGCAGAACGAAGCGCAGGAAGGACAAAGCACTTCGATCACCAGCGGGTTGTCGTTTTAC
+ TTGCACTTTCCTTCCGTAGGTAGCCCAGAATTCGAGAAAGCCCATATCCATCGCAAAGGGAAACAAATGC
+ GATTAGTGTTTGAAGACCAAGCTGGGTGTCCAATGTGTCGCACCACGATTAGCCAGTTGAGCCCATAACT
+ CCTGGCCCGCCGATCATCGTACCGCAAAAGGGAATCAAATGCGAGGTGGTACTACAGCAGTCGAGCTCCT
+ CGTTGAGCTCCTGGTTTAAGTCGAACTCCCAACTGAGCTCCTGGTCGAGTTCTTCGCTTCAGCGTTTTTA
+ TCGTAAAGGGAATCCAACGCGATGTACAGCGACAGCGGCAGGCAGGGTCACCCAATACACAAAGGTATAC
+ CAATATGATCAGAGTTCCAGTCCGTGCAATTACGCTTTTCAGAACCTCTCAAAAACTAATCTGCACGTGT
+ CTAAATCTGGCTGCCATGCCAGGCGCGACATCAATCATATTCGCCATGTTGGTCTCAAAGGGAATCCAAG
+ AGACACGCGCCCCGCGGTACAACCAACTGAAGACCAAATAGATTTTGTTATGCATTTATAACCAAGCATT
+ TTAGAAGTCATATCCTCATAATTTTTTCCTTTAGTGTTTCCAAATCTATGTATTCTAAACGAATCGTTTC
+ ATTATCTTGTAGGCTTTTATAAACCTTTAATTTATTACTTGTAAACCTTTCCTCTAAGAGTCAATGCAGA
+ CATCCGACTTCGCTGACGATTGCATCGGGACTGCATTACCCTAGGATAGACGGTCCGGTCTAGAAGTAGC
+ AGCAAGAGTCAGTTAAATATCAGTACCGCTATTAGCAGAAGATTCATGGCAGTAAGATGATGTGGATGCA
+ CCGTACATAGACGTTTCAAACTGCAGAGGATCGTTTGACCCCCGAACCAAGGCAGGGAGACCATACATAC
+ ACAGGCGGAGGCAGTGCTGACCCTCAATACATTCGAGTATTTCAACACTCTACCTTTTACCTATATTTAC
+ TGGGCATTCAATCACCAAATTCGCATCCTGGGTCTATTTGGAGCATATTAAGAACGAACACTACACGGCG
+ TAGGAGCACCACACGATTTGGTCATTTTTATTATGAGAAGTCCTAAAATCCTCCTCGGATCATTCCTCAT
+ TATCTGCATTTGGAGCAACAAGTAGGCTGGAGGTATCATTTCTTCACTAAGCACCATCGATTTCACACTA
+ CTGGCTTGGGATAGCACCTAATTCTTTACGAGTTTCGGCACTGATGACGACTTCAATCCTTGTTTCAACC
+ CGTACCCCTTCGAACCAATATAAAAGTTGGATTGCATACAGCTTTCGCTTCGCTACACACTGGTCGATTC
+ TTTTTCTTTGTGAGGACCCTTCGTGAGGATATTAGATTTGTTGAAGAATGATTCTCTAACTTGGACTGCG
+ GCGTGGGATTCAGTCTAATTTAACCATCGACAGCGGCCTAGGAGTAAATTTGGACAGCGGCGTGGGATTT
+ TCGGCTCTCAAAGACGACGGCGGCGGACGTACGGATAGTTCAGACTGCGGCGAGGGATATCAAGTTTTTG
+ CAACGCGGGATTATTAGGGCGTTTAGGCCAGGGCGCTAGGAACCATATTCTTAAGACTACTGGAATTTAC
+ ATCAATGGAGATGACTGCGGCGTGGGAGACGGAGATCGGGACTGCAGCGAGGGATCGAGGTTCTGGACAG
+ CGGCGCGGGATTCTTATAAGATTGGACGGCGGCGTGGGACCTTTTTTGACGGCAGCGTGGGAGTTTAGGA
+ CTGCAGCGCGGGAATTTCTGACGGCGGCGAGGGATCCTCGGTTTAATTTTTCGGCAATTGGTCAGCCATC
+ GCATTCCATATACATGCGTGTCACTCCATTTATTGATAGTTCAAAGCTGATATACTTAGGTGGCGTGATC
+ AGCGTAATCACGCCTCCAAAAATACGCATCCCTGATTATCCCTTATATGGAAAATCTTCATTGAATATAC
+ ATTTATTTACACTTCTGGAATACCGGAAAGCAACCCCAATACTTATGCCGATGATTCTAATACATGAAAC
+ GATTTAAGATCACAATAAATTGATTTTTGAAAAGAATGCTAATCTTAATTTGGTTTATTGGGTTTTGGTA
+ AAATTTTATAATTGCTCAAATGGAAAGGTTTCCATAAGGATAAGTCCTGCCAGGGACTGTTGCATTATAG
+ GTTGAATAAAACGATCCATTATTTTTGCCAATGACAAATGGTGGATTTACGATTTTACCTTGGGATGGGT
+ TTGGTTGAAGAACGCCAGTTACTCCTGGTTGGTGATTATTACTGGCCACCCAGACGCTGGAAGGACCTGA
+ ATCTTGCGCTGGAACGCTACCTGGTAAAACGCCATGAGATCCCTGATTGGCGTGAACCAACGAACGGTTC
+ TGATATGGTATTATAAATCCGGGTGCCTGGAGGACAGGTTGGTGAACCGCCGGGGCAGTCAAATTGGACT
+ TTTCGACAGCTCTGTGAATCGTCGAGTGGTTGTATACACCGCTATAGGTGCGGGCGGGCGCGATGGCATT
+ TGGGCGACGAAAAGCAGGGTCAGCTAACACCGTGGACTGGAACTGCAGATGCCCAAAAATAATAGCTGAG
+ TAGAAAACGGATATTTTAGAAGGAGCTTTCACACAGAATAAAATATATTTATGTATATAATGTACCTAAG
+ ATTACGACCAATTGATAAATCGCCTCCATGTTTGCAAGTATTCTCTCTGAAATTCAGAACGGAACTGTCT
+ TGGGAATCCATTTCGAAATTTTCTACAAGTGCGTCAAGGTTATCTTGATTGTTTTGCATTAGTATGTATT
+ TATTTTATTTATATTATTTTGCGTTGTTATGTACTGCGTGGCGTCTTATCTCTGTGCCATAATAATATTT
+ AAACTGAAAATATCTTAGTTGGAGTATATTAATCTATTACATTAAATAGCTGGTTGTTGCATATCAACCT
+ CGCGTCATCGCAAAAAGACCCTCACAAGAACCTCTTCGAACTATTTGAATGTCTAAAAACGAATAGTGAA
+ GTATATTTTCGATTAAAAAATAATAATATAATGGATATAATGGACTCACCAGCTCCACAGAAACGAGCAC
+ AATTAAATTTTTCCTCGTTCATATAAAGCTGCATATTGCTGCCGCAAATGGGATTGTATTGCGATGTGGT
+ GGGACAGTTACCAAAGCAGTTCAGAAATTCCTTGGTTGGGGCCGGTGCTGGTACAAATGGTGTAAGACCT
+ CCTGGTATTCTTACATTGTTAACCAAAACTAAGTTTGCGCTGGTGGGCGAAATTGGTATTGACGTCGTTG
+ CGGCGGCATTGTTCCATGGGCTACGAGATGTTTCGAAAATTAAAGGTTCTTGGGCTGCGCCCAACTGACT
+ TAAACAAGCAAAAATAAATATTGGATGCCAATTGATGCACATCTTTAACTGAATCCTGAAGCTTATAGTC
+ GTATGTGCTTTCGTTCGCTGATCGAGGGAAACTGAACCAACACAAGAATCAGCTGCACTAAGCATAAGGA
+ ACTTCACATATACTGGAAAGTTTTAATTCAGTGAATCAAAATACAAAGTAGTAAATAAGATATGGGAACG
+ CCACTGAATACAGGTTTCTAAAGCAGTCAATCGTCTGGAAAATCCAGTTCTGTACGATGCCCGCTATCAA
+ TTTTAAGTTTATTATCATGTGCTTATATTTGCAATAATCTAGGGAAATCCCAGATTTGATTCATCAAAAA
+ TATGGGTTGGAAATGACCAACAAGAAACTTTAAAATTCGTGATGACTTATCCAATAATAATATTATAGTA
+ AGGGACTGCTGTAATTCGAGGGCCAGGCATGGAAAACGCAGGAGAAACATATTGCATAGAACGCTCCAGC
+ TTTTGGTAGTTTTTCGAAATAGCTGCGAAGCCAATGGTAGCTGAAAATCTCTTTATATTGTTGTACCCAT
+ ACAATTAAATGTAGGTGCACTACTTACAGCTTGAAGTGGAAGGCACATTAAATGGTTCTGCACTCCATGC
+ ATCAGTGCCATTCTGTACCATTTCTTGCTTGTAATCTGGACTCAAGGCTCTTTGTAAGCATTTTCCCATA
+ TGGATGCTTTCCTTAGTTCGCCCACAGCGACAGACGGCCAGTAAAGGTTTGTACATCTCCGGAGATACGA
+ ATCGCGATTCGCCTTGGTTGTTGTGCACAAAAGGGCACAGGTCTATAGGGTAGAGTATGTGAGTGCACAA
+ TTATAAACCTCTATGTAAATATACCTTTTAATTTTAGCTGGTTACTTAGTTGAGAATTAATCTCAGATTG
+ GTGGTAGAACTTGTTAGTTTGCTTGCCCGAAATTTCGCTCCAAGCTTTTGGAAAACTACGACGCGAATTG
+ TGCTCCATGCGCACTTGCTCCTTTCTAAAATTGTTAATAATATCTGCTATTCATATTTTAATAAGATGTG
+ CTGAACTCTTACAGCTTTCCAATCACTTTAGCAGGTTCCATCGTTTTATTATGTTTAACTAGTCAATAAT
+ TTTGTTTAATAAACCCGTTTTCTGCGCACGCTCGCCATGGCAACCAGTTAATTAGTATTTTTATACCCAT
+ TACTCGTAGAATAAACAACTTCTGGACAGTCTAGTAACGACTACGTTATATAGTGACATTTGCAACCGAA
+ AGAAGACTTTTGGGAAAGTTCCATGTATAACTGCTTTAAAACTGAGAGACTGGATTGCGTAGAAACTGAC
+ GGACGGGCTTTGTTATGTCGCATCGTCTGCTGATATTGATCAAGAATATAGGAATATAGTTTGTGATCAT
+ AAAGGGTACCTTCATTGCGAAGCAAATTTCGGACTGTTACAAAATATACCCTATGCAAGGGCCTACAAAA
+ ATTTCAATGCAGATCAACAAATGAGGATTTTGTTGTTATTTTAGTGCAAAGAATCCGTCTAATAATATTA
+ ATAAGCTATTTAAGGTATATTTTTGTTTTTGCTGAGTAGGTGTGAATTTAAAAGTCCAATGAGCAGTAAA
+ CAAACCAAAGACTAAATAAATGCAAGTTATTTTCAAAATATGCTGAACATTTATTATAAGCTTGTATTTT
+ TACAAGTTACATACGCCTAAGTTTAAACCTACAGCATATGATAAGGATATCAAATGAAATGCATGCTGTT
+ TATTTACACTTTAATGTTTTGTACAAAGGGGGTTTTACTTAATTATTTTTAATCTTACAAATGTCTGGTG
+ AATATGAAATTTATTGCATACTGGTGTACGTTACTAAATATGGTCAATATGTACATAATTTATTATAATT
+ AATTATATGTGTTTTTATTGATAATATATGTTTATATAACATTTGATTCAAAATAAGAATACATAACTGA
+ AGGACGTTTTTCAAATTGTTAGAAGTGTCTTTATAAACTATAATCATTTGTTCTAAAGTTTTCAAGGGCT
+ ATTATTTCTTATGTTCTTTGGTCAAAAACATTTTCGCGAAAATTTTTAATTTTTTGCACAAAGTATGACT
+ CTAGTGCTTCAGCACACTTATAAAAGGATGATTCTTTTGGGTTATAGTAACGGCAGTTGTCAAAAATTTT
+ TGTCATATCGCCTATAAACTCAGATAGTTTGGTATAGGTGTTTGATTCGAGTTTAATTTCCATCCGTTTG
+ AGATCTATAGAAAAAAATATCCCCATTTTATTTATTTTCGAATAAATTTATTTTTTGTGTTACATACCCA
+ TTGGCTCTTTAATCACTTTGTAATAATCGGGTGCTTCCTTCGGATCAACCGGTTCCATAAATGGCCAAGC
+ ACTTTTGTGTAACTGTAGGGAAATTTAATATTTATTCCATTTTTGATGTGCTACAGTTGAGAGTTTTTCG
+ TTAGCCAGAAATGAATGTGAAACGAATGAACGAATTGGATATTTGATTCACTTGGTCTTGAACTTATAAT
+ ACTTTCGTTCTGTTCGTTACTTTGTAATATTTTTTCAACAATTTTACAAACATTACCGTATTTTAACATG
+ TTTGATGCCATCAATATATAAACGATTTGTTCGTTTATCTAACACAGAATAACGATTCCCACAAAATTAA
+ ATTTTATTTAATTAAGGTCCCTAATAATAAATAAAAATTATTATGAATTTCAGGTTATTACCTGCATCTG
+ CTTAATTAAGTTTTTCAGCTCTTCAACGTCATTTGAAGTCAGTTTCTTCATATTTGCAGCGTTAGCATCG
+ TTTTTGCGTTGGCATTCAGGGCAAACATATTCATCAATAAACTCTGCTTCGCTCTGAAGTATTCCAACGC
+ AACGGCCATGAAACCAATCCTGGCATTTATCACAGCATATATAAAATTGTGACTCGTCGTATGGTTGACG
+ ACAGCTACAGTAAAGCTGTTGCGTTTCTCTCGCCCTCTTGCAATCAATGCAAATGAACTCCGATAGTTTT
+ TTAGAAGCTTCCTCGGTAATACTGACACAATCCCCATGGAACCAATTGCTGCACAAGTCGCACCCCACGT
+ AAAACCTACATAGACACAATTACAATATATTAATTAAAAGCGCGTTAAGAATATGCATTTCTGCATTACT
+ TTGTGTCATCATATGGAGTACGGCAAATGCAATACAACTTTTCCTTTTTTCTTGTCAACTTTTTTGGTCG
+ GCCTGCGCCATGTCTGGGGTTCTGCACCTCTGTCCTACGATTTGATTTAGGTATTATTAGATATATCATA
+ TTGCACACAAGTGCATGAGTATACGTACCGTTTAAAATCTAAATTTGGTTCGCCACTTCTCTCATTTTCG
+ CTTTGTTCATCCGGTGAAGCGTTACTTAAGGGGCGTACATGTCTTTGGACTTTAGTTTTTACATCTTCGT
+ GTATTTCGCTTTGTAAATTACGCTCTAATAAGGAACGCTTGCGCAAAATATTTTTTTTAAGCAATTCTTT
+ ATGACGTTCCAATTGCGATTGCTTTTGCTCTCCAAGTTCAGCGACTTCGTCATTCTTGCTCCGATTTTTT
+ TTTAAAATTCGATTAAATTGGCTGCTTGTTGTCATAGCATTTGGGCGTCTTAAGGAAGTACGAATTTTCC
+ ATTCAGTGTCATCAGTTTGGCGACTGGGAGTTAGTGCTTCCTCATTCACACTGCCCCTTGAGCATGTTTC
+ CCACTCATTCGTCGAATTCGCATTTTCTTGTTGCTTCTGCATACAAACAAGTTTTTCTTCAAGTTCCGGA
+ CTTAAATTACCTTGTTTCAGAGCATTTGAAATAGCTGAAAATCATGGCACTTATTATTTCAAACACATTT
+ GTATTTTTATTCATTTTTTAACACTTACACTTCTGTATGTATCCTCTGGTAACAACGAAGCTTTCGTTTT
+ GTTTATTTTCTAAGTCTGTTTCTGATATATCGAGGCCGGCAAGGTTAGTTGGTTCATCATGTTCTGAACC
+ CTCTAATAGGGAAGATGTACCGGCAAAGGACTCATTAGTTGTAATATTAGAATTTTCTGTTTCTGCACAT
+ TTACTGTTTTCCTGATCATCGCCATTATTAATAGCAATATCTTTAATAGTTGAATTGGCTTCGTAAGTTG
+ TTGCTAGCGTATCGGCGTCGATTTCGATGTTGTTGGTCTGCAATGAACATCGTTTAAGGTCTTCACTTTC
+ ATATTTTAGGCGATGCTGCTCAATATTGTCTTGATCTTCAACTAGAACTAGATTATAAATTTTTAATTTT
+ TTTTGCTTGCAAAATTGGCTTACAATTATTGTTGGTGCGGCACGGCAATTCACTTCTTAAAATTCTACCT
+ TCGAATACTTCACGGGGAGGTGAAGGTACAATTTGATTCGGCGGACTGCAGACGACAATAATCTCATCAT
+ CATAATCTTCTTCTTCTTCAATTTCTTGCACAAAATAATTCGAATTCATCATACGAGTATAAGCTATTGA
+ TACGCCGCCACCAACCTAATCGTTTCCAAAAACGTAAGTTATTTTCAAAATTTGAGAATTTGATTGCGTT
+ AATATGAACAAATACTAAGAGCGCAAAGAACAAAATTTAGGAACACACCTACCTGACTTTAATCAGAGAT
+ CAGTTGTAGAATTTACTCCAGGCAACCTTTTAATGTGTTTTATTGAAGTTGTTGTAGTTGTCGAAGAGAT
+ TAACACGTGGTTAGGAGTTGAAGTTGTTGACACGTGACATTATGGCATGGTTAAAAGTTTTTAAGCAGTG
+ GAAGCATGAATTTGATTTTAAGGTATATGGCACTTTCATTACAGAAATAGGATAGTATTTAAATTGGATT
+ AAAAATTATAATGCAACTTGTGTAAAAGAGATTAAAATGCTATGAGACTGGTGTACGGATATGTAAGGTG
+ TATATAGGCCGTGTTATTGCAAAATTTAATTTTTGACAAGTGTAAACTTCATTTCGATTTAGATGAGATG
+ ATTATAAAAATGGTAAAGCCTTTGTGTTTATTATAAAGGACATGTCAGAAAATCTAGCTCAGTGGCGACA
+ TTAGCACATGCGTTTTATATGGAGAAATCTTTTCTTAATTTTCCATTTAAAAAAACAAGACTTGCCTTTA
+ ATTTGTATAACATCAAATATGCCAGTCAACGAAAACTCTGCGTGGGGTTAATCTCTTCAGCAGTTCGTAT
+ TTTAAATCAGATTGAATTAAAATGGAAATTTAGCTTGGCCATTGAAATGTGACCAATTATTTTGTAATCC
+ TAAAGTGAATTCAACTGATATCTGATTAATATTTATAGTCTATTAGCTCTGTATAAATTCTTTTCTTGCA
+ CAGATTTCAAAGGTACGTTTGCAGACTTCTCTTTTTACTTATATATCAAGCATGCGCTTTTTGTCAACAC
+ AAAGGCCAATTTGCAAATAATCATCCAACTAATTCAGAAACAAAAATTCACAAACTTTTAAGCTTATTTT
+ CATTGCGGTTTGTAGGATATTGAATTCAGGAGGAATACACAATTTTATAACATCAGACACACGCCTAAAA
+ ATGCTCACATTTGCAGGCTTTATAGTGTGTATGTATATGAGCTGAAATAATTATAGCAAAAATTTAAACC
+ AAAAATTTCTTGTTTTATTACAACGTGATACTCCATTTTTTTTACTTTCTAAATCCATTGTAAACGTTTT
+ ATTTAAATCTTTCTCTTCTTTGATACACGTCCCGGCTCAATGGATGTAGTTAGTTAATATAGGGGTTACT
+ GCCACTTTCTACAGTATTTTCATAAAGCTTATGATATCAGCATTCCAAAGATAAATTCGGTACTTAGGCA
+ ACTTTAAAATTTTGCACTTGTTGTTGCTGGTTTAAAATTAATTCCAAAAGAAAAAATCTTTTACACCCAC
+ GAAAAGACGTTTTTCAGCCAATGGCTGAACGATCTGATTTTTATGAAGATAGAATTTTTAAGATTTAAGT
+ GGGCGCAAGAGTATTTCAAAGATTAAAGCATTGATATTTGGCTTAACTATGCTTTGGATGACTGATTTCG
+ AAATTTATTCGTAAAAAAGAAACAGAGCTGGTCACAATTAGTGTAGTTGCATAATAGGTTTTATTGCAAA
+ ATGCGCTTTACAATTTACAAATATTCGATGTATTACTAAGAAACCAAATGTCCCTCAGGCAAGAAAAGCT
+ AATCGGAGCAAAGTTGTTCTAATACTTTTGCCTTGGTTTTTAACATTAGGTGACAGTCTGGATTATTGTT
+ AAGTTAATAAGCTTAATGTGCTTCCTACTCACTATGTAATATTTACTTATATTTAATAAGGTATTCACAC
+ TTTTAGGCTAAATACATTTTTATATTTTTTAAATTATGTAAACAAAATAAATATGACATATTTAAGTAAT
+ TATTCGGTATCATGTATTTTTAAATATCGAGCTCCTGTGTGGAGAATTGCTTGTTGAATAATTATTTTGC
+ AATAGTAAGCCTTGGTTCATATTTCAATAAGTCTGTTGCTGTACTTGGAAACTATAAGTTATTGTTTACA
+ GCTTAGGAATGTATACAAATTAGGAAACGCAATGTATTCAATTCATGTTCATTAAAATACAACAAACAAA
+ CAAATTAGGTGTACCAAACGAAACGTATAGAAAGTGCAAGTGAAGCAGCGACATGCCGCTCGGGTTGAAT
+ AAATAAAAAACTTAACTTAAACGTAGGATGGAACAAAAAACAAATTGGCATTTCGGTCGAGAATCAGCAA
+ ATGCAACCCTCACAGTCCTGTTCCTATTCCTCATTTATACTTTTACATTATAATTATAACTAAAAACTAC
+ TCACTTGCTGATGCGCAGCCGATTGGTGAACAGGGGTTAGAGGAGGTGGCTGTGATTGAACTGCATTTTC
+ CGGCTGTACCGCCAAGTATATTTTTGTTGGGCCTAGAACACCAAGTTTGCCATTTGACTCTTGAGCTAAA
+ ATATAAGTGGGAGATATTAAAAGGTTACAAAATATATTATAGAATTACACACCCTTCATTAGTTGCTGCT
+ TCACCTGCGTTTGCACCAATTGCAGTTGTTGTGCAGTGAAATCGTTGCCCACCAGGCCTTGCAATACTAT
+ ACGTGGACCATGCTCGGTTTGCAATACTTGAGCGGTGACACATTTAATTACTGTTCCAGGCGGCTGATTC
+ TGCAGAAGACTTTCCTCAACACTCAAGGCTTGCTGTTGGGCTGGAGCCTGGACAGCCTGGGTGAGAACCG
+ GCTGCTGAGTTATTGGGGTAACGCCACTTTCGAAGTTTGTGGGTGACTGTTGATGTATTTGCTGCTGCTG
+ CACAACGACTTGTTGTGGACTTTGTGGTGGGAGAGCCTGTTGCTTGACTGGTGAGGTCTGCGGGTTAGCT
+ TGAGGTACTGCAGTAGCTGAATTACTTGTAACGATGTGAGCGTTCCCATCACCTTGGTGTTTAATATGTG
+ CCACGATTTGAGCCTGATTATTTCCCAACGGTTTTACGATTACTTGTTGCCCATTCACTGTTGCCACCTG
+ CAATTTGCCCTGTGCTAACTGCTGGGCTAAAGTTGAATTTGGAACCAAGACTTGTTGTGTGCCAGTTTCA
+ TTGCTATCAGTCGTGGTGATTTGCGTTTTTTCTTCAATGGTTTGCTGCGATTGTTGTTGAACCACAAGCT
+ GTTTAACCAGTTTGGTTTGTGCACTTGGCGAAGATTGTACAATTTGGTTTGATTGAACAACGAATTGTTG
+ CTGAGGCTGGACGACATGATGTTGTTGCTGCTGCTGCTGGGTTTGAATCTGCTGCTGAACCATCTGCAAT
+ GCTTGACTCTGCGGCACATTCCTCTGAGTAACAATAGTTTGACCGGGGCTTAAGATAATCCGTTGACCGC
+ CAACTACTATCTGCTGCTGCACGTTGCTGGTATTAACAATTTGCTGAATTACTTTTTGCGTTGGTTGATT
+ ACCGACCTGTGTCATGGAGATCTGTTGTGGTGACTGCTGAATTGGTTGCGATTGTACTAGTTGCTGCTGT
+ TGAACCGGTGATGTTCCTTGCTGTTGTGCCGCCGATGTAGATATAATAACCTTTTGCCCTTGTGCATTTT
+ GGCCCACTACCAGTTTTGACCCAGACTGTACGAATACTTGCTGTAGAGTTTGCCCAGAGGTACTAGTGTT
+ AACCACTTTCGACACTATCTTTTGCACAGGGGATGATGAAGTTGCTGGTGATGAAGATGTTGATTGCTGC
+ TGCTGTTGGGCCAGTAACAACTTATTCTTAATTTGAGCAAGCGGTAAGGCTACGCGCGAGGATGATGCTA
+ TGGATTGGGTCGCAGAATTTTTCGTGACATGTTTAACTGCAATTTGCTTTATCACTGGCGTCACTGGATT
+ TGTAGTAGTCTGTGCTGAACTGATTGCCGGTGACGACGAAGTAGAAGCTGGCTTAATGGGAACCTTCATT
+ TTGTTTCCTAGAAATAAATGGTAATACATTACATTTGTAATATTAGATTTGAGCTTTTTAAAATATAACC
+ CACCTTGCCCCGCCGAATTTGAAGATGTTGTGGTAGTCAGCACATGGAGTTTTCCATCCGGCATTTGAAC
+ CAGCTGCTGCCCAGGATTCAACCCGCGTACGCTTACTTTGCCATCTGGGCCCCTTATAATTTGTACTTTA
+ TGCGGTGTAGATGTGGATGGATTTGATTGAGTGCTTGTCGAGCCTCCTACAGTAGGTGAAGCAGCTGCTG
+ CTGCAGTATTAGCTCCTCCTGTTCTTGAAACCTGTGTTACTGCCTGCTGAATAATTCGAGTTGTGCCATC
+ AGGGTTTTTAACAATGACACGCCTGCTACCGATAACTTGGCCTTTAACTGAAATGGTATAATATAATGGT
+ CAGTTCCTCCCTATGAATAAAACTTAAAATAGTTTACCTGGTGTCACAGAACGGGTTATTTCGCCAGTTG
+ CAACCAATTTTCTCTGCTGATGAACAGCGCGCTGTAATTTTAATTGTTGTTCCATTTTTTCTTTAACATC
+ TTCACTCAACTTGGGTGCCAGTTGGACGCGTCCGGCGACGCCAAGAGCTCCATTAGTTGAAGTGTTGGAA
+ CCATTACTACCACTTGCCTCCAATTGACGGGATGCTACAGATCGCGTAACAGCTGATAGGCGTGCCTTTT
+ CTTGTTTTTCTCCCATAAATTTAATTTCCCATAACTCCAATTTATCTTCGTCGACCCATTCCTCGGTAAT
+ TTGTGGCTCGGTTGGCTGAGGAGATTCAGCACGCTTTCGTTTTCGCAGTCCGGACCGTATGGATGTTACT
+ TCTAGAACGAGAAATAAATAATTTATTTTGAATGCCTTTACGGAAATGCACATTAATTCTCACCTCTTAC
+ AGTCTTCGGCATTTCAAGTGGAATAACAACTTTTCGTCGCAAATAGCTTGTTTTTTCACCATAGCGTCCT
+ GAGTGCCGAAGTTTGAGCAATTCCAATGTTACAATTTCAGTATCCGTAGTAACCTGATGCTTCCCATCCG
+ TGGATGGGGGCTTTGCTATCATGTCATCCCAGCGGAGACACGACCACAATATTCGAAGCTGAAGTGCTAG
+ GCTGGATAAGGACGTGGCATTAGATGTTCTGTAGGACCAGCAGGTTCGGAAGAGGGGACGCGAGCACTGA
+ TACTGCCAAATTGTGTTATTTTTCGCAGCGTGATGAAAACCATTTGTCGATGATTTTCCACCCAGACGAG
+ CCAGCTTCAGGAGCTCAAATCGTGGTAGCACTAAAAGGCTACGCTTTTTTTTATGAGTAAGAAAATTGGA
+ TATAAGTGGATACCGAGAGTATGATGGCTTTTTAGTTATCGTTGACTTATCCTCAGTTTTGACAGCTTGC
+ TCATACAACTTGGCCGCATCATTAAGGAGGTATACACGACCCCGAGGTGAACTAGTCGAATAGACCCGCT
+ CGTTTCCATTCTCAAATGTCTCTCGTTCGTATTTTTTGACACATTCGCGCTTAACCGGACGTGCAGTAAT
+ AGGAAATCTGCGGTTCTGTTTGTTAAGTGGTATATCCTTGTCTAACGTCTGATCCAACACATCTTTAGTG
+ CCGATGTAGCTTTTTTTCGATTTCTGGTTACGCTTTCGCCGCCATCCAGGTGTCATATCGACATCTTCAG
+ CGTTACCAGAGTTTAAGCCCGTAACAATGGAATCTTCGGTACTCTCAATTTCAACATTACTACAAACGTC
+ CATACTCTCAATATAGTCTATTTTATCGGAGTCTTGTGTGTTCGAGTCAGGAGTTGTATTGCATCCGGAA
+ CTGGCATTCACCTCTTGTTTAATTTTCGTGTTGGTTACGCACTCCTGGTCAACCAGGATGCATTCGGTCA
+ ATAAAGAATCGCTAAAAGGAACGGCGTGCGCTCGTGCATGTTCCCAATCTTGAAGTAAATCCAACGGCGC
+ TTCGGATTCAGCTGGCTTCCCCTCTTCAGAATCATCCACGGCCACCTGAGTGGATTCTCTTTTACCCTCC
+ GTCAGCTTCTGCTCGAGAATAGATGGCTTTTTAACAGCGCCCAAAATAGCGGCAACTGTCTCTTTTGAGC
+ CATTACCGGCAGTATGCGCCTTTCGTAACAACAAAAGAAGTTCTTTTTTGGCCCGAGCTTTTTGAAGACA
+ TAAGGGAGAGTAGCAAGTATTTTGGGTTATTTGAGAGACAGCATTTGAATTGGTGTTACACTCCTTTGTA
+ TAACAACGAAAAACTTTAGCAAATCGATTAAGCTGACTAAATTGTAAGCGCACGGTTTGAATTTGTTTAG
+ CCAGCGAATTAACAAGTTCCAAGTTTACGTTTGCAGGACCCCCCTTTGCTTGGACTTCAGTAAGGCGAAG
+ TAAACGCTTCTCTAGAAACGTTTGTTTGCTGTTGGCTGTATTATTTTGGGAAGAAACAAGAAGCGGCTTC
+ ATATCAGAAGGAATTTTAGAAGCCATCTGCTCCTCGACCTCGGCCAACTTTAAACGGCGATCCAATAAGT
+ CATCTAATCTAGATTTGCGAGCCACTTTTGAATAATAAGTACGGCCTGGAGCATTTAGCGCTTTGCTGAC
+ GTCGATGTGCCCTTTGATTTTCTCCGTAACATCTTCTATAACTTTCACATTTTTATATTGGTCCGGTAAA
+ TAATGACACACCTGACCATCGACATTGCTTGACTCACATTGTTGCATAAACCGTTGGGTGCGTGGGTCGA
+ CTAAAATAATTTCATTTACGTCGTTTTCCTCTCCCATGGTGTAATGTACGTAGACTCTATTGTGTGTTAG
+ AGGTTGGGCTCGACGTGCACGAACACCACAGCGTCGACTGCTTGAGAGCCAAAGCCAGCCCCATTGCCCG
+ TGGACCCGGTATTCTTCTCCTTTTTGCTTCCAGACTTGATGTTTGAGACCCAGGGTATACTTTATGTAGT
+ TAAATGCTAAGCGATTACGTTCTTCCTCATCATCCCGCTCGCGCTTCTCTCGCTTTTCTAGTTTTTTTCG
+ CTCCTCTCGTTCGGCACTAGTTATGCGTTGCAAAGTTGTGTGTCCGAGTTGCTCATGCCAGACGTTGGCA
+ AAAACAACGCTCTTAAGGGACGCTTGAAAAAGTAACAATACTACCGCAAATTCAGAAGGTCGACGGGCGT
+ TCATCACCGCAGCATTCCAAATTTTTTTGTTAACTACCCAGTTAATATTTAAAAAGGAAGCTGCTATATT
+ GGATTCGAAGTTTATCAATGTTTGCCTTAGAGTTGTTATCATATTGTCAGTAGTTCCCATGGTTATACCG
+ ATCCATTTAAAGTCAGAAGCCGTCGTTAACGAGAACTTATGGGACAGATGGCGTCGCTTATCTCGCTCCT
+ CGTTTCGTTGCGGCTTGTTGAGTGCAATTGGATTTGTTGAATACTGGTTGACATAGTTCTTAAATCCTTG
+ CTCCATGCCAAGTTTAAAATGCAAAGTACCATTAGTCAGCTGATTGGATTTTTGACGCGTGACCATTTTA
+ CATTCTTCTTGTTTTTTTGTTCCCTCTATAGATTGACTCTCAGATTTAGCATCACCATCTTTTTCATCCT
+ CGTCAAGCACCTCTTTCTCCAAAAGTTCATTTTTAGCCTCTTGTTCGATTTCGATAACACTACGCTTCGT
+ GTGTTTGTGTTCATTGGTTAAGGTCTCAGTCAGTTTCATTTGGCGCTCGATTTCGTCTCTCCTTTCTGTA
+ ATCTGGCTATGCAGACGAGTTTCCAGTTCTTCGGCGTCCAGTCGACTGAGCAGCAATTTTAACTTACTTG
+ TCGTACTGTAATACCAGCATGTAAAGTTCTCCTGATCCTCGATAAAAATGCGACGTGCAATAAACCAATA
+ TTTGCGCCCATGACGATCAACACCGAGGCTATCATGCCGGATTAGCACGCCTTGTTTTTCTTGTGGCAAC
+ ACGCAGTCCACTACGCCACTTACCTTATGCGAGCGGCAAAGCCCGCACTGCCAATCCTCAGTAGGTACGT
+ CATTCATTGGCGGGTCTACACATTCCAAATGATAGACAGCAGGGCACGTCTCGCAACATAATAAATCACC
+ GAGCCGATGGCACACTCGGCAATGGTCATCATAATGAATAGGTCCCTCCTGCAGCATTACATCTCGTATA
+ GAATTGGAAGTTAAAAATTGATCTGACAGAAACTGGAGCACTTCAAGCCGGTTGTCAATGCCCGTGTAAG
+ GGTATTCAGTGTGGCTTAAAATGTGAAACACGTTGCGATCAAATGTCTTATCGCTTTCTACATAGCTTCG
+ CAAAACTTCCGGCCACGTTATAGAGTCAATCAGGTAAAGACTTATATTAACCGTATCTTTTTGATCCAGC
+ GGGCCAAAATGTGTACCCTGCGCGTCCTCTTCTCGAAGAATCGCTTTAAGCAGCATTATGTGTACCTCCG
+ TCAATAATGCACTTTGCTCCTCACAAGCCAGCGCTGCACACAAGTCTTCAAATCGGAATGGTGAAAGGCG
+ GACCATGTGGCGAAATCGTCGCAGTACTTCATAGATACTTAGCGCGCGCAAAACGTGTGTATTAGCAATG
+ AAAAGATCCTCCGACGAGTCCGGCAAATCAAGCGCTGCATACTGACGACCTTCCTGCAGCCACACAGGTT
+ CTGGGCTAGGAGGACGTGGCGGCCGACCAACTCCATTTTGGTTAAAGCTGCACACGGAAAACTCTGATTC
+ GCTCTCGTTGGCTACTTCTAGGCTCTCGTCGTCGCTGGGAGTAAGCAGCATATCATCCTCATTATCGGAT
+ TTATCTTCTTCGGAATCCCCAAAATCTGACCCGTAGTGATACTCCGACTCGTACCCTGAAAAGAGGAACA
+ GTAGCTCTTAGAACCAATATGATTTCACCAACACCTAAGTGCATAAAACCTGACATACTGTCACTGCTAT
+ TGTGGACCCAATTTCTACTGAATTGTATTTAAGTAATTGTTATTAAACTCATGCCAACTAGACTGAAAGA
+ TTTTTTGTCGTAAGATTTCAAAAATAATCGTTGGTATTAGAGCAGATAGACCTATCGAAACTGACTCGCC
+ CGGTAGTGGTTGTCACGAAAATATTAAATTTGATCTTTTATGAAGCGGAAGCTCTTTAACGCACAGGAAA
+ ACTCGTTTGAAGTATGAGTACCATTCAAAACGATCAAAGTTTTCTCCACTGCAATCAATATATGGCACAT
+ TATGTTCCCTATTAATCTTCGAACTAGTCAGAGCGAAACTGTAAGTCTTGACTCCCAAGTTAGAGTTTAG
+ GTGCCCCTTTAACCCACCTTTCCTTCCAGAGTAGCTACTGGTGTTCGGTTGCACGGCGGATTTGCGGCCT
+ CGTCCCCTCTTAGCGGCGCTCCCGCGACTGCGATTGGTGTGGTTGTTGTGGCTGCTCCTGCTGCCCTCGT
+ CGCTCTGTGGAGAAATGCCCCTGGATGCCGACGGAGTGCTGGGCTGCGACTTTCCCTCGCTGAGATACTT
+ CGGCTTCTTGAGAAGCTGGTAATTGAAGCGTCCTGATGCGCGTTCGTTGGGCGTCTTTGGCGGACGTCCA
+ CGTTTACGGCTGCCGCGACCGCTCATCTTGTTTGTTTTCGCCTTGCGTATTTATCTGGCTGTGTGCAGGG
+ GTGCGTGGGGGTACTCTCCTCAGATATTGTTCCAAGTTAATGCTGCGAGGCTGCACATTAGATCTGAAAC
+ GAAAATTAACCCATTAGTACACGGTGCCACAGGAACGCACACCGCATCTCACTCGCACTCAGCTAGCTAT
+ GTATTTACGGGGCACATTCAAACACACATTTACTCAACAGCGTATGTGGGGGAAAAATCGATCAGATCGT
+ CAAAAGTTTGTCGTTGGGTGTTCACTTTCTTTGTATTGCGCAAATTTGGAGTTGAAAAAAACCCGCCAAA
+ AGAGCTTGTTTAGTTCAGAATAACGGTTCCGATTAAATACATTAAGTACATGTATTCAAAACACATTCTT
+ GGCTTCTAGTGTTGGACGGCAAACGCACTGGACAGCACCACCAAGTTCGATTGTATGTGTGCGAGTGCGA
+ TGAAATGAAGCCAACGCACATTGTCCGCCATTTAAGCAACCGTGAAAATTTTTGCGTCTGTTTAAATGTC
+ ACTCTTCTTTCACAATTAACACATGGATTAACTGCGCAAATTACCCAGCATGTTGCGGAATAATTGCACA
+ GGATTTAACACGATATATTCTAATATTTTTAACTATCTTCAGCACACTGCGAAAGAGACTTTTACCTAAC
+ ATTACAGTTTTGAACATAGCTAAAGACGGTGTACAGTCGGCCAATCACAGCGACTCTTCTATTGCGTGAA
+ GTCAGAAGCGTCCTCTTGCGGTCGGCTTGGAGAACTAATTCTTTATGGTTGCACAAACGATATAGGCAGG
+ GTTGCTTTTGGCATTTACGCTGAACCGCACTGACAGATGTATTTTTATTTTTATCGACGTGTTGAGCGGG
+ CGTTTAAAGAAAACCCGTTAACTTGTAATCAAAATAAACTTACCTTTGCTCACTATCTTAAAAATTAAAA
+ CGGTATTTTTGATGCGGTAAAAAAAATGTATTTTTTTGTAAATTTATTTTAGTGTATTACATTCTACCCA
+ ATTTCGCATTTTAAATCCTGGTGATCTCATTTCGTAAATTGCCGACCACGAAAAATCCATTAAAAATGTT
+ ATCGATAATAAGTTGCCGTTACGATTTTTTGTTTACTGGGAAAGGTTTTTATATTATTATTACTTAAATT
+ TTTTAAAAAATTATTCTAAAAATACTAAATTAAAGTATTTTAATTGTGTTTGTTGAGAAATGTGTTATTG
+ TTAAAGAAATTAGGGTAAACAATTTGCTTTGAAGCCCTGAAAACATCGTTATCTTATCGCCTGCACAAAG
+ TGATTCCATTGCAGAATTAAAACTTCTTTTTCGCTAGTATTACTTTATTAATCAAGCTCAGTGGTTGCAT
+ TTTAAATAGCAAGCATAAATTATTTGACATGTACGTAAACAATAATTGCCATAAATAGTTTATTTTTAAA
+ AATACAATAATTGAATAAAATATGATCTAATCAAATAATCAGTGCGCAAAAATTGACATTTAACGCGGTT
+ TTGTATAAGTTGATGAGTGTAATTTTCCGAGTATTGATCAATTCTAAGGAATGTGCTACCACATTCGTCT
+ GACGTCATGTGTTATATTATGATAACGCACTCTACTGGTATCTTACACAGATAAGATAGCCCATATCTTA
+ CCAGTTCCCACACCACCTAACTAATGTCAAAATTTGGTTTGTTTACATACTTTCTGTGTAAACGAACTCG
+ GCAATTTTGTTTTATTCATTTTATGCTATATATTTTTTGTAGATTGGTTGAAAAGGCAATATGAATCTAG
+ GCCACTGGAATTTTCTCCTAGCTCTAATCAGTTTACAAACGTTTTTTAACGCCTCCGCACAGATAAGCAC
+ TGTAAATAACAGTTCGAAGGGATCAAACAACTCAAAGTAAGAAATACTCAAAATATTTGTTTTCGAAAAA
+ TACTAATTTTGGAATCTTTGCATTTTCTATAATATATTTTGCTTTGCTTAGTATTTTCCATGAAGACACA
+ TTCAATAGCACTTCGATTGACGTTCTGGACGCCTCAATACATTCAACACTGGTTGTACCTCAAACATATT
+ CGACAGAAGCTGCAACAATATCAGGTGCTAGGTTCGCAACCTCTGTTCCTGTTCAAAGTCCTGTAGACAA
+ CCCGTTAGATCCGGCGGACTGTTCTCAACGGGAAAAGTACAGAAAGCAACCAGTTGCAACACCATCGTCT
+ CGTTTAAGAAAATGCTGCCCACATGGAGAAAACTTAAATATATATCGGGAAAATCAAAGCGATTCGATGT
+ GCGACAACGGGCTCTTAAGCTTCGAACCGACTATAATAAGTGCAGTTCTGTTCGATAACTGCATTGAAGA
+ TTTGGAGGTTGAGACTACGCTCGACTACGACATTGGAAATCCGTGCAACAGGTATGAAAGCGAATGTTAA
+ ATTGAATCAAAGTACAAATTCTTCTGCAAAATTAGTTCTCTTTTGTACGACGACAAAGACGATGTTTTCT
+ TTGTTCTGCAAGACGGTTCGTTATTAATCATCGACAAATTTGGCAACGAATCATACACTGTGAAGGAACA
+ TTATTGCTTGGATATTGATAAGTCAGGACACTTGTTTGCCTTTACATGTGTAACCCAAGTGGAAGAACAA
+ ATTGCCTTCGCAAAAGTAAGTCAATGTAACATTATTTTCTATTTACCAACGGATGAATATTATTTCAGGT
+ CGTTTTTGTTGCCGTTCTTATGCTTATATCTATGCCCTGCCTGCTATTAGTTAGTTATTTGCACATGACA
+ CTTCGTTTATTGCGTAACTTGCATGGTCTCTCGCTAAGTTTGATGTCTCTGTGCTTGGCGTCTGGATACT
+ TTGTGCACTCCGTTGTGCACATCTATGGGATCCCGAACCAAGGGTTCATTGGCTACGTCATACAGTTTTG
+ TATTTTAAGTTACTTCTTCTGGTACTTGTGCATATGCTTCAATGTTCTTTTGAATGTGTGGTACAAGTTG
+ CCTTGCTGCATTCAATGCTCAAAGAGTTGGGCCACCTTTAATTTTGCGTGTTACGCTGTTTTTGCCTTTT
+ CCGGACCGGCCACAATAGTTGCACTAACTGTTCAAAAAGGACTCCCAGGAATGCCGTCTTACTTTCTGCA
+ AGGCAAGTTATTGACTTTAATAGTTAAAAGTATAAGTAGTAACATATGTATTATTTAAAGGCCTAACTGA
+ ATCCATCCGAGATTCCCAACGTTACTTTATTCCTCCAGTGTCTACTATACTTTTTCTAAGTTTTTTGGTA
+ AGCACTTCTTTTCGTACCTGTTTTTTGTTTTATGCAATTGTACATTCTTAGCTTAACATCATATCGTTCT
+ TCGGATTTCAACGTATAAGCGGCTACGCCAAGGCTGAAAAAAACATTCAGGAGCGAAAATGCTTGTTTGA
+ CCAACAAAAATATGAAGATGTTAAAAAAGAGTGAGTGCAGAATTATTGCAGTCCAAACACATGCATTTAT
+ TTTAATTTTTGTCGTTAGCGCTAAATGTGTCAGCTTACTTGGAATAATAATGGTCGTTAGCTGGCTGCTC
+ GAAATAATAACATTTTACTCGGGATCGAATTCAAATTACCTGATACTCTGTGACATGGTGAATGGACTCC
+ AGGGAGTTTGGGTACTGCTCATTTTTCTAGTCGTGCGCAGGCGTCGCACAATAATATTAAGGTGGTGGTA
+ TGATCGTGGTTCCCACGAAATTGAAGGCACAGAGCTGCAAGCTCTTAGTAATAGTCCCACATAGATATAT
+ AGAATTATAATACAATTACATTACATACGTTCAAATCTGCGATCGCCGTTAATATTACATTATTTTTTAA
+ TTATATTAAATTCTGGTTTATTTGACCTGTAAAGAATGATGTGCTTATAAGCAAATCAAATTGATGAAAA
+ GAGAAAAACATTCGAAAATTGCTGAACAGCTGAACCTGATATCCTTTAATAGAATATATGTTGTTGCGGG
+ CCACATTACCGAACCATTTCCCAAACATATTTGTGAAAATTTAACTTTGTGTAAATTGTGGTTTATTTAA
+ ACTTATATAAATACTATTAAATATTAAATGTTTGCTGTCACTTATATGGTCATATAAAGATAAATAGTCA
+ TTTTATTGTAAGAATGTTTTACCATCTTTGCTAATACTCTAAAAGGAAATGTGTAATTAGGCGTGCGTGT
+ TACCAAAATGAGCCATTTCTGTTTTTTTGTGGATTGCGGTTGTTTTGAATTATGATACGAAGACAACGTT
+ TTGTAACGTTTCTTAATACGGCGATTTCATCATAAGAATAATTGTGTATTTACATGTTATATGCTACGTA
+ TATGGGATCCAATTGGTCGGCCAGAAAACCATCCCGTAAATGCATCCGTTGCTTTTCGCCCCGACTATTA
+ ATAGGCACCACACCTAGAAACAAAAGTTTCCAAAATGAATAATTTTCATTAGAAAAAATGTATCACAAAC
+ CTGGATCAACGACCACTACAACGCCGACTATAAGCTGATGATCTTCTAATACTGTGTTTGTGACCAAGGG
+ AACCAAATCCAAAGCTTCTGATTCATTGCCGTCCAACTCGACAACAACGACTAATAAGTTAGTCCAGGTG
+ AAAACGGCGCTGAATAAAAAAAAATAATGCGTGATCTTTTCAACAAGTACGTCTTTAAGGTCTTACCACT
+ CAGCAATTTTTTTGTGACAGCGCATTACCGAATTTTCGATATCAATTGGGTGATAGTTCATGCCACGTAA
+ AGAGATCACTTCATCAACAGCTCCGACTACATACACTGCGTCGTGTAGTTCTTGATCATTAGCATTGCTT
+ GCGCCGCCTACCAGGCTATGCTCGGAATTTCCACCCAAGGAAACATTTGAAAAATTTAGTTGCAATTGAC
+ TTATCGAATTCAAAGATTCTGTATCACTATCGCGACTTGCCACACTTGGTGTGGTCTCGTCAAGCAGTGA
+ TGCTGATTGCGAGCATTCGGTGCGGCGTAAGAATCCTAAATACCCAGTGCGTGCATATAGTTCTGAGGTG
+ GCCCCAGTTACCAATTTCGCGTTGAAGTGATCATTGTAGTCAGTTTCGTCACCATAAATTGTAAAGTAAC
+ CATTTGCGTTGTGAGGAGCTTGAACCTTAGGAATAAATAAATAATAAATTAGTTTTGTTAAGATGATTAT
+ GCAGTTTGTAAATTGTTACCCAGATTTCTCCCAAATGCGAGTCGCCACAGTGGCCCTTAGTTTCGGGATT
+ TGCAATTATCACTTTTACGCCTGGTAAAAGTTTACCTGATTCAATTACACACAACGAATTTGGCGCTCCA
+ CGCTCTACCAGAGCAACACGATTATTTCGCAATGCTCTCATATCTACATACACTTGAGCACTCTCTGCAG
+ AACTAGCCCCTTGGACACAAATGGCCGGATTTACACGACATCCAAACGAAGTTGACACGCAGCGCGTATT
+ CAGACCAAGGGCTTGAAATAGCTTGCAGAACTGCTGGGTCAGTTGCACTCTGGGGCGCTCTTCTGCCACC
+ ACGACACACGTCCGTACGCATCTCAAATCTATGTTTCGTTGCTTTAAGGAAGGTATAGAATTGCTGAGAG
+ CTTTAGTGCATAACTCAATTACACCATATGAACAGAATGTGTCGCGAACGCGGTGTTGCGATAGAGTTGA
+ CAGCCATAAACTGGGATTCGCTTCGACCTCGTAGGGCGCGATAAGTATAGAATGGTGGCCACTGTATACT
+ CCGATAAGAGTCCACATAACAAATCCAAGGCCGCAGTACGGATCCAAACATAAAGCAACATGTCGAGAAG
+ GGTACAGCTCACAAGCCAATTTTAAACTGGCGCACAGACTAGAGAGAGATCTGTTGGATAGACAAAAATT
+ GAATACACACATTTCGTTAAGACTCAATTCGATCTATGTACCGATGCGTAATGTTAACACCGCTAAGACG
+ TCCACAAGTTGATACGCTAAAGTCCAAATAGGCGCTAGAGTCAAAGGAAACCGTGGCTATGCCGGCATAT
+ TTTCGTTTCGGGTTGTCATCAATATCTAATATAGGGGGCCATGTCTTTGGGTCAATCGAGGTTGCTGCCT
+ CTCGCGATTTGAGTAACTTAATAATTGGCTGTATGGAGAGTACAATGCCACTTTTAGAGACATCAACAAT
+ CATCCGAACAGTGGGTAACGTGGTATTTAAATTTTGTGGATGTGGAGGCCGAATGGTAATTGGTATTGCA
+ CCCAAATAAAGGCATCCATAAAATGCACACAGCAAATCGAGACCTGGGGGAAATATAAGCGCTGCGGGAA
+ AATCGGACTTCATTAACATTCCTATAGTGTGTACACAGAAAAACTTACCAACGTGGTCTCCTGGCTCAAT
+ TCTTCCTCGTTCTTGTAACAATGCCGCTATTTTCTCTGCCCGCTTATGCAACTCAGAGCATGTCAGTGTT
+ TTCGCGATGGCACCTGAAGCGCAAGTCTAGAATTCGTTTCTTTCAAAAAGGAACAAAACTTACCCTTGGA
+ GTTCAGCAGTGTAAATATTATATGATCGGGGGACGTGTTTGCTCGCCAACGCAACACACCTGTTATCAAT
+ TGAGGCTGTTGAAGTTTGGACAGTTTTTTAGTCGCAATTTTCGACATTAGATATGTTAACCGACCTTTCT
+ TTCGCAATCTTCTGCTAGGCCAACATCCCGTCCATGGGCTTCAGCAAGGCGATTGCCCTGAACTAAATTT
+ CCAACCATCACAGAGGCTGGTCCTACACCCGTGTCTGTAATACCACATCCAGATGATGAGCTTAATTTTG
+ CGGCAGTTTGCACACCTTATTTGTTTGAGGAATGGTTAGTAGTAGAATGATTTATCGGTTTTGTACAAGG
+ ATTCATTACAGAAGTGATTAATTTATGCGATTTCATTAGTTATGTTGGCATTTGTGTTTGTTGTTGATAT
+ AATACAGTGTTGTTATTTGGTTTTTGCAGTGAGTGTTGTTGTGGTCATAGAAGTAATCGCAGCATTGTTG
+ AAGGGTTGGTGGTTAAAAATAGAGGAAAGCAATATTTGTATTTTATTAAGGTAAATAAAGCACAGAAAGT
+ CCAACAAGCCAATTTGTAACAATTCTTAAAAATCAAGTATGCGGAGAACTTACCTTGATGTAGTTCCCGT
+ GGCTTTGGTAGATTGGTAACACATGTATGTGGGCACATTAAAACATTCGCTGGGTGGAGAGATCCCTCCA
+ AGAACCTTCGCCGTGCTTCGCATAAATGTATGCCCCCAAGAGGAGTCTTTGGCAAATGATTCGGCGGAAC
+ CAATGCCAGGCAGTAAATTCCGACTTGGTGAATGGAGTCTACTGCTTGCAGAACACGTGACATCCATTGG
+ AAACTTTCTTCCTCCGAGCAGTCCGGACGTTGTTCAGCAATGACGCACACGCGTTCGTCGCGCAAAACTT
+ TAATGCTAAATACAGCAATGCGTCCTCGATAAATAAACCGCATGGGTTCCACAGCTAACACTGTGGCAAT
+ AATGTCATCCGCATTGTGCTTTCTACCGGTAACGGTCATCAGACCATCACGGGACCCGCACACAAAGACC
+ AAGCCACCCGGACCAAGAAAGCCCAGTAGACCTGATCTAACGTAAAAGTCTTCGCCAATTGGTTTGGAAA
+ TAATGTTCACCGTGCCATTTCCATCTTTTGGTTGTTCCAATTCTTCTAATAGAGGCTGAACCTTGAATGT
+ TGAATTTGTCATTCCGTCGAGACCAAAATAACTGGCGCTTGTGGATCCGCTAGTAACGCATATTTCGCCG
+ ACTTGATCGGTTTTGCACAGCACAGGTGGTCCTTCCGATCGAACAACCACCATTTGTGCAGCTGGCATAA
+ CTTGACCACAGTCCTGCAAAGTGAGCGATGTTAATGAGTCTTCACTGTCAACGCGTACAACTCCATGCGA
+ TAGTGCTGCCATTGAAAGCACACCACGTCCAGTAGCTGACGGACTAAATCCACAAGATCCTCGCCCAGGA
+ CGCCGAAGGGAAACAGTAAATACTTCGGAGCTACTGGCACATGGACAAATCGCATCTGAGCGTAATCCTT
+ TAGCTTGAAAAACACTCAAGAACTGGTCACACGAGGATAACGACCAGGGGTTGGCTCCATCGGCTACAAG
+ CAACATACGTAGAGAGGAAAGCGATATATCCTTATGATCTTTAGTAGCGAGTAGTCCCCAATGTAGATCT
+ CGACTCTTAACCAAGCAACAAGAAGCTCGGTGTTTTGTTATTAATTGCATCCAGCTCGACGGACGCAGTT
+ TCATTAATGCGTAGGGTATGAAAATAACGTGCATACCATTTAGAACGGATGTCAAGACCGAATGCCATAA
+ TCCAACTTCACGCTTGAAGTCCAATACACATACAATTGTCTCGCCTTCGGTATAATGGCAGGCCATAGTC
+ AAAGCACGGCAATGATTAATCATCGCTGCGCGAGTAACAGTGACACCTGCAAAGCAGATTTATAATTATT
+ TATAAATATTTGGATGCTGATATATGTTGCACTTACCCATAACACTGCCTTCCTTATCTGTCGTGTATTC
+ TATATAAGCTGCTGCCGAATCATCGGCCCGTAAATTACCAACATTGAATTCTTTGGGCGGCTTAGGTAAA
+ TGCTCAGTCACAAACCACTGCAAGCGCGGCCAGCCCTTTAATTTTGCTATTTCCCCCGTGGTGGTTGATT
+ TAGGAAGACCTTTTAAGCAAGCTTCTGAGGTAAGAGCTACAGTTATGCCACAAGAACTCAATAAGAATCC
+ CACTTGCTGCGGAGGAGTATCCGAGCTAGACAGCGGCAATTCTATTGGAAGGGGTACTAAGCCCCGAAAC
+ ATACAACCATACCAGGCTGTAATGAAACTGTAATTTATCTGATTAATATTGGATACAAATACATCAAAGA
+ TTTGTCTTGTTCTTTAGAGGTTACGCAAGGACTGGAAATGAAGGAATTTCGATAGAATAATCACATAAAC
+ ACACATACTAACCTTAAGGGGTCATTATTGGGGTAAACCAGGGCCACACGATCGCCGGGCTTCAGTGTTA
+ CTTGCTCAGGACCCTTGCTAAATATTTTTGTGGACAAAGCATGGGCAATCTTTTGTGCGCGCGAAAGTAG
+ CTTGCCATATGTTAAGGTAGTTGTTACTTTTCCATTCGGATCGAGCACTGTAGCCATTGGACTTTTAAAC
+ GAGTTTGTTCCATAACGTTGGAGTGCGCATTCGAGCGTTCTTGGAAGTCCTGCAGGTATGGATAGCTGCT
+ CGCCTTGCACAGGAGTCATTGTGCTGCCCTCTGGTTTGGGAGCATTGGGATCTTTCGTATTGGCAGCAAT
+ CTCCAGTTCAATGTCGTTATCCTCATAGAACTCCGGTAGTGGGCGACGCTTGGGTCTTTTAAGGGTGTTA
+ AGCAGTTGCTGAATCTTAGCCGACACCTTCCACTTGCCATTGGCATCTGTCTCGTTCAGTTCATTTTGAG
+ AAACATTAACATATCGAGTCACTCGATCCGCAGCACGATGTGCATTATTAAACTGTGTGATGTCGGGAGC
+ ATTGTCTACAAACAAACGATGATTAAAACAAAATCATACAAAAAACACATAAACTACACTTTAGTGGAAT
+ TTACTTTATTCCGCGGTGTATTAAATTACTTACACTGTTTTTGTTTAAACGCTTTGTCCGAAAAGTCATT
+ TTCCCGCTTGTATGCAATCGGCGGGTAGTCCGAACTTAAAGGTTCTGAAGTTGGCTGTGTAATGATTATT
+ TAATTAATTAAAAAACTACATTTTTATGCAATCTGCCTAAGTTTATATACCCTAACTTCAATTATACAAA
+ GCAATTTAATAGAAAAAAATCATAGTCTCGATGATTCTTATGATAAAAAGTTTTAAATTTGTATACACTA
+ GTTAAAGAGTATAATTCTTTTAATACATATATTTCGGTCTTAGTCTGTTCACATCTGAACAGTATATATT
+ TACTGCAATAAATATTCACAATCAACATATTGTCGAAGCTAGCTTTTTTTCCTCTTTAAATGTATTATTA
+ TTATATTACTCACAAGTGGGGGTAAGTTTTGCGGTGGTCGCCTTTCTGGAGCGCTATTCGGCGCCGTATA
+ CTTTTGATTTGTAATTTGGTTCTGTTTCACGTCTGTCCTCGCATGCTGCTGTGAACCCATCGATGATTCA
+ CGAATTGGAGGTTTAATTATCGGTTCTGGTGGCAGTATGCTATTGCTTATATGATCCCGTGGATAATTGT
+ ACTCCTTGTCGGGGGAAATTGTCTCCTCGGGTATGGATTCGTCATCCGTCGATGAGTCCAGCTCATCATT
+ GCACCCAGGGCTTCGGTTTAATACAGATGTGCGCTTCGATGGCATTGGAAGGCTGGGTTTTGGCCGTCCC
+ TTAAGAGCTGCAAGGGCCTGTTGCACAGCCTCTTGTCGTACTTCTAGGGGTCAGATGATCAGAGATAAAA
+ TGTTGTTGCTGTAACTTGTTCTACTAACCAGAATGATAACGTTTCTCATTGTGCGTTACTTTGCGCTGTG
+ TGCGTCGTTGACGATGCTGACTATTATTAGTTGACTGTTGGTTCTGAAAAGCACTTGGTTCGCGAGTGTT
+ CTGATACCCGGGATCGCCGACTGCTCCACCCTGCGGTCGCATATTTTCGTAGCCAGGAGCCCCAGCATTT
+ CCGCTCTGTGGTGCCGATGACAAGCTCATGGCGGCTTGCTGATGGAAGTCAATTTTTTTGGAATGTCTTT
+ GCTGCGAGGAGGACAGGGAGGGCACTTCAGTCACATAACTGTAGCCCTCGCTGGACACAATGACGCCGTC
+ GTTATTGATGTTTCCGTGGTTGGTGCTGTTGTTGGCATTTTTAACGTTGTAGTATGGCGGTGGCGGCGTA
+ CTTTTCACTTTATCGCCTGTTCACAACAAAAGGATCAAGAACTTTCTGGTGACGACCAAACGACCAAATA
+ TCAATGTTTTCGAACATACCTTCTGGCTTCTTTAGGAACGGCTGCAACAGCTTCGCCCTTTTCTTTTCGT
+ AGCCTTTCTGCGTAATGTCACCTAGAAAAGCAGATGGAATTGTTTTCTTAACGATTAATATGTCCGCTGG
+ GCCTCGTCGTTTTTTGAAAAGCGTGGAGTAGCGACTGAATCATGTATTCATGCTGAAAGCCACACAACAC
+ AACACACACACTTTTCTTTTAATTGGTCGGTCCCCGACTATATGTGGGCAGCTTTCAGCGAAAGAAAAGC
+ CGAGAACAGCACTTGTAATCCCATTTGGGGGCGACAAGTATCCAATGATTTGAATCAGACCAGACTACGT
+ CTGCCACAGTTTTCACGCGATTTTCTACAACTCAGTCGCCGCACTTTAACAACAATATTTTATTTTTGTG
+ TGTATTATTCAAATAGGTATACCTTCCGACAGCTCTAAGTCCAGTTCGGCGAGCTTCTCGCGGACGTAGC
+ CAGGCAGCGAGGCAGTGTGCTCCATGGCAGATGAAAAGTGTGGCTTTAGGGTTTTGTTCTATCCTCTTCC
+ TTGGAGGATTCGTCTAAACTTTGGCTGGTCGCAGTACACAAACACACCCAGACACCGCTACTTTCCCACT
+ TCGTTGTCAAAAATCGATCGATTTGCCATTTATTCTATTTCACATTTTGCCGACGCAAATAAATACATCC
+ GTACTTGCGCAGCACCAGTACTTTGGGTTAGTTAGAAAACACGATATTACGAATGTCTTTTACGAATTTG
+ CACAATGAAAGTAAACAAAGAAAAATAGCAGTACAAATCGATTTTATGAACTAGCGAAAAATTGATAACT
+ ATTTCTTCATACTCTTGGGACAACGGCCTTTTTCAATTTTCGAGATGCGGTCACACTGCCCAAGTAATCG
+ AACCACGAATTTAAGTGTTATTTTTAATGATATTAGGCATAGAACCATTACAATTAAAAAGCTCTATTAT
+ TTATTACTTTAATCGCTTGTCTCTTAAAATTCGATTCAACAAAAGCAATTGGTGGCATTTTGCTAGGTAG
+ CCCTGAAATACTGTAGAGACTATCGATATCTGCACCTAAGGCGCCTATTATCACATTCGGATTACGAAGA
+ CAAAGACATGCGAAACCTGGATACGATTAGTGGCGAAGAAAAGCAAAGTCCTGCCAACTTAGTCTAAATT
+ GTTTCTAAGCCGGCTGCCTATACGCCTGCGTTTTGAGCAAAGCGGTAGTATCTTTTTCGGAACCATCGAT
+ AGCTTGTCATCTCCAGTAAAAATGCGTGAGTTTATTTAAAAAAAACGCTAGGCATACAACTAATTATTCT
+ TATGATGCAGAGAACTTGAAGATCCAAGAGGAAGTCAATTCATTGATGCGTCTAGGCCAGCACTTCGATG
+ ACCAGTTAAAGCTGGCTAGCGTCGAGTTGGGCGATTTCTCGGACGATGACCTGGCGCTCCTTGACAAATG
+ CGCCCAATATTATTCACTTTTGCACATTCACGACATCAATCTGAACTACTTGCGCGACTTCTATTGTGCC
+ AAGAAGAGGGAATGCATAGAAAACCGGCAGACCACAGTGCAGCAACGCGTAGAGCTGCAGCGCATCCTCT
+ CGTCCATCGAGGAGGCGACTAGGGACGTAGTTATGTTGGAGAGGTATTGGTGAACAAATCCCTTTAATAG
+ TTGAATCCCTGACCAAAACCATTCTTCTGCAGATTTAATGCTGCTGCGGAAGAGCGGCTCATCCCGGATA
+ TCGTCGTAATGCAGCGAAACGCCCAACAGCTTGCAACAAAACAGGCCTTACTGGACCGGCAAAAAACCCT
+ TAAGATCCCAAAGGATTTTAGCATTGAAAGTGTCATCGAGAAGGTAGATTCGCTGGAGCAGCGCTAAAGA
+ AGTGAATTGCTTTCGTTTTTAAAAAATTATTTAATTGTATTTACTCAGTAATGCAAAACACTTTACAAAA
+ ACATAAAATCTGCAAATTTTAAAGATGAATGTTGAGGTTTACAACTTGGAACACTACACAATCAGAGGGT
+ GCACTTATTTTGGTTATTGTACGCATTTTAAAAACGTTCCAATTGTTGCTAGGTTGTGTCAAATATTTAT
+ TTAAAGTATCATGATAGGAAAACTAGAAGACCAAATAATAATTTGCCAGCTGCTTAAAGCATACAAAAAG
+ TGTACCGTGTTCTTCCATGCCATTGCTCATATGTATGTATTTGTGTATTTCCAATGTGGTATATGTATCA
+ TATATATTGGTGTATAGATAGAATTAGTAATTTCATATTCTTTAAGTTCTTGCTTGTTGTTATGTATATA
+ AAGGGCGGGTATGTGGCAGACAATCTTTTCGGCTAGCAACGCGCTCCACGCCACAGGCCTACTCCACGTT
+ TCCGGGCATCTTTTAGCGGAACTCGGGCGCATCATCTTGCGTTATGTCACCGTACTTCCAGATGGCCAGA
+ TGCGCGACCCGAGCTGCTTCCTGCGCGGCTTTGTACTGGTCCACTAGTTCCTTGAGCTTCCGCTCTCCAC
+ GCTGTTCGGCCAGAACAAGGCCCTCGGCTACAAGCTGCTTTCCAAAATCGACTTTAGTAGTTGGATCGCG
+ AAGAGTGGCCAAGTTCGGCGACCCAGTCACCTTTAGCTCGACATTGAGTTGAACCTTATGGTTCAAAACG
+ TCTTCGGAAAAGGCACGCAAGGCTTCTTCCTTATCTTCGTTGTCAGTTGGCAGGGCGACTAAGGCCAAAG
+ CATACTCCGTAGCGTAGGGCTTTTCGCTGCTGAAGGCTGGTGGCAGGGCTGCCAAACGGTTGGTCGGAAG
+ TGTCTAAAAATGGAAACGAGTGTTAATACTGCCAGGAAAAAATCACAATGGTTTTGGTATGAGTGTGTCG
+ CAACTCGAATACTTTTGAAGCGTGGTTCTGGCGCCCCCAGCTACTCAGTGCTCTTGTTTCTCGCGTATTT
+ TAAACCTGCTACTTTGGACAATGGTTGACCCAAAAAATATGGAACTACCTTTGCACCGTTGAAGAGGATG
+ CCACACGACTTGAAACGGCGAACGCATTTAACGCAGCTGTAGGGTTTGCTTACGCCATCACGAATCTTAT
+ AAAATCATTCGATGAAGCCTATTTAATGTGGCAAGCTTATGACTCATGCGTTTCACTTCAAGCCGGAAAC
+ GGATCTAAGGAACTTGCAGTAATTTAAATGTTAGTCAAAGCGACACTTACCTCCTTGTTTCCATAATCGA
+ TGTACAGGACTGTAGCATTACTGCCCTGCACGCGTTCCACCTTGGCACGATACCACTGATTATCAAGTGT
+ AAACTGAGCGGCCACCAGGTCACCACGCTTTGGCGTGTACGATCCAGCGATGGGTGGGTTGGACTGGAAA
+ TCGGCGTGAAGTTTGCTCATAAGCGACTCTAGCTTGGATCCGCTCTCCACAGATTGCGCGAAGAATGTCA
+ GAGTTTCGGTGATCTCAGTGACAATAACGTTTTCGTAGTTGACTTTACGCTCCGCCACTACCTTGTCCTC
+ CTTTTCTTCCTCGGTGACAGTTTTTTCTTTAGGCACTTCTTCTACGTAGTTTGTCCAGATGTTCTTTTTG
+ GCGGCCTTGGCACGGTCTTCAGCAATCTTCAACTGGCGGTAGTATTCAGATTTTTCAGCACTAAAGTGCA
+ CTTCAGCAAGACCCTCTTCGACAAGAGCAACTGACAAGTTGGCGCCGCTGTCCGTCCAGAGCCAACCAAT
+ CACTGAAGATCCTGCCTTGTCGGTGGTATCGATATGAACAGAAACGTCGCGTTGCAAGACACGCTCCCTG
+ GTAAAGGTCAAAGCCTCGTCGCCAAATGGTTCCCCCTCTTGGGCAGGAACGCCATTAAGCGCTGGACGAG
+ AGGAACGCGGACATGAAATCCCAGCAAGCAGGAATGTTACCAGGCAACTGTCCTTCGGTACAAAGATTCG
+ GAGGCGGGATCCGCTGGCGACAAACTCTACAATGGCTTCAGTACGCAAAGCACGCTGCCACGATGGCAAG
+ TATTGAACTTTAATTCGGGAATGATCAACAGTCAGGTCGTTAACACGCAGTGTGGCGTTATCCTTCTTTG
+ CGTGCAGTCCCTTTAGTCCCTTGATGGCTTGCTGTTCGGCGGCAATCAATTGATCATAGGCGGAAGATCT
+ CTGATCGTCGTCCTGGCGATAGCGAACACATGTTGCCAAACCTTTGGCTACCATTGCCTCAGCCACGTTC
+ TGACCGCCAATAGAGACGGTATAGCAGTATTTCTCAGGGAAGTTTTCGCGCGGCGGTGAGATGTAGTCCA
+ GGTTGCATTGAACTTTTTTATTAATTAGTTTTTTACGCAGAAACTCACGGGCATCGAACATGTGTGGAAT
+ TTCGTAAAGTGGTCTGTAGTTTTTTCCGCGTGGTGGTGCCTTGACGATTTCCTCGCCATCGGTGCCAACA
+ ACCGCGCGTTGGTCACGCGGCGGCCTGATAGACGAGAAGAAAACCTTCTTTACTTGTCCATTGGAAAGAC
+ GTACATTAATAGCATCGCCATTGAAGACTTCCACCACTGTTCCAGAGAAGTCTTTCTCCTTCGAGTTGAA
+ AGCAGGAGTTTTAGCTTGGTAGTCCTGCCATTGGCGAAGACGCTTCTCCTTGGCAAAACGCTCCGCAGCC
+ CGCAGTTTATCGGTGCCTGAAGAGAAAAGCGAATTAGTCAGAGTTGAAATACGAAAAATTGTTAATAAAA
+ TGCAATGTCGTCGGGGTGAAATGAACGCAGCGACAATAATCAGTCGCAAAGTTCTTGGAATCCGTCGTTT
+ TTCTGGCAGCCGATTGCAAACAGTAAACAGCACGACGATAGGTTATTTACCAATTTGGTGCTGTGCTGTG
+ CAAGCGAGCTGCGAACTTAACTTGATTCTGGTCTTACCTGTCTTCATAACAGCCATTGACCAGTCCACAC
+ ACTTGGCAAGTCCCTCTCGCAGGAGTGATTCTGCAATGTTTCCCTTGGGATACAGAATAGTTCCAATGAA
+ GTTAGAGTTGTTAACCGATTCCAGTCGGATTTCCACATCGCGTTGCAACAGGCGGGTTTCCACATAGTAG
+ CGAGCTTCGTCAGCAAAAGGCACCTTTACACTGAGGTCGGGCTTGCCATCAGCATCTAATTTCACTCCTG
+ GACAACGGATGCCCGAAATCATTAGCGTTATGTAGTGGAAGTCCGGCAGCAAGAATGCTCGGACCGTGGA
+ TCCATCGCGCACGTGCTCGATGATCGCCTTCACGGGGTTTCCTCCGTAGATGTCGACCAGGTGTGCGGGA
+ TTCTCATGGGACCACTTGATGTTGCGAACCTTGTCGGCGGCACTTGCGGTGGGCGACCATTTTCCGCGGC
+ CTGCTGCACGCGCCTGGTCCTCCAACTCGATGAGTGTTTGCTGCTCGGCTGTGGGACGTCCCTCTCGACG
+ GACCGACACCAGGCCCTCTCGGACAATCGACTCGACCACATTTTCACCGGTTTCCTTGTCCTTACCGATC
+ CACACAAAACCGTACTCCCGGTTCGAGTTGGCTGGCTTGTCAAACGTGAAAGTCACCTCCACACCTATCA
+ ACTTTTTACGCAAGAATTCCCGCGACTCCCAAGCCCAGGGCTCGTCCTTGGTCTCGTCTCCGCCAGCGCC
+ AGGACGACGGGCCAACTTCGGGGCAAGGACATGCGAGAAAGTAATTTGTTTCTCCGGAGGCGGGGCACCC
+ TTAGTTGCGCGAATAACTACCGTATCGCCGGAGAGAACCTGAATCAGAGCGAGGAGTGAGGTTAAAATAA
+ AATGCACGTGTGGGGTCACTAGAGGTGGAATAGTATCGATTGCCCTTTTGGATCTGGGTCCTAAGCGACC
+ AAACACACTATCGATATATGTAATATTTTAGATCGGCTCACGTAAAAAGGAAAACTACTTTCTAGCTGTT
+ TTGATATTATTTACATATAAAAATGAACTCTGCTGAGCAAGGACGTGCTATTTAACTAACATAACAGTTC
+ CTCATAGACAGCGCCTGCGCACAAATCTTCTTGGTTTGTCCTATGGAAAATGCGAGCAACGGTATTTTAT
+ TGAATTTATTCGTACTGCAAATGCATTCCGTTAATCCAACTGAAAACAAAATTGTTGCCAAACCGGTTTA
+ GGGTGCCCAAAACGGAGGCAACGTGCAAGAGTGCAGCTCAAATCTCTTCTAGATACAAAAAATCGACATA
+ AAAAGAAAATAATGGTCTTGTAATTGGGAGCAAATACCAAATGTCCAAGGGAAAACATGCAAGGTGTTAC
+ TGATAAGGGCGTCAGATATTACCTGTAAAAGCAACAGGTTTTTTTGAAAATGGGAATCATCCAAATGCAA
+ GGTTGAATGAATTTCGGGATGTTTTCTTTGGTTGCAGGGTGCCAACGTCACCAAATCAGATTACGCCTGT
+ AAATCTCTACAGCCGCTGGAAACTCAGTTGTTATCAGAGTCGTTGGATAAAGTGCTGACTGAAAACAGCC
+ GGTAATCTTTGGGCGCTGGTCACAAAGCCACCCAGAAGTAAAAGTATATGATGAACTACCCACTCCCAGG
+ GACAATTATCAGCATTGGGCGCCGGACACGGTCTCCGTATACGCCAAGGAGGTTAGAAACGAACCGTTCG
+ GCACACAAATCAGTTCTCAGCAAGTGTGTGGGCGGGCGAAAAAAACTACAGCTTTGCAATAGATGGTTTA
+ TAATGCCGGTAAATGGGGCCGTACTAGTTAGCTGTCCCTCTGTGACAACAACAGCCAGAACATCTACCGC
+ CAAAGACACCGCGTCGAAGAAAATCTGCCAGCTTGGCACCTACGATAACTTTCATTTCTTTGGATCGGAC
+ AGCGTGTGCAACGTGTCACACACGCACAGAGTCTATACGCGTCTCACTCGCACTTGTCAGAGTTGCACTA
+ GAGCTGCTTTGGTAGGCGCTGCCGCGTTTGCCACGCCGATAGGAGGATAGTACCTCTTAGTTTGGACGAA
+ CTTTCTTTTCAAGGAGTCTGCGCACTGAAATCCTAGCCACGAGTTTCATCCCAGAGCCGCAGACCAATCC
+ GACTTACCTGCTTTACAATGCCGGACAACGACTTTGTAGGCGCTGGCGGGGCGTCTTTAGCTGCTCCGGC
+ AGCTGTCGCGGTGTTCGCTGCTGTTGCCATTTTTTTATTGAATGCGGGGGAGATACTAGCAGAGGGCCGT
+ GGCACTAGGCTTCAATAGCGGAATATTGCGTTGATTGCGTTTCGGAGCTAAACACCGCTTTCAACCTAAT
+ GAAGTTTGACCAAGAGAAGAACCGCTCTCAAAATCTAAAAAATTTTCACTGAAGTGACACTGCTAGCTAG
+ AGCTGAGAAGTCAGCGCGATAGCATCGATATTTTCGTGACACGCTTGTCATCCGATAGGTAGTGCTAAAC
+ ATTTTTCTTAATTGCCAACTTAATTTACAAAAAATATGAATGACGGTAAAATTGAGAGGGATTTGGGATC
+ CTTTATATTGGGAATTTTTATATATTCATATTTATTTTAATTGTATTTATGCGTAATTTATCAGACGAAC
+ TTTGGAATTTCCAATAATTCTAGATTTTTTTGTTTCATTTCAAAACTAATTTTAATTCGCTTAACGAGTG
+ CATATCTATATTATGTTTACTTTAAATTTATCTGTGGGGGCAGCCTTAGATGTTCACATTGCAGGCCATA
+ GTGTCGATAGATCCAGGCGCCAAAAGAGTATCGCTATCGATAAATGGTCGCCAGCTGTTCGGCGAATGTT
+ ACGTGATTTCCTATTTGTAACATTGCTAAAAATCGAGTAAAATGAATCAAGCCGATGTAACAAAGCTCAT
+ GTCACAGCTGCGTATAGCGGTCAGGCCCAACAAGCGCCATCTGAAGAATGTCGATGGCCCGGAAGGTCGG
+ CTGCTGAAGCTGCGTAAGACCGTCACTGCGTTGGTGAAGCACGAGCGTATTGAACTGTTCTACAACCGTG
+ CCGATGAAGCTCGTGGCTACGCCGAACTGGTAAGAGACCACCGGCGATACGCCAAAGGCTGGAATCCAAA
+ TAAAGTTTCCTCCCCTCGCAGCTCATTTCCAATGCCATACGCCATGGGGACCGACACCAAGCCACCATGG
+ AACTGGCGGACTATTGGCTGCTGGAAAAGCAACTGGTTCATAAGCTCTTCAAGGTGCTGGTACCGCGCTA
+ TGAGACTTACAATGTGTCCTACACTCGCATGTACAAAGCCCCTCGGGAGTATCCTGGCATTTACTACAGG
+ CGGTCTGTGCTGGAGCTTCGGGGCAATCCCTACCCTTCGCTGGCGGCGGATCATTCTCAGAACCGGAATC
+ TGCTGCACAATGTGCTTCTGGACGAGGCGAGAAAGGAGTTTAGGCGTCAAAAACTGTCGGAGTTAGTTCA
+ CTAATAGCTCTTTTCACTAACCGCCTGTTTATTTAGTAGATTAGCAAGCAGTTTGTCGCTTAGAATTCAC
+ GTAAGACTTAAAAGCATCTTTATTATAAATGTATGTATACACAAAACGAATTGTTTGAATTAAGAGTTGA
+ ACTTATACAAACGACTAAAGTCTACTGACATTGCAGTGATTGAAGTAATCCGGTTTCCAATCTACCGAGT
+ TAGAGAATTAGCTTTAGAATGATTCAATTTCTGAACGGATAACTTACCCTTTCCCGTAAGGCAGGCATCC
+ AGCAACATTTCACAAATGCTGTAGAAGAATTGGTGCTCATTTGTCGACGATGCGCAGACAGGCAAAAACG
+ GATCACAATTGGTAATAGCACTACAACCCGAGTTGCTGCTCAATACTGGCAGACATACGGACAGCGCGAG
+ GAACATTATGATGTTGAAGATCAGGAACCAAGCCAAATAGATATTCATTTTGGATGAATTCGCAGAATTA
+ TCATTCACTAGCGTATTAAATGACATCGTCACCTAAAAATTATTTCATAGCAGCAAACAGATTGGGAGCG
+ AATCTTTTTTCGCAGATCAATCTTTATATGTATATATTTTATTTATTTTGAAATATGATCCGTTAAAGTT
+ CCTCTTTACGTTCCATTCGGTCACAGAATGTAAATCCGAATTTGGCTGCCGACATGAACAGCCATCTAAC
+ AACTGATAAGCACTGGGGGACCTACGCGCTGATGCATACTAATTCGCTCATGTTCCTGAACCCCAAAGTT
+ ACCATGGAAACGAGCTCGGAACACTGACCAATGAATCAATGATAACTTCACCTCTATTTTTCACCGGAAG
+ CTTTTGTTCGTTTCCTCCCAGACTTCGGTATGAATGGGGTTGCTCAACTGACTGGAACCCAGCGTTCTTT
+ GTAGTTTCGCGTACATTTAATCCGGCCGGCCCCGATATGTTTGTAAACTAGTGCAACTTTGCGGATGAAA
+ TGGTGTTGGAGAGCATGTTTGATAGATTGCTAAAGTTCGAGTAAAATTATTGAAGCCGATGGTACAATGC
+ AAATCACAACTGCGTGTAGCGATCAGACCCAATGGTAAAAGTAAAAGACCATTGGCTTTAACTACAGGTA
+ GTCTGTGCAGGACCTTCAATGCAATCCTCTTCTTCGCCAGAGCCGACAGGCCATAAAATGGAATGCGACA
+ CTTAATGATGCAGAATAACTTTGAATTAATAATTTTGCATAGTTAAGTAACATGTAACTATATAATCTTT
+ CTATAAGTCGCAACTCCCAGCCTTTAACTTAAAATGTTAAAAAAAACCATTCACGGATATTCATTACAAG
+ CTTCCTAATTTTTAGATGTACAAAAGGACTTGTCTTGGTGCGTCATAAATTTCATGGTTTGAGGTGCGAC
+ TGCAGAGCAGACTGACAGTATGAACACGTGACGCCGGGTCTCTTAATTACATTTGCATTATTAAATTTTA
+ TGACAGCTGTTGGACTCAATAACGCCTACGAACTGACCCCAGGTCGCTGGTTATGGGACGTTGCAATCCC
+ AATTAAATCCCCGCTACCTTTAACAGAAATGAAGCATTTGCATTTTGTGGCATAGAAGAATATGAATCCT
+ TTATAAATTATACTCAAAAACTTCTCCAACAGGTGATTCTAGTTTTAAAAATTAAGAATAAACTTGTATA
+ TGTAACAGAAGTTCTTAACTAGCACCTGACATGTGGCATGTACATACATATGTATGACTGATGCCAAGAC
+ ATGGGCGGTGCATCGGTGTGTCCGATGAGGAGCACACGACGACCAACGAAGACCAATCGTAATAGGGTGG
+ GGCTGGCATAGTGCTCCTAAGGAACAGGGGTCTGCTTTCAGGAAATATTTCAGTGCGTCATACGTGGATA
+ ATGCAAAAGAACATATTGGCCGAACTAGCATTTCTATTACATCACGTGAACGAGAGTGTATGTACGTGCG
+ ATATTTTCTTGCAGGACATTGTAAACTAATCGGTGGGGTGTCTCCTATATTTTTCTGTAAATAAACATTT
+ TCGATATTGCCGAGCAGACTCGGTTCTGCCTAGATTGTGGTCCACTGCATCCAGTTGAGCATCATATAAT
+ TTCGGATAAAAATAGAATGTAAAATATTTATGTTTAGAACTTGCGCAGCTCATTGATAAAAGCCCAAGCG
+ CCGGTGCGCACTCTCTCAGTAGAAACGGACAAAAAGGACATGAAGGCGAAACTGGACGGGAAAAATCGAG
+ AGAACAGGCTTTCTCATGAGCATAAAATCCTGCAAGATATTATACATGCCGTGGCCTTTTATGCTGCTGT
+ TCTTATATCATTTCATTCAGTTTCGAAGAGTCGTGCAACGAGAGCAGTTGAAACCATTGTCTTTAAACAA
+ ATTCTGCGCTGTGTCTGAGTCTGGAGTTTTTCTGTGTGTATAACTTACGGTTGGTCTCAAATTTTATGGG
+ TTGTGTGCAAGTGGAATTTGAATAAAAGCATTATTGTAAACTAAACTAAACAGCAGGAAAAACTGCGCCA
+ TAGTGAACTAGCAACCTGTGCCGAAAGGGAAAAACTGAGAAAAAATCCAAACTCATGAATATTGATGAAT
+ TTCCTTGGTGCAAATGTGTCGTGTGTGTGTGTGTGTATGTTGTATCAAAAGGGCATCCCAGTTACAGTGC
+ AAAAATGCTATTTTCGAATAAAAATGAACTCTTCGATACATTTTGATCTGAGTCATACCTTTTCTGTAAC
+ TACAATTCCACCATATTTTTTCATTGAGAAATGGGTTATTTTTTCGCAGTGGGCAGCAGCAGAAGTCGCA
+ CCATGAGAATTAATTGCAACGCGCTTTTCCTGGCATCGCTAGTGACTTGGTCGGGGGTGATGTGCAGCAC
+ GGTACTGGGCACCACAGAAGGCCAGGAAACACCTTTGGCCCTTCCTGTGGCGGAGCAGACGCAGCCCACT
+ ACAGCCATACAAGGAGAAGTATGGGAGGAGGACGATCACGAAGTGCTTATAAGAAATGAACGTGGCACCA
+ AGAGCGACGGTGAGTCGGGGGATGGTTGAGCGCTTAAGGGAGATTGGGAGTTTGTGTGAGTTCTCTGCGA
+ CCAGGAGCTGCTTTAATACACTGTGCTCCTTTTTTCCTCAAGGTCTGTCTTGTCGATATGGCAAAAATCC
+ GTGGACTGAGTGTGACACCAAAACCAATACGCGTTCAAGAACATTGACATTAAAGAAGGGCGACCCGGCA
+ TGCGACCAAACGCGAACCATTCAGAAGAAATGTAAAAAAGGTAATAAGATAGGATAGGACTCTTCGTGTT
+ CGCCTATAAGAAGGACTTATGCCAATTGTCATCCTCAACCCTCCCAACAGCCTGTCGATATGAAAAGGGA
+ TCTTGGTCGGAATGTGCAACCGGACAAATGACTAGAGCTGATAAGTTGAAAGCGAGCAGTGATCCGTCCT
+ GCGAAGCCACGCGGGTCATCAAGAAGAACTGCAAGCCCGGAAAGTCCAAGGACAAAAGTGCCAAGGAGCA
+ GCGGAAGAACAAAGATAAAGGTAAGTTGACTAGTTGTGAATTTGAATAGCACATTGAAAAGAGTTGGTTA
+ ATTGGTCTGCATTAATTTGGGGTTTTATCATTGATATGTTTTATGGCAAAGACCACTAAGCCCAAATTTC
+ TTCTATTTACATGCAGCTGCTCGCAAAGGACGCGTTTAAGTGATATCGAACTCGATTATTTTAAATTCCA
+ GTGTTATTTTGTTTGACTCCAATGCAAATAACTATAATTGATTTTTTTAATTCAAAACTGAAAAATCGTA
+ ACGACGTTAACTGTCTGCTATGTATACCCAAAGGCATTTAAATAAAATGCACACATTAATTAATGTTGTA
+ GTTTGATTTACAAGCAAACGAAACGATAACCATAATATAAACGAAAGCTGTACGACGTAATAGAAACCTT
+ GCGGAGTCTAAAATATGTATGCAATGCAGAATAAGATATATTCATACAATACCATACCATACCGACATAA
+ ATACCGACTTATTTAGTTTATTACCCAATGAAAATCATATGTACATCCAAGCCAACACCTATTACCATTT
+ TATCTGAAATGATGAAATCTGTAAGGGCAGTTGCCGTATTGAAATAAAGGATAATTCTTAAATACAGCCT
+ CCTAGACTGCGTGGCTGTTGGGTCCCCTTCATACACTTAGCAGAGTTGTTCTTCAATGGAATTTAAATAA
+ TATTAACCGTAAAATCGGAATGAAACCCAAATAAATAAGATATACTGAAAACATTTTTTCATTCACAGCT
+ AACAAATAAATAAAACACTTAGTGTAAATATTGTAAAAATAATGACATACTGTAGAGGAAAAATTTCTGA
+ AAGACGAAGAATGAGACGCGACGGTCTAAACACAGATCCATCGTAGTTGCAGTGTAGGCAATTGGCATTT
+ TAAAGTAGTTTACAACTCACTTCTACCGGGTACAATTAACATATAAATTTGGAAGTATGATTCCCAAAAC
+ TAATATACAAGTCGAAATGCAGACATACTTACATACTTACATTCATATATATTCTGATCAAAAACTTACC
+ ATTTCAAAGATGTGGTTTATCTTTTTAATAAACACGTACATATATAAACTTAGAGCGTTAACTACGAATT
+ AATGTATCTATCTGTAAGCAGTTTTACAACCATACCCGTGCATTCACAACTACGAACGACGAAGTCGAGG
+ AGAACAACAGCTCAGTCACAGCATTCAAATTCATAGTATGAATTTTATACACATCATCCGTAGGGGCAGT
+ TATCTTCTTTAAGTCTTTGAATTCCGTAAGGAACAGCATGAAAGCGACTCCCCCAAAGGGAAGTGAAATT
+ TGTTTACGTACGTATACAACACAAGAAAAAGTAAATGAACTTTAATAAATACAGATATTACGAAATAAAA
+ CACTCTACCATTTTAATACAAGTATGCATTCGGTTTATGATTATGAATTTCGTTCCTACTGCAAATATCT
+ CTCGGGTTGTTTGTTATGCTGCGCTTTTAACTGCGTGCTAGCAGTTCCCTCTTTCTTTTGAGGAATGACC
+ ATGCGCACTTCGACTGTCGTGGGATAAAAATGGTAAATCCGGCTTTTTCTTAAAGGTGCCAAATGATGTA
+ TTGTAGATAGCCATCCCACAATGCGGGGTTAAGTCGGTAAGGCTGGATGGTAAAAAATTAGAACTAGGTC
+ CCCGATCTTACACATATACTATATACAGGTACGTGAGTGTTAATTAATTACTTTAAAACATTAGGGACTT
+ AGATTGGCATTTATACAAATCAAAGTAGCTCTTTTCGTACTTGTAATTCAAAACCTTTTTCTGTTCTTTT
+ TTATACCATACTATCACTTTAAAGTGGTTTTAACCAAAATGCATACATTTCGTTTTTTGTTTTTCGTTTT
+ CCTTGTCTGCGTCCGCTCTTTGTTTTTTTAACCAAAGTAAATCTGACTCAGGGAAGTCACTCAAAACATG
+ TTTGCCTGAGCTCTCGTATTCCAAATGGAACTCCGGGAAAAATATATGCTCGTATACACTCAAAAGTGGC
+ TCAAAACTGTATCTATTCGTATTTTGATATACACAATAATAAAACTGCTCGAAGAACTCCAATCTGTTAC
+ ACAATGCCTGGTCATTGTTTACATTTAGCTTACTTGTGTGCTTATATGCACCTATACACATACTATGTGT
+ GTAGATAAAGGATGGCTTATCTTATCACTGACGAAACAGCGGAGCATGCAAGAATGCTGTTTGTCTTTGT
+ ACATTGGCTTCGATTAAGTAGTCAAAAAGGAAAACGGTAAACGGCATGCATAGCTTTGCCTCCGCACTCT
+ CTAATCTCTAGGGTCGGACGTTATGACCTGTCCTGCTTTGATAAATCTTTTCTATATTTCGTTTATTTCG
+ CATACTTCCCTACTTATTTCAAATGCACTAATGCGAAAAACATTATTTTTTCAAATCAAACGGTCAAGTG
+ TGCTTCTAATGAAATCTCCGAAAAGGTCTATACTCCTCATACATTTCTGCAGTCGGCAAAAAAGGAGGCA
+ CATACTCGTAGAAATTTTTCATCGCTGTGTATATGGATTTGTAAATGGTATAAAAAGCATGTATCAGTAT
+ CAGTGTCAGTTCTCTTCCCGCTGCTCTCATTGGGCTCTCTGGGTTGAGCAGTTTTCGAGCCTCTCGAGTT
+ CGAGTTCACCGAGTTCGAGTCGCGGCGGTTCGCCCACTCAGTTTGCCCACAGCTCTGAATGCGAGCGTAA
+ CGATCGCAAGCCGCCTGTCTTACAGTGAAGTGCATTTTCTCAAGCCGCTTCCTTGATTTGTATTTGGTTG
+ GACAACAGCCTATAACTTGAACCCGTCTTTAATGCCCGTATCTCTGTGAGAGTGAGTTTCCAATGGCGAT
+ TTGGCGAGTGCGCGTGTGCAGGGCACCCCTTCCTGTGTTGTCGTCCGGAGAGGATTCGCGTTGAGTGGAA
+ CAGCCGTATAAGAGTGGTTGGGCTAGCGGATTTAAAGGAATGTGGGTGCTGTGCCTTTAAGTTAGGACTC
+ CTTGTGACTCGGGATACGAGAGAAGAGGCTGGATCGCGAGATATTTCTAAAAATATATGGCAATGAATGG
+ GGATATACAAAATGTATCTGCACGAAAACTCATATGCTCGCCAGATGTTTAGCTTGAGTAAAAACTTCCT
+ TAGAATTTCCGTTTTTATTATTTCTGTTTTATTATTTCAGGTTTTAATCAGAGCTTCTTTCCCTTAATGT
+ AATTTCATGTGTGTATTTGCGCAATGTTCGGGCTCCAATTAACAGTGCTCTACAAGTTTTTCTGTTTTTC
+ AGTTTCTGTTTTTTTCCCCTTTTCGTTTTTAATAAAAACATTTTGAAGTTTGATTACACTCTTTCCTATA
+ TCTTTCGATTCTATTACCTTTATATATTGGCCTAGACGCGAGGTTTCATCCACTTGAGAGTGAACTATTA
+ GATTTCTTATATTAAGTTGATGTCTTGCGAATTTGATACTCTCCTTCGGTGCCTCAGACACAGAAGTCGA
+ GGACGAAGCTTTAAAAAACACACGACCCGAACAACTAGACATACTTTCGAAAACTGGTGATTGCCGTTTT
+ TTGCATAAGAACGCTTTTTGTTGTTTCGTCAAATTGGAAAAATATTGGTTTTTCTTTAGGTGGGCTTTAG
+ ACTTCGCTTTTTCGTTTGCAATAAATATTTTTTTAAGACGTCTGCGTCTGTTCTTTGTGCTGTAATTAAT
+ GTAGTTAATCGGGGTGCGCAACAAGATGTGATAACCTGCTTTCGTCTGAAAAATCTCAGATAGTTCGCCA
+ TCTTTCAGCAACAAAATGTTTCTCTCAAAGACGAAAGGCGTTTGTGTAAGACTCAAGGGGCCCAAGTCAC
+ CGCCATGCCGGGCAGAGCAGCAATCGGAGATCATATTTGCCAATTCAGCAAACTCAAATTTGCCTGATTG
+ AATTAGATCCCTCGCATGCATGATCTTATTTAGCGCTTCCTGCTTAGTTCTCCTTACCATCCGTTCGCGA
+ TATGAACTACACCTGTCCGATTCGCTGTGCTTCACCAGGATGTGTCTGCAGCGGAGCTGGTCATTGAAGT
+ CAGAGTAGTCTCCAAGAATGGCGCCCCAGGCATTCCTATCCTTTTCTCGGTGGTGGCTTGGAGGCAGTGT
+ GAAGTGTACCTTTCTGGTAATTGTGTCGTAGAAATAGCACTCCTTGGTACTGTGAGCTATGCGCTCTTCC
+ CATCCAAAGGGCAGCTTGTTTGGCCTTTCGGAAGTACGTTCTTCAGTTAGGTTCGATAGCCCACTGTCCC
+ CATCACCATAGGAGGCGCTTTTCACGTTAACACTCGAATATACGCTTTTAGAGCTCGCGTCAAAGCAACC
+ CCAAGAGTGGTCACAAATCTGATCTCCATTTTTGCCATCTTCTTTTTTAAATATATCAAACTTGCATAGC
+ GCCGGATTCTTGGAGTTCATTTTTGCACAAACTAGACGGTGTAGGTATTTATGTGACAAGTGTAGGTACT
+ GAATAGGTTACTGCTTTGAACCAAAGTCTTAAAGAAAAATAAAGCAATGCATTCTTGTTTGTTTTACAGC
+ TCGGCTTTAAAGCATATATTTTTAATTATATTTTATTTTCATGACTTTATTGTTTTTAGGTTTCCGAAAT
+ AGTTATGAATCTTATACTGGCTTTAACCACGGCTCTGCACCTAGTTTTGGTGGTATTGGCGCACAATCCG
+ CTATCAACTCGTGGCGAAAGCCTTTCTGATGGCATACGTCTGGTCATGGAAAAGAGGTCGGGCGATGTGG
+ TACACATTCGTCCAGCTCGGGGCACACTGGAGGCCGAAACAGTCGCATCCACAACAAATAGTGACACCCA
+ CCGCACCAGGAACAATCGTAAGCCGAACAAGCCTCAAGAGCACTCTCAGCAGGTTGGGGCCCACAAGTCG
+ GGATCTAGAAAACTAGTGGTTGCGGAAAATGGCGGGGCACTGTCATCACAACTACCACAACCAAATCACA
+ AGCAAGGCCACAAGAACACTGATAAGCAACAACGAGGAGGGGGATCCAAGCAGCAGCGAGGACATAGCCA
+ ACATCATGGAGGAAATAGGAAAGGGCCTAAGGCAGCGACTCCAGAGAATGGTAAGCCTTAGGACTGCCAC
+ GTCAGAATTCAAATAGTTTTTAAATGCAAAGTCTTATATTTGCTTGTTAACAGGATCGACTTGCCGATAC
+ GCAAAGAGCGCTTGGTCCAATTGTGATCACAAGACCAACATGCGTTCACGAGTCCTGTCCCTAAGGAAAG
+ GAGAGCAAAACTGCTTGCCCACGCGGACCATACAAAAGAAGTGCAAGAAAGGTGCGCGCGGTAACTTCTA
+ TATGTATCATAATCCTACACAGCGCCTCCCCAAAAGGGGAACGTAGTAGAATCGGGCATTCCCATAAAAG
+ AGCAAGGCGGTGTCATTGCCGGCTTAATGGGTCCAAAGGTCACAAAATGCAAAAATCACTCTTGTTGACC
+ CATATACAAGAATGCTTCCTTCTGGGGAGGATTGTGCTCTCTTCGACCCACTTCGAGGTTCTCCCCGCCA
+ CAGCTTCGTTTCGTTTCCTAGGAAATACTGCAGTTCCTGTTCCTAACAATGCAGCGAGTGCATCCTTCAT
+ AATAGCAAATACTTTCCAAAATTAATTTGAAATTTTGCGTACTTCCTTCGGTAGGCTGCCGCTATGAAAA
+ GGGTGAATGGTCTCAATGCGTCGGAGGACAAATAACCAGAGAGGATAAGTTGGAACCAGAGGCAACTGGC
+ GGTAGTGATCAAAACTGCAATCCTGTGCGTACCGTCAGCAAGAAGTGTAAAGCAAATGGCAATTCCAGTG
+ GAGGAAAACAACACGGCCAGAGTCGTCGAACAAAAGAGCAAAAGCAAAAGGATAAGGGTAAAAGTGGTGA
+ ATTTGACCCCTTTGTGAAAAGTTTGATCCAAATTCTCTGTTTACAGGAGCCAGTCACATTTCGTCTTGAT
+ AATGAAAATTATTTATTTTATACGTATACGGAAGCAACATTTTTAATATTAAATAAGCGATTTTTAAATG
+ CTAGCCCGTACGGACTACTTGAACAACAATAAAGAATTGGCCTTCTTAGGGCTAAATGAAAGCACTCTTT
+ TAGAAATTCTTGAAACAAGGCTTTCACAAACCCCAATACCGCGAAAACCTGCACAAAATGAGACCTGTTA
+ TTGAGTAATCAAAGAGCATTGATAGAACTGTTAGTTGGCTCTGAGTTTTTATTTAATATTAGACGCGACA
+ GTAAAATAACCGTCTGCGACAAAATTTAATTAACATTACACAAAAGAAAACGTTACCTCTAACTCGGCTT
+ GGTAATATAAAGATGTTAAATTTAATAGTGTTTCTTTACTTAACTGCAAGCCCCCTTTAAATTGATCGAT
+ CTTTCGAGGCAAATCTTCAAGTTACCAATGTCTTTAATAGCCATTGAAAGGGTGTTATGTGGCTGGCCCA
+ AGATTTGCCGCAAACTTATTGTAACGTCGCGGTCGCTGACCTCCGGCTTGCGGCGGGCACTGGTCAAGCA
+ GCCCCGTAAAGGCGGAGATGTTGGAAAACCCGGAATGGAGCTTGGGCGCTGTTCGTGCTTTGGACTCCGT
+ GTGAACCTCAGCAATGCATCCGTCGTATACGTTGGCCACCGACGCTACTCGACGTACGAGAAGACGTCTA
+ CGCAAATTTTAACGAAGCTCTTTCCACAAACCTCTGAGGAGTCCAACGACGAGGAAAGTCGTGAGCGGCG
+ GAAACTTGAGGAGGAGGAGGAGCAGAAGGAATTGGAGCGGGCATTTAGGCGGATGAAACTGGGCTTTGGG
+ CTTTTCGGCATAGGTAGCATGTTGTTCTCGTTTTGGGCTATATATTTCTATGGAAGGCCGTCCTTGGATG
+ AGCACGGAAATGAAGTAATCGACGAATTTAGTTGTCTGCCACAGATGCAGCAGCTTATGTGGCGGACATG
+ GAAGTCGGTGAACCGCTTTCAACGGTTTTTCAAAGAGCCGTCGAGAAAAAAGCTGCTTCCTGATCCCCTT
+ CAGCCCCCCTACGTGCAGCCGCCGTATACTTTGGTACTTGAGATTAAGGATGTGCTGGTACATCCCGATT
+ GGACCTACGAAACAGGATGGCGCTTCAAGAAGCGCCCTGGCGTTGACGTGTTTTTGAAAGAATGTGCCAA
+ GTATTTTGAGATTGTTGTTTACACGGCGGAGCAAGGAGTTACTGTGTTCCCGCTGGTCGACGCGCTTGAT
+ CCGAACGGCTGTATTATGTATCGCCTGGTTCGCGACTCTACGCACTTTGATGGAGGGCACCACGTGAAGA
+ ACCTTGACAACCTCAACCGAGACCTAAAGCGAGTGGTTGTCGTGGACTGGGATAGAAATTCCACCAAGTT
+ TCACCCTTCGAATTCATTCTCGATCCCGCGGTGGTCTGGAAACGACAATGACACTACCCTCTTTGAACTC
+ ACGTCGTTTCTTAGTGTTCTAGGAACGAGTGAGATCGACGATGTCCGAGAAGTGCTGCAATACTACAATC
+ AGTTTAGTGACTCGTTATCCCAGTTCAGAGAAAACCAGCGAAAGCTGGGTGAGCTAATGCACGCCGAGGA
+ GGTAGAAAAAACTAGCAAGTCTAGGCCCGTTGTCAAGAACTGGACCCGTGGCTTCATAAATCATTAAAAA
+ GATTGTGCGTTTGATGTGTCCCTTAAATACTGTTAATTCACCCAAAAAATTACATTAAAACTTTCCTAGC
+ ATTCTTCAATGTCTACCTACTAACAGCAGTTACTTTTGCAGTTTTTTGCGTATTCTGATTGAAAAAGTCT
+ GAAAACATATGATTTCTGATTTGGCATTTAAAGCAGACTGCCCTGCGGAACGTCAATGCTTCCTTGAAGG
+ TAACAGTGCAGCCACTAGGCGGATACATAGCCGTAATGTTGTGAAAAATGTTGTGTTACGGTTTTATATG
+ AATGCAGGCTTCCAGAAATCCTCAGTCCAGCACGAGCACGCAAGCTCAGCAACATGTTGCTGCCATGTGA
+ TGGTGTGCGTGAGCACGTGCCAAAATAACTACGACACATGTGTACTCTTGAGGGAATGTTTCCACAATCA
+ ACAACTACGCACTTCACACCACTAGGTGAGTCATGCGCAGTATCGTCCCTGCGAACATTCATCCGAATGT
+ TGGCATAAGTAAGTAAAGGGATCAGGTGTACTGTAAGCCTTCCGTCTAGTTACTTTCGATGCAGATTTTG
+ ATTCTGGCTGAGGGTTCGTGGCTGGCTGGGCCTCTTCTCCTTATGTTGAAAACACACAACAATTCGGTGG
+ TGGAAGTATACTGCGGACGTCAAACTGGCGAGCCAGGGCGCAGGCGTTGGTTCATTTGGCACTTTGTCTG
+ GTACTCTCCCACATCGGCATCCTGCAATCTCTTTGGCTCAGCATCCTTGTAAGCTGTTGTCGGAGCAATC
+ TGGGCATGGGGCAACTGAAAGGAAAGCAACTTTCCCATTCAGGAGCGCACAAGCCGCAGGAATCGCGAGC
+ GCAGACAATTCAGTTCGGCTTTAACGTAATGGACGGAAGGTTTGAATATCGCTTCTCGCCCCAGTTGTAC
+ AGATAAAGTCCCACTGCACGCAATAGGGCACTTGGAAGATACAATAGAACGCCGAGCAGTGTGTGTATAT
+ AGGTTTGAATGCTTACGATTGGGAATAAGTGGCAAAATATTGCAACTATGACCTAAACGCAAGGCAGTTA
+ ATAACTTCGCCAGCTTTTGGCCAGATTCGTGACACACTTAACTTGAAACTTCAATGCTAGTGGGATGGAT
+ ATCTACTCTCAAGCCGTGTTTTAATGCCCCAAGGATTCCGCTTTCTTGCCACAGACAATGAGCAGGTGCG
+ TGTGCAGTTAAACTAATAAAATTGTAGTGGACCCACCCGACCCACATATTTTGCCTATTTGCTCCTATTT
+ GTGTTTTTTTTGGTTACCTATGCATATGTTATGCATATGTATGCTCAACAAACCATGTGGAAATTGCCGA
+ TGGGAAGCTTTAGACTAAATGCATTGACTGCGTATCCTTCACTGCCACACCCTAAAGTGACTATGCTATC
+ ACTCACTCGCAGGGGGAAATGACCCACAATCATAACAATAAAGATACAGATGAGAGCCCACATGTACATA
+ TTTTATGGAATGACTGATAACCAATGTATTTAGAATGCATGACACACTTTGAATTAAGTGCTGTAGTTAA
+ GTCACACATGGCACTGCACTATCTGCAGATTTCAGCCAAATTGGCCATTTAAAATCTTATTTTCTAGATT
+ TGCATGTAATCTATAAATAATGGCAACTGAAACCTTTTTGGATCTGAATTATGAGAGGGGCAAGGTGTCG
+ AAGAGGTCACTGCGACCAAAGCTATTAAAATTGACAGATGTGACGATACCACATCGAAGTCGGAAGAAAA
+ ACAAAGTTAAGGTGAGTTGCGAGTTGTGAGAGGGAAAGAACATTTGAGCAACTAGATCTTAAAGCGCTGT
+ TTGTTTTCAGACCAAAGACCGATCAGCCACATCCGTGCGCGACAGGATCTATGATGATCCTGCCTACACA
+ GAGGACATAAGCCACTTGGCGAATCCCATGCGTCGCAGTAGCATTTCTGGGAAATCCTTCTTGGAACACA
+ AGACGAGGTCAGATACGGGCGGTCAGGCATCATCCAGCAGCCTACTGGCCAAAAACCAGCTGCCCCAGGA
+ GCTGCATCAGTATGTGTCAGGGAAGCAGGCCAAGATCAAACAACACCACACAGCCACAATAGCTTCCGGT
+ AGCACCGCCATCAGCATAAACTACGAATGTGATTCGAGCAGCACCGACAACGAGGTCCAGGAACCAATCC
+ AAACCAAAGGTGGTATGAACCGCAGGGTGCGCAGCCTAGAGCGCAATCTGGCCGCCACAGGCTCCGAAAG
+ GGCCGAAAAGAAGGGAACTCAGAAGCGCACCTCGAAACAAAAGCGGAATCTTAGCTTAGACAACAATCGC
+ CATCAGCCCGCAGGACATCCGAAGCGGGAGGCGGTAGCTGTAGCTAAGGTCGGTCACGATGCTGACACAC
+ GAGCCCGCAAAGAGCGAAATCGGAAGCCCTACGGCGAGATGGGTCCGGATGGTGGTGTCCCGACCGAGGT
+ CAGTGAGTTAGATGACGGGTACTCTGCTCGCGGTTCCGCTCAGAGTTCCGCCTGCACCTTACCAGCAGAA
+ TCAGCCGCCGACGCGGCGAAAGTTGCTATCGGCAAACGGTTCCTGCGCGGCGAGATTGGAATTAAAAGCT
+ TTAACTACTATCTGCTAAAGGAGGGCTTAAAGAGCTCGAAAAAACTAGTGGACCAACAGCGAACCCCAGC
+ TGGCAGTGGCAGTGTGGAGTCACCTCTGAAGGCCGAAAAACGACATTGCCGCAGCGAGGAAAACATCTAC
+ GAGGAGATCTTCTTTAAGGACACGGCCAACGCGGTGAGCTCGTCGGCAACAGGAGTAGCCACCGGCATGG
+ CGATGCCCGTTGCCCTGACAATGTGTGATCAAGAGACGCACAGCCTGGAAAAAGGAGCTCAGCCGCATGG
+ AATAGGCGCCACCAATCCCGCATTTGCAGACTGCGAGTTTTGTATGGAGCAATGCAGCAAGGAAAACTGT
+ GAATATTGCTTGGCCCACGTTGAACAAGTAGCAAGTAAAAAACTGAAGGCGGGGCAAACACAGGAAGAGC
+ AGTACCTCAACCAAGGACATAGGAAAAACCACACTATGGATTCGCGGCCTAGTGCTCCGGTGGTCGAGGT
+ GCCGACCGCCCATATACTAGAGTTCCAGTCGTACAACCCAAATAATCCAGGCGTTTACAAAATTGAGACG
+ ACTCCAGTGGCCATAACAGGAGACTACAACCCGATTCTACAATTTCAGCAGTCTTCTGCTACTACATCGA
+ CCTCAGCTACCACCACGCCAAGTGAACCCCAGATTTATGGTGGATACTACCTGCCCCATGCGAACCAGAG
+ GCCATACCACTCGCCAACTGTTAACAGCCAGCTGCCAAATCACTACGCCGTGGGTGGCAGTCTGCTCTTG
+ GCCCAGGTTACGGGGGCCACTCAAGGGTCCGCCACGCCGCCTCGGCGACCCCAGCAGCACTTTATAGTGG
+ GATATCAGAACGGAGGAGGTATGTCCGCAGGTGCGGCTTCCTTACAGCGCTTTAACACGAAGTCCTCGTC
+ CTCGAGCGACTCGCTTCCCTATCACAAATATAATACCATGGCGCGACTGGAGGCAAATGTGCTAGCAGCT
+ CCTGCCACTGGGGATCTTTACTATGCGGTCAGTGGGACGCAGCCACTGCATCCGCTTATGTATGCTGCCA
+ ATAGACCCATTGGAGGATCCCAGATACTGGTGGATCCCTACGATCCGCAGATGTACAAGAGCGACTCAAA
+ GGCATCAATTCTGAGCGAGTTCTCCCTTCGCAGCAGCGACAACTCGCAACGCTACGCTCGGCATCCTCAT
+ CGGCGACATGGCGGGCGCGTCAGTGATTCCAGTCTGTTTTCAGTGTACTCAAACTCTGGCCAAAGGCGGT
+ ACTTTGGAAGCTCGGAAGGCAGGTTCGGATACGATTGTAGACGCTGCAGTCTGGATGGCGTCATTGGAAT
+ GAGTACTGCGACTGGAGGGTCTATGATGGCTCCCGATAAGTGCAGCTACTCGGACAACTGCCGGTTCGAG
+ TGCCGAAACTGCGACTGCTCGTCAAATTACTTTAGCTCAGACTTTGATGATGTTTACGGATCAATAGCGC
+ GAGGAGGAAGCAGCGGAATCCCGCGAAAAACTGCAGCAGGGACACTGCCATCAAGCGCACAAGACGATCA
+ AGTTGAGCGATTGGAAGCCCCACCAGCGTCGATGGAGCAGCAGCAGTACGCAGACCTAAAACAGAACAAG
+ TACGCCCAAGATTTCTTTAAGCATGTTAACGACGTAAAACGTAGCATTTACCAGTCGGAAATGAAGAGAA
+ ACAATAGCTTGGAGTCCTCAAGGAGTGGTCCAAGAGCTGGCGGCAGCACAAAAAGCAATGTCAAAGCAAG
+ TCCCAAGCGGGCCGCCTCACAGGAAACTAGATTAGTAACTACTCTTCCGCTAAGCAGGAGTCGGCTTTCT
+ GCCGGCGTAAAGCCGACACCTGCACCAAGGACCAGTCTCCAGACACCGACTCCTTTGCCGGAGACTACCG
+ TCGCAAGTAAGTACAACCGATGTGGGATTCTATTGTATAGCATTGTAAATAACCCTGGAATTATTCATAG
+ AAGATCCCACGCCTAGTAAGCGAAAAAGTCAACCAACTGTCCGGAGAGAGTATCCTTCCTTGGACAGGCT
+ CGTTGCGTCTACCACGGGCACCATTCCGAAGAAGAACAGCAGGAACATAACAGCGGCCAGCTTACAAAGC
+ CCGAAGCTGACGCAAAAAACTAGATCAGAGGCTCCCGAAAAGAAGGTTGCACCTGAAGATCAGTTGCCGC
+ TGCCTCCGTCCGGCAAACGACACCATCGCACAGGCGCATCGAAGACAAATACAAACGCTCCCTGTTCCAG
+ CCTACGCAGGAAAGACATTCCGGCTCCACCTCCGCCTTCCCCCGCTACATATTCCGACCTCCAGGAGCTA
+ AAGGCCAATATGGAGGGTTTTCGAGACGATACTAAGTCACGAAGCTTGGAGTACGACACTAACGATCTTA
+ CGGCTGACGATAATTCCAATAAAACTCAGAAAAAAAGTCTCAGCGGACCACCGAATCCAATGACGGAAGC
+ CCCAATTGGAGCCACTGATGCAGGTGCAGTGGAGACTGACGACAACGACGTCTTCTATGATGCACGCAGC
+ GAGGATTCTGGCGGTGGTATCTTGCCCTCGAATACCAGTGATATATCGAAAATGGTGAGTGCTTTGCTAT
+ TGGTAGCAGAATTTTGGAATCGTGTAATGTGAAATACAAGCCCTTATTTGAGTAGCCCGACTAGTAGCTA
+ TGACAATTAATACAAATTACTATTGTAGATATATATTATTTTTATTACTTCAAATTTTGGCTATTTGTAA
+ AATCGATTTTCCAAAGCCTACATTTGTTTGAAAGACGAACTTTTAAAAGTACAGAACACCGAAATTTGCC
+ AACTCAGTTACAGCCTGAACATAGATTAATAGTTGTTAGAAATAATTGGACGGGGAGCATTGATAATGAA
+ AAGGGGCCGAGTTGAAATAAACATGAATAAGATTTCAATTAAACGATTTTTTACAGAGTCCATCCCACAT
+ GGCGACATTCACACGGGCGGCAACTAACGAAAATCGCAAAGGCGCCTTTGACAACGAAAAGGAGCACTCT
+ GCCGAGGATGATGATTCTCCGTCTCCCGCCGCCCCTGCGCCAGAGGGGCGTGAGCAGGCGTCCTCCATCA
+ CGGGCAGACCGAAAGGGAATGGCAACAGTAAAATAACCACAACCCCAAGCTGTGAGCTCGGGAGCTCGGC
+ CGAAGCGGAAAGCAAGCTGGACTCCGCCGCACTCTGTCGACCCCGACCACGACCTCGCCAAGCGTCTCCC
+ CACCTCCCGCCCGAATGCACGGACACTGGGGGGGCTGGTGACGAACAGGCAAGCAAAACAAAACACGAAA
+ AGAAGACTCCAGCAGACGCCCCCAGGCAACATGTTGGACCAACATGTTCGGAGGGGCAGCGAACCGCCGC
+ GCTAGCAACAAATGTTGCTTGCGCACTCTCAACAACCACCAACGCTGGCAACACGAGCGCCAGCAACAGC
+ GTATTGGAGCTGGAGCTCAGTTGCAAGACGGGCAACACGGACAGCGAAACGCCAGCGGTAGCGCACAGGT
+ ACGCGACTCTGCCATTGCGCCCAATCTATGATGTGAAACTTAAAGTGTTAGTCACCTGAACTTTTTGTGG
+ CAACGGGCAATTTTCGGGGCAAGCATCGGTGCACGGCGAACACTTGTTGTTCTTGGCTACTTGGATGCCC
+ AGGACTCTGGCCAAGTGAAGTGAAATGTTTTTCGTGCTCCTCAAAACACAGGGGCATCGGTGAAAAATTC
+ AATCAACTAGTGAACTTAAATAGTAAATTCCCATTACCACATGGTTCGATTTTAAAGTGCGTTAATTGGG
+ CTAGTGAAGCTATTTGCACTCCACGAGAGGCAACCGTATGCGCAGCAGCTCCTGAGAGGGTTACTGTGGG
+ TGACATTTGGTATCACCTTGTGTTAGCCTCCCCTTAAAACTTCACTTTAAAGCGGCTGGTATCTGAAATG
+ GGTGAAATGGGGGATCGATGGCAGCAGCTGGCTTGCCAATTGCATTCCCAGCCGGATATGTACTTTGCAG
+ TGGTCTGATTCGTGAGATTATTTCATTCAATGTTTGGATACTTTATCGGCGTTCAATCAATTACCTAAGA
+ GCCCAGCTGGGTGCAAAGTTCAATTGTGGAAGGAGCTACATTGCCGTGTTTTTATGGCCTGATTGAACCA
+ TTTGAAAAGCAAGTGCCGGGCTAAAAGCCTACTGAATTGATGGTTGATTGCCCATTCAATCAACTCTTCT
+ TTCGCGATAATTTGTCGAGTGTGTCTTAAAGCAGCTGGGCATATTAATATAATTAATTACCAAACCTTAC
+ GTTCACGTGATGGATGACAGTGTATATGTACATATGACAGAACTCGGCGCGTTTACATCTGCGTGTAAAT
+ ATCCTGCGGCATGGTGAATAGACATAAATCAACCTCAGAGCACAAATTCAGGAAAACAACGAGCGGCTAA
+ TGCAAGTGTAATCGTGGATATGTGCTTTTTTCCGCCAACTTTTTCCAACCATATCCCTTGATTATAAACT
+ GAACGATATATGTATAAGTTTTTTTCAATAGCGCGTCCTGTGTTGCGCTATGTCCATTTCCCTTTCTTCT
+ CTACAAAAATTCGGCAATCAATAATTTTAGCAAAATGCTTCACCTCCTGACTTTCCCCATCGTTTGTGGA
+ AAACCCCCGATCCGAGACCAGCCATAAATATATTGTGACCTTCCTTTCTTTTCGTTTTTGTGTTGGTATT
+ CAATCACTTGCACACATACATAACTAATGTGTGTGCACAGCCGCACTTTTCTTAATTATTTGTAGCTGCA
+ GAGGAAGAAATAATAGCTTAATTTCACACTGAAGCCTTTTTGTGTGGGTTTTGATGCACATGTTAAGCAT
+ ACGCCGTGTAGTCCACGAGTTAATTATGCCGAGCCATGCGGTTGATTGATTCATTGCATAGGGTGTAGGT
+ AAAGTTTCAATCGAACGGGCAAATTTTAAGCGCTGCTAATTGAAAACAAGTTCAGCTCGCAATGAGGGGG
+ CAAAACAAGTGAGAAAAGCAATCCAGGGCCATCGACAATTCAGAAATTTTATTGCTACAATTTGGTATTT
+ TGCGAAATTGGGGACGACCTTCAAAACCTTCAAGCCGAAAATAAAAAGTTGGCTGGAAACTCGCAATTGC
+ ATTAATTTACTATAAATTGCATGCAGCCTACCATTCGATAATTATGAGTCTGATCATTATGAGCACGGGC
+ TTGCAAATATGGTATAGAAAACGAGAAACTCGTTTCCTATGGCCGCAACTTCATTTGGTCATTGGCTTTT
+ AGTCAATGCCGCTGGAGCTCGACCAACGTTACCACATCGTGCACCATCGAAGAAGCAGCTTCTGGGCTAG
+ TAAAATGGAAAAGTGCAAGTTGCCTAACAGGTATGCGAGATAATGCAATCGATTTACTAGTACCCGTCCA
+ CGTCCTCCTCCACTTCCTTGGCCCGCCCTCGTCCTCTGCTCTTCTGCTCTGCTTTGCTGAAGACAAGTGC
+ GGCTTAACATGATTGAAAACCAGTTTTATGATGCATGCCGCAGATGCAAGCGCAGTGCTTTGTGCTTTAT
+ TTACGATATCCAAACCTGCAATCACTGCTGCTCAATAGACATCGAGTTTTTTAAAGAAATGCGCAAACGT
+ TTTTCAGCGAAAACTTTTCCACCTCGAATATTACGGAAAACGAAAGGCTTGTTTCAAAGTGCACAAGACT
+ GTTGTCCTCTTGTTATGTTTTATTTAATAAGAAAGTAAGAGGAATTCTCAGCGGGCTCGGGTGGTATGTA
+ AGTCGTAATTATTTAGTCACTTAACTTTCACTGCGAAAATTATTCATTCCGTTCCAAACAAAGTTTGATT
+ CGCCGAATGAAAAGTGCACAGCTTCAAGACAGAATAGTACAAAATTTTTTTTTTTCGCCGCATATGGAAT
+ TTTAGATACATTTCAAATAGTAACGACAAATTATTAAGACTTGAAAGCACTCTCTCAGATGCCCCAGCAA
+ AGATGTAATCCCGCCACTTCCTGGATTTTTGAATCCCGGCAACATACTTTACATTACACGTGTAATACCT
+ TTATATTGTTCATAATACTTTTTAGGCAATTTTGTGTTGCTTTAATGTGATGATTTAGTTTTCTAATAGA
+ ACACGTATGTGTAGTGCATACATGCAAATTGATCAAAGCACGTGGGCCGTCGTTGAACGTTTTTTATGCC
+ CACGCACCAAAGAGTTCAGAACATTACCTTATAAGAAATAGCCGAGCACCTTTCTTTTTTCCTCCACAGT
+ TTGTACACCGAATGGCAGTTTCATATTTAGTTTTTAACTACAATTTTATAAGTTAGACCTTCCAAGCAGA
+ AGTAGAATGCGATTACAAGAAATACTTCATGGTAATGTAAGCACTCATGACGTGGGACTACTATTGATAT
+ CTAGCCAAATATTTAATAGACTGACCAACGAGATACTCTTGTGATTCGACGTGGTCGACGACATTCAAAA
+ AGTATCAACGCTTCCCAAAGTGAACTAGGCTTAATAACACCTACACACAAGCAAGATAATTTGGCAGATA
+ GGCAAGAATCCGAAGACTTTAACGTTTGGTGTTGGCTGTTGACCATTTTGGTATGACAAGTTTTGAAGTG
+ ATTGTATTTGTATGCCAAATTAAAAGCGTGGGGCTGAACAGATTCTTTGGTTTTGCGTTACTAGCCCCAT
+ CAGTATAGAGCCGCTTACAAACGAAGCATCAAAGATATGTAAATTGAGAGATACACTTTCAAAGGCTAGT
+ TGTACTAACCACTGACACTTTTAACCATAAATTTAACGGACTATTTACGCTAATTTAAAGTCATGACACC
+ CACCATACACCTTGCAATCGCAGCGTTAATTATGAAATGAGCTTGTATTTATGTGTGTGTGTCATTTTCT
+ CCGCGACTGTTTTTCCAACAGGTTTAGCAACAGTTTCTCCCACCTATTGTTCAGTCTCAGGGTCAAGTTT
+ AAAAAACATTGACAGCTTTTCGAAATATCTGCCCCAACGAGAACACCGAAGACGCCCAAGTTTTACCAAA
+ ATTTGAGTTGCGATTGAGTTAGTGCTTTTGCCTCCGTCCCTGGGCTCAACTTGCGACCAACACTCGAAAG
+ CGCGTCGTTGTCAGCCACCAGCAGTGGCAGTGGCAGCAACAAGGCAAAGCACTTACAGCTGGTGAAACTG
+ CACAAGACTGCTGTGGCAGCGTTTACTGCTGCATTGGTGCAGATGTCAACGAGTTCACGCGAGTGCTGAA
+ CCATGTTCCCGGACATTGAACCGATGTTCGAGCGCCGGCTCTCGGCCTGGCTCGATTGTCCTAGCCATTA
+ GGCCGGCAAGCCGCTGGAAGAGCATTAGCGCTCGAACGGATAAGGGTCCTAAGTCAATTCACTGTGAACC
+ CTTTAGCAGTCGACACTAGAGAACTGTAATGGGGGGGCGACTAATGATTTCAGATGTTCTACTTCATTTC
+ CCGCACTTATATTACAGTGACCCGACATCCGATGTGCCTGCCTGTGGGACAGCGGAGAATCCAACGCACC
+ TAAGAGCACTGACACGCCAGGACTACGCCTGCATCGACTCGAGCGAGGCTCAATCGGACGACAGTCACCT
+ GACACGCGACTCTATCACCCGGGAGTCCCAAAATGACGAGCTCTCCTCGTCGACTCTTGAGAAACTAGAC
+ GTTAGCACACTGCCACTGCCCGCACTCCCCAAACGTCGCAGAACCCGCTCCCGCACCAGCCCCTCCAAGC
+ ACAGGCAACAACAGCAACAGCAGCAGCAACAGCAGCAGCAGCGTCATGAAGTTATCGAAGATGCCAATGC
+ GGTTGATGCATCGACCGCAGCAGCAGGACAACAGCACCCCAAGCCACGTCAGGGAGCAGCCTCTCCAGAG
+ TCCCAAAAGCCAGAAATAAGCGGTGCAAAGAACAACGCAGCCGGCGAGCAGCAAAAGCAGCCACAGTCGC
+ AACAGCAGCAGACACACCTCTCCGCCTTCCAGCAGTACGTCGCCAAGCGAAGGGAGAGTCTGGAGGCGTC
+ CAATCGTTGTTTCAACGAGAAGCTAGAGGCGCGCAGAATGCATTACCACATGGGTGGGAGCGCAGCAAAT
+ GGTAACGCAACCGCCTCCCATCTGACGGCTGGCTCCAATGGAGTGCCCACTTATCTTTTCGGTGAAAATT
+ TCTATGGAGTGCCCGCAACTGGACGTAAGTCCATATCTCCCACCACCAAGAAGGAGGAAATATTCCTGAA
+ CAAGTCCGGATGGGTGCAGGTCAACACGACGCGTGGGGTCAACAAGGATGACAATGGCGGGGGCTACCGA
+ AGCCTCAGCTACGCCCAACAAAATGGTGGCGGACGTGTTGCGGCGATGCTGACGGATCCTGGGAGACGCT
+ CAGACCTGGCACGAAAGTCATTCATCCTGCAGCATCAGCAACAGCATCAATCCAATATCAGCATGACTGA
+ GCCGAAGTTTGTTGGCTCCAAAGTGGAAGAGCTGATTCAAAGGAACGAAGCACGGCTAAGCGGCTGTTCC
+ ATACGGTACCCTTCCCTGCGTCCGGGCCATCGGATTATCGATCCGCAGCTGGCTAACATCCTTAACGAAC
+ GGCCAGGCTTCTTGCCAGTGAAGGGCCCGACTGATCTCGACTCCCCCCTCACTCCCATTCTCTCCCCACC
+ TCCCGCTTTCCAGGACAACAGCCGAAGTGCTCGGCGTCAGGAGAGGCGCAACCCCGGACGCCAGCAGGGT
+ CCTCTGCCCCTGCCCGTGCCGTTTCGGTCGGAGCCCCAGATGGACCCTCAAAACCCCATTAATGGCTCCG
+ CCAAAGGCATGGTTTTTTCCCGTAGTTTCGAGTACGACACACGTCGTCACACGCCCACCGACAACTACGT
+ AGAGACGTTTTCCCGCAGCTTTGATGGAAACTTGTCGGATCGCCTGCTCAACCTGGCCGTTCTGGCCGGC
+ CAGCGGGAACGGTCGCCCAACTTCAGCACCCTGACCGGTAACTCTCCGAACTACCTTACGAAACGGGAGA
+ GCGGCGGTGGAAGCAGTGGCTCTCTTCGCAGCCGCGACAGCTCGCCCAAGTATCTGCATCCGCAGGCCAC
+ AACTGCTTACTTAAATGCCGCTGTCAAAGAGGCGCCTCCTGTCTACAGTGTCCCCACTGGCAGTCAGGCC
+ AAGTATTCGCCGCGTTCCCGTTTCGAAAGGACTACTGAGCGTTCCAAAACCCACGCCCTGGGACGTTCCC
+ GTAAGTCCCAGTTCAGCCGCGTGGGCAGTGCCGGACCTCTGATAGCGCATCCAAACACTGCAAATGTGGG
+ AGTGTCTCGTTTCCGAAGCTTTGACACGTCCAAGAGCCAGCGTCTTAATTCGTGCGACAGTGGTGCGAGA
+ TCAGGTCAGTAGACAGAATCATTTGATTACCAATAACTTTCGCCTTGTCAAAGTTGCTCGATAATAAAAC
+ ATGGGAAATAAGCACCTGCGAAGTGTCACGTGCACCTTGTCCGTCCGACTTTTATACATTTTATTGTTTA
+ GTCCGTTCAGGAGCACCTTGTGCTCGTAAGAGCTTCAGAAAAAAGCCTGTCAAATCAGCGACAGAGGTGT
+ CGTTATTTCTCATAATATTTGTTATTAGTCGTTGGCCAGTTCACTGGGTCCAAATGTGTTCAGCCTAATT
+ GAGGTTTTTTTTTTGACAGATCTCTCCAACGATGAGCTGGACAATGAAGATGGCGGGTTGAACGACTTTC
+ TATCCGCCGGCAGCCACAAGTTTCCTAAAATTGGAACGAGTAGCGTCAGCGTATCGCCATTCAAAATGCA
+ ACGCCAGAGATCCCTGACACCAGATCGGAATGACTCCCATAGCTCGACTAGCAGCTTACGGAAGCAAAGA
+ TCAAACACCCCTGAGTCCAGATCCTTGACTCCTGAGGAACGGCGCAAGAAGGGGTCCCAGCTTTCATTGG
+ GCGGTGCCCGGCAAAGCTCCAGCTCGAGGAGCAACACGTTTGAGGGCCGCCAGCGGCACGATGACAAAAC
+ CCCACCCAACATATCACGCAGCTCCTCCAGCTCCAGCTACAGTGGCGGCGAGTCCCACGAGCCCCTTAAT
+ GGCACCGGCAGCACGACTGTTACACCCTCGGCCGGAAGTGGCTCCACCAGCCATCGACGCGCATTGACCG
+ CGAAACAAGCGGAGCAGGAGCACCGCATTCGACGCTCGAGGTTGGTTAAATGACTTATTGTTAATGCGTT
+ AAAGCCACAAATATTCCATTGCACCAATACTTTGCTTTCAACCTCACGACTCCTTTCCAGATCGTTGCAA
+ CTAACCGAACGCTCTCCGAACCGAGCGCACAAATCCATTGTTAACGTGGGTGCCCTGGTCCCGCAGCAGC
+ GGTCGGTAGGTGTTCCCTATCAGCAGTCCCGTGTACCAGGTGGGGGCGTTTTCCCCCCCACTATCCGAAC
+ CTCGCCAGCGGGGGCAAAGATCCATGTCAATTCGCCTGCTCCACCCAACAGCTCGGTGAGAGTGCGACAC
+ AACGAGACGGACAAGGCGCGCTCCTTCGACTTTGACTACAACAACTTTAGTCGTGGTGGAGGAGCAAAGG
+ GTTCAAGTCGCACCGCACACACTAGTGGCAGCGGAGGAGATAGCGGAAGCAATCAGAATCTGCGCGTGGA
+ GAGGGAGTCCCGCTCCTTCGACGACGAAATTTGTGAAGCGGTGCTCAACAACAACAACGGCAGCAACGGA
+ AGTGTAAGTGGCCTGCGCTTCCTACAGCCTGCAACCGATTCCGGGCAGGTGTCGATGGCATCCACGTCGT
+ CTTCCCGCCTGCGCAAGTCCAACTCGCCTGTCAGCGCGTCTGGAATGGAGGCGTCGCGGTCGCCACAGTC
+ ATCGGGATCCTCAACCAACAATCTCCATCAGCAGGCGAGGCAATCGGGCAGTCCACAGAGCTACGGGACG
+ CGACTTTGCGACCACGAGCTGACTTACGAAATGCTACGAAAGTCGCCGATCATGAACTTCCGGCGTGGGG
+ ACAGCGGCGACTACGAACTGCCAGTGATGCTACGGAATCGGGAAACCATCAATTCGGGGGGCAACAGTGA
+ GCTCAACTTTATGAGCAACGAGACGCGAATCTACGAGCATCCTACAACCGTTCTAAAGTCACAGCGATCC
+ CTCCGCCAAAGTCCGGGGTCTCGGGACGACCTAAATCTTGAGGTTGCAGTGGGAGTGGGAGGCGACTACA
+ TCTACAGGCAGCCGGCCAACCAGCCGCGTAGCAGCAGGTACTAGAACGAAAACCTCTACAGCTGAAGATT
+ CGGCATCCCCAGTGACGGCGTGCTATCTGTATATTAACCTAATCTAACTAACCGCACACAATCCGAAGTC
+ CACCACTTGAACCAAATTTAAGAACGCCCAAGGCACTAACACGACCAGAGAAGCACCTGTAGGTGTTTGT
+ GTTTAAGAGACTGCTTATTCATACTAAATAATCTAGGAGGTAACCAAATTGATGAACTGTGTGGTGGTGG
+ CAGACTTACTCCTTTCATAAACCCGCCACGGGTGGCTACATCCGTACTAAAATACACGTACTAACTTACC
+ AACTATACGCAAACTAGATACCCAAAGGAAGCGTTCCCACCTCTAATTTCCTATATCAGATTAAGGATGT
+ CTTGTGTGCGTGGCTTATGTATCTCGTGCTGTTTCATAGTGTTAAAGCGGAGTTCCTCACAACGGCAACG
+ ACGAAAAGTTGCACCAAAACTTTGGACACATGCGATTATTGGCCACGCTGCGCCGCCTGTCAGCATAAAA
+ GTGTCTCGGGAGAACTCAAAAAAGGACCGTCTGCCTCCGGAAAACCATTAACCGTTCTGGATAACGTGCA
+ GCCCCATGTCACCTCAGTGATCGTTAATGAAGACAACGCAGTCCCGGGCCCACAGCTCCGAAGCCTGGAA
+ AAATCCAATCCGTCATGGACCTTCCTTTGTAGCGGAATTGCCAGCATTTGCCAACCTGTGCAGCAGACGG
+ AAACCGACCATAGCACTGCCCAGGAGGCGGCGGAGGAGGATATTGTCATCAGGTGAGTTTTACCTTGCAA
+ CTTTTGAAGTGACAGATTAGAGCCAGACACGTCTTCCCCTGCTAATGGCTTCATTTTGACGAGCTATTGC
+ CGACTAACAAGCTCTGGCAGCCGGTCCAACAATAATATGAGTGGCTACGCCGGAATAAAACTGGATACGG
+ TCAATAATGGATAAGAGTCATCAAAATTTGTTTCCCCTTTTAGGAAGGTAAAACCCAACAAAAGCCGCAG
+ GACGGGACGTAGTCGTTCTCTGCCAAGTGTAATGCTGCGAAGACTTTATCTTGCTGGGTAAGATTTCATT
+ TATATACTCTTGATTAGTTCAATTAGTGTCTAGAACGATTGCTCGTCAGCTCGGTAGCAAGAGAATGTCC
+ CTTAAATGATTCAATGTTCAATAATCCTTTGTACGCAAGCCAGCTATTATGTTGTCTTCCACCCGCCTGG
+ TCGACAGGACAAAAAAGGAGACGCTTCCACTTTCTTGTCCAACAAATGAACAACCGGTTGTGGCACAGCC
+ TCCCATATCAAAATACTGAGTTCAGCGACCTACTACTCGACTACACTAAAGACACACATTTGACATCGTC
+ CTACCTTTCCCCCTCTCGCCATTTGGCCATCGTCCTTTTTACGTAGTCCATTAATAAGCAATGACGGTGT
+ CGGTAGGGGAGCGTTCGTGTCGCCGAGGGGCAAAATGAGCGAAGTGCAGCTGACGAGTATTGACATAGAT
+ GGTAGAGGCCATACGGAAGTTGTGCAAAATAAACAGCCTCCTGAAGTCCTGACTGTTGCAATAAAAATCC
+ CTAAAATCCCCTTGTCAATTTGTAAAAGTACCAAGTGGAATTGTCAAATTGGTTGCATACTTGTAGGCGC
+ AAGCATGCGCAGAAAGTTGACCCCTTCATTGCGTAATAAGAAGTCAAGTTTATGGCAAGGGAATACTTAA
+ AGAAACAATATTAGGAAATCTAAACAATTATTAGCTAGTTAGAACGATTTAAGTTCGTCGTTAAACAACA
+ TTTATATGCACGCTTTGATTTCCAATATTCGATTGGCTTATATTATGAACTAGGCAGACTTATTTCGATT
+ AAAGCTTCATTTGTCATTTGTTCACCAAAAAAGACAGTTGAAATTGTATATTAACTGAACTGATGGCAGA
+ GACTTATTGCTGTCATGCATCTAATTTTAAAAGAACCGCGCATTGCCCACTACCAGATGGAGGATCCTGG
+ TGGGGATCTTGGCTAACACCTGGACTTGGCTACATTTGGTATTTTTTATAGCACGGTGGTATTTCTAAAA
+ CGCGCACGCGGCCACACTAACAGCAAATATTGAAAAAAACAATAGTTGAGCGGACGCGAAAAATGCACTT
+ ATAGGTAACGGCGGTGCGCGCGTCTTTCCGCCCCCTGAACGGAACTCAGCTGTTGGGAGCTTGTATCGAA
+ TCCGCAACCAGCCACTGACCACATCCCCAGCAGGATAACATCGCCAGTCCGCGCCCAACTCGGTCTCTAC
+ ACCCAGTGCCCAAATACACCAACTGACAACCGTAGAATCGTGTGAGAAACAGACGCCCTTGCCGGTCGCC
+ GAACAGAACGCCAAGCGTAGGCTGGTGGCGCGTGTGTGTATCTGTGTATACGTACTGCTGGCATTCTCGG
+ GAACGCTTGGGCAGAAGCCAAAATGTGTGCCAGCGCATAGGGAACGAAAGAACGCAAATAGCGCATCTAC
+ ATTAAGAAACAGGCAAAATCAATAACACCAAACCAAACCGAACCGAACCAAAGCAAGCAAAGATTATTAC
+ GCAAAACGACGGGCGCATATGAAAATGTCTATAACGGGCGCAGATAGTGGGCGTGCTTCGGCCACCGAGC
+ TCGAGGAGTCCGCCGTCGCGACGATGCAGCTCAGGGAACCCACCACACCCCCGCCACCCATCAGCGGCGA
+ GGACGTTTTCGCCAGCCGCGTCTCCCATACCACGTGGTACTTGCCAGTGGAGGACTCGTCCTCGCCGCCC
+ GCATCAAGCACCAACGAAGCTCGTGGCGCGTCGCCTGACGCTGAGCCCCGGGAAGGGGATGCAGCTGGCG
+ ACTCGTCAATGAGCACCAGTGACGAGTAAGTTGGTTCCGGTTTCCCCAAGACGGGCACCATTGGAATGGC
+ ATCCTTTAATACGCCAATAATTATCCCTTCTATTTCCTTTAAATTGTGGCCATTACGCGGCCCACTGACC
+ AATTACTCTTCGAACCCCTGATTCTTGGCCGGGTGTCTGATGAATTTTCACTTGACTTCCTTCCTGCACG
+ CTTCTATCGACCTGTTGAGGTAGATGGACACGCGATATAGGTTTCGTTTCTATAAAGGATTTCCCTTCTG
+ TGCATCCCTGCCTCAACTGCCCAACGACTGACTGTTTTGGGTACAAGAGTTTTTCTGGTTTTCCCATAAA
+ GTTATTCCCCTCTGATGTCACAACGTTTAGCTGTTCCCTTTGGTTTGTATGATTTGTTTAATCAAGAACT
+ TTTAGAGCGGAAATACTGCGTGGCTCATGTTTGCTCATATAGACTTTAGTTATACTATGGGTCAGAGGAG
+ CCAACCAGTCGAGCCTGGCATGCGAGATATGGATATGCGATTCGTCACGAGCCACAAAAAAAAACATTTC
+ ACAAGGGGCTTTTTGCGGCAGATTCCGCAGACTGCTCGGCGTTCCAACCATATTTCGGAGTACCGCTGTT
+ TCAAAATGGTTCAAGGCTATCAACAAGTTTTTAATCCCTCTTCGGGTTTACCCAATTCGATCATTAGAAA
+ TATTTGCCACCATTGACTACTGAAAAATTTCAAAATGTATGCCAAATTCATACCATGAAGTCTTAAAAAC
+ TTGGCGAGATTAAAATACTTGCACACGAAAATAGCAGCGACCATTACGCATACTTCCAAATGGAATAAAT
+ ATATTTATTTCTGTATACTCTCCAACACATTTTGACTACGATAACATTTTGTAAGTGACCAAACACAGAA
+ AGATTGAGTATCTAGAGTGGTGGTACGCTAATTTCACTTACAACTAGCGGATTCGTATTCGCAGAAATCA
+ ATCGAATCTCAGTACTCCGCAAATAACAGCGATTCATCTGATTGAATCTACTCCTTGTCCAACTGTCTGT
+ TTGCAAAGGTGCAATAGCCCAGCCACTCCCTAGCCTGTGAAGTAACACATATTACCACTTACATATTTTC
+ ACGGAGCAGAGCTATGCAGCTCGTAAAACTTATTGTGGCTCGCAGTGGAAAGTAGTGCTTTCGGGCACGA
+ AATCATTTGGATAAAATATTGTTTAATTATGGTACATATAAAATTCCCAAAGTAGTAGAGGCCTGGGGAA
+ AGCTATAGCGAGTCAGCCACCACATCTGTTGACCATGCGTTGGCTTTGATGCTAGGTGCGCTTGATTTTC
+ ATTGCGTTTTATTTCACTGCCAGCGGCAGCCTGCGAATCATAGCAACGAAGTAATGCAGCCTGGTGTCTC
+ TGCGGTAAATGAGACATTGTGGCTAAAAATGCATGCAAAGAGGCACCGCCCCCTAGTAGTTGGAAAACTT
+ GTCCCTGGAAAAGAAACAGCTCTGACGGATGACGGCGCATCTGGCAGTTGGTTAGAAGTCAGAAGCTCAA
+ CGAGCATGCTAACATAATTCACTTGACATTTCCAGGCTAAACATACATTTGAAATACGTTAGTGTAAGGG
+ TTTCTTCAGGACCGAAAGTGAAGTCGGCTTATGGAAACCCTTCTACCGCTGACTACGTTAACACCTAAGA
+ CAAATTGCCAAAAGAAGATGTACATGATGTATTTGATAGAGATTTAAACCTGCCCTTTTCCACTCCAAAT
+ GTCTTGCAATGAAGAAAACATCAGTGCCTAAACCAAAACCAGATTTCTTTCTATTTCAAGCTGCCTGCCA
+ TCAATAAATAAACAAGTTGCCCATCTGCTGCGTCTGCTCCGACATCATACAATGTGCATCTGCCATCACT
+ TATCGTTCCTTGGCGGCGTTTCTATTTTTGAAACTCTCATTACCGTCAGAAACAAACTCTTTTTTCGGGC
+ ATTTAAATACAAACATTTACAGTTGAGTACTGCGGTGAAAGAAAGCGTTTCTAAACAGAATATATAATCC
+ TGATCGGAATCCTTAGCCAAGTCGATCTAGCCACTTCGCAGGTTTGCCTGTGAGCTTGGAAACTATATTA
+ TGGTTCCTGCAGTTTCTCCCTGGAACTTTCACTAGCTGAGTAAAGAGTATCTGAATTTCGACTATGGCGT
+ TCTCCCATATTATATTTAAGGTCATCATCCCATCCTATCCCATCCCATCGTATTCTTTGGGACGCAGAAA
+ ATGAACTTCAAGGAACGCGTGAGCTGCAAGTCTGAACACTAATAACAAACAGTCCATGTATACATAACAT
+ ACAACTACCAGGCAGCATGTATTTCATCTCACCTAAGGTAAAATCTCAACTACACTGAAGACGACAAATT
+ CTCTCTGCCGAACCTTTGAACATATGTATGAATAATCAATTCGTCCTCTAATCTGCTTATCAGTAAAACG
+ GTGTCAGCTTTGCTTGAATTTGCTCAAACTGCTGAGCGTTTTGATTTACTTTTAAGCAACTTTATAGTAC
+ TTTAACCGAACCGTGAAATATAAAAAGGCAAGCAGTCCTAACGTTCGTAACGTATACATATCGGTAAACT
+ TTCAATTAGTTTGGTTGGGACTTAAATTCCGGAAGAAATGTGTGTGTATTTGCGCAAATTGCAGCGAAAG
+ CTGTAATTAGAGACTCTCTCTTGATACCAATACAAGTCAAAATGGCATTTATAATGAGGTAAAGTACCCC
+ ACAACGTCATTTAATATGTACATATGTATGTGCATGTGCGCAAGTCACAACAAATGCAAGCCTCAAAGTG
+ CGGACATTAAACAATATAAATCAAATAACAAAAACTCGTAATTTTATTAGGTTTATATAAATATATTCAA
+ TATCGGTAATTGGCGTTTAGGTAATACCTACTTAAAACGTCATATTATACAAGCCTTAACCAACCCAATT
+ TACAAATTTGAAGACCATTTACTTGTTATAAATTTATGAGAACATTTCTTAAAAAAGAAAGCCCCAGCAC
+ CATTTACTTTTCGGCAAAGAGTGCATGTCGGAGTGGGGAATTGCATGCGTACCTCGAATTCCAAAGAGCG
+ GTGCCGTATTCACTTTACGCTACTTCCTCCTACTCTAACCATGCTTGATTTTTTACTTTAATTATGCATT
+ CAAAAATTGTACTCAAAACCCACTTCAGAATCATAATCATTGTTGGCTTTATTTCATGTGTATGGGCTTA
+ TTTGTAAATCATATTTAATAGACTGGGGCGCTAGTCATTCTTGACAGCCTTTCCTAGCATCAAAAGAAAA
+ CAATAGAAAGCCCTACAGTCAGTTTCCTCGACCATCAGATACCCCTCACTTACCATGTGGGTGGTCAATA
+ TTACAACCTTTTGTATACCTATAAAATCCTTACAAGATTGTGGATTTTATAATGCTATGCTCGCAAAACG
+ ATATTTTTAATAGGTAATAAAAAGCTTGCAAATTTATAAGTTTACTGTCAAGCAAACCTAAATGGTTGGG
+ TATTTCGTTTATTTAAAAAGCTGGAACTCTGTAAATCGGTTTTCCTAAAAGTATAAGTACACAGGTTGGT
+ TTATTGCGATTGGAATTTTGCGCATACCAGGTAGCAAATGGCCAGAACCTACCTGCTTCATTACATTCGC
+ TTGTCTGAATTGCAAAAACCGGTTTGATTTGTGTTGCACTTTCAGATACTGCATCTGCCTATGCGTTACA
+ CCGCGCACTTTGATCAGTTACATTTAATATCCTGCTCCACATAAAGTCTTCCAATACCACTTCAAGTGAT
+ ATAACCAACCTTGAGATACGTTCAAAAAATCTAGTTTCTCTCAAAAAAATACAGAATTACTCTCCCCATA
+ TCTTTGAATATTTTTACACTGAATTATTTGGGTCTCCAGCACCTGCCTGTTTACAAAAAGAACGACAGAC
+ CTCAGTGAAGCAGATGGACTTCCTGTTTTGTTCCTTTAAGAGGGGTCGTTTGTATTTCAGATTCGAGTTC
+ AGGAATACGACCTTTAGTTATTGGCTAAATGTGTATCTTACGGCATCCTAGTCGGCAGTGCTTAGAAGTG
+ CCTTCCAGAACAATCGCTATAAAAGCCTATGCCTGAGATTGACTCTCATATGCGGCTGATAGATCACGTG
+ CTCATACAAACTTTAAAATTGTTGTTAACCACACGCCATTTGAGAGCGGGACGGAGCACAGCTGAAGAGC
+ TGACAGGAGTAAAACCGGTTTGAGCGGCAGATGTTTCATAGCTTCCTCTTTAATGACTCATCGTTATCCT
+ TCTTGAGTCAAAATGCCGCACTTGAGTTCTTTTGGATAACGAGGAAGTCCGTAATGTAAAGAGGCAGCTG
+ AAAACGAGCCTTTATTTAGGAAAGGGAAGACAGCATTTAAAAGGGAAAAATATAAGTCGGATAAATAACT
+ TATAAATAAATTTAAATTTAAATGTTGCACATGCTTGAAGCTAAACGCTGCTTGGGAAAAGTGGTTGTCC
+ AGGGATTTTTTTACAAATAGCCAGTCCAACATAGAAACTGCATCATTGCCAAACTCACTCAAAATCCATC
+ CCCTAGGATCCTTTGAAACAGCACAACAATAACAATAAGCAGGATTGAGTGCGTCGAGCAGCCGGGTAGC
+ CGCTGAGGGATGAACTAAGATCAGTCTGAGCCAGAACAACGAACCGTACGGATACGCTCAGCGGAGTCTC
+ TCGGGACACTACATCGCGACATTGATTTCATTTAGCATTGAAACAGTATGGTTACATATCACTTTCGGTC
+ AAGCCTAACTCAGTTTAGTGTGCCACAGCTCGAAGCGCCAAGTGGCGAAAGTGCAAAGCGCAGCAAAGTG
+ CGAAAAGAAGGCAACAAGTCGAATATGAACACAAACAGTCCCAGCAAAAATGTGACTGTGAAATCGTCAC
+ AGCTATATAGGTATATAGCGCCCAGGAACCGATCCATGCTTGTCATGAAGGATCCACGGAGCATGCGAAC
+ CTTACGACGGTAAGCTGATTTGGTAGAAATGCGTTCATACGCAACTACGCCGCATTGATGAAATAGGCTT
+ CAACACACTCCTTGAACTAGGTTTTAGCGCGCTTCTTGAACTGAACATCTGCCTGATGTTGAGACCGTTT
+ TCTGGGGATCAGGGGCAAAACTGCATTCCTTCACGTATCCCAAACTTAAATGGTTTTTGTAACGAGCACG
+ CAAAGTATTCATAGCCTGCTGTTTGCTCTGCAGTTCGTTTAAAGAAAAATCATATGAGGATCGGCCCGAA
+ GGTAAAGAAAATTACAAAGATATTCCAAAGATACCCCAGGGGCACACTACCTTCTCCTCCCGCTGTCGTC
+ GTGTGAGAGGATGTCCTGTTGATTCCTAATTCCCCACCCCAGATTACCATCGGCCTTTGCTAGCATTTAG
+ GGTCGTATCTCGGTGTGTTTGTTTTCTTTGTTTCCGACGGTTCTCGAAATACTTGTTCTTTGCCTACAAT
+ AAGCATACGGAAATGGAATTCGCGAAGTTTACATAGGATTCGGTTCGAGAAAATCCTTTTTCGGCCTTTT
+ CCGAGCAACTTGTTTTTGTATTGTAAAATATACCTGCGTCACCAATTCAGGACCGTCGCCGCCACATTTT
+ CACACGCATCCGTTTGGCGAGTGGCGTAACCTTAGGAAAGATTTCTTTGAAATCTATAATTTGCTTTACA
+ AGCTGAACCCTTTTTGCCACCAAATAACAAACTACCAAAATAGTGTACATACTCTACTGACTACTTTCGT
+ TTAGACACTCAAGGCCACGGCTTCGTTCATTAAACAAAATGTTTTCTATATCTTTCAGAATGCCAAAACC
+ TGGAAGCAATGAAATGGGAACAACCAGTGACTGCGCTGCGAGTTTGGTAAGTGAAATAATTTATTGAATT
+ AGGAGTTCGGTATTACTCCAAGGCTTACTCCAAGTACTCAGCTCTGAATCTGTAGAAACTAATTCAATAG
+ CGGGGAAGTCATTCAACTCGGGCAATTAATTTTATGACAGTGTAGGAGATCTTGCCCCAAGACCAAACTT
+ TCTCTGAGCTGCCGATACCGGCAGTAAGGTGGCAGAGAGTTCAATAGACAGATCACATTTCTGCCTAAGA
+ TATTTATATAAGAAATTATCCAATGACGCGGATTCGAAAAAGCGTCGATGCAACCGCAAATCACATCGCC
+ CTGCATAACAATAGGGGCTTTCTTACTACTCCCCCGATCAATGCACTGGGCACAAAGCTACTTGCAATTT
+ ATTCACGGCAACCGCATCCCAGAAGAGTAGGGTGTCACGGTTGAGTAAATGCTACACTAAAGCCCTCACT
+ GTCTTATCTGATTCCATAAATGAGCCCGAAATATGATCTCTGTAAAAGGTGTAAAGGTCTGGTTGTGACC
+ ACCATCTTGAATGAGCGATATAATGGCGACTCGTCATTAAATCAATATCTCAATTAAGGCTTCGTTTGTT
+ GCATTTTGATTAGGTTCCCAGTCACATGCCGCTGAGCATCCTTCCATTGTTCCATGCAGGTGATGTCGAA
+ GGAAAAACTAATCACGCAAGACAAAACATGAAAACAGTCAGCCTGGCAGACTGCCATTGGTCAAGCCATC
+ AGTCTGTTGGCGAGGTCGCAGACAATAAGTTGACCCAGCCTGTGCAACAAAGGCAGACATCTGAGACAAG
+ TGGCAGAGGCCCGTGCTATGCCATTCTCGCCTTAATCTAATCAAACCACTTCCAGCGAGACTCCTGACAA
+ TAGAGCTCGCAGATAGAGTTGATCTCAAAGGCATTATGTCCCATAATGCAAGGGCCAAACTACAAGGGGT
+ CTCTACACACTTACAGCCGGGCGACGACATCAACGCTCGGCAGTAGTCGC
+
More information about the llvm-commits
mailing list