pax_global_header00006660000000000000000000000064126052244560014520gustar00rootroot0000000000000052 comment=28bcaa3ea9de8394441c0ceac5b96cf409015a10 nanopolish-0.4.0/000077500000000000000000000000001260522445600136735ustar00rootroot00000000000000nanopolish-0.4.0/.gitignore000066400000000000000000000002251260522445600156620ustar00rootroot00000000000000 # Backup files .*swp .*swo .*swm # Generated files *.o .depend nanopolish nanopolish_test # libhdf5 directories bin/ hdf5-*/ include/ lib/ share/ nanopolish-0.4.0/.gitmodules000066400000000000000000000002331260522445600160460ustar00rootroot00000000000000[submodule "htslib"] path = htslib url = https://github.com/samtools/htslib [submodule "fast5"] path = fast5 url = https://github.com/mateidavid/fast5 nanopolish-0.4.0/.travis.yml000066400000000000000000000004521260522445600160050ustar00rootroot00000000000000# travis.yml for github.com/jts/nanopolish language: cpp # Install and export newer gcc before_install: - sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test - sudo apt-get update -qq - sudo apt-get install -qq g++-4.8 script: make CXX=g++-4.8 nanopolish && make CXX=g++-4.8 test nanopolish-0.4.0/Dockerfile000066400000000000000000000003701260522445600156650ustar00rootroot00000000000000FROM centos:7 WORKDIR / RUN yum group install "Development Tools" -y RUN yum install git wget tar zlib-devel -y RUN git clone --recursive https://github.com/jts/nanopolish.git WORKDIR /nanopolish RUN make libhdf5.install nanopolish CMD ./nanopolishnanopolish-0.4.0/LICENSE000066400000000000000000000021211260522445600146740ustar00rootroot00000000000000The MIT License (MIT) Copyright (c) 2015 Ontario Institute for Cancer Research Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. nanopolish-0.4.0/Makefile000066400000000000000000000051621260522445600153370ustar00rootroot00000000000000# # Sub directories containing source code, except for the main programs SUBDIRS := src src/hmm src/thirdparty src/common src/alignment # # Set libraries, paths, flags and options # #Basic flags every build needs LIBS=-lz CXXFLAGS = -g -O3 CXXFLAGS += -std=c++11 -fopenmp CFLAGS=-O3 CXX=g++ CC=gcc HDF5=install # Check operating system, OSX doesn't have -lrt UNAME_S := $(shell uname -s) ifeq ($(UNAME_S),Linux) LIBS += -lrt endif # Default to automatically installing hdf5 ifeq ($(HDF5), install) H5_LIB=./lib/libhdf5.a H5_INCLUDE=-I./include LIBS += -ldl else # Use system-wide hdf5 H5_LIB= H5_INCLUDE= LIBS += -lhdf5 endif # Bulild and link the libhts submodule HTS_LIB=./htslib/libhts.a HTS_INCLUDE=-I./htslib # Include the header-only fast5 library FAST5_INCLUDE=-I./fast5 # Include the src subdirectories NP_INCLUDE=$(addprefix -I./, $(SUBDIRS)) # Add include flags CPPFLAGS += $(H5_INCLUDE) $(HTS_INCLUDE) $(FAST5_INCLUDE) $(NP_INCLUDE) # Main programs to build PROGRAM=nanopolish TEST_PROGRAM=nanopolish_test all: $(PROGRAM) $(TEST_PROGRAM) # # Build libhts # htslib/libhts.a: cd htslib; make # # If this library is a dependency the user wants HDF5 to be downloaded and built. # lib/libhdf5.a: wget https://www.hdfgroup.org/ftp/HDF5/releases/hdf5-1.8.14/src/hdf5-1.8.14.tar.gz tar -xzf hdf5-1.8.14.tar.gz cd hdf5-1.8.14; ./configure --enable-threadsafe --prefix=`pwd`/..; make; make install # # Source files # # Find the source files by searching subdirectories CPP_SRC := $(foreach dir, $(SUBDIRS), $(wildcard $(dir)/*.cpp)) C_SRC := $(foreach dir, $(SUBDIRS), $(wildcard $(dir)/*.c)) EXE_SRC=src/main/nanopolish.cpp src/test/nanopolish_test.cpp # Automatically generated object names CPP_OBJ=$(CPP_SRC:.cpp=.o) C_OBJ=$(C_SRC:.c=.o) # Generate dependencies PHONY=depend depend: .depend .depend: $(CPP_SRC) $(C_SRC) $(EXE_SRC) $(H5_LIB) rm -f ./.depend $(CXX) $(CXXFLAGS) $(CPPFLAGS) -MM $(CPP_SRC) $(C_SRC) > ./.depend; include .depend # Compile objects .cpp.o: $(CXX) -o $@ -c $(CXXFLAGS) $(CPPFLAGS) -fPIC $< .c.o: $(CC) -o $@ -c $(CFLAGS) -fPIC $< # Link main executable $(PROGRAM): src/main/nanopolish.o $(CPP_OBJ) $(C_OBJ) $(HTS_LIB) $(H5_LIB) $(CXX) -o $@ $(CXXFLAGS) $(CPPFLAGS) -fPIC $< $(CPP_OBJ) $(C_OBJ) $(HTS_LIB) $(H5_LIB) $(LIBS) # Link test executable $(TEST_PROGRAM): src/test/nanopolish_test.o $(CPP_OBJ) $(C_OBJ) $(HTS_LIB) $(H5_LIB) $(CXX) -o $@ $(CXXFLAGS) $(CPPFLAGS) -fPIC $< $(CPP_OBJ) $(C_OBJ) $(HTS_LIB) $(H5_LIB) $(LIBS) test: $(TEST_PROGRAM) ./$(TEST_PROGRAM) clean: rm -f nanopolish nanopolish_test $(CPP_OBJ) $(C_OBJ) src/main/nanopolish.o src/test/nanopolish_test.o nanopolish-0.4.0/README.md000066400000000000000000000051451260522445600151570ustar00rootroot00000000000000# Nanopolish [![Build Status](https://travis-ci.org/jts/nanopolish.svg?branch=master)](https://travis-ci.org/jts/nanopolish) A nanopore consensus algorithm using a signal-level hidden Markov model. ## Dependencies The program requires [libhdf5](http://www.hdfgroup.org/HDF5/release/obtain5.html) and a compiler that supports C++11. Development of the code is performed using [gcc-4.8](https://gcc.gnu.org/gcc-4.8/). libhdf5 can be automatically installed by the Makefile if you do not have it already (see below). ## Installation instructions You will need to run ```git clone --recursive https://github.com/jts/nanopolish.git``` to get the source code and submodules. You can then compile nanopolish by running: ``` make ``` This will automatically download and install libhdf5. ## Brief usage instructions The reads that are input into the HMM must be output as a ```.fa``` file by ```poretools```. This is important as ```poretools``` writes the path to the original ```.fast5``` file (containing the signal data) in the fasta header. These paths must be correct or nanopolish cannot find the events for each read. Let's say you have exported your reads to ```reads.fa``` and you want to polish ```draft.fa```. You should run: ``` make -f scripts/consensus.make READS=reads.fa ASSEMBLY=draft.fa ``` This will map the reads to the assembly with ```bwa mem -x ont2d``` and export a file mapping read names to fast5 files. You can then run ```nanopolish consensus```. It is recommended that you run this in parallel. ``` python nanopolish_makerange.py draft.fa | parallel --results nanopolish.results -P 8 nanopolish consensus -o nanopolish.{1}.fa -w {1} --r reads.pp.fa -b reads.pp.sorted.bam -g draft.fa -t 4 ``` This command will run the consensus algorithm on eight 100kbp segments of the genome at a time, using 4 threads each. Change the ```-P``` and ```--threads``` options as appropriate for the machines you have available. After all polishing jobs are complete, you can merge the individual segments together into the final assembly: ``` python nanopolish_merge.py draft.fa nanopolish.*.fa > polished.fa ``` ## To run using docker First build the image from the dockerfile: ``` docker build . ``` Note the uuid given upon successful build. Then you can run nanopolish from the image: ``` docker run -v /path/to/local/data/data/:/data/ -it :image_id ./nanopolish eventalign -r /data/reads.fa -b /data/alignments.sorted.bam -g /data/ref.fa ``` ## Credits and Thanks The fast table-driven logsum implementation was provided by Sean Eddy as public domain code. This code was originally part of [hmmer3](http://hmmer.janelia.org/). nanopolish-0.4.0/fast5/000077500000000000000000000000001260522445600147155ustar00rootroot00000000000000nanopolish-0.4.0/htslib/000077500000000000000000000000001260522445600151605ustar00rootroot00000000000000nanopolish-0.4.0/scripts/000077500000000000000000000000001260522445600153625ustar00rootroot00000000000000nanopolish-0.4.0/scripts/consensus-preprocess.pl000077500000000000000000000011331260522445600221230ustar00rootroot00000000000000#!/usr/bin/env perl # # Extract fast5 file names from a poretools fasta file and prepend an index to uniquify names # use strict; use Bio::Perl; use Getopt::Long; my $inFile = Bio::SeqIO->new(-file => $ARGV[0], '-format' => 'Fasta'); my $outFile = Bio::SeqIO->new(-fh => \*STDOUT, '-format' => 'Fasta'); open(FM, ">consensus_fast5.fofn"); my $id = 0; while(my $seq = $inFile->next_seq()) { my $in_name = $seq->display_id(); my $out_name = "$id.$in_name"; my $desc = $seq->desc(); print FM "$desc\n"; $seq->display_id($out_name); $outFile->write_seq($seq); $id++; } nanopolish-0.4.0/scripts/consensus.make000077500000000000000000000016521260522445600202500ustar00rootroot00000000000000SHELL=/bin/bash -o pipefail .SECONDARY: BWA=bwa # Get the path to the Makefile ROOT_DIR:=$(shell dirname $(realpath $(lastword $(MAKEFILE_LIST)))) # Get the name of the input file without a suffix READS_BASE=$(basename $(READS)) # # A pipeline to recompute a consensus sequence for an assembly # all: $(READS_BASE).pp.sorted.bam $(READS_BASE).pp.sorted.bam.bai # # Preprocess the reads to make a name map # and uniquify names # %.pp.fa: %.fa $(ROOT_DIR)/consensus-preprocess.pl $^ > $@ # handle .fasta too %.pp.fa: %.fasta $(ROOT_DIR)/consensus-preprocess.pl $^ > $@ # # Make bwa index files for the assembly # $(ASSEMBLY).bwt: $(ASSEMBLY) $(BWA) index $^ # # Map reads to the assembly using bwa # %.pp.bam: %.pp.fa $(ASSEMBLY).bwt $(BWA) mem -x ont2d -t 8 $(ASSEMBLY) $< | samtools view -Sb - > $@ # # Sort BAM # %.sorted.bam: %.bam samtools sort -f $^ $@ # # Index BAM # %.sorted.bam.bai: %.sorted.bam samtools index $^ nanopolish-0.4.0/scripts/nanopolish_makerange.py000066400000000000000000000010561260522445600221220ustar00rootroot00000000000000import sys from Bio import SeqIO recs = [ (rec.name, len(rec.seq)) for rec in SeqIO.parse(open(sys.argv[1]), "fasta")] # Do not change, must match nanopolish segment lengths SEGMENT_LENGTH = 10000 # Ok to change this SEGMENTS_PER_BATCH = 10 for name, length in recs: n_segments = (length / SEGMENT_LENGTH) + 1 for n in xrange(0, n_segments, SEGMENTS_PER_BATCH): if ( n + SEGMENTS_PER_BATCH) > n_segments: print "%s:%d-%d" % (name, n, n_segments) else: print "%s:%d-%d" % (name, n, n + SEGMENTS_PER_BATCH) nanopolish-0.4.0/scripts/nanopolish_merge.py000066400000000000000000000060021260522445600212630ustar00rootroot00000000000000import sys import glob from Bio import SeqIO from Bio import pairwise2 def merge_into_consensus(consensus, incoming, overlap_length): # if first segment, no overlapping needs to be done if consensus == "": return incoming or_con = consensus[-overlap_length:] or_inc = incoming[0:overlap_length] # These parameters are designed to give us the region of highest similarity # between the two sequences alignments = pairwise2.align.globalms(or_con, or_inc, 2, -10, -10, -3) best = alignments[0] aln_con, aln_inc, score, begin, end = best # We merge at the midpoint between the two aligned segments m_con = 0 m_inc = 0 assert(len(aln_con) == len(aln_inc)) for i in xrange(0, len(aln_con) / 2): a = aln_con[i] b = aln_inc[i] if a != '-': m_con += 1 if b != '-': m_inc += 1 #merged = or_con[0:m_con] + or_inc[m_inc:] debug_segment_merge = False if debug_segment_merge: print 'OR', or_con print 'OR', or_inc print 'Before trim' print aln_con print aln_inc print 'After trim' print aln_con[begin:end] print aln_inc[begin:end] print score, begin, end, m_con, m_inc print 'Merging:' print or_con[0:m_con] print or_inc[m_inc:] m_con += len(consensus) - overlap_length merged = consensus[0:m_con] + incoming[m_inc:] return merged # Make placeholder segments using the original assembly as a guide original_assembly = sys.argv[1] recs = [ (rec.name, len(rec.seq)) for rec in SeqIO.parse(open(original_assembly), "fasta")] # Do not change, must match nanopolish segment lengths SEGMENT_LENGTH = 10000 OVERLAP_LENGTH = 200 segments_by_name = dict() for name, length in recs: n_segments = (length / SEGMENT_LENGTH) + 1 segments_by_name[name] = [""] * n_segments for fn in sys.argv[2:]: for rec in SeqIO.parse(open(fn), "fasta"): (contig, segment) = rec.name.split(":") segments_by_name[contig][int(segment)] = str(rec.seq) # Confirm all segments are present segment_not_found = False for contig_name in sorted(segments_by_name.keys()): for (segment_id, sequence) in enumerate(segments_by_name[contig_name]): if sequence is "": sys.stderr.write("ERROR_MISSING %s %d\n" % (contig_name, segment_id)) segment_not_found = True if segment_not_found: sys.exit(1) # Assemble while making sure every segment is present for contig_name in sorted(segments_by_name.keys()): assembly = "" for (segment_id, sequence) in enumerate(segments_by_name[contig_name]): if sequence is "": print "ERROR, segment %d of contig %s is missing" % (segment_id, contig_name) sys.exit(1) sys.stderr.write('Merging %s %d\n' % (contig_name, segment_id)) assembly = merge_into_consensus(assembly, sequence, OVERLAP_LENGTH) # Write final assembly print(">%s\n%s\n" % (contig_name, assembly)) nanopolish-0.4.0/src/000077500000000000000000000000001260522445600144625ustar00rootroot00000000000000nanopolish-0.4.0/src/alignment/000077500000000000000000000000001260522445600164405ustar00rootroot00000000000000nanopolish-0.4.0/src/alignment/nanopolish_alignment_db.cpp000066400000000000000000000371461260522445600240340ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_alignment_db -- abstraction for working // with sets of reads/events aligned to a reference genome // #include #include #include "nanopolish_alignment_db.h" #include "htslib/faidx.h" #include "htslib/hts.h" #include "htslib/sam.h" // Various file handle and structures // needed to traverse a bam file struct BamHandles { htsFile* bam_fh; bam1_t* bam_record; hts_itr_t* itr; }; AlignmentDB::AlignmentDB(const std::string& reads_file, const std::string& reference_file, const std::string& sequence_bam, const std::string& event_bam) : m_fast5_name_map(reads_file), m_reference_file(reference_file), m_sequence_bam(sequence_bam), m_event_bam(event_bam) { _clear_region(); } AlignmentDB::~AlignmentDB() { _clear_region(); } std::string AlignmentDB::get_reference_substring(const std::string& contig, int start_position, int stop_position) const { assert(m_region_contig == contig); assert(m_region_start <= start_position); assert(m_region_end >= stop_position); return m_region_ref_sequence.substr(start_position - m_region_start, stop_position - start_position + 1); } std::vector AlignmentDB::get_read_substrings(const std::string& contig, int start_position, int stop_position) const { assert(m_region_contig == contig); assert(m_region_start <= start_position); assert(m_region_end >= stop_position); std::vector out; for(size_t i = 0; i < m_sequence_records.size(); ++i) { const SequenceAlignmentRecord& record = m_sequence_records[i]; if(record.aligned_bases.empty()) continue; int r1, r2; bool bounded = _find_by_ref_bounds(record.aligned_bases, start_position, stop_position, r1, r2); if(bounded) { out.push_back(record.sequence.substr(r1, r2 - r1 + 1)); } } return out; } std::vector AlignmentDB::get_event_subsequences(const std::string& contig, int start_position, int stop_position) const { assert(m_region_contig == contig); assert(m_region_start <= start_position); assert(m_region_end >= stop_position); std::vector out; for(size_t i = 0; i < m_event_records.size(); ++i) { const EventAlignmentRecord& record = m_event_records[i]; if(record.aligned_events.empty()) continue; HMMInputData data; data.read = record.sr; data.anchor_index = -1; // unused data.strand = record.strand; data.rc = record.rc; data.event_stride = record.stride; int e1,e2; bool bounded = _find_by_ref_bounds(record.aligned_events, start_position, stop_position, e1, e2); if(bounded) { assert(e1 >= 0); assert(e2 >= 0); data.event_start_idx = e1; data.event_stop_idx = e2; out.push_back(data); } } return out; } std::vector AlignmentDB::get_events_aligned_to(const std::string& contig, int position) const { assert(m_region_contig == contig); assert(m_region_start <= position); assert(m_region_end >= position); std::vector out; for(size_t i = 0; i < m_event_records.size(); ++i) { const EventAlignmentRecord& record = m_event_records[i]; if(record.aligned_events.empty()) continue; HMMInputData data; data.read = record.sr; data.anchor_index = -1; // unused data.strand = record.strand; data.rc = record.rc; data.event_stride = record.stride; AlignedPairConstIter start_iter; AlignedPairConstIter stop_iter; bool bounded = _find_iter_by_ref_bounds(record.aligned_events, position, position, start_iter, stop_iter); if(bounded && start_iter->ref_pos == position) { data.event_start_idx = start_iter->read_pos; data.event_stop_idx = start_iter->read_pos; out.push_back(data); } } return out; } std::vector AlignmentDB::get_variants_in_region(const std::string& contig, int start_position, int stop_position, double min_frequency, int min_depth) const { std::vector variants; std::map> map; std::vector depth(stop_position - start_position + 1, 0); size_t num_aligned_reads = 0; for(size_t i = 0; i < m_sequence_records.size(); ++i) { const SequenceAlignmentRecord& record = m_sequence_records[i]; if(record.aligned_bases.empty()) continue; AlignedPairConstIter start_iter; AlignedPairConstIter stop_iter; _find_iter_by_ref_bounds(record.aligned_bases, start_position, stop_position, start_iter, stop_iter); //printf("[%zu] iter: [%d %d] [%d %d] first: %d last: %d\n", i, start_iter->ref_pos, start_iter->read_pos, stop_iter->ref_pos, stop_iter->read_pos, // record.aligned_bases.front().ref_pos, record.aligned_bases.back().ref_pos); for(; start_iter != stop_iter; ++start_iter) { int rp = start_iter->ref_pos; char rb = m_region_ref_sequence[start_iter->ref_pos - m_region_start]; char ab = record.sequence[start_iter->read_pos]; if(rp < start_position || rp > stop_position) { continue; } // Increment depth depth[rp - start_position]++; if(rb != ab) { Variant v; v.ref_name = contig; v.ref_position = start_iter->ref_pos; v.ref_seq = rb; v.alt_seq = ab; std::string key = v.key(); auto iter = map.find(key); if(iter == map.end()) { map.insert(std::make_pair(key, std::make_pair(v, 1))); } else { iter->second.second += 1; } } } } for(auto iter = map.begin(); iter != map.end(); ++iter) { Variant& v = iter->second.first; size_t count = iter->second.second; size_t d = depth[v.ref_position - start_position]; double f = (double)count / d; if(f >= min_frequency && d >= min_depth) { v.add_info("BaseCalledReadsWithVariant", count); v.add_info("BaseCalledFrequency", f); variants.push_back(v); } } std::sort(variants.begin(), variants.end(), sortByPosition); return variants; } void AlignmentDB::load_region(const std::string& contig, int start_position, int stop_position) { // load reference fai file faidx_t *fai = fai_load(m_reference_file.c_str()); // Adjust end position to make sure we don't go out-of-range m_region_contig = contig; m_region_start = start_position; m_region_end = std::min(stop_position, faidx_seq_len(fai, contig.c_str())); // load the reference sequence for this region // its ok to use the unthreadsafe fetch_seq here since we have our own fai int fetched_len = 0; char* ref_segment = faidx_fetch_seq(fai, m_region_contig.c_str(), m_region_start, m_region_end, &fetched_len); m_region_ref_sequence = ref_segment; // load base-space alignments _load_sequence_by_region(); // load event-space alignments _load_events_by_region(); free(ref_segment); fai_destroy(fai); } void AlignmentDB::_clear_region() { // Delete the SquiggleReads for(SquiggleReadMap::iterator iter = m_squiggle_read_map.begin(); iter != m_squiggle_read_map.end(); ++iter) { delete iter->second; iter->second = NULL; } m_squiggle_read_map.clear(); m_sequence_records.clear(); m_event_records.clear(); m_region_contig = ""; m_region_start = -1; m_region_end = -1; } BamHandles _initialize_bam_itr(const std::string& bam_filename, const std::string& contig, int start_position, int stop_position) { BamHandles handles; // load bam file handles.bam_fh = sam_open(bam_filename.c_str(), "r"); assert(handles.bam_fh != NULL); // load bam index file std::string index_filename = bam_filename + ".bai"; hts_idx_t* bam_idx = bam_index_load(index_filename.c_str()); assert(bam_idx != NULL); // read the bam header to get the contig ID bam_hdr_t* hdr = sam_hdr_read(handles.bam_fh); int contig_id = bam_name2id(hdr, contig.c_str()); // Initialize iteration handles.bam_record = bam_init1(); handles.itr = sam_itr_queryi(bam_idx, contig_id, start_position, stop_position); hts_idx_destroy(bam_idx); bam_hdr_destroy(hdr); return handles; } void AlignmentDB::_load_sequence_by_region() { assert(!m_region_contig.empty()); assert(m_region_start >= 0); assert(m_region_end >= 0); BamHandles handles = _initialize_bam_itr(m_sequence_bam, m_region_contig, m_region_start, m_region_end); int result; while((result = sam_itr_next(handles.bam_fh, handles.itr, handles.bam_record)) >= 0) { SequenceAlignmentRecord seq_record; // copy sequence out of the record uint8_t* pseq = bam_get_seq(handles.bam_record); seq_record.sequence.resize(handles.bam_record->core.l_qseq); for(int i = 0; i < handles.bam_record->core.l_qseq; ++i) { seq_record.sequence[i] = seq_nt16_str[bam_seqi(pseq, i)]; } // copy read base-to-reference alignment seq_record.aligned_bases = get_aligned_pairs(handles.bam_record); m_sequence_records.push_back(seq_record); /* printf("sequence_record[%zu] prefix: %s alignstart: [%d %d]\n", m_sequence_records.size() - 1, m_sequence_records.back().sequence.substr(0, 20).c_str(), m_sequence_records.back().aligned_bases.front().ref_pos, m_sequence_records.back().aligned_bases.front().read_pos); */ } // cleanup sam_itr_destroy(handles.itr); bam_destroy1(handles.bam_record); sam_close(handles.bam_fh); } void AlignmentDB::_load_events_by_region() { assert(!m_region_contig.empty()); assert(m_region_start >= 0); assert(m_region_end >= 0); BamHandles handles = _initialize_bam_itr(m_event_bam, m_region_contig, m_region_start, m_region_end); int result; while((result = sam_itr_next(handles.bam_fh, handles.itr, handles.bam_record)) >= 0) { EventAlignmentRecord event_record; std::string full_name = bam_get_qname(handles.bam_record); // Check for the template/complement suffix bool is_template = true; size_t suffix_pos = 0; suffix_pos = full_name.find(".template"); if(suffix_pos == std::string::npos) { suffix_pos = full_name.find(".complement"); assert(suffix_pos != std::string::npos); is_template = false; } std::string read_name = full_name.substr(0, suffix_pos); std::string fast5_path = m_fast5_name_map.get_path(read_name); // Do we need to load this fast5 file? if(m_squiggle_read_map.find(read_name) == m_squiggle_read_map.end()) { m_squiggle_read_map[read_name] = new SquiggleRead(read_name, fast5_path); } event_record.sr = m_squiggle_read_map[read_name]; // extract the event stride tag which tells us whether the // event indices are increasing or decreasing assert(bam_aux_get(handles.bam_record, "ES") != NULL); int event_stride = bam_aux2i(bam_aux_get(handles.bam_record, "ES")); // copy event alignments event_record.aligned_events = get_aligned_pairs(handles.bam_record, event_stride); event_record.rc = bam_is_rev(handles.bam_record); event_record.stride = event_stride; event_record.strand = is_template ? T_IDX : C_IDX; m_event_records.push_back(event_record); /* printf("event_record[%zu] name: %s stride: %d align bounds [%d %d] [%d %d]\n", m_event_records.size() - 1, bam_get_qname(handles.bam_record), event_stride, m_event_records.back().aligned_events.front().ref_pos, m_event_records.back().aligned_events.front().read_pos, m_event_records.back().aligned_events.back().ref_pos, m_event_records.back().aligned_events.back().read_pos); */ } // cleanup sam_itr_destroy(handles.itr); bam_destroy1(handles.bam_record); sam_close(handles.bam_fh); } bool AlignmentDB::_find_iter_by_ref_bounds(const std::vector& pairs, int ref_start, int ref_stop, AlignedPairConstIter& start_iter, AlignedPairConstIter& stop_iter) const { AlignedPairRefLBComp lb_comp; start_iter = std::lower_bound(pairs.begin(), pairs.end(), ref_start, lb_comp); stop_iter = std::lower_bound(pairs.begin(), pairs.end(), ref_stop, lb_comp); if(start_iter == pairs.end() || stop_iter == pairs.end()) return false; // require at least one aligned reference base at or outside the boundary bool left_bounded = start_iter->ref_pos <= ref_start || (start_iter != pairs.begin() && (start_iter - 1)->ref_pos <= ref_start); bool right_bounded = stop_iter->ref_pos >= ref_stop || (stop_iter != pairs.end() && (stop_iter + 1)->ref_pos >= ref_start); return left_bounded && right_bounded; } bool AlignmentDB::_find_by_ref_bounds(const std::vector& pairs, int ref_start, int ref_stop, int& read_start, int& read_stop) const { AlignedPairConstIter start_iter; AlignedPairConstIter stop_iter; bool bounded = _find_iter_by_ref_bounds(pairs, ref_start, ref_stop, start_iter, stop_iter); if(bounded) { read_start = start_iter->read_pos; read_stop = stop_iter->read_pos; return true; } else { return false; } } nanopolish-0.4.0/src/alignment/nanopolish_alignment_db.h000066400000000000000000000103631260522445600234710ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_alignment_db -- abstraction for working // with sets of reads/events aligned to a reference genome // #ifndef ALIGNMENT_DB #define ALIGNMENT_DB #include #include #include #include "nanopolish_anchor.h" #include "nanopolish_variant.h" // structs struct SequenceAlignmentRecord { std::string sequence; std::vector aligned_bases; }; struct EventAlignmentRecord { SquiggleRead* sr; uint8_t rc; // with respect to reference genome uint8_t strand; // 0 = template, 1 = complement uint8_t stride; // whether event indices increase or decrease along the reference std::vector aligned_events; }; // typedefs typedef std::map SquiggleReadMap; class AlignmentDB { public: AlignmentDB(const std::string& reads_file, const std::string& reference_file, const std::string& sequence_bam, const std::string& event_bam); ~AlignmentDB(); void load_region(const std::string& contig, int start_position, int stop_position); const std::string& get_reference() const { return m_region_ref_sequence; } std::string get_reference_substring(const std::string& contig, int start_position, int stop_position) const; std::vector get_read_substrings(const std::string& contig, int start_position, int stop_position) const; std::vector get_event_subsequences(const std::string& contig, int start_position, int stop_position) const; std::vector get_events_aligned_to(const std::string& contig, int position) const; std::vector get_variants_in_region(const std::string& contig, int start_position, int stop_position, double min_frequency, int min_depth) const; int get_region_start() const { return m_region_start; } int get_region_end() const { return m_region_end; } private: void _load_sequence_by_region(); void _load_events_by_region(); void _clear_region(); // Search the vector of AlignedPairs using lower_bound/upper_bound // and the input reference coordinates. If the search succeeds, // set read_start/read_stop to be the read_pos of the bounding elements // and return true. bool _find_by_ref_bounds(const std::vector& pairs, int ref_start, int ref_stop, int& read_start, int& read_stop) const; bool _find_iter_by_ref_bounds(const std::vector& pairs, int ref_start, int ref_stop, AlignedPairConstIter& start_iter, AlignedPairConstIter& stop_iter) const; // // data // std::string m_reference_file; std::string m_sequence_bam; std::string m_event_bam; // loaded region std::string m_region_ref_sequence; std::string m_region_contig; int m_region_start; int m_region_end; // cached alignments for a region Fast5Map m_fast5_name_map; std::vector m_sequence_records; std::vector m_event_records; SquiggleReadMap m_squiggle_read_map; }; #endif nanopolish-0.4.0/src/alignment/nanopolish_anchor.cpp000066400000000000000000000265371260522445600226650ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_anchor - a collection of data types // for representing a set of event-to-sequence // mappings. #include #include #include #include #include "htslib/faidx.h" #include "nanopolish_common.h" #include "nanopolish_anchor.h" #include "nanopolish_squiggle_read.h" HMMRealignmentInput build_input_for_region(const std::string& bam_filename, const std::string& ref_filename, const Fast5Map& read_name_map, const std::string& contig_name, int start, int end, int stride) { // Initialize return data HMMRealignmentInput ret; // load bam file htsFile* bam_fh = sam_open(bam_filename.c_str(), "r"); assert(bam_fh != NULL); // load bam index file std::string index_filename = bam_filename + ".bai"; hts_idx_t* bam_idx = bam_index_load(index_filename.c_str()); assert(bam_idx != NULL); // read the bam header bam_hdr_t* hdr = sam_hdr_read(bam_fh); int contig_id = bam_name2id(hdr, contig_name.c_str()); // load reference fai file faidx_t *fai = fai_load(ref_filename.c_str()); // Adjust end position to make sure we don't go out-of-range end = std::min(end, faidx_seq_len(fai, contig_name.c_str())); // load the reference sequence for this region int fetched_len = 0; char* ref_segment = faidx_fetch_seq(fai, contig_name.c_str(), start, end, &fetched_len); ret.original_sequence = ref_segment; // Initialize iteration bam1_t* record = bam_init1(); hts_itr_t* itr = sam_itr_queryi(bam_idx, contig_id, start, end); // Iterate over reads aligned here std::vector read_anchors; std::vector> read_substrings; // kmer size of pore model uint32_t k; // Load the SquiggleReads aligned to this region and the bases // that are mapped to our reference anchoring positions int result; while((result = sam_itr_next(bam_fh, itr, record)) >= 0) { // Load a squiggle read for the mapped read std::string read_name = bam_get_qname(record); std::string fast5_path = read_name_map.get_path(read_name); // load read ret.reads.push_back(std::unique_ptr(new SquiggleRead(read_name, fast5_path))); const SquiggleRead& sr = *ret.reads.back(); k = sr.pore_model[T_IDX].k; // parse alignments to reference std::vector aligned_pairs = get_aligned_pairs(record); std::vector read_bases_for_anchors = uniformally_sample_read_positions(aligned_pairs, start, end, stride); /* for(size_t i = 0; i < read_bases_for_anchors.size(); ++i) { printf("%d ", read_bases_for_anchors[i]); } printf("\n"); */ // Convert the read base positions into event indices for both strands HMMReadAnchorSet event_anchors; event_anchors.strand_anchors[T_IDX].resize(read_bases_for_anchors.size()); event_anchors.strand_anchors[C_IDX].resize(read_bases_for_anchors.size()); bool do_base_rc = bam_is_rev(record); bool template_rc = do_base_rc; bool complement_rc = !do_base_rc; for(size_t ai = 0; ai < read_bases_for_anchors.size(); ++ai) { int read_kidx = read_bases_for_anchors[ai]; // read not aligned to this reference position if(read_kidx == -1) { continue; } if(do_base_rc) read_kidx = sr.flip_k_strand(read_kidx); // If the aligned base is beyong the start of the last k-mer of the read, skip if(read_kidx >= sr.read_sequence.size() - k + 1) { continue; } int template_idx = sr.get_closest_event_to(read_kidx, T_IDX); int complement_idx = sr.get_closest_event_to(read_kidx, C_IDX); assert(template_idx != -1 && complement_idx != -1); assert(template_idx < sr.events[T_IDX].size()); assert(complement_idx < sr.events[C_IDX].size()); event_anchors.strand_anchors[T_IDX][ai] = { template_idx, template_rc }; event_anchors.strand_anchors[C_IDX][ai] = { complement_idx, complement_rc }; // If this is not the last anchor, extract the sequence of the read // from this anchor to the next anchor as an alternative assembly if(ai < read_bases_for_anchors.size() - 1) { int start_kidx = read_bases_for_anchors[ai]; int end_kidx = read_bases_for_anchors[ai + 1]; int max_kidx = sr.read_sequence.size() - k; // flip if(do_base_rc) { start_kidx = sr.flip_k_strand(start_kidx); end_kidx = sr.flip_k_strand(end_kidx); // swap int tmp = end_kidx; end_kidx = start_kidx; start_kidx = tmp; } // clamp values within range start_kidx = start_kidx >= 0 ? start_kidx : 0; end_kidx = end_kidx <= max_kidx ? end_kidx : max_kidx; std::string s = sr.read_sequence.substr(start_kidx, end_kidx - start_kidx + k); if(do_base_rc) { s = gDNAAlphabet.reverse_complement(s); } if(ai >= read_substrings.size()) read_substrings.resize(ai + 1); read_substrings[ai].push_back(s); } } read_anchors.push_back(event_anchors); } // If there are no reads aligned to this segment return empty data if(read_anchors.empty()) { return ret; } // The HMMReadAnchorSet contains anchors for each strand of a read // laid out in a vector. Transpose this data so we have one anchor // for every read column-wise. assert(read_anchors.front().strand_anchors[T_IDX].size() == read_anchors.back().strand_anchors[T_IDX].size()); // same for all anchors, so we use the first size_t num_anchors = read_anchors.front().strand_anchors[T_IDX].size(); size_t num_strands = read_anchors.size() * 2; ret.anchored_columns.resize(num_anchors); for(size_t ai = 0; ai < num_anchors; ++ai) { HMMAnchoredColumn& column = ret.anchored_columns[ai]; for(size_t rai = 0; rai < read_anchors.size(); ++rai) { HMMReadAnchorSet& ras = read_anchors[rai]; assert(ai < ras.strand_anchors[T_IDX].size()); assert(ai < ras.strand_anchors[C_IDX].size()); column.anchors.push_back(ras.strand_anchors[T_IDX][ai]); column.anchors.push_back(ras.strand_anchors[C_IDX][ai]); } assert(column.anchors.size() == num_strands); // Add sequences except for last anchor if(ai != num_anchors - 1) { // base, these sequences need to overlap by k - 1 bases int base_length = stride + k; if(ai * stride + base_length > fetched_len) base_length = fetched_len - ai * stride; column.base_sequence = std::string(ref_segment + ai * stride, base_length); column.base_contig = contig_name; column.base_start_position = start + ai * stride; assert(column.base_sequence.back() != '\0'); // alts if(ai < read_substrings.size()) column.alt_sequences = read_substrings[ai]; } } // cleanup sam_itr_destroy(itr); bam_hdr_destroy(hdr); bam_destroy1(record); fai_destroy(fai); sam_close(bam_fh); hts_idx_destroy(bam_idx); free(ref_segment); return ret; } std::vector get_aligned_pairs(const bam1_t* record, int read_stride) { std::vector out; // This code is derived from bam_fillmd1_core uint8_t *ref = NULL; uint8_t *seq = bam_get_seq(record); uint32_t *cigar = bam_get_cigar(record); const bam1_core_t *c = &record->core; // read pos is an index into the original sequence that is present in the FASTQ // on the strand matching the reference int read_pos = 0; // query pos is an index in the query string that is recorded in the bam // we record this as a sanity check int query_pos = 0; int ref_pos = c->pos; for (int ci = 0; ci < c->n_cigar; ++ci) { int cigar_len = cigar[ci] >> 4; int cigar_op = cigar[ci] & 0xf; // Set the amount that the ref/read positions should be incremented // based on the cigar operation int read_inc = 0; int ref_inc = 0; // Process match between the read and the reference bool is_aligned = false; if(cigar_op == BAM_CMATCH || cigar_op == BAM_CEQUAL || cigar_op == BAM_CDIFF) { is_aligned = true; read_inc = read_stride; ref_inc = 1; } else if(cigar_op == BAM_CDEL || cigar_op == BAM_CREF_SKIP) { ref_inc = 1; } else if(cigar_op == BAM_CINS) { read_inc = read_stride; } else if(cigar_op == BAM_CSOFT_CLIP) { read_inc = 1; // special case, do not use read_stride } else if(cigar_op == BAM_CHARD_CLIP) { read_inc = 0; } else { printf("Cigar: %d\n", cigar_op); assert(false && "Unhandled cigar operation"); } // Iterate over the pairs of aligned bases for(int j = 0; j < cigar_len; ++j) { if(is_aligned) { out.push_back({ref_pos, read_pos}); } // increment read_pos += read_inc; ref_pos += ref_inc; } } return out; } std::vector uniformally_sample_read_positions(const std::vector& aligned_pairs, int ref_start, int ref_end, int ref_stride) { uint32_t num_anchors = ((ref_end - ref_start) / ref_stride) + 1; std::vector out(num_anchors, -1); for(size_t pair_idx = 0; pair_idx < aligned_pairs.size(); ++pair_idx) { // We use a loop here in case there is no read base // aligned to one of the anchor positions we are interested in. // In this situation the loop will catch it and emit the last seen // read position int ref_pos = aligned_pairs[pair_idx].ref_pos; int end_pos = pair_idx + 1 != aligned_pairs.size() ? aligned_pairs[pair_idx + 1].ref_pos : ref_pos + 1; for(; ref_pos < end_pos; ++ref_pos) { if(ref_pos >= ref_start && ref_pos <= ref_end && ref_pos % ref_stride == 0) { uint32_t anchor_id = (ref_pos - ref_start) / ref_stride; assert(anchor_id < num_anchors); out[anchor_id] = aligned_pairs[pair_idx].read_pos; } } } return out; } nanopolish-0.4.0/src/alignment/nanopolish_anchor.h000066400000000000000000000064211260522445600223200ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_anchor - a collection of data types // for representing a set of event-to-sequence // mappings. #ifndef NANOPOLISH_ANCHOR_H #define NANOPOLISH_ANCHOR_H #include #include "htslib/hts.h" #include "htslib/sam.h" #include "nanopolish_common.h" #include "nanopolish_squiggle_read.h" #include "nanopolish_fast5_map.h" struct AlignedPair { int ref_pos; int read_pos; }; struct AlignedPairRefLBComp { bool operator()(const AlignedPair& o, int v) { return o.ref_pos < v; } }; struct AlignedPairRefUBComp { bool operator()(int v, const AlignedPair& o) { return v < o.ref_pos; } }; // typedefs typedef std::vector::iterator AlignedPairIter; typedef std::vector::const_iterator AlignedPairConstIter; // An event index and orientation that gives us a handle // into the event sequence for some SquiggleRead struct HMMStrandAnchor { // HMMStrandAnchor() : event_idx(-1), rc(false) {} HMMStrandAnchor(int ei, bool f) : event_idx(ei), rc(f) {} // int event_idx; bool rc; // with respect to consensus }; // A pair of vectors containing all of the anchors // for both strands of a SquiggleRead struct HMMReadAnchorSet { std::vector strand_anchors[NUM_STRANDS]; }; // This data structure represents a column of a // multiple alignment where the base sequence // is a subsequence of a contig that we // we have mapped events to. It also holds alternative // sequences sampled from the reads at starting at this column. struct HMMAnchoredColumn { std::string base_sequence; std::vector anchors; std::vector alt_sequences; // reference name and coordinate for the segment std::string base_contig; size_t base_start_position; }; // struct HMMRealignmentInput { std::vector > reads; std::vector anchored_columns; std::string original_sequence; }; // functions HMMRealignmentInput build_input_for_region(const std::string& bam_filename, const std::string& ref_filename, const Fast5Map& read_name_map, const std::string& contig_name, int start, int end, int stride); // Return a vector specifying pairs of bases that have been aligned to each other // This function can handle an "event cigar" bam record, which requires the ability // for event indices to be in ascending or descending order. In the latter case // read_stride should be -1 std::vector get_aligned_pairs(const bam1_t* record, int read_stride = 1); std::vector uniformally_sample_read_positions(const std::vector& aligned_pairs, int ref_start, int ref_end, int ref_stride); #endif nanopolish-0.4.0/src/alignment/nanopolish_eventalign.cpp000066400000000000000000000753741260522445600235520ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_consensus.cpp -- entry point to consensus functions // #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "htslib/faidx.h" #include "nanopolish_eventalign.h" #include "nanopolish_iupac.h" #include "nanopolish_poremodel.h" #include "nanopolish_transition_parameters.h" #include "nanopolish_matrix.h" #include "nanopolish_profile_hmm.h" #include "nanopolish_anchor.h" #include "nanopolish_fast5_map.h" #include "nanopolish_hmm_input_sequence.h" #include "H5pubconf.h" #include "profiler.h" #include "progress.h" // // Getopt // #define SUBPROGRAM "eventalign" static const char *EVENTALIGN_VERSION_MESSAGE = SUBPROGRAM " Version " PACKAGE_VERSION "\n" "Written by Jared Simpson.\n" "\n" "Copyright 2015 Ontario Institute for Cancer Research\n"; static const char *EVENTALIGN_USAGE_MESSAGE = "Usage: " PACKAGE_NAME " " SUBPROGRAM " [OPTIONS] --reads reads.fa --bam alignments.bam --genome genome.fa\n" "Align nanopore events to reference k-mers\n" "\n" " -v, --verbose display verbose output\n" " --version display version\n" " --help display this help and exit\n" " --sam write output in SAM format\n" " -w, --window=STR compute the consensus for window STR (format: ctg:start_id-end_id)\n" " -r, --reads=FILE the 2D ONT reads are in fasta FILE\n" " -b, --bam=FILE the reads aligned to the genome assembly are in bam FILE\n" " -g, --genome=FILE the genome we are computing a consensus for is in FILE\n" " -t, --threads=NUM use NUM threads (default: 1)\n" " --scale-events scale events to the model, rather than vice-versa\n" " --progress print out a progress message\n" " -n, --print-read-names print read names instead of indexes\n" " --summary=FILE summarize the alignment of each read/strand in FILE\n" "\nReport bugs to " PACKAGE_BUGREPORT "\n\n"; namespace opt { static unsigned int verbose; static std::string reads_file; static std::string bam_file; static std::string genome_file; static std::string region; static std::string summary_file; static int output_sam = 0; static int progress = 0; static int num_threads = 1; static int scale_events = 0; static int batch_size = 128; static bool print_read_names; } static const char* shortopts = "r:b:g:t:w:vn"; enum { OPT_HELP = 1, OPT_VERSION, OPT_PROGRESS, OPT_SAM, OPT_SUMMARY, OPT_SCALE_EVENTS }; static const struct option longopts[] = { { "verbose", no_argument, NULL, 'v' }, { "reads", required_argument, NULL, 'r' }, { "bam", required_argument, NULL, 'b' }, { "genome", required_argument, NULL, 'g' }, { "window", required_argument, NULL, 'w' }, { "threads", required_argument, NULL, 't' }, { "summary", required_argument, NULL, OPT_SUMMARY }, { "print-read-names", no_argument, NULL, 'n' }, { "scale-events", no_argument, NULL, OPT_SCALE_EVENTS }, { "sam", no_argument, NULL, OPT_SAM }, { "progress", no_argument, NULL, OPT_PROGRESS }, { "help", no_argument, NULL, OPT_HELP }, { "version", no_argument, NULL, OPT_VERSION }, { NULL, 0, NULL, 0 } }; // convenience wrapper for the two output modes struct EventalignWriter { FILE* tsv_fp; htsFile* sam_fp; FILE* summary_fp; }; // Summarize the event alignment for a read strand struct EventalignSummary { EventalignSummary() { num_events = 0; num_matches = 0; num_stays = 0; num_skips = 0; sum_z_score = 0; sum_duration = 0; alignment_edit_distance = 0; reference_span = 0; } int num_events; int num_matches; int num_stays; int num_skips; double sum_duration; double sum_z_score; int alignment_edit_distance; int reference_span; }; // Modify the aligned_pairs vector to ensure the highest read position // does not exceed max_kmer void trim_aligned_pairs_to_kmer(std::vector& aligned_pairs, int max_kmer_idx) { int idx = aligned_pairs.size() - 1; while(idx >= 0 && aligned_pairs[idx].read_pos > max_kmer_idx) idx -= 1; if(idx < 0) aligned_pairs.clear(); // no valid data else aligned_pairs.resize(idx + 1); } // Modify the aligned_pairs vector to ensure there are no alignments // outside of the given reference coordinates void trim_aligned_pairs_to_ref_region(std::vector& aligned_pairs, int ref_start, int ref_end) { std::vector trimmed; for(size_t i = 0; i < aligned_pairs.size(); ++i) { if(aligned_pairs[i].ref_pos >= ref_start && aligned_pairs[i].ref_pos <= ref_end) { trimmed.push_back(aligned_pairs[i]); } } aligned_pairs.swap(trimmed); } // Returns the index into the aligned_pairs vector that has the highest ref_pos // that is not greater than ref_pos_max. It starts the search at pair_idx int get_end_pair(const std::vector& aligned_pairs, int ref_pos_max, int pair_idx) { while(pair_idx < aligned_pairs.size()) { if(aligned_pairs[pair_idx].ref_pos > ref_pos_max) return pair_idx - 1; pair_idx += 1; } return aligned_pairs.size() - 1; } // get the specified reference region, threadsafe std::string get_reference_region_ts(const faidx_t* fai, const char* ref_name, int start, int end, int* fetched_len) { // faidx_fetch_seq is not threadsafe char* cref_seq; #pragma omp critical cref_seq = faidx_fetch_seq(fai, ref_name, start, end, fetched_len); assert(cref_seq != NULL); std::string out(cref_seq); free(cref_seq); return out; } // // // void emit_tsv_header(FILE* fp) { fprintf(fp, "%s\t%s\t%s\t%s\t%s\t", "contig", "position", "reference_kmer", (not opt::print_read_names? "read_index" : "read_name"), "strand"); fprintf(fp, "%s\t%s\t%s\t%s\t", "event_index", "event_level_mean", "event_stdv", "event_length"); fprintf(fp, "%s\t%s\t%s\t%s\n", "model_kmer", "model_mean", "model_stdv"); } void emit_sam_header(samFile* fp, const bam_hdr_t* hdr) { sam_hdr_write(fp, hdr); } std::string cigar_ops_to_string(const std::vector& ops) { std::stringstream ss; for(size_t i = 0; i < ops.size(); ++i) { ss << bam_cigar_oplen(ops[i]); ss << BAM_CIGAR_STR[bam_cigar_op(ops[i])]; } return ss.str(); } std::vector event_alignment_to_cigar(const std::vector& alignments) { std::vector out; // add a softclip tag to account for unaligned events at the beginning/end of the read if(alignments[0].event_idx > 0) { out.push_back(alignments[0].event_idx << BAM_CIGAR_SHIFT | BAM_CSOFT_CLIP); } // we always start with a match out.push_back(1 << BAM_CIGAR_SHIFT | BAM_CMATCH); int prev_r_idx = alignments[0].ref_position; int prev_e_idx = alignments[0].event_idx; size_t ai = 1; while(ai < alignments.size()) { int r_idx = alignments[ai].ref_position; int e_idx = alignments[ai].event_idx; int r_step = abs(r_idx - prev_r_idx); int e_step = abs(e_idx - prev_e_idx); uint32_t incoming; if(r_step == 1 && e_step == 1) { // regular match incoming = 1 << BAM_CIGAR_SHIFT; incoming |= BAM_CMATCH; } else if(r_step > 1) { assert(e_step == 1); // reference jump of more than 1, this is how deletions are represented // we push the deletion onto the output then start a new match incoming = (r_step - 1) << BAM_CIGAR_SHIFT; incoming |= BAM_CDEL; out.push_back(incoming); incoming = 1 << BAM_CIGAR_SHIFT; incoming |= BAM_CMATCH; } else { assert(e_step == 1 && r_step == 0); incoming = 1 << BAM_CIGAR_SHIFT; incoming |= BAM_CINS; } // If the operation matches the previous, extend the length // otherwise append a new op if(bam_cigar_op(out.back()) == bam_cigar_op(incoming)) { uint32_t sum = bam_cigar_oplen(out.back()) + bam_cigar_oplen(incoming); out.back() = sum << BAM_CIGAR_SHIFT | bam_cigar_op(incoming); } else { out.push_back(incoming); } prev_r_idx = r_idx; prev_e_idx = e_idx; ai++; } return out; } void emit_event_alignment_sam(htsFile* fp, const SquiggleRead& sr, const bam_hdr_t* base_hdr, const bam1_t* base_record, const std::vector& alignments) { assert(!alignments.empty()); bam1_t* event_record = bam_init1(); // Variable-length data std::string qname = sr.read_name + (alignments.front().strand_idx == 0 ? ".template" : ".complement"); // basic stats event_record->core.tid = base_record->core.tid; event_record->core.pos = alignments.front().ref_position; event_record->core.qual = base_record->core.qual; event_record->core.l_qname = qname.length() + 1; // must be null-terminated event_record->core.flag = alignments.front().rc ? 16 : 0; event_record->core.l_qseq = 0; event_record->core.mtid = -1; event_record->core.mpos = -1; event_record->core.isize = 0; std::vector cigar = event_alignment_to_cigar(alignments); event_record->core.n_cigar = cigar.size(); // calculate length of incoming data event_record->m_data = event_record->core.l_qname + // query name event_record->core.n_cigar * 4 + // 4 bytes per cigar op event_record->core.l_qseq + // query seq event_record->core.l_qseq; // query quality // nothing copied yet event_record->l_data = 0; // allocate data event_record->data = (uint8_t*)malloc(event_record->m_data); // copy q name assert(event_record->core.l_qname <= event_record->m_data); strncpy(bam_get_qname(event_record), qname.c_str(), event_record->core.l_qname); event_record->l_data += event_record->core.l_qname; // cigar assert(event_record->l_data + event_record->core.n_cigar * 4 <= event_record->m_data); memcpy(bam_get_cigar(event_record), &cigar[0], event_record->core.n_cigar * 4); event_record->l_data += event_record->core.n_cigar * 4; // no copy for seq and qual assert(event_record->l_data <= event_record->m_data); int stride = alignments.front().event_idx < alignments.back().event_idx ? 1 : -1; bam_aux_append(event_record, "ES", 'i', 4, reinterpret_cast(&stride)); sam_write1(fp, base_hdr, event_record); bam_destroy1(event_record); // automatically frees malloc'd segment } void emit_event_alignment_tsv(FILE* fp, const SquiggleRead& sr, uint32_t strand_idx, const EventAlignmentParameters& params, const std::vector& alignments) { uint32_t k = sr.pore_model[strand_idx].k; for(size_t i = 0; i < alignments.size(); ++i) { const EventAlignment& ea = alignments[i]; // basic information if (not opt::print_read_names) { fprintf(fp, "%s\t%d\t%s\t%zu\t%c\t", ea.ref_name.c_str(), ea.ref_position, ea.ref_kmer.c_str(), ea.read_idx, "tc"[ea.strand_idx]); } else { fprintf(fp, "%s\t%d\t%s\t%s\t%c\t", ea.ref_name.c_str(), ea.ref_position, ea.ref_kmer.c_str(), sr.read_name.c_str(), "tc"[ea.strand_idx]); } // event information float event_mean = sr.get_drift_corrected_level(ea.event_idx, ea.strand_idx); float event_stdv = sr.get_event_stdv(ea.event_idx, ea.strand_idx); float event_duration = sr.get_duration(ea.event_idx, ea.strand_idx); if(opt::scale_events) { // scale reads to the model event_mean = (event_mean - sr.pore_model[ea.strand_idx].shift) / sr.pore_model[ea.strand_idx].scale; fprintf(fp, "%d\t%.2lf\t%.3lf\t%.3lf\t", ea.event_idx, event_mean, event_stdv, event_duration); // unscaled parameters uint32_t rank = params.alphabet->kmer_rank(ea.model_kmer.c_str(), k); PoreModelStateParams model = sr.pore_model[ea.strand_idx].get_parameters(rank); fprintf(fp, "%s\t%.2lf\t%.2lf\n", ea.model_kmer.c_str(), model.level_mean, model.level_stdv); } else { // scale model to the reads float event_mean = sr.get_drift_corrected_level(ea.event_idx, ea.strand_idx); float event_duration = sr.get_duration(ea.event_idx, ea.strand_idx); fprintf(fp, "%d\t%.2lf\t%.3lf\t%.3lf\t", ea.event_idx, event_mean, event_stdv, event_duration); uint32_t rank = params.alphabet->kmer_rank(ea.model_kmer.c_str(), k); GaussianParameters model = sr.pore_model[ea.strand_idx].get_scaled_parameters(rank); fprintf(fp, "%s\t%.2lf\t%.2lf\n", ea.model_kmer.c_str(), model.mean, model.stdv); } } } EventalignSummary summarize_alignment(const SquiggleRead& sr, uint32_t strand_idx, const EventAlignmentParameters& params, const std::vector& alignments) { EventalignSummary summary; uint32_t k = sr.pore_model[strand_idx].k; size_t prev_ref_pos = std::string::npos; // the number of unique reference positions seen in the alignment size_t num_unique_ref_pos = 0; for(size_t i = 0; i < alignments.size(); ++i) { const EventAlignment& ea = alignments[i]; summary.num_events += 1; // movement information size_t ref_move = ea.ref_position - prev_ref_pos; if(ref_move == 0) { assert(ea.hmm_state == 'E'); summary.num_stays += 1; } else if(i != 0 && ref_move > 1) { summary.num_skips += 1; } // event information summary.sum_duration += sr.get_duration(ea.event_idx, ea.strand_idx); if(ea.hmm_state == 'M') { summary.num_matches += 1; uint32_t rank = params.alphabet->kmer_rank(ea.model_kmer.c_str(), k); GaussianParameters model = sr.pore_model[ea.strand_idx].get_scaled_parameters(rank); float event_mean = sr.get_drift_corrected_level(ea.event_idx, ea.strand_idx); double z = (event_mean - model.mean) / model.stdv; summary.sum_z_score += z; } prev_ref_pos = ea.ref_position; } int nm = bam_aux2i(bam_aux_get(params.record, "NM")); summary.alignment_edit_distance = nm; if(!alignments.empty()) { summary.reference_span = alignments.back().ref_position - alignments.front().ref_position + 1; } return summary; } // Realign the read in event space void realign_read(EventalignWriter writer, const Fast5Map& name_map, const faidx_t* fai, const bam_hdr_t* hdr, const bam1_t* record, size_t read_idx, int region_start, int region_end) { // Load a squiggle read for the mapped read std::string read_name = bam_get_qname(record); std::string fast5_path = name_map.get_path(read_name); // load read SquiggleRead sr(read_name, fast5_path); if(opt::verbose > 1) { fprintf(stderr, "Realigning %s [%zu %zu]\n", read_name.c_str(), sr.events[0].size(), sr.events[1].size()); } for(int strand_idx = 0; strand_idx < 2; ++strand_idx) { EventAlignmentParameters params; params.sr = &sr; params.fai = fai; params.hdr = hdr; params.record = record; params.strand_idx = strand_idx; params.read_idx = read_idx; params.region_start = region_start; params.region_end = region_end; std::vector alignment = align_read_to_ref(params); EventalignSummary summary; if(writer.summary_fp != NULL) { summary = summarize_alignment(sr, strand_idx, params, alignment); } // write to disk #pragma omp critical { if(opt::output_sam) { emit_event_alignment_sam(writer.sam_fp, sr, hdr, record, alignment); } else { emit_event_alignment_tsv(writer.tsv_fp, sr, strand_idx, params, alignment); } if(writer.summary_fp != NULL && summary.num_events > 0) { fprintf(writer.summary_fp, "%zu\t%s\t%s\t", read_idx, read_name.c_str(), sr.fast5_path.c_str()); fprintf(writer.summary_fp, "%s\t%s\t", sr.pore_model[strand_idx].name.c_str(), strand_idx == 0 ? "template" : "complement"); fprintf(writer.summary_fp, "%d\t%d\t%d\t%d\t", summary.num_events, summary.num_matches, summary.num_skips, summary.num_stays); fprintf(writer.summary_fp, "%.2lf\n", summary.sum_duration); } } } } std::vector align_read_to_ref(const EventAlignmentParameters& params) { // Sanity check input parameters assert(params.sr != NULL); assert(params.fai != NULL); assert(params.hdr != NULL); assert(params.record != NULL); assert(params.strand_idx < NUM_STRANDS); assert( (params.region_start == -1 && params.region_end == -1) || (params.region_start <= params.region_end)); std::vector alignment_output; // Extract the reference subsequence for the entire alignment int fetched_len = 0; int ref_offset = params.record->core.pos; std::string ref_name(params.hdr->target_name[params.record->core.tid]); std::string ref_seq = get_reference_region_ts(params.fai, ref_name.c_str(), ref_offset, bam_endpos(params.record), &fetched_len); // k from read pore model const uint32_t k = params.sr->pore_model[params.strand_idx].k; // If the reference sequence contains ambiguity codes // switch them to the lexicographically lowest base ref_seq = params.alphabet->disambiguate(ref_seq); std::string rc_ref_seq = params.alphabet->reverse_complement(ref_seq); if(ref_offset == 0) return alignment_output; // Make a vector of aligned (ref_pos, read_pos) pairs std::vector aligned_pairs = get_aligned_pairs(params.record); if(params.region_start != -1 && params.region_end != -1) { trim_aligned_pairs_to_ref_region(aligned_pairs, params.region_start, params.region_end); } // Trim the aligned pairs to be within the range of the maximum kmer index int max_kmer_idx = params.sr->read_sequence.size() - k; trim_aligned_pairs_to_kmer(aligned_pairs, max_kmer_idx); if(aligned_pairs.empty()) return alignment_output; bool do_base_rc = bam_is_rev(params.record); bool rc_flags[2] = { do_base_rc, !do_base_rc }; // indexed by strand const int align_stride = 100; // approximately how many reference bases to align to at once const int output_stride = 50; // approximately how many event alignments to output at once // get the event range of the read to re-align int read_kidx_start = aligned_pairs.front().read_pos; int read_kidx_end = aligned_pairs.back().read_pos; if(do_base_rc) { read_kidx_start = params.sr->flip_k_strand(read_kidx_start); read_kidx_end = params.sr->flip_k_strand(read_kidx_end); } assert(read_kidx_start >= 0); assert(read_kidx_end >= 0); int first_event = params.sr->get_closest_event_to(read_kidx_start, params.strand_idx); int last_event = params.sr->get_closest_event_to(read_kidx_end, params.strand_idx); bool forward = first_event < last_event; int last_event_output = -1; int curr_start_event = first_event; int curr_start_ref = aligned_pairs.front().ref_pos; int curr_pair_idx = 0; while( (forward && curr_start_event < last_event) || (!forward && curr_start_event > last_event)) { // Get the index of the aligned pair approximately align_stride away int end_pair_idx = get_end_pair(aligned_pairs, curr_start_ref + align_stride, curr_pair_idx); int curr_end_ref = aligned_pairs[end_pair_idx].ref_pos; int curr_end_read = aligned_pairs[end_pair_idx].read_pos; if(do_base_rc) { curr_end_read = params.sr->flip_k_strand(curr_end_read); } assert(curr_end_read >= 0); int s = curr_start_ref - ref_offset; int l = curr_end_ref - curr_start_ref + 1; std::string fwd_subseq = ref_seq.substr(s, l); std::string rc_subseq = rc_ref_seq.substr(ref_seq.length() - s - l, l); assert(fwd_subseq.length() == rc_subseq.length()); HMMInputSequence hmm_sequence(fwd_subseq, rc_subseq, params.alphabet); // Nothing to align to if(hmm_sequence.length() < k) break; // Set up HMM input HMMInputData input; input.read = params.sr; input.anchor_index = 0; // not used here input.event_start_idx = curr_start_event; input.event_stop_idx = params.sr->get_closest_event_to(curr_end_read, params.strand_idx); // A limitation of the segment-by-segment alignment is that we can't jump // over very large deletions wrt to the reference. The effect of this // is that we can get segments that have very few alignable events. We // just stop processing them for now if(abs(input.event_start_idx - input.event_stop_idx) < 2) break; input.strand = params.strand_idx; input.event_stride = input.event_start_idx < input.event_stop_idx ? 1 : -1; input.rc = rc_flags[params.strand_idx]; std::vector event_alignment = profile_hmm_align(hmm_sequence, input); // Output alignment size_t num_output = 0; size_t event_align_idx = 0; // If we aligned to the last event, output everything and stop bool last_section = end_pair_idx == aligned_pairs.size() - 1; int last_event_output = 0; int last_ref_kmer_output = 0; for(; event_align_idx < event_alignment.size() && (num_output < output_stride || last_section); event_align_idx++) { HMMAlignmentState& as = event_alignment[event_align_idx]; if(as.state != 'K' && as.event_idx != curr_start_event) { EventAlignment ea; // ref ea.ref_name = ref_name; ea.ref_position = curr_start_ref + as.kmer_idx; ea.ref_kmer = ref_seq.substr(ea.ref_position - ref_offset, k); // event ea.read_idx = params.read_idx; ea.strand_idx = params.strand_idx; ea.event_idx = as.event_idx; ea.rc = input.rc; // hmm ea.model_kmer = hmm_sequence.get_kmer(as.kmer_idx, k, input.rc); ea.hmm_state = as.state; // store alignment_output.push_back(ea); // update last_event_output = as.event_idx; last_ref_kmer_output = curr_start_ref + as.kmer_idx; num_output += 1; } } // Advance the pair iterator to the ref base curr_start_event = last_event_output; curr_start_ref = last_ref_kmer_output; curr_pair_idx = get_end_pair(aligned_pairs, curr_start_ref, curr_pair_idx); #if EVENTALIGN_TRAIN // update training data for read params.sr->parameters[params.strand_idx].add_training_from_alignment(hmm_sequence, input, event_alignment); global_training[params.strand_idx].add_training_from_alignment(hmm_sequence, input, event_alignment); #endif } // for segment return alignment_output; } void parse_eventalign_options(int argc, char** argv) { bool die = false; for (char c; (c = getopt_long(argc, argv, shortopts, longopts, NULL)) != -1;) { std::istringstream arg(optarg != NULL ? optarg : ""); switch (c) { case 'r': arg >> opt::reads_file; break; case 'g': arg >> opt::genome_file; break; case 'b': arg >> opt::bam_file; break; case '?': die = true; break; case 't': arg >> opt::num_threads; break; case 'n': opt::print_read_names = true; break; case 'v': opt::verbose++; break; case OPT_SCALE_EVENTS: opt::scale_events = true; break; case OPT_SUMMARY: arg >> opt::summary_file; break; case OPT_SAM: opt::output_sam = true; break; case OPT_PROGRESS: opt::progress = true; break; case OPT_HELP: std::cout << EVENTALIGN_USAGE_MESSAGE; exit(EXIT_SUCCESS); case OPT_VERSION: std::cout << EVENTALIGN_VERSION_MESSAGE; exit(EXIT_SUCCESS); } } if(argc - optind > 0) { opt::region = argv[optind++]; } if (argc - optind > 0) { std::cerr << SUBPROGRAM ": too many arguments\n"; die = true; } if(opt::num_threads <= 0) { std::cerr << SUBPROGRAM ": invalid number of threads: " << opt::num_threads << "\n"; die = true; } if(opt::reads_file.empty()) { std::cerr << SUBPROGRAM ": a --reads file must be provided\n"; die = true; } if(opt::genome_file.empty()) { std::cerr << SUBPROGRAM ": a --genome file must be provided\n"; die = true; } if(opt::bam_file.empty()) { std::cerr << SUBPROGRAM ": a --bam file must be provided\n"; die = true; } if (die) { std::cout << "\n" << EVENTALIGN_USAGE_MESSAGE; exit(EXIT_FAILURE); } } int eventalign_main(int argc, char** argv) { parse_eventalign_options(argc, argv); omp_set_num_threads(opt::num_threads); Fast5Map name_map(opt::reads_file); // Open the BAM and iterate over reads // load bam file htsFile* bam_fh = sam_open(opt::bam_file.c_str(), "r"); assert(bam_fh != NULL); // load bam index file std::string index_filename = opt::bam_file + ".bai"; hts_idx_t* bam_idx = bam_index_load(index_filename.c_str()); assert(bam_idx != NULL); // read the bam header bam_hdr_t* hdr = sam_hdr_read(bam_fh); // load reference fai file faidx_t *fai = fai_load(opt::genome_file.c_str()); hts_itr_t* itr; // If processing a region of the genome, only emit events aligned to this window int clip_start = -1; int clip_end = -1; if(opt::region.empty()) { // TODO: is this valid? itr = sam_itr_queryi(bam_idx, HTS_IDX_START, 0, 0); } else { fprintf(stderr, "Region: %s\n", opt::region.c_str()); itr = sam_itr_querys(bam_idx, hdr, opt::region.c_str()); hts_parse_reg(opt::region.c_str(), &clip_start, &clip_end); } #ifndef H5_HAVE_THREADSAFE if(opt::num_threads > 1) { fprintf(stderr, "You enabled multi-threading but you do not have a threadsafe HDF5\n"); fprintf(stderr, "Please recompile nanopolish's built-in libhdf5 or run with -t 1\n"); exit(1); } #endif // Initialize output EventalignWriter writer = { NULL, NULL, NULL }; if(opt::output_sam) { writer.sam_fp = hts_open("-", "w"); emit_sam_header(writer.sam_fp, hdr); } else { writer.tsv_fp = stdout; emit_tsv_header(writer.tsv_fp); } if(!opt::summary_file.empty()) { writer.summary_fp = fopen(opt::summary_file.c_str(), "w"); // header fprintf(writer.summary_fp, "read_index\tread_name\tfast5_path\tmodel_name\tstrand\tnum_events\t"); fprintf(writer.summary_fp, "num_matches\tnum_skips\tnum_stays\ttotal_duration\n"); } // Initialize iteration std::vector records(opt::batch_size, NULL); for(size_t i = 0; i < records.size(); ++i) { records[i] = bam_init1(); } int result; size_t num_reads_realigned = 0; size_t num_records_buffered = 0; Progress progress("[eventalign]"); do { assert(num_records_buffered < records.size()); // read a record into the next slot in the buffer result = sam_itr_next(bam_fh, itr, records[num_records_buffered]); num_records_buffered += result >= 0; // realign if we've hit the max buffer size or reached the end of file if(num_records_buffered == records.size() || result < 0) { #pragma omp parallel for for(size_t i = 0; i < num_records_buffered; ++i) { bam1_t* record = records[i]; size_t read_idx = num_reads_realigned + i; if( (record->core.flag & BAM_FUNMAP) == 0) { realign_read(writer, name_map, fai, hdr, record, read_idx, clip_start, clip_end); } } num_reads_realigned += num_records_buffered; num_records_buffered = 0; } if(opt::progress) { fprintf(stderr, "Realigned %zu reads in %.1lfs\r", num_reads_realigned, progress.get_elapsed_seconds()); } } while(result >= 0); assert(num_records_buffered == 0); // cleanup records for(size_t i = 0; i < records.size(); ++i) { bam_destroy1(records[i]); } // cleanup sam_itr_destroy(itr); bam_hdr_destroy(hdr); fai_destroy(fai); sam_close(bam_fh); hts_idx_destroy(bam_idx); if(writer.sam_fp != NULL) { hts_close(writer.sam_fp); } if(writer.summary_fp != NULL) { fclose(writer.summary_fp); } return EXIT_SUCCESS; } nanopolish-0.4.0/src/alignment/nanopolish_eventalign.h000066400000000000000000000040301260522445600231740ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_eventalign.cpp -- align squiggle events // to kmers of a sequence // #ifndef NANOPOLISH_EVENTALIGN_H #define NANOPOLISH_EVENTALIGN_H #include "htslib/faidx.h" #include "htslib/sam.h" #include "nanopolish_alphabet.h" #include "nanopolish_common.h" // // Structs // struct EventAlignmentParameters { EventAlignmentParameters() { sr = NULL; fai = NULL; hdr = NULL; record = NULL; strand_idx = NUM_STRANDS; alphabet = &gDNAAlphabet; read_idx = -1; region_start = -1; region_end = -1; } // Mandatory SquiggleRead* sr; const faidx_t* fai; const bam_hdr_t* hdr; const bam1_t* record; size_t strand_idx; // optional Alphabet* alphabet; int read_idx; int region_start; int region_end; }; struct EventAlignment { // ref data std::string ref_name; std::string ref_kmer; int ref_position; // event data size_t read_idx; int strand_idx; int event_idx; bool rc; // hmm data std::string model_kmer; char hmm_state; }; // Entry point from nanopolish.cpp int eventalign_main(int argc, char** argv); // print the alignment as a tab-separated table void emit_event_alignment_tsv(FILE* fp, const SquiggleRead& sr, uint32_t strand_idx, const EventAlignmentParameters& params, const std::vector& alignments); // The main function to realign a read std::vector align_read_to_ref(const EventAlignmentParameters& params); // get the specified reference region, threadsafe std::string get_reference_region_ts(const faidx_t* fai, const char* ref_name, int start, int end, int* fetched_len); #endif nanopolish-0.4.0/src/common/000077500000000000000000000000001260522445600157525ustar00rootroot00000000000000nanopolish-0.4.0/src/common/logsum.cpp000066400000000000000000000320031260522445600177620ustar00rootroot00000000000000/* p7_FLogsum() function used in the Forward() algorithm. * * Contents: * 1. Floating point log sum. * 2. Benchmark driver. * 3. Unit tests. * 4. Test driver. * 5. Example. * 6. Copyright and license information. * * Exegesis: * * Internally, HMMER3 profile scores are in nats: floating point * log-odds probabilities, with the log odds taken relative to * background residue frequencies, and the log to the base e. * * The Forward algorithm needs to calculate sums of probabilities. * Given two log probabilities A and B, where s1 = \log * \frac{a}{f}, and s2 = \log \frac{b}{g}, we need to * calculate C = \log \frac{a + b}{h}. * * The Forward algorithm guarantees that the null model denominator * terms f = g = h, because it is always concerned with summing terms * that describe different parses of the same target sequence prefix, * and the product of the background frequencies for the same sequence * prefix is a constant. * * The naive solution is C = log(e^{A} + e^{B}), but this requires * expensive calls to log() and exp(). * * A better solution is C = A + log(1 + e^{-(A-B)}), for A >= B. For * sufficiently small B << A, e^-{A-B} becomes less than the * machine's FLT_EPSILON, and C ~= A. (This is at about (A-B) > * -15.9, for the typical FLT_EPSILON of 1.2e-7.) * * With some loss of accuracy [1], we can precalculate log(1 + * e^{-(A-B)}) for a discretized range of differences (A-B), and * compute C = A + table_lookup(A-B). This is what HMMER's * p7_FLogsum() function does. * * This only applies to the generic (serial) implementation. * See footnote [2] for discussion of why we remain unable to * implement an efficient log-space SIMD vector implementation of * Forward. */ #include #include "logsum.h" // storage float flogsum_lookup[p7_LOGSUM_TBL]; /* p7_LOGSUM_TBL=16000: (A-B) = 0..16 nats, steps of 0.001 */ /***************************************************************** *# 1. floating point log sum *****************************************************************/ // Initialize the lookup table used in p7_FLogsum int p7_FLogsumInit(void) { static int firsttime = TRUE; if (!firsttime) return eslOK; firsttime = FALSE; int i; for (i = 0; i < p7_LOGSUM_TBL; i++) { flogsum_lookup[i] = log(1. + exp((double) -i / p7_LOGSUM_SCALE)); } return eslOK; } /* Function: p7_FLogsumError() * Synopsis: Compute absolute error in probability from Logsum. * * Purpose: Compute the absolute error in probability space * resulting from 's table lookup * approximation: approximation result - exact result. * * This is of course computable analytically for * any given ; but the function * is useful for some routines that want to determine * if has been compiled in its * exact slow mode for debugging purposes. Testing * 0.0001> * for example, suffices to detect that the function * is compiled in its fast approximation mode given * the defaults. */ float p7_FLogsumError(float a, float b) { float approx = p7_FLogsum(a,b); float exact = log(exp(a) + exp(b)); return (exp(approx) - exp(exact)); } /***************************************************************** * 2. Benchmark driver. *****************************************************************/ #ifdef p7LOGSUM_BENCHMARK /* gcc -o logsum_benchmark -g -O2 -I. -L. -I../easel -L../easel -Dp7LOGSUM_BENCHMARK logsum.c -leasel -lm * ./logsum_benchmark */ /* A table-driven FLogsum() is about 20x faster than a direct * C = A + log(1+e^{-(A-B)}) implementation, "naive2()": * time/call clocks/call * naive1: 110 nsec 250 SRE:J8/71 10 Aug 2011 * naive2: 87 nsec 200 MacOS/X desktop, default build (gcc -O3), 2.26 GHz Xeon * FLogsum(): 4 nsec 9 * * Times in units of nanoseconds/iteration: cpu time * 10 * based on default 1e8 iterations (-N 100000000). * Clocks based on 2.26GHz = 2.26 clocks/nsec */ #include "p7_config.h" #include #include "easel.h" #include "esl_getopts.h" #include "esl_random.h" #include "esl_stopwatch.h" #include "hmmer.h" static ESL_OPTIONS options[] = { /* name type default env range toggles reqs incomp help docgroup*/ { "-h", eslARG_NONE, NULL, NULL, NULL, NULL, NULL, NULL, "show brief help on version and usage", 0 }, { "-n", eslARG_NONE, NULL, NULL, NULL, NULL, NULL, NULL, "naive time: A + log(1+exp(-(A-B)))", 0 }, { "-r", eslARG_NONE, NULL, NULL, NULL, NULL, NULL, NULL, "really naive time: log(exp(A)+exp(B))", 0 }, { "-s", eslARG_INT, "42", NULL, NULL, NULL, NULL, NULL, "set random number seed to ", 0 }, { "-v", eslARG_NONE, NULL, NULL, NULL, NULL, NULL, NULL, "be verbose: show individual results", 0 }, { "-N", eslARG_INT,"100000000",NULL,"n>0", NULL, NULL, NULL, "number of trials", 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, }; static char usage[] = "[-options]"; static char banner[] = "benchmark driver for logsum functions()"; static float naive1(float s1, float s2) { return log(exp(s1) + exp(s2)); } static float naive2(float s1, float s2) { if (s1 > s2) return s1 + log(1 + exp(s2-s1)); else return s2 + log(1 + exp(s1-s2)); } int main(int argc, char **argv) { ESL_GETOPTS *go = p7_CreateDefaultApp(options, 0, argc, argv, banner, usage); ESL_RANDOMNESS *r = esl_randomness_CreateFast(esl_opt_GetInteger(go, "-s")); ESL_STOPWATCH *w = esl_stopwatch_Create(); int N = esl_opt_GetInteger(go, "-N"); int i; float *A, *B, *C; p7_FLogsumInit(); /* Create the problem: sample N values A,B on interval -1000,1000: about the range of H3 scores */ A = malloc(sizeof(float) * N); B = malloc(sizeof(float) * N); C = malloc(sizeof(float) * N); for (i = 0; i < N; i++) { A[i] = esl_random(r) * 2000. - 1000.; B[i] = esl_random(r) * 2000. - 1000.; } /* Run */ esl_stopwatch_Start(w); if (esl_opt_GetBoolean(go, "-n")) { for (i = 0; i < N; i++) C[i] = naive2(A[i], B[i]); } else if (esl_opt_GetBoolean(go, "-r")) { for (i = 0; i < N; i++) C[i] = naive1(A[i], B[i]); } else { for (i = 0; i < N; i++) C[i] = p7_FLogsum(A[i], B[i]); } esl_stopwatch_Stop(w); esl_stopwatch_Display(stdout, w, "# CPU time: "); esl_stopwatch_Destroy(w); esl_randomness_Destroy(r); esl_getopts_Destroy(go); return 0; } #endif /*p7LOGSUM_BENCHMARK*/ /*-------------------- end, benchmark ---------------------------*/ /***************************************************************** * 3. Unit tests *****************************************************************/ #ifdef p7LOGSUM_TESTDRIVE #include "easel.h" #include "esl_getopts.h" #include "esl_random.h" static void utest_FLogsumError(ESL_GETOPTS *go, ESL_RANDOMNESS *r) { int N = esl_opt_GetInteger(go, "-N"); float maxval = esl_opt_GetReal(go, "-S"); int be_verbose = esl_opt_GetBoolean(go, "-v"); float maxerr = 0.0; float avgerr = 0.0; int i; float a,b,result,exact,err; for (i = 0; i < N; i++) { a = (esl_random(r) - 0.5) * maxval * 2.; /* uniform draws on -maxval..maxval */ b = (esl_random(r) - 0.5) * maxval * 2.; exact = log(exp(a) + exp(b)); result = p7_FLogsum(a,b); err = fabs(exact-result) / maxval; avgerr += err; maxerr = ESL_MAX(maxerr, err); if (be_verbose) printf("%8.4f %8.4f %8.4f %8.4f %8.4f\n", a, b, exact, result, err); } avgerr /= (float) N; if (be_verbose) { printf("average error = %f\n", avgerr); printf("max error = %f\n", maxerr); } if (maxerr > 0.0001) esl_fatal("maximum error of %f is too high: logsum unit test fails", maxerr); if (avgerr > 0.0001) esl_fatal("average error of %f is too high: logsum unit test fails", avgerr); } static void utest_FLogsumSpecials(void) { char *msg = "logsum specials unit test failed"; if (p7_FLogsum(0.0, -eslINFINITY) != 0.0) esl_fatal(msg); if (p7_FLogsum(-eslINFINITY, 0.0) != 0.0) esl_fatal(msg); if (p7_FLogsum(-eslINFINITY, -eslINFINITY) != -eslINFINITY) esl_fatal(msg); } #endif /*p7LOGSUM_TESTDRIVE*/ /*------------------- end, unit tests ---------------------------*/ /***************************************************************** * 4. Test driver. *****************************************************************/ #ifdef p7LOGSUM_TESTDRIVE /* gcc -o logsum_utest -msse2 -g -Wall -I. -L. -I../easel -L../easel -Dp7LOGSUM_TESTDRIVE logsum.c -leasel -lm ./logsum_utest */ #include "p7_config.h" #include #include #include "easel.h" #include "esl_getopts.h" #include "esl_random.h" #include "hmmer.h" static ESL_OPTIONS options[] = { /* name type default env range togs reqs incomp help docgrp */ {"-h", eslARG_NONE, FALSE, NULL, NULL, NULL, NULL, NULL, "show help and usage", 0}, {"-N", eslARG_INT, "1000", NULL, "n>0",NULL, NULL, NULL, "number of samples", 0}, {"-S", eslARG_REAL, "20.0", NULL, "x>0",NULL, NULL, NULL, "maximum operand value", 0}, {"-s", eslARG_INT, "42", NULL,"n>=0",NULL, NULL, NULL, "random number seed", 0}, {"-v", eslARG_NONE, FALSE, NULL, NULL, NULL, NULL, NULL, "show verbose output", 0}, { 0,0,0,0,0,0,0,0,0,0}, }; static char usage[] = "[-options]"; static char banner[] = "test driver for logsum.c"; int main(int argc, char **argv) { ESL_GETOPTS *go = p7_CreateDefaultApp(options, 0, argc, argv, banner, usage); ESL_RANDOMNESS *r = esl_randomness_CreateFast(esl_opt_GetInteger(go, "-s")); p7_FLogsumInit(); utest_FLogsumError(go, r); utest_FLogsumSpecials(); esl_randomness_Destroy(r); esl_getopts_Destroy(go); return eslOK; } #endif /*p7LOGSUM_TESTDRIVE*/ /*------------------ end, test driver ---------------------------*/ /***************************************************************** * 5. Example. *****************************************************************/ #ifdef p7LOGSUM_EXAMPLE /* gcc -o example -g -O2 -I. -L. -I../easel -L../easel -Dp7LOGSUM_EXAMPLE logsum.c -leasel -lm * ./example -0.5 -0.5 */ #include "p7_config.h" #include "easel.h" #include "hmmer.h" int main(int argc, char **argv) { float a = atof(argv[1]); float b = atof(argv[2]); float result; p7_FLogsumInit(); result = p7_FLogsum(a, b); printf("p7_FLogsum(%f,%f) = %f\n", a, b, result); result = log(exp(a) + exp(b)); printf("log(e^%f + e^%f) = %f\n", a, b, result); printf("Absolute error in probability: %f\n", p7_FLogsumError(a,b)); return eslOK; } #endif /*p7LOGSUM_EXAMPLE*/ /*--------------------- end, example ----------------------------*/ /***************************************************************** * HMMER - Biological sequence analysis with profile HMMs * Version 3.1b2; February 2015 * Copyright (C) 2015 Howard Hughes Medical Institute. * Other copyrights also apply. See HMMER's COPYRIGHT * file for a full list. * * This file was originally part of HMMER. This version is used with * Sean Eddy's permission as public domain code. * * Original version control information: * SVN $URL: https://svn.janelia.org/eddylab/eddys/src/hmmer/branches/3.1/src/logsum.c $ * SVN $Id: logsum.c 3474 2011-01-17 13:25:32Z eddys $ *****************************************************************/ /* Footnotes. * * [1] The maximum relative error is on the order of 1/SCALE, or 0.001. * [xref SRE:J8/71]. * * [2] SIMD vectorization of a log-space Forward remains vexing. * Sparse-rescaled probability-space Forward vector * implemementation only works for local; glocal or global may * underflow long delete paths. Would be desirable to use a * log-space implementation if we could make it fast. Problem is * implementing the p7_FLogsum() lookup table in SIMD; lookup * tables of this size in current SSE, Altivec appear to be * infeasible. I considered the possibility of using a functional * fit to f(x) = log(1+e^{-x}) for x >=0, for example with a * Chebyshev polynomial, because a numerical f(x) would vectorize. * Decided that this computation would necessarily be expensive on * the order of log(x) or exp(x), so replacing log(1+exp(-x)) with * f(x) doesn't look like compelling -- might as well compute * log(1+exp(-x)) directly! The table-driven approach is about 20x * faster (about 9 clocks, compared to about 200 for the direct * log,exp calculation), and even if we could get an f(x) * calculation to be as efficient as log(x) -- say 100 clocks -- * the 4x SIMD vectorization does not compensate for the 10x hit * in speed. [xref SRE:J8/71] */ nanopolish-0.4.0/src/common/logsum.h000066400000000000000000000045071260522445600174370ustar00rootroot00000000000000// // logsum -- a port of Sean Eddy's fast table-driven log sum // This code was originally part of HMMER. This version is used with // Sean Eddy's permission as public domain code. // #ifndef LOGSUM_H #define LOGSUM_H #include #include #include /* p7_LOGSUM_SCALE defines the precision of the calculation; the * default of 1000.0 means rounding differences to the nearest 0.001 * nat. p7_LOGSUM_TBL defines the size of the lookup table; the * default of 16000 means entries are calculated for differences of 0 * to 16.000 nats (when p7_LOGSUM_SCALE is 1000.0). e^{-p7_LOGSUM_TBL / * p7_LOGSUM_SCALE} should be on the order of the machine FLT_EPSILON, * typically 1.2e-7. */ #define p7_LOGSUM_TBL 16000 #define p7_LOGSUM_SCALE 1000.f #define ESL_MAX(a,b) (((a)>(b))?(a):(b)) #define ESL_MIN(a,b) (((a)<(b))?(a):(b)) #define eslINFINITY INFINITY #define TRUE 1 #define FALSE 0 #define eslOK 1 /* Function: p7_FLogsumInit() * Synopsis: Initialize the p7_Logsum() function. * * Purpose: Initialize the lookup table for . * This function must be called once before any * call to . * * The precision of the lookup table is determined * by the compile-time constant. * * Returns: on success. */ int p7_FLogsumInit(void); /* Function: p7_FLogsum() * Synopsis: Approximate $\log(e^a + e^b)$. * * Purpose: Returns a fast table-driven approximation to * $\log(e^a + e^b)$. * * Either or (or both) may be $-\infty$, * but neither may be $+\infty$ or . * * Note: This function is a critical optimization target, because * it's in the inner loop of generic Forward() algorithms. */ inline float p7_FLogsum(float a, float b) { extern float flogsum_lookup[p7_LOGSUM_TBL]; /* p7_LOGSUM_TBL=16000: (A-B) = 0..16 nats, steps of 0.001 */ const float max = ESL_MAX(a, b); const float min = ESL_MIN(a, b); //return (min == -eslINFINITY || (max-min) >= 15.7f) ? max : max + log(1.0 + exp(min-max)); /* SRE: While debugging SSE impl. Remember to remove! */ return (min == -eslINFINITY || (max-min) >= 15.7f) ? max : max + flogsum_lookup[(int)((max-min)*p7_LOGSUM_SCALE)]; } #endif nanopolish-0.4.0/src/common/nanopolish_alphabet.cpp000066400000000000000000000035631260522445600224770ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_alphabet -- support for multiple alphabets // #include #include "nanopolish_alphabet.h" const uint8_t DNAAlphabet::_rank[256] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,1,0,0,0,2,0,0,0,0,0,0,0,0, 0,0,0,0,3,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }; const char* DNAAlphabet::_base = "ACGT"; const char* DNAAlphabet::_complement = "TGCA"; const uint32_t DNAAlphabet::_size = 4; const uint8_t MethylCpGAlphabet::_rank[256] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,1,0,0,0,2,0,0,0,0,0,3,0,0, 0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }; const char* MethylCpGAlphabet::_base = "ACGMT"; const uint32_t MethylCpGAlphabet::_size = 5; DNAAlphabet gDNAAlphabet; MethylCpGAlphabet gMCpGAlphabet; nanopolish-0.4.0/src/common/nanopolish_alphabet.h000066400000000000000000000133161260522445600221410ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_alphabet -- support for multiple alphabets // #ifndef NANOPOLISH_ALPHABET_H #define NANOPOLISH_ALPHABET_H #include #include #include #include "nanopolish_iupac.h" // A table to map { A, C, G, T } => { 0, 1, 2, 3 } extern const uint8_t dna_base_rank[]; // Abstract base class for alphabets class Alphabet { public: // basic functions virtual uint8_t rank(char b) const = 0; virtual char base(uint8_t r) const = 0; virtual uint32_t size() const = 0; // return the lexicographic rank of the kmer amongst all strings of // length k for this alphabet inline uint32_t kmer_rank(const char* str, uint32_t k) const { uint32_t p = 1; uint32_t r = 0; // from last base to first for(uint32_t i = 0; i < k; ++i) { r += rank(str[k - i - 1]) * p; p *= size(); } return r; } // Increment the input string to be the next sequence in lexicographic order inline void lexicographic_next(std::string& str) const { int carry = 1; int i = str.size() - 1; do { uint32_t r = rank(str[i]) + carry; str[i] = base(r % size()); carry = r / size(); i -= 1; } while(carry > 0 && i >= 0); } // returns the number of unique strings of length l for this alphabet inline size_t get_num_strings(size_t l) const { size_t s = size(); size_t n = 1; for(size_t i = 0; i < l; ++i) { n *= s; } return n; } // reverse complement a string over this alphabet virtual std::string reverse_complement(const std::string& seq) const = 0; // remove ambiguous nucleotides from the string virtual std::string disambiguate(const std::string& seq) const = 0; }; struct DNAAlphabet : public Alphabet { static const uint8_t _rank[256]; static const char* _base; static const char* _complement; static const uint32_t _size; virtual uint8_t rank(char b) const { return _rank[b]; } virtual char base(uint8_t r) const { return _base[r]; } virtual uint32_t size() const { return _size; } virtual std::string reverse_complement(const std::string& seq) const { std::string out(seq.length(), 'A'); size_t last_pos = seq.length() - 1; for(int i = last_pos; i >= 0; --i) { out[last_pos - i] = _complement[_rank[seq[i]]]; } return out; } // return a new copy of the string with ambiguous characters changed virtual std::string disambiguate(const std::string& str) const { std::string out(str); for(size_t i = 0; i < str.length(); ++i) { assert(IUPAC::isValid(str[i])); out[i] = IUPAC::getPossibleSymbols(str[i])[0]; } return out; } }; // DNABaseMap with methyl-cytosine struct MethylCpGAlphabet : public Alphabet { static const uint8_t _rank[256]; static const char* _base; static const char* _complement; static const uint32_t _size; virtual uint8_t rank(char b) const { return _rank[b]; } virtual char base(uint8_t r) const { return _base[r]; } virtual uint32_t size() const { return _size; } virtual std::string reverse_complement(const std::string& seq) const { std::string out(seq.length(), 'A'); size_t i = 0; // input int j = seq.length() - 1; // output while(i < seq.length()) { if(seq[i] == 'M') { out[j--] = 'G'; i += 1; // CpG methylation model requires M to be followed by G // (if there is space) if(j >= 0) { assert(i < seq.length()); assert(seq[i] == 'G'); out[j--] = 'M'; ++i; } } else { out[j--] = DNAAlphabet::_complement[DNAAlphabet::_rank[seq[i++]]]; } } return out; } // return a new copy of the string with ambiguous characters changed virtual std::string disambiguate(const std::string& str) const { std::string out(str); for(size_t i = 0; i < str.length(); ++i) { if(str[i] == 'M' && i != str.length() - 1 && str[i + 1] == 'G') { // CpG site, assume its methylated not an ambiguity symbol out[i] = 'M'; } else { assert(IUPAC::isValid(str[i])); out[i] = IUPAC::getPossibleSymbols(str[i])[0]; } } return out; } // Convert CpGs of the sequence to mCpG std::string methylate(const std::string& str) const { std::string out(str); for(size_t i = 0; i < out.length() - 1; ++i) { if(out[i] == 'C' && out[i + 1] == 'G') { out[i] = 'M'; } } return out; } // Convert methylated bases to C std::string unmethylate(const std::string& str) const { std::string out(str); for(size_t i = 0; i < out.length(); ++i) { if(out[i] == 'M') { out[i] = 'C'; } } return out; } }; // Global alphabet objects that can be re-used extern DNAAlphabet gDNAAlphabet; extern MethylCpGAlphabet gMCpGAlphabet; #endif nanopolish-0.4.0/src/common/nanopolish_common.cpp000066400000000000000000000016131260522445600222010ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_common -- Data structures and definitions // shared across files // #include #include #include #include "nanopolish_common.h" #include "nanopolish_squiggle_read.h" // Split a string into parts based on the delimiter std::vector split(std::string in, char delimiter) { std::vector out; size_t lastPos = 0; size_t pos = in.find_first_of(delimiter); while(pos != std::string::npos) { out.push_back(in.substr(lastPos, pos - lastPos)); lastPos = pos + 1; pos = in.find_first_of(delimiter, lastPos); } out.push_back(in.substr(lastPos)); return out; } nanopolish-0.4.0/src/common/nanopolish_common.h000066400000000000000000000045471260522445600216570ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_common -- Data structures and definitions // shared across files // #ifndef NANOPOLISH_COMMON_H #define NANOPOLISH_COMMON_H #include #include #include #include #include "nanopolish_alphabet.h" #include "profiler.h" #include "logsum.h" #define PACKAGE_NAME "nanopolish" #define PACKAGE_VERSION "0.4.0" #define PACKAGE_BUGREPORT "https://github.com/jts/nanopolish/issues" // // Enumerated types // enum AlignmentPolicy { AP_GLOBAL, AP_SEMI_KMER }; // // Constants // // strands const uint8_t T_IDX = 0; const uint8_t C_IDX = 1; const uint8_t NUM_STRANDS = 2; // // Data structures // class SquiggleRead; // This struct is used as input into the HMM // It tracks where the event stream starts/stops // for the partial consensus sequence under consideration struct HMMInputData { SquiggleRead* read; uint32_t anchor_index; uint32_t event_start_idx; uint32_t event_stop_idx; uint8_t strand; int8_t event_stride; uint8_t rc; }; // A representation of an event->kmer alignment struct HMMAlignmentState { uint32_t event_idx; uint32_t kmer_idx; double l_posterior; double l_fm; double log_transition_probability; char state; }; // The parameters of a gaussian distribution struct GaussianParameters { GaussianParameters() : mean(0.0f), stdv(1.0f) { log_stdv = log(stdv); } GaussianParameters(float m, float s) : mean(m), stdv(s) { log_stdv = log(stdv); } float mean; float stdv; float log_stdv; // == log(stdv), pre-computed for efficiency }; // // Functions // #define ESL_LOG_SUM 1 // Add the log-scaled values a and b using a transform to avoid precision errors inline double add_logs(const double a, const double b) { #if ESL_LOG_SUM return p7_FLogsum(a, b); #else if(a == -INFINITY && b == -INFINITY) return -INFINITY; if(a > b) { double diff = b - a; return a + log(1.0 + exp(diff)); } else { double diff = a - b; return b + log(1.0 + exp(diff)); } #endif } // split a string based on a delimiter std::vector split(std::string in, char delimiter); #endif nanopolish-0.4.0/src/common/nanopolish_fast5_map.cpp000066400000000000000000000101661260522445600225730ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_fast5_map - a simple map from a read // name to a fast5 file path #include #include #include #include #include #include #include #include "nanopolish_fast5_map.h" #include "nanopolish_common.h" #include "htslib/kseq.h" // #define FOFN_SUFFIX ".fast5.fofn" KSEQ_INIT(gzFile, gzread); Fast5Map::Fast5Map(const std::string& fasta_filename) { // If the fofn file exists, load from it // otherwise parse the entire fasta file std::string fofn_filename = fasta_filename + FOFN_SUFFIX; struct stat fofn_file_s; struct stat fasta_file_s; int fofn_ret = stat(fofn_filename.c_str(), &fofn_file_s); int fasta_ret = stat(fasta_filename.c_str(), &fasta_file_s); // Use the stored fofn if its available and newer than the fasta if(fofn_ret == 0 && fofn_file_s.st_mtime > fasta_file_s.st_mtime) { load_from_fofn(fofn_filename); } else { load_from_fasta(fasta_filename); } } std::string Fast5Map::get_path(const std::string& read_name) const { std::map::const_iterator iter = read_to_path_map.find(read_name); if(iter == read_to_path_map.end()) { fprintf(stderr, "error: could not find fast5 path for %s\n", read_name.c_str()); exit(EXIT_FAILURE); } return iter->second; } // void Fast5Map::load_from_fasta(std::string fasta_filename) { gzFile gz_fp; FILE* fp = fopen(fasta_filename.c_str(), "r"); if(fp == NULL) { fprintf(stderr, "error: could not open %s for read\n", fasta_filename.c_str()); exit(EXIT_FAILURE); } gz_fp = gzdopen(fileno(fp), "r"); if(gz_fp == NULL) { fprintf(stderr, "error: could not open %s using gzdopen\n", fasta_filename.c_str()); exit(EXIT_FAILURE); } kseq_t* seq = kseq_init(gz_fp); while(kseq_read(seq) >= 0) { if(seq->comment.l == 0) { fprintf(stderr, "error: no path associated with read %s\n", seq->name.s); exit(EXIT_FAILURE); } // This splitting code implicitly handles both the 2 and 3 field // fasta format that poretools will output. The FAST5 path // is always the last field. std::vector fields = split(seq->comment.s, ' '); assert(read_to_path_map.find(seq->name.s) == read_to_path_map.end()); read_to_path_map[seq->name.s] = fields.back(); } kseq_destroy(seq); gzclose(gz_fp); fclose(fp); // Sanity check that the first path actually points to a file if(read_to_path_map.size() > 0) { std::string first_read = read_to_path_map.begin()->first; std::string first_path = read_to_path_map.begin()->second; struct stat file_s; int ret = stat(first_path.c_str(), &file_s); if(ret != 0) { fprintf(stderr, "Error: could not find path to FAST5 for read %s\n", first_read.c_str()); fprintf(stderr, "Please make sure that this path is accessible: %s\n", first_path.c_str()); exit(EXIT_FAILURE); } } // Write the map as a fofn file so next time we don't have to parse // the entire fasta write_to_fofn(fasta_filename + FOFN_SUFFIX); } void Fast5Map::write_to_fofn(std::string fofn_filename) { std::ofstream outfile(fofn_filename.c_str()); for(std::map::iterator iter = read_to_path_map.begin(); iter != read_to_path_map.end(); ++iter) { outfile << iter->first << "\t" << iter->second << "\n"; } } // void Fast5Map::load_from_fofn(std::string fofn_filename) { std::ifstream infile(fofn_filename.c_str()); if(infile.bad()) { fprintf(stderr, "error: could not read fofn %s\n", fofn_filename.c_str()); exit(EXIT_FAILURE); } std::string name; std::string path; while(infile >> name >> path) { read_to_path_map[name] = path; } } nanopolish-0.4.0/src/common/nanopolish_fast5_map.h000066400000000000000000000021601260522445600222330ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_fast5_map - a simple map from a read // name to a fast5 file path #ifndef NANOPOLISH_FAST5_MAP #define NANOPOLISH_FAST5_MAP #include #include class Fast5Map { public: Fast5Map(const std::string& fasta_filename); // return the path for the given read name // if the read does not exist in the map, emits an error // and exits std::string get_path(const std::string& read_name) const; private: // Read the read -> path map from the header of a fasta file void load_from_fasta(std::string fasta_filename); // Read the map from a pre-computed .fofn file void load_from_fofn(std::string fofn_filename); // Write the map to the .fofn file void write_to_fofn(std::string fofn_filename); std::map read_to_path_map; }; #endif nanopolish-0.4.0/src/common/nanopolish_iupac.cpp000066400000000000000000000034611260522445600220150ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_iupac -- handle iupac ambiguity codes // #include #include "nanopolish_iupac.h" // IUPAC alphabet bool IUPAC::isUnambiguous(char c) { switch(c) { case 'A': case 'C': case 'G': case 'T': return true; default: return false; } } // Returns true if c is a valid ambiguity code bool IUPAC::isAmbiguous(char c) { switch(c) { case 'M': case 'R': case 'W': case 'S': case 'Y': case 'K': case 'V': case 'H': case 'D': case 'B': case 'N': return true; default: return false; } } // Returns true if c is a valid symbol in this alphabet bool IUPAC::isValid(char c) { return isUnambiguous(c) || isAmbiguous(c); } // std::string IUPAC::getPossibleSymbols(char c) { switch(c) { case 'A': return "A"; case 'C': return "C"; case 'G': return "G"; case 'T': return "T"; case 'M': return "AC"; case 'R': return "AG"; case 'W': return "AT"; case 'S': return "CG"; case 'Y': return "CT"; case 'K': return "GT"; case 'V': return "ACG"; case 'H': return "ACT"; case 'D': return "AGT"; case 'B': return "CGT"; case 'N': return "ACGT"; default: return ""; } } nanopolish-0.4.0/src/common/nanopolish_iupac.h000066400000000000000000000014441260522445600214610ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_iupac -- handle iupac ambiguity codes // #ifndef NANOPOLISH_IUPAC_H #define NANOPOLISH_IUPAC_H #include // IUPAC ambiguity alphabet namespace IUPAC { // Returns true if c is [ACGT] bool isUnambiguous(char c); // Returns true if c is a valid ambiguity code bool isAmbiguous(char c); // Returns true if c is a valid symbol in this alphabet bool isValid(char c); // Returns a string defining the possible unambiguous bases for each symbol // in the alphabet std::string getPossibleSymbols(char c); }; #endif nanopolish-0.4.0/src/common/nanopolish_klcs.cpp000066400000000000000000000052461260522445600216530ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_klcs -- function to compute the longest // common subsequence of k-mers for two strings // #include #include "nanopolish_klcs.h" // Helper to backtrack through the kLCS matrix void _kLCSBacktrack(const UInt32Matrix& m, const std::string& a, const std::string& b, const int k, uint32_t row, uint32_t col, kLCSResult& result) { if(row == 0 || col == 0) return; const char* ka = a.c_str() + row - 1; const char* kb = b.c_str() + col - 1; if(strncmp(ka, kb, k) == 0) { kLCSPair p = { row - 1, col - 1 }; result.push_back(p); return _kLCSBacktrack(m, a, b, k, row - 1, col - 1, result); } else { if(get(m, row - 1, col) > get(m, row, col - 1)) { return _kLCSBacktrack(m, a, b, k, row - 1, col, result); } else { return _kLCSBacktrack(m, a, b, k, row, col - 1, result); } } } // Return the longest common subseuqence of k-mers between the two strings kLCSResult kLCS(const std::string& a, const std::string& b, const int k) { uint32_t n_kmers_a = a.size() - k + 1; uint32_t n_kmers_b = b.size() - k + 1; uint32_t n_rows = n_kmers_a + 1; uint32_t n_cols = n_kmers_b + 1; UInt32Matrix m; allocate_matrix(m, n_rows, n_cols); // Initialize first row/col to zero for(uint32_t row = 0; row < m.n_rows; ++row) set(m, row, 0, 0); for(uint32_t col = 0; col < m.n_cols; ++col) set(m, 0, col, 0); // Fill matrix for(uint32_t row = 1; row < m.n_rows; ++row) { for(uint32_t col = 1; col < m.n_cols; ++col) { const char* ka = a.c_str() + row - 1; const char* kb = b.c_str() + col - 1; uint32_t score = 0; if(strncmp(ka, kb, k) == 0) { uint32_t diag = get(m, row - 1, col - 1); score = diag + 1; } else { uint32_t left = get(m, row, col - 1); uint32_t up = get(m, row - 1, col); score = std::max(left, up); } set(m, row, col, score); } } kLCSResult result; _kLCSBacktrack(m, a, b, k, n_rows - 1, n_cols - 1, result); // Backtrack appends from the end to the start, reverse the vector of matches std::reverse(result.begin(), result.end()); free_matrix(m); return result; } nanopolish-0.4.0/src/common/nanopolish_klcs.h000066400000000000000000000013111260522445600213050ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_klcs -- function to compute the longest // common subsequence of k-mers for two strings // #ifndef NANOPOLISH_KLCS_H #define NANOPOLISH_KLCS_H #include #include #include #include "nanopolish_matrix.h" // The indices of a k-mer match in a pair of sequences struct kLCSPair { uint32_t i; uint32_t j; }; typedef std::vector kLCSResult; kLCSResult kLCS(const std::string& a, const std::string& b, const int k); #endif nanopolish-0.4.0/src/common/nanopolish_matrix.h000066400000000000000000000045651260522445600216730ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_matrix -- matrix manipulation functions // #ifndef NANOPOLISH_MATRIX_H #define NANOPOLISH_MATRIX_H #include #include #include #include #include #include "nanopolish_matrix.h" // // Template Matrix for POD types // template struct Matrix { T* cells; uint32_t n_rows; uint32_t n_cols; }; typedef Matrix DoubleMatrix; typedef Matrix FloatMatrix; typedef Matrix UInt32Matrix; typedef Matrix UInt8Matrix; // template void allocate_matrix(Matrix& matrix, uint32_t n_rows, uint32_t n_cols) { matrix.n_rows = n_rows; matrix.n_cols = n_cols; uint32_t N = matrix.n_rows * matrix.n_cols; matrix.cells = (T*)malloc(N * sizeof(T)); memset(matrix.cells, 0, N * sizeof(T)); } // template void free_matrix(Matrix& matrix) { assert(matrix.cells != NULL); free(matrix.cells); matrix.cells = NULL; } // Copy a matrix and its contents template void copy_matrix(Matrix& new_matrix, const Matrix& old_matrix) { allocate_matrix(new_matrix, old_matrix.n_rows, old_matrix.n_cols); uint32_t bytes = sizeof(T) * new_matrix.n_rows * new_matrix.n_cols; memcpy(new_matrix.cells, old_matrix.cells, bytes); } // template inline uint32_t cell(const Matrix& matrix, uint32_t row, uint32_t col) { return row * matrix.n_cols + col; } // template inline void set(Matrix& matrix, uint32_t row, uint32_t col, U v) { uint32_t c = cell(matrix, row, col); matrix.cells[c] = v; } // template inline T get(const Matrix& matrix, uint32_t row, uint32_t col) { uint32_t c = cell(matrix, row, col); return matrix.cells[c]; } // inline void print_matrix(const DoubleMatrix& matrix, bool do_exp = false) { for(uint32_t i = 0; i < matrix.n_rows; ++i) { for(uint32_t j = 0; j < matrix.n_cols; ++j) { uint32_t c = cell(matrix, i, j); double v = matrix.cells[c]; if(do_exp) v = exp(v); printf("%.3lf\t", v); } printf("\n"); } } #endif nanopolish-0.4.0/src/common/nanopolish_variant.cpp000066400000000000000000000250631260522445600223620ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_variants -- tools for calling variants // #include #include #include "nanopolish_profile_hmm.h" #include "nanopolish_variant.h" #include "nanopolish_haplotype.h" // return a new copy of the string with gap symbols removed std::string remove_gaps(const std::string& str) { std::string ret = str; ret.erase( std::remove(ret.begin(), ret.end(), '-'), ret.end()); return ret; } // extract differences between the pair of strings std::vector extract_variants(const std::string& reference, const std::string& haplotype) { AlnParam par = aln_param_nt2nt; par.band_width = std::max(20, abs(reference.size() - haplotype.size()) * 2); AlnAln* aln = aln_stdaln(reference.c_str(), haplotype.c_str(), &par, 1, 1); // Make aligned strings where gaps are padded with '-' std::string pad_ref(aln->out1); std::string pad_hap(aln->out2); assert(pad_ref.size() == pad_hap.size()); //std::cout << "PR: " << pad_ref << "\n"; //std::cout << "PH: " << pad_hap << "\n"; // parse variants from the alignment std::vector variants; // generate a map from padded bases to positions in the original reference sequence std::vector ref_positions(pad_ref.size(), 0); size_t pos = 0; for(size_t i = 0; i < pad_ref.size(); ++i) { ref_positions[i] = pad_ref[i] != '-' ? pos : std::string::npos; pos += pad_ref[i] != '-'; } // diff_start iterates over the places where these sequences are different size_t diff_start = 0; while(1) { // find the start point of the next difference between the strings while(diff_start < pad_ref.size() && pad_ref[diff_start] == pad_hap[diff_start]) { diff_start++; } // check for end of alignment if(diff_start == pad_ref.size()) break; // find the end point of the difference bool is_indel = false; size_t diff_end = diff_start; while(diff_end < pad_ref.size() && pad_ref[diff_end] != pad_hap[diff_end]) { is_indel = is_indel || pad_ref[diff_end] == '-' || pad_hap[diff_end] == '-'; diff_end++; } // If the difference is an indel, we include the previous matching reference base diff_start -= is_indel; Variant v; v.ref_name = "noctg"; assert(ref_positions[diff_start] != std::string::npos); v.ref_position = ref_positions[diff_start]; v.ref_seq = remove_gaps(pad_ref.substr(diff_start, diff_end - diff_start).c_str()); v.alt_seq = remove_gaps(pad_hap.substr(diff_start, diff_end - diff_start).c_str()); variants.push_back(v); diff_start = diff_end; } aln_free_AlnAln(aln); return variants; } void filter_variants_by_count(std::vector& variants, int min_count) { std::map> map; for(size_t i = 0; i < variants.size(); ++i) { std::string key = variants[i].key(); auto iter = map.find(key); if(iter == map.end()) { map.insert(std::make_pair(key, std::make_pair(variants[i], 1))); } else { iter->second.second += 1; } } variants.clear(); for(auto iter = map.begin(); iter != map.end(); ++iter) { Variant& v = iter->second.first; if(iter->second.second >= min_count) { v.add_info("BaseCalledReadsWithVariant", iter->second.second); variants.push_back(v); } } } void filter_out_non_snp_variants(std::vector& variants) { std::vector tmp; for(size_t i = 0; i < variants.size(); ++i) { bool is_snp = variants[i].ref_seq.length() == variants[i].alt_seq.length(); if(is_snp) { tmp.push_back(variants[i]); } } variants.swap(tmp); } std::vector select_variants(const std::vector& candidate_variants, Haplotype base_haplotype, const std::vector& input) { // make a copy of the variant set to modify std::vector all_variants = candidate_variants; // Calculate baseline probablilty std::vector selected_variants; double base_lp = profile_hmm_score(base_haplotype.get_sequence(), input); while(!all_variants.empty()) { double best_variant_lp = -INFINITY; size_t best_variant_idx = 0; size_t best_supporting_reads = 0; std::vector base_lp_by_read; for(size_t j = 0; j < input.size(); ++j) { double tmp = profile_hmm_score(base_haplotype.get_sequence(), input[j]); base_lp_by_read.push_back(tmp); } for(size_t i = 0; i < all_variants.size(); ++i) { // apply the variant to get a new haplotype Variant& v = all_variants[i]; Haplotype derived = base_haplotype; derived.apply_variant(v); // score the haplotype double variant_lp = 0.0f; size_t supporting_reads = 0; #pragma omp parallel for for(size_t j = 0; j < input.size(); ++j) { double tmp = profile_hmm_score(derived.get_sequence(), input[j]); #pragma omp critical { variant_lp += tmp; supporting_reads += tmp > base_lp_by_read[j]; } } if(variant_lp > best_variant_lp) { best_variant_lp = variant_lp; best_variant_idx = i; best_supporting_reads = supporting_reads; } } if(best_variant_lp - base_lp > 1.0) { // move the best variant from the all list to the selected list Variant& best_variant = all_variants[best_variant_idx]; best_variant.add_info("TotalReads", input.size()); best_variant.add_info("SupportingReads", best_supporting_reads); best_variant.add_info("SupportFraction", (double)best_supporting_reads / input.size()); best_variant.quality = best_variant_lp - base_lp; selected_variants.push_back(best_variant); //printf("SELECTED %zu from %zu: \n\t", best_variant_idx, all_variants.size() + 1); // apply the variant to the base haplotype base_haplotype.apply_variant(selected_variants.back()); base_lp = best_variant_lp; } else { // no variant improved upon the base haplotype, stop break; } } return selected_variants; } std::vector select_variant_set(const std::vector& candidate_variants, Haplotype base_haplotype, const std::vector& input, const uint32_t alignment_flags) { size_t num_variants = candidate_variants.size(); size_t num_haplotypes = 1 << num_variants; double base_lp_by_strand[2] = { 0.0f, 0.0f }; double base_lp_by_rc[2] = { 0.0f, 0.0f }; double base_lp = 0.0f; std::vector base_lp_by_read(input.size()); #pragma omp parallel for for(size_t j = 0; j < input.size(); ++j) { double tmp = profile_hmm_score(base_haplotype.get_sequence(), input[j], alignment_flags); #pragma omp critical { base_lp_by_read[j] = tmp; base_lp += tmp; base_lp_by_strand[input[j].strand] += tmp; base_lp_by_rc[input[j].rc] += tmp; } } double best_lp = -INFINITY; std::vector best_variant_set; // The haplotype id is a bitmask indicating which variants // to apply to get the haplotype. We skip the empty // variant set. for(size_t hi = 1; hi < num_haplotypes; ++hi) { Haplotype current_haplotype = base_haplotype; std::vector current_variant_set; for(size_t vi = 0; vi < num_variants; vi++) { // if bit vi is set in the haplotype id, apply this variant if( (hi & (1 << vi)) == 0) { continue; } current_variant_set.push_back(candidate_variants[vi]); current_haplotype.apply_variant(current_variant_set.back()); } // score the haplotype double current_lp = 0.0f; double current_lp_by_strand[2] = { 0.0f, 0.0f }; double current_lp_by_rc[2] = { 0.0f, 0.0f }; size_t supporting_reads = 0; #pragma omp parallel for for(size_t j = 0; j < input.size(); ++j) { double tmp = profile_hmm_score(current_haplotype.get_sequence(), input[j], alignment_flags); #pragma omp critical { current_lp += tmp; supporting_reads += tmp > base_lp_by_read[j]; current_lp_by_strand[input[j].strand] += tmp; current_lp_by_rc[input[j].rc] += tmp; } } if(current_lp > best_lp && current_lp - base_lp > 1.0) { best_lp = current_lp; best_variant_set = current_variant_set; // Annotate variants for(size_t vi = 0; vi < best_variant_set.size(); ++vi) { Variant& v = best_variant_set[vi]; v.add_info("TotalReads", input.size()); v.add_info("SupportingReads", supporting_reads); v.add_info("SupportFraction", (double)supporting_reads / input.size()); v.add_info("TemplateQuality", current_lp_by_strand[0] - base_lp_by_strand[0]); v.add_info("ComplementQuality", current_lp_by_strand[1] - base_lp_by_strand[1]); v.add_info("ForwardQuality", current_lp_by_rc[0] - base_lp_by_rc[0]); v.add_info("ReverseQuality", current_lp_by_rc[1] - base_lp_by_rc[1]); v.quality = best_lp - base_lp; } } #ifdef DEBUG_HAPLOTYPE_SELECTION std::stringstream ss; for(size_t vi = 0; vi < current_variant_set.size(); ++vi) { const Variant& v = current_variant_set[vi]; ss << (vi > 0 ? "," : "") << v.key(); } fprintf(stderr, "haplotype: %zu variants: %s relative score: %.2lf\n", hi, ss.str().c_str(), current_lp - base_lp); #endif } return best_variant_set; } nanopolish-0.4.0/src/common/nanopolish_variant.h000066400000000000000000000067101260522445600220250ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_variant -- tools for calling variants // #ifndef NANOPOLISH_VARIANT_H #define NANOPOLISH_VARIANT_H #include #include "stdaln.h" #include "nanopolish_common.h" // forward declare class Haplotype; struct Variant { static void write_vcf_header(FILE* fp) { fprintf(fp, "#CHROM POS ID REF ALT QUAL FILTER INFO\n"); } Variant() { } Variant(const std::string& line) { read_vcf(line); } // generate a unique identifier for this variant std::string key() const { std::stringstream out; out << ref_name << ':' << ref_position << ':' << ref_seq << ':' << alt_seq; return out.str(); } void write_vcf(FILE* fp) { fprintf(fp, "%s\t%zu\t%s\t", ref_name.c_str(), ref_position + 1, "."); fprintf(fp, "%s\t%s\t%.1lf\t", ref_seq.c_str(), alt_seq.c_str(), quality); fprintf(fp, "%s\t%s\n", "PASS", info.c_str()); } void read_vcf(const std::string& line) { std::stringstream ss(line); std::string dummy; ss >> ref_name; ss >> ref_position; ss >> dummy; // ID, not used ss >> ref_seq; ss >> alt_seq; ss >> quality; ss >> dummy; // FILTER, not used ss >> info; // VCF is 1-based but we internally represent a variant as 0-based ref_position -= 1; assert(!ref_name.empty()); assert(!ref_seq.empty()); assert(!alt_seq.empty()); assert(ref_position >= 0); assert(quality >= 0.0f); } template void add_info(const std::string& key, T value) { std::stringstream ss; ss << key << "=" << value; if(info.empty()) { info = ss.str(); } else { info.append(1, ';'); info.append(ss.str()); } } std::string ref_name; size_t ref_position; std::string ref_seq; std::string alt_seq; double quality; std::string info; }; inline bool sortByPosition(const Variant& a, const Variant& b) { return a.ref_name == b.ref_name ? a.ref_position < b.ref_position : a.ref_name < b.ref_name; } // Determine potential variants between the reference and haplotype string std::vector extract_variants(const std::string& reference, const std::string& haplotype); // Remove variants that are in the vector fewer than min_count times void filter_variants_by_count(std::vector& variants, int min_count); // Remove snps or indels void filter_out_non_snp_variants(std::vector& variants); // Select variants to add to the base haplotype one-by-one std::vector select_variants(const std::vector& candidate_variants, Haplotype base_haplotype, const std::vector& input); // Select groups of variants to add to the base haplotype std::vector select_variant_set(const std::vector& candidate_variants, Haplotype base_haplotype, const std::vector& input, const uint32_t alignment_flags); #endif nanopolish-0.4.0/src/common/profiler.h000066400000000000000000000047711260522445600177560ustar00rootroot00000000000000///---------------------------------------------- // Copyright 2011 Wellcome Trust Sanger Institute // Written by Jared Simpson (js18@sanger.ac.uk) // Released under the GPL //----------------------------------------------- // // Profiler.h -- Lightweight macro-based function profiler. // #ifndef PROFILER_H #define PROFILER_H #include #include //#define USE_PROFILER 1 #if USE_PROFILER // Change this to determine how often the profile should print #define PROFILE_TICKS_BEFORE_PRINT 1000 // This class writes the lifespan of the object // to the output variable, in nanoseconds class TimeTracker { public: TimeTracker(size_t & output) : m_output(output) { timespec start; clock_gettime(CLOCK_REALTIME, &start); m_start_ns = start.tv_sec * 1000000000 + start.tv_nsec; } ~TimeTracker() { timespec end; clock_gettime(CLOCK_REALTIME, &end); size_t end_ns = end.tv_sec * 1000000000 + end.tv_nsec; // Update the result using an atomic compare and swap size_t diff = end_ns - m_start_ns; while(!__sync_bool_compare_and_swap(&m_output, m_output, m_output + diff)) {} } private: size_t m_start_ns; size_t& m_output; }; // Place this macros at the start of the function you wish the profile // The static variable updates are done via atomic compare and swaps so // the profiling should be threadsafe #define PROFILE_FUNC(x) static std::string __profile_name = x; \ static size_t __profile_iterations = 0; \ static size_t __profile_total_nanoseconds = 0; \ double micro_seconds = (double)__profile_total_nanoseconds / 1000.0f; \ double avg_per_iteration = micro_seconds / __profile_iterations; \ while(!__sync_bool_compare_and_swap(&__profile_iterations, __profile_iterations, __profile_iterations + 1)) { } \ if(__profile_iterations % PROFILE_TICKS_BEFORE_PRINT == 0) \ fprintf(stderr, "[Profile] count: %zu time: %.0lf ms avg: %.0lf us func: %s\n", __profile_iterations, micro_seconds / 1000, avg_per_iteration, __profile_name.c_str()); \ TimeTracker __profile_timer(__profile_total_nanoseconds); #else // Eliminate the macro #define PROFILE_FUNC(x) #endif // #ifdef HAVE_CLOCK_GETTIME #endif // #ifndef PROFILER_H nanopolish-0.4.0/src/common/progress.h000066400000000000000000000041721260522445600177730ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // progress -- Small class to write the progress // of a long running task to stderr // #ifndef PROGRESS_H #define PROGRESS_H #include class Progress { public: Progress(const std::string message) : m_message(message), m_os(std::cerr) { #if HAVE_CLOCK_GETTIME timespec start; clock_gettime(CLOCK_REALTIME, &start); m_start_time = start.tv_sec; #else m_start_time = 0; #endif } // derived from: http://stackoverflow.com/a/14539953/378881 void print(float progress) const { // print int max_leader = 40; int bar_width = 50; std::string leader; if(m_message.size() > max_leader) { leader = m_message.substr(0, max_leader - 3) + "..."; // truncate } else { leader = m_message + std::string(max_leader - m_message.size(), ' '); // pad } m_os << leader << " ["; int pos = bar_width * progress; for (int i = 0; i < bar_width; ++i) { if (i < pos) m_os << "="; else if (i == pos) m_os << ">"; else m_os << " "; } m_os << "] " << int(progress * 100.0) << "% in " << get_elapsed_seconds() << "s\r"; m_os.flush(); } // void end() const { print(1.0); std::cerr << std::endl; } double get_elapsed_seconds() const { // get current time #if HAVE_CLOCK_GETTIME timespec now; clock_gettime(CLOCK_REALTIME, &now); return now.tv_sec - m_start_time; #else return 0; #endif } private: std::ostream& m_os; std::string m_message; size_t m_start_time; }; #endif nanopolish-0.4.0/src/hmm/000077500000000000000000000000001260522445600152435ustar00rootroot00000000000000nanopolish-0.4.0/src/hmm/nanopolish_emissions.h000066400000000000000000000075141260522445600216660ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_emissions -- Emission distributions and // related functions for the HMMs // #ifndef NANOPOLISH_EMISSIONS_H #define NANOPOLISH_EMISSIONS_H #include #include "nanopolish_common.h" #include "nanopolish_squiggle_read.h" //#define MODEL_STDV //#define DEBUG_HMM_EMISSION 1 // From SO: http://stackoverflow.com/questions/10847007/using-the-gaussian-probability-density-function-in-c inline float normal_pdf(float x, const GaussianParameters& g) { static const float inv_sqrt_2pi = 0.3989422804014327; float a = (x - g.mean) / g.stdv; return inv_sqrt_2pi / g.stdv * exp(-0.5f * a * a); } inline float log_normal_pdf(float x, const GaussianParameters& g) { static const float log_inv_sqrt_2pi = log(0.3989422804014327); float a = (x - g.mean) / g.stdv; return log_inv_sqrt_2pi - g.log_stdv + (-0.5f * a * a); } inline float z_score(const SquiggleRead& read, uint32_t kmer_rank, uint32_t event_idx, uint8_t strand) { const PoreModel& pm = read.pore_model[strand]; float level = read.get_drift_corrected_level(event_idx, strand); GaussianParameters model = pm.get_scaled_parameters(kmer_rank); return (level - model.mean) / model.stdv; } inline float log_probability_match(const SquiggleRead& read, uint32_t kmer_rank, uint32_t event_idx, uint8_t strand, float state_scale = 1.0f, float log_state_scale = 0.0f) { const PoreModel& pm = read.pore_model[strand]; // event level mean float level = read.get_drift_corrected_level(event_idx, strand); GaussianParameters model = pm.get_scaled_parameters(kmer_rank); // we go to great lengths to avoid calling log() in the inner loop of the HMM // for this reason we duplicate data here and require the caller to pass // in the scale and log(scale), presumably these are cached model.stdv *= state_scale; model.log_stdv += log_state_scale; float lp = log_normal_pdf(level, model); #if MODEL_STDV // event level stdv float stdv = read.events[strand].stdv[event_idx]; float model_sd_mean = pm.state[kmer_rank].sd_mean * pm.scale_sd; float model_sd_stdv = pm.state[kmer_rank].sd_stdv * sqrt(pow(pm.scale_sd, 3.0) / pm.var_sd); lp += log_normal_pdf(stdv, model_sd_mean, model_sd_stdv); #endif #if DEBUG_HMM_EMISSION printf("Event[%d] Kmer: %d -- L:%.1lf m: %.1lf s: %.1lf p: %.3lf p_old: %.3lf\n", event_idx, kmer_rank, level, model.mean, model.stdv, exp(lp), normal_pdf(level, model)); #endif return lp; } inline float log_probability_event_insert(const SquiggleRead& read, uint32_t kmer_rank, uint32_t event_idx, uint8_t strand) { static const float scale = 1.75f; static const float log_scale = log(scale); return log_probability_match(read, kmer_rank, event_idx, strand, scale, log_scale); } inline float log_probability_background(const SquiggleRead& read, uint32_t event_idx, uint8_t strand) { return -3.0f; } inline float log_probability_kmer_insert(const SquiggleRead& read, uint32_t kmer_rank, uint32_t event_idx, uint8_t strand) { return log_probability_match(read, kmer_rank, event_idx, strand); } #endif nanopolish-0.4.0/src/hmm/nanopolish_hmm_input_sequence.h000066400000000000000000000051071260522445600235410ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_hmm_input_sequence -- a nucleotide sequence // that is input into the hidden Markov model // #ifndef NANOPOLISH_HMM_INPUT_SEQUENCE #define NANOPOLISH_HMM_INPUT_SEQUENCE #include #include "nanopolish_common.h" #include "nanopolish_alphabet.h" // // This class is a general wrapper around a string // that allows different alphabets to be used. // class HMMInputSequence { public: // constructors HMMInputSequence(const std::string& seq) : m_seq(seq), m_alphabet(&gDNAAlphabet) { m_rc_seq = m_alphabet->reverse_complement(seq); } HMMInputSequence(const std::string& fwd, const std::string& rc, const Alphabet* alphabet) : m_seq(fwd), m_rc_seq(rc), m_alphabet(alphabet) { } // size_t length() const { return m_seq.length(); } // returns the i-th kmer of the sequence inline std::string get_kmer(uint32_t i, uint32_t k, bool do_rc) const { return ! do_rc ? m_seq.substr(i, k) : m_rc_seq.substr(m_rc_seq.length() - i - k, k); } // get the number of kmer ranks supported by the alphabet for this sequence size_t get_num_kmer_ranks(size_t k) const { return m_alphabet->get_num_strings(k); } // get the lexicographic rank of the i-th kmer // if the do_rc flag is set, return the rank of // reverse-complemented version of the ki-th kmer // NOT the ki-th kmer of the reverse-complemented sequence inline uint32_t get_kmer_rank(uint32_t i, uint32_t k, bool do_rc) const { return ! do_rc ? _kmer_rank(i, k) : _rc_kmer_rank(i, k); } private: inline uint32_t _kmer_rank(uint32_t i, uint32_t k) const { return m_alphabet->kmer_rank(m_seq.c_str() + i, k); } inline uint32_t _rc_kmer_rank(uint32_t i, uint32_t k) const { return m_alphabet->kmer_rank(m_rc_seq.c_str() + (length() - i - k), k); } HMMInputSequence(); // not allowed const Alphabet* m_alphabet; std::string m_seq; std::string m_rc_seq; }; #endif nanopolish-0.4.0/src/hmm/nanopolish_profile_hmm.cpp000066400000000000000000000215221260522445600225040ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_profile_hmm -- Profile Hidden Markov Model // #include #include "nanopolish_profile_hmm.h" //#define DEBUG_FILL //#define PRINT_TRAINING_MESSAGES 1 void profile_hmm_forward_initialize(FloatMatrix& fm) { // initialize forward calculation for(uint32_t si = 0; si < fm.n_cols; si++) { set(fm, 0, si, -INFINITY); } for(uint32_t ri = 0; ri < fm.n_rows; ri++) { set(fm, ri, PS_KMER_SKIP, -INFINITY); set(fm, ri, PS_EVENT_SPLIT, -INFINITY); set(fm, ri, PS_MATCH, -INFINITY); } } // Terminate the forward algorithm by calculating // the probability of transitioning to the end state // for all columns and a given row float profile_hmm_forward_terminate(const FloatMatrix& fm, const FloatMatrix& tm, uint32_t row) { assert(false); return -INFINITY; /* float sum = -INFINITY; uint32_t tcol = fm.n_cols - 1; for(uint32_t sk = 0; sk < fm.n_cols - 1; sk++) { // transition probability from state k to state l float t_kl = get(tm, sk, tcol); float fm_k = get(fm, row, sk); sum = add_logs(sum, t_kl + fm_k); } return sum; */ } // convenience function to run the HMM over multiple inputs and sum the result float profile_hmm_score(const HMMInputSequence& sequence, const std::vector& data, const uint32_t flags) { float score = 0.0f; for(size_t i = 0; i < data.size(); ++i) { score += profile_hmm_score(sequence, data[i], flags); } return score; } float profile_hmm_score(const HMMInputSequence& sequence, const HMMInputData& data, const uint32_t flags) { const uint32_t k = data.read->pore_model[data.strand].k; uint32_t n_kmers = sequence.length() - k + 1; uint32_t n_states = PS_NUM_STATES * (n_kmers + 2); // + 2 for explicit terminal states uint32_t e_start = data.event_start_idx; uint32_t e_end = data.event_stop_idx; uint32_t n_events = 0; if(e_end > e_start) n_events = e_end - e_start + 1; else n_events = e_start - e_end + 1; uint32_t n_rows = n_events + 1; // Allocate a matrix to hold the HMM result FloatMatrix fm; allocate_matrix(fm, n_rows, n_states); profile_hmm_forward_initialize(fm); ProfileHMMForwardOutput output(&fm); float score = profile_hmm_fill_generic(sequence, data, e_start, flags, output); // cleanup free_matrix(fm); return score; } void profile_hmm_viterbi_initialize(FloatMatrix& m) { // Same as forward initialization profile_hmm_forward_initialize(m); } std::vector profile_hmm_align(const HMMInputSequence& sequence, const HMMInputData& data, const uint32_t flags) { std::vector alignment; const uint32_t k = data.read->pore_model[data.strand].k; uint32_t n_kmers = sequence.length() - k + 1; uint32_t n_states = PS_NUM_STATES * (n_kmers + 2); // + 2 for explicit terminal states uint32_t e_start = data.event_start_idx; uint32_t e_end = data.event_stop_idx; uint32_t n_events = 0; if(e_end > e_start) n_events = e_end - e_start + 1; else n_events = e_start - e_end + 1; assert(n_events >= 2); uint32_t n_rows = n_events + 1; // Allocate matrices to hold the HMM result FloatMatrix vm; allocate_matrix(vm, n_rows, n_states); UInt8Matrix bm; allocate_matrix(bm, n_rows, n_states); ProfileHMMViterbiOutput output(&vm, &bm); profile_hmm_viterbi_initialize(vm); profile_hmm_fill_generic(sequence, data, e_start, flags, output); // Traverse the backtrack matrix to compute the results // start from the last event matched to the last kmer uint32_t row = n_rows - 1; uint32_t col = PS_NUM_STATES * n_kmers + PS_MATCH; while(row > 0) { uint32_t event_idx = e_start + (row - 1) * data.event_stride; uint32_t block = col / PS_NUM_STATES; assert(block > 0); assert(get(vm, row, col) != -INFINITY); uint32_t kmer_idx = block - 1; ProfileState curr_ps = (ProfileState) (col % PS_NUM_STATES); HMMAlignmentState as; as.event_idx = event_idx; as.kmer_idx = kmer_idx; as.l_posterior = -INFINITY; // not computed as.l_fm = get(vm, row, col); as.log_transition_probability = -INFINITY; // not computed as.state = ps2char(curr_ps); alignment.push_back(as); // Update the event (row) and k-mer using the current state // The next state is encoded in the backtrack matrix for the current cell ProfileState next_ps = (ProfileState)get(bm, row, col); // If we hit the softclip state we are done aligning if(next_ps == PS_PRE_SOFT) { break; } #if DEBUG_BACKTRACK printf("Backtrack [%zu %zu] k: %zu block: %zu curr_ps: %c next_ps: %c\n", row, col, kmer_idx, block, ps2char(curr_ps), ps2char(next_ps)); #endif if(curr_ps == PS_MATCH) { row -= 1; kmer_idx -= 1; } else if(curr_ps == PS_EVENT_SPLIT) { row -= 1; // kmer stays the same } else { assert(curr_ps == PS_KMER_SKIP); // row stays the same kmer_idx -= 1; } col = PS_NUM_STATES * (kmer_idx + 1) + next_ps; } // std::reverse(alignment.begin(), alignment.end()); // free_matrix(vm); free_matrix(bm); return alignment; } // Print the alignment between the read-strand and a sequence void print_alignment(const std::string& name, uint32_t seq_id, uint32_t read_id, const HMMInputSequence& sequence, const HMMInputData& data, const std::vector& alignment) { size_t n_matches = 0; size_t n_merges = 0; size_t n_skips = 0; size_t n_mergeskips = 0; const uint32_t k = data.read->pore_model[data.strand].k; char prev_s = '\0'; for(size_t pi = 0; pi < alignment.size(); ++pi) { uint32_t ei = alignment[pi].event_idx; uint32_t ki = alignment[pi].kmer_idx; char s = alignment[pi].state; double level = data.read->get_drift_corrected_level(ei, data.strand); double sd = data.read->events[data.strand][ei].stdv; double duration = data.read->get_duration(ei, data.strand); uint32_t rank = sequence.get_kmer_rank(ki, k, data.rc); const PoreModel& pm = data.read->pore_model[data.strand]; GaussianParameters model = pm.get_scaled_parameters(rank); double norm_level = (level - model.mean) / model.stdv; double model_sd_mean = 0.0f; double model_sd_stdv = 0.0f; n_matches += (s == 'M'); n_merges += (s == 'E'); n_skips += (s == 'K'); n_mergeskips += (s == 'K' && prev_s == 'E'); double lp_diff = 0.0f; if(pi > 0) { lp_diff = alignment[pi].l_fm - alignment[pi - 1].l_fm; } else { lp_diff = alignment[pi].l_fm; } std::string kmer = sequence.get_kmer(ki, k, false); printf("DEBUG\t%s\t%d\t%d\t%c\t", name.c_str(), read_id, data.rc, "tc"[data.strand]); printf("%c\t%d\t%d\t", s, ei, ki); printf("%s\t%.3lf\t", kmer.c_str(), duration); printf("%.1lf\t%.1lf\t%.1lf\t", level, model.mean, norm_level); printf("\t%.1lf\t%.1lf\t%.1lf\t", sd, model_sd_mean, (sd - model_sd_mean) / model_sd_stdv); printf("%.2lf\t%.2lf\t%.2lf\n", exp(alignment[pi].l_posterior), alignment[pi].l_fm, lp_diff); prev_s = s; } // Summarize alignment double time_start = data.read->events[data.strand][data.event_start_idx].start_time; double time_end = data.read->events[data.strand][data.event_stop_idx].start_time; double total_duration = fabs(time_start - time_end); double num_events = abs(data.event_start_idx - data.event_stop_idx) + 1; double final_lp = alignment[alignment.size() - 1].l_fm; double mean_lp = final_lp / num_events; // Print summary header on first entry static int once = 1; if(once) { printf("SUMMARY\tseq_name\tseq_id\tread_id\tis_rc\tstrand\t"); printf("lp\tmean_lp\tnum_events\t"); printf("n_matches\tn_merges\tn_skips\tn_mergeskips\ttotal_duration\n"); once = 0; } printf("SUMMARY\t%s\t%d\t%d\t%d\t%c\t", name.c_str(), seq_id, read_id, data.rc, data.strand ? 't' : 'c'); printf("%.2lf\t%.2lf\t%.0lf\t", final_lp, mean_lp, num_events); printf("%zu\t%zu\t%zu\t%zu\t%.2lf\n", n_matches, n_merges, n_skips, n_mergeskips, total_duration); } nanopolish-0.4.0/src/hmm/nanopolish_profile_hmm.h000066400000000000000000000055001260522445600221470ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_profile_hmm -- Profile Hidden Markov Model // #ifndef NANOPOLISH_PROFILE_HMM_H #define NANOPOLISH_PROFILE_HMM_H #include #include #include #include "nanopolish_matrix.h" #include "nanopolish_common.h" #include "nanopolish_emissions.h" #include "nanopolish_hmm_input_sequence.h" // // High level algorithms // // Calculate the probability of the nanopore events given a sequence float profile_hmm_score(const HMMInputSequence& sequence, const HMMInputData& data, const uint32_t flags = 0); float profile_hmm_score(const HMMInputSequence& sequence, const std::vector& data, const uint32_t flags = 0); // Run viterbi to align events to kmers std::vector profile_hmm_align(const HMMInputSequence& sequence, const HMMInputData& data, const uint32_t flags = 0); // Print the alignment between the read-strand and a sequence void print_alignment(const std::string& name, uint32_t seq_id, uint32_t read_id, const HMMInputSequence& consensus, const HMMInputData& data, const std::vector& alignment); // // Forward algorithm // // Initialize the forward algorithm void profile_hmm_forward_initialize(FloatMatrix& fm); // Terminate the forward algorithm float profile_hmm_forward_terminate(const FloatMatrix& fm, uint32_t row); // // Viterbi // // initialize viterbi void profile_hmm_viterbi_initialize(FloatMatrix& m); // // Training // void profile_hmm_update_training(const HMMInputSequence& sequence, const HMMInputData& data); // Convenience enum for keeping track of the states in the profile HMM enum ProfileState { PS_KMER_SKIP = 0, PS_EVENT_SPLIT, PS_MATCH, PS_NUM_STATES = 3, PS_PRE_SOFT // intentionally after PS_NUM_STATES }; // Flags to modify the behaviour of the HMM enum HMMAlignmentFlags { HAF_ALLOW_PRE_CLIP = 1, // allow events to go unmatched before the aligning region HAF_ALLOW_POST_CLIP = 2 // allow events to go unmatched after the aligning region }; // Convert an enumerated state into a symbol inline char ps2char(ProfileState ps) { return "KEMNS"[ps]; } // Pre-computed transitions from the previous block // into the current block of states. Log-scaled. struct BlockTransitions { // Transition from m state float lp_me; float lp_mk; float lp_mm; // Transitions from e state float lp_ee; float lp_em; // Transitions from k state float lp_kk; float lp_km; }; // #include "nanopolish_profile_hmm.inl" #endif nanopolish-0.4.0/src/hmm/nanopolish_profile_hmm.inl000066400000000000000000000403161260522445600225060ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_profile_hmm -- Profile Hidden Markov Model // inline float calculate_skip_probability(const HMMInputSequence& sequence, const HMMInputData& data, uint32_t ki, uint32_t kj) { const PoreModel& pm = data.read->pore_model[data.strand]; const TransitionParameters& parameters = data.read->parameters[data.strand]; uint32_t rank_i = sequence.get_kmer_rank(ki, pm.k, data.rc); uint32_t rank_j = sequence.get_kmer_rank(kj, pm.k, data.rc); GaussianParameters level_i = pm.get_scaled_parameters(rank_i); GaussianParameters level_j = pm.get_scaled_parameters(rank_j); return parameters.get_skip_probability(level_i.mean, level_j.mean); } inline std::vector calculate_transitions(uint32_t num_kmers, const HMMInputSequence& sequence, const HMMInputData& data) { const TransitionParameters& parameters = data.read->parameters[data.strand]; std::vector transitions(num_kmers); for(uint32_t ki = 0; ki < num_kmers; ++ki) { // probability of skipping k_i from k_(i - 1) float p_skip = ki > 0 ? calculate_skip_probability(sequence, data, ki - 1, ki) : 0.0f; // transitions from match state in previous block float p_mk = p_skip; float p_me = (1 - p_skip) * parameters.trans_m_to_e_not_k; float p_mm = 1.0f - p_me - p_mk; // transitions from event split state in previous block float p_ee = parameters.trans_e_to_e; float p_em = 1.0f - p_ee; // p_ie not allowed // transitions from kmer skip state in previous block float p_kk = p_skip; float p_km = 1 - p_skip; // p_ei not allowed // log-transform and store BlockTransitions& bt = transitions[ki]; bt.lp_me = log(p_me); bt.lp_mk = log(p_mk); bt.lp_mm = log(p_mm); bt.lp_ee = log(p_ee); bt.lp_em = log(p_em); bt.lp_kk = log(p_kk); bt.lp_km = log(p_km); } return transitions; } // Output writer for the Forward Algorithm class ProfileHMMForwardOutput { public: ProfileHMMForwardOutput(FloatMatrix* p) : p_fm(p), lp_end(-INFINITY) {} // inline void update_4(uint32_t row, uint32_t col, float m, float e, float k, float s, float lp_emission) { float sum_1 = add_logs(m, e); float sum_2 = add_logs(k, s); float sum = add_logs(sum_1, sum_2) + lp_emission; set(*p_fm, row, col, sum); } // add in the probability of ending the alignment at row,col inline void update_end(float v, uint32_t row, uint32_t col) { lp_end = add_logs(lp_end, v); } // get the log probability stored at a particular row/column inline float get(uint32_t row, uint32_t col) const { return ::get(*p_fm, row, col); } // get the log probability for the end state inline float get_end() const { return lp_end; } inline size_t get_num_columns() const { return p_fm->n_cols; } inline size_t get_num_rows() const { return p_fm->n_rows; } private: ProfileHMMForwardOutput(); // not allowed FloatMatrix* p_fm; float lp_end; }; // Output writer for the Viterbi Algorithm class ProfileHMMViterbiOutput { public: ProfileHMMViterbiOutput(FloatMatrix* pf, UInt8Matrix* pb) : p_fm(pf), p_bm(pb), lp_end(-INFINITY) {} inline void update_4(uint32_t row, uint32_t col, float m, float e, float k, float s, float lp_emission) { // probability update float max = std::max(std::max(m, e), std::max(k, s)); set(*p_fm, row, col, max + lp_emission); // backtrack update uint8_t from; if(max == m) from = PS_MATCH; else if(max == e) from = PS_EVENT_SPLIT; else if(max == k) from = PS_KMER_SKIP; else if(max == s) from = PS_PRE_SOFT; set(*p_bm, row, col, from); } // add in the probability of ending the alignment at row,col inline void update_end(float v, uint32_t row, uint32_t col) { if(v > lp_end) { lp_end = v; end_row = row; end_col = col; } } // get the log probability stored at a particular row/column inline float get(uint32_t row, uint32_t col) const { return ::get(*p_fm, row, col); } // get the log probability for the end state inline float get_end() const { return lp_end; } // get the row/col that lead to the end state inline void get_end_cell(uint32_t& row, uint32_t& col) { row = end_row; col = end_col; } inline size_t get_num_columns() const { return p_fm->n_cols; } inline size_t get_num_rows() const { return p_fm->n_rows; } private: ProfileHMMViterbiOutput(); // not allowed FloatMatrix* p_fm; UInt8Matrix* p_bm; float lp_end; uint32_t end_row; uint32_t end_col; }; // Allocate a vector with the model probabilities of skipping the first i events inline std::vector make_pre_flanking(const HMMInputData& data, const TransitionParameters& parameters, const uint32_t e_start, const uint32_t num_events) { std::vector pre_flank(num_events + 1, 0.0f); // base cases // no skipping pre_flank[0] = log(1 - parameters.trans_start_to_clip); // skipping the first event // this includes the transition probability into and out of the skip state pre_flank[1] = log(parameters.trans_start_to_clip) + // transition from start to the background state log_probability_background(*data.read, e_start, data.strand) + // emit from background log(1 - parameters.trans_clip_self); // transition to silent pre state // skip the remaining events for(size_t i = 2; i < pre_flank.size(); ++i) { uint32_t event_idx = e_start + (i - 1) * data.event_stride; pre_flank[i] = log(parameters.trans_clip_self) + log_probability_background(*data.read, event_idx, data.strand) + // emit from background pre_flank[i - 1]; // this accounts for the transition from the start & to the silent pre } return pre_flank; } // Allocate a vector with the model probabilities of skipping the remaining // events after the alignment of event i inline std::vector make_post_flanking(const HMMInputData& data, const TransitionParameters& parameters, const uint32_t e_start, const uint32_t num_events) { // post_flank[i] means that the i-th event was the last one // aligned and the remainder should be emitted from the background model std::vector post_flank(num_events, 0.0f); // base case, all events aligned post_flank[num_events - 1] = log(1 - parameters.trans_start_to_clip); if(num_events > 1) { // base case, all events aligned but 1 { uint32_t event_idx = e_start + (num_events - 1) * data.event_stride; // last event assert(event_idx == data.event_stop_idx); post_flank[num_events - 2] = log(parameters.trans_start_to_clip) + // transition from pre to background state log_probability_background(*data.read, event_idx, data.strand) + // emit from background log(1 - parameters.trans_clip_self); // transition to silent pre state } for(int i = num_events - 3; i >= 0; --i) { uint32_t event_idx = e_start + (i + 1) * data.event_stride; post_flank[i] = log(parameters.trans_clip_self) + log_probability_background(*data.read, event_idx, data.strand) + // emit from background post_flank[i + 1]; // this accounts for the transition from start, and to silent pre } } return post_flank; } // This function fills in a matrix with the result of running the HMM. // The templated ProfileHMMOutput class allows one to run either Viterbi // or the Forward algorithm. template inline float profile_hmm_fill_generic(const HMMInputSequence& sequence, const HMMInputData& data, const uint32_t e_start, uint32_t flags, ProfileHMMOutput& output) { PROFILE_FUNC("profile_hmm_fill_generic") const TransitionParameters& parameters = data.read->parameters[data.strand]; // Calculate number of blocks // A block of the HMM is a set of PS_KMER_SKIP, PS_EVENT_SPLIT, PS_MATCH // events for one kmer uint32_t num_blocks = output.get_num_columns() / PS_NUM_STATES; uint32_t last_event_row_idx = output.get_num_rows() - 1; // Precompute the transition probabilites for each kmer block uint32_t num_kmers = num_blocks - 2; // two terminal blocks uint32_t last_kmer_idx = num_kmers - 1; std::vector transitions = calculate_transitions(num_kmers, sequence, data); // Precompute kmer ranks uint32_t k = data.read->pore_model[data.strand].k; // Make sure the HMMInputSequence's alphabet matches the state space of the read assert( data.read->pore_model[data.strand].states.size() == sequence.get_num_kmer_ranks(k) ); std::vector kmer_ranks(num_kmers); for(size_t ki = 0; ki < num_kmers; ++ki) kmer_ranks[ki] = sequence.get_kmer_rank(ki, k, data.rc); size_t num_events = output.get_num_rows() - 1; std::vector pre_flank = make_pre_flanking(data, parameters, e_start, num_events); std::vector post_flank = make_post_flanking(data, parameters, e_start, num_events); // The model is currently constrainted to always transition // from the terminal/clipped state to the first kmer (and from the // last kmer to the terminal/clipping state so these are log(1.0). // They are kept as variables as it might be relaxed later. float lp_sm, lp_ms; lp_sm = lp_ms = 0.0f; // Fill in matrix for(uint32_t row = 1; row < output.get_num_rows(); row++) { // Skip the first block which is the start state, it was initialized above // Similarily skip the last block, which is calculated in the terminate() function for(uint32_t block = 1; block < num_blocks - 1; block++) { // retrieve transitions uint32_t kmer_idx = block - 1; BlockTransitions& bt = transitions[kmer_idx]; uint32_t prev_block = block - 1; uint32_t prev_block_offset = PS_NUM_STATES * prev_block; uint32_t curr_block_offset = PS_NUM_STATES * block; // Emission probabilities uint32_t event_idx = e_start + (row - 1) * data.event_stride; uint32_t rank = kmer_ranks[kmer_idx]; float lp_emission_m = log_probability_match(*data.read, rank, event_idx, data.strand); float lp_emission_e = log_probability_event_insert(*data.read, rank, event_idx, data.strand); // state PS_MATCH float m_m = bt.lp_mm + output.get(row - 1, prev_block_offset + PS_MATCH); float m_e = bt.lp_em + output.get(row - 1, prev_block_offset + PS_EVENT_SPLIT); float m_k = bt.lp_km + output.get(row - 1, prev_block_offset + PS_KMER_SKIP); // m_s is the probability of going from the start state // to this kmer. The start state is (currently) only // allowed to go to the first kmer. If ALLOW_PRE_CLIP // is defined, we allow all events before this one to be skipped, // with a penalty; float m_s = (kmer_idx == 0 && (event_idx == e_start || (flags & HAF_ALLOW_PRE_CLIP))) ? lp_sm + pre_flank[row - 1] : -INFINITY; output.update_4(row, curr_block_offset + PS_MATCH, m_m, m_e, m_k, m_s, lp_emission_m); // state PS_EVENT_SPLIT float e_m = bt.lp_me + output.get(row - 1, curr_block_offset + PS_MATCH); float e_e = bt.lp_ee + output.get(row - 1, curr_block_offset + PS_EVENT_SPLIT); output.update_4(row, curr_block_offset + PS_EVENT_SPLIT, e_m, e_e, -INFINITY, -INFINITY, lp_emission_e); // state PS_KMER_SKIP float k_m = bt.lp_mk + output.get(row, prev_block_offset + PS_MATCH); float k_k = bt.lp_kk + output.get(row, prev_block_offset + PS_KMER_SKIP); output.update_4(row, curr_block_offset + PS_KMER_SKIP, k_m, -INFINITY, k_k, -INFINITY, 0.0f); // no emission // If POST_CLIP is enabled we allow the last kmer to transition directly // to the end after any event. Otherwise we only allow it from the // last kmer/event match. if(kmer_idx == last_kmer_idx && ( (flags & HAF_ALLOW_POST_CLIP) || row == last_event_row_idx)) { float lp1 = lp_ms + output.get(row, curr_block_offset + PS_MATCH) + post_flank[row - 1]; float lp2 = lp_ms + output.get(row, curr_block_offset + PS_EVENT_SPLIT) + post_flank[row - 1]; float lp3 = lp_ms + output.get(row, curr_block_offset + PS_KMER_SKIP) + post_flank[row - 1]; output.update_end(lp1, row, curr_block_offset + PS_MATCH); output.update_end(lp2, row, curr_block_offset + PS_EVENT_SPLIT); output.update_end(lp3, row, curr_block_offset + PS_KMER_SKIP); } #ifdef DEBUG_LOCAL_ALIGNMENT printf("[%d %d] start: %.2lf pre: %.2lf fm: %.2lf\n", event_idx, kmer_idx, m_s + lp_emission_m, pre_flank[row - 1], output.get(row, curr_block_offset + PS_MATCH)); printf("[%d %d] end: %.2lf post: %.2lf\n", event_idx, kmer_idx, lp_end, post_flank[row - 1]); #endif #ifdef DEBUG_FILL printf("Row %u block %u\n", row, block); printf("\tTransitions: p_mx [%.3lf %.3lf %.3lf]\n", bt.lp_mm, bt.lp_me, bt.lp_mk); printf("\t p_ex [%.3lf %.3lf %.3lf]\n", bt.lp_em, bt.lp_ee, 0.0f); printf("\t p_lx [%.3lf %.3lf %.3lf]\n", bt.lp_km, 0.0, bt.lp_kk); printf("\tPS_MATCH -- Transitions: [%.3lf %.3lf %.3lf] Prev: [%.2lf %.2lf %.2lf] sum: %.2lf\n", bt.lp_mm, bt.lp_em, bt.lp_km, output.get(row - 1, prev_block_offset + PS_MATCH), output.get(row - 1, prev_block_offset + PS_EVENT_SPLIT), output.get(row - 1, prev_block_offset + PS_KMER_SKIP), 0.0f); printf("\tPS_EVENT_SPLIT -- Transitions: [%.3lf %.3lf] Prev: [%.2lf %.2lf] sum: %.2lf\n", bt.lp_me, bt.lp_ee, output.get(row - 1, curr_block_offset + PS_MATCH), output.get(row - 1, curr_block_offset + PS_EVENT_SPLIT), 0.0f); printf("\tPS_KMER_SKIP -- Transitions: [%.3lf %.3lf] Prev: [%.2lf %.2lf] sum: %.2lf\n", bt.lp_mk, bt.lp_kk, output.get(row, prev_block_offset + PS_MATCH), output.get(row, prev_block_offset + PS_KMER_SKIP), 0.0f); printf("\tEMISSION: %.2lf %.2lf\n", lp_emission_m, lp_emission_e); #endif } } return output.get_end(); } nanopolish-0.4.0/src/hmm/nanopolish_transition_parameters.cpp000066400000000000000000000306511260522445600246230ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_transition_parameters -- parameters for khmm model // #include #include #include #include "nanopolish_transition_parameters.h" #include "nanopolish_poremodel.h" #include "nanopolish_squiggle_read.h" TransitionParameters::TransitionParameters() { // initialize training data TransitionTrainingData& td = training_data; td.n_matches = 0; td.n_merges = 0; td.n_skips = 0; // allocate_matrix(td.state_transitions, 3, 3); for(int i = 0; i < td.state_transitions.n_rows; ++i) { for(int j = 0; j < td.state_transitions.n_cols; ++j) { set(td.state_transitions, i, j, 0); } } // // Initialize transition parameters // // these are fixed across all models skip_bin_width = 0.5; skip_probabilities.resize(30); trans_start_to_clip = 0.5f; trans_clip_self = 0.90f; } // TransitionParameters::~TransitionParameters() { free_matrix(training_data.state_transitions); } void TransitionParameters::initialize(const std::string& model_name) { is_initialized = true; if(model_name == "r7.3_template_median68pA.model" || model_name == "r7.3_complement_median68pA_pop1.model" || model_name == "r7.3_complement_median68pA_pop2.model") { initialize_sqkmap005(); } else if(model_name == "r7.3_e6_70bps_6mer_template_median68pA.model") { initialize_sqkmap006_template(); } else if(model_name == "r7.3_e6_70bps_6mer_complement_median68pA_pop1.model" || model_name == "r7.3_e6_70bps_6mer_complement_median68pA_pop2.model") { initialize_sqkmap006_complement(); } else { printf("Error: unknown model: %s\n", model_name.c_str()); exit(EXIT_FAILURE); } } void TransitionParameters::initialize_sqkmap005() { assert(!skip_probabilities.empty()); trans_m_to_e_not_k = 0.15f; trans_e_to_e = 0.33f; skip_probabilities[0] = 0.51268137; skip_probabilities[1] = 0.47243219; skip_probabilities[2] = 0.42888741; skip_probabilities[3] = 0.34932588; skip_probabilities[4] = 0.27427068; skip_probabilities[5] = 0.22297225; skip_probabilities[6] = 0.17585147; skip_probabilities[7] = 0.14705882; skip_probabilities[8] = 0.12183525; skip_probabilities[9] = 0.11344997; skip_probabilities[10] = 0.10069393; skip_probabilities[11] = 0.09153005; skip_probabilities[12] = 0.08765206; skip_probabilities[13] = 0.08491435; skip_probabilities[14] = 0.08272553; skip_probabilities[15] = 0.07747396; skip_probabilities[16] = 0.08439116; skip_probabilities[17] = 0.07819045; skip_probabilities[18] = 0.07337461; skip_probabilities[19] = 0.07020490; skip_probabilities[20] = 0.06869961; skip_probabilities[21] = 0.06576609; skip_probabilities[22] = 0.06923376; skip_probabilities[23] = 0.06239092; skip_probabilities[24] = 0.06586513; skip_probabilities[25] = 0.07372986; skip_probabilities[26] = 0.07050360; skip_probabilities[27] = 0.07228916; skip_probabilities[28] = 0.05855856; skip_probabilities[29] = 0.06842737; } void TransitionParameters::initialize_sqkmap006_template() { assert(!skip_probabilities.empty()); trans_m_to_e_not_k = 0.17f; trans_e_to_e = 0.55f; skip_probabilities[0] = 0.487; skip_probabilities[1] = 0.412; skip_probabilities[2] = 0.311; skip_probabilities[3] = 0.229; skip_probabilities[4] = 0.174; skip_probabilities[5] = 0.134; skip_probabilities[6] = 0.115; skip_probabilities[7] = 0.103; skip_probabilities[8] = 0.096; skip_probabilities[9] = 0.092; skip_probabilities[10] = 0.088; skip_probabilities[11] = 0.087; skip_probabilities[12] = 0.084; skip_probabilities[13] = 0.085; skip_probabilities[14] = 0.083; skip_probabilities[15] = 0.082; skip_probabilities[16] = 0.085; skip_probabilities[17] = 0.083; skip_probabilities[18] = 0.084; skip_probabilities[19] = 0.082; skip_probabilities[20] = 0.080; skip_probabilities[21] = 0.085; skip_probabilities[22] = 0.088; skip_probabilities[23] = 0.086; skip_probabilities[24] = 0.087; skip_probabilities[25] = 0.089; skip_probabilities[26] = 0.085; skip_probabilities[27] = 0.090; skip_probabilities[28] = 0.087; skip_probabilities[29] = 0.096; } void TransitionParameters::initialize_sqkmap006_complement() { assert(!skip_probabilities.empty()); trans_m_to_e_not_k = 0.14f; trans_e_to_e = 0.49f; skip_probabilities[0] = 0.531; skip_probabilities[1] = 0.478; skip_probabilities[2] = 0.405; skip_probabilities[3] = 0.327; skip_probabilities[4] = 0.257; skip_probabilities[5] = 0.207; skip_probabilities[6] = 0.172; skip_probabilities[7] = 0.154; skip_probabilities[8] = 0.138; skip_probabilities[9] = 0.132; skip_probabilities[10] = 0.127; skip_probabilities[11] = 0.123; skip_probabilities[12] = 0.117; skip_probabilities[13] = 0.115; skip_probabilities[14] = 0.113; skip_probabilities[15] = 0.113; skip_probabilities[16] = 0.115; skip_probabilities[17] = 0.109; skip_probabilities[18] = 0.109; skip_probabilities[19] = 0.107; skip_probabilities[20] = 0.104; skip_probabilities[21] = 0.105; skip_probabilities[22] = 0.108; skip_probabilities[23] = 0.106; skip_probabilities[24] = 0.111; skip_probabilities[25] = 0.114; skip_probabilities[26] = 0.118; skip_probabilities[27] = 0.119; skip_probabilities[28] = 0.110; skip_probabilities[29] = 0.119; } // double TransitionParameters::get_skip_probability(double k_level1, double k_level2) const { assert(is_initialized); size_t bin = get_skip_bin(k_level1, k_level2); assert(bin < skip_probabilities.size()); return skip_probabilities[bin]; } // int statechar2index(char s) { switch(s) { case 'M': return 0; case 'E': return 1; case 'K': return 2; } assert(false); return 0; } // void TransitionParameters::add_transition_observation(char state_from, char state_to) { int f_idx = statechar2index(state_from); int t_idx = statechar2index(state_to); int count = get(training_data.state_transitions, f_idx, t_idx); set(training_data.state_transitions, f_idx, t_idx, count + 1); } void TransitionParameters::add_training_from_alignment(const HMMInputSequence& sequence, const HMMInputData& data, const std::vector& alignment, size_t ignore_edge_length) { // do nothing if the alignment is too short if(alignment.size() <= ignore_edge_length) { return; } const PoreModel& pm = data.read->pore_model[data.strand]; const uint32_t k = pm.k; size_t n_kmers = sequence.length() - k + 1; uint32_t strand_idx = 0; char prev_s = 'M'; for(size_t pi = 0; pi < alignment.size(); ++pi) { uint32_t ei = alignment[pi].event_idx; uint32_t ki = alignment[pi].kmer_idx; char s = alignment[pi].state; // Record transition observations // We do not record observations for merge states as there was no kmer transitions // We also do not record observations for the beginning of the matches as the // alignment may be poor due to edge effects if(pi > ignore_edge_length && pi < alignment.size() - ignore_edge_length) { // skip transition training data // we do not process the E state here as no k-mer move was made if(s != 'E') { uint32_t transition_kmer_from = alignment[pi - 1].kmer_idx; uint32_t transition_kmer_to = alignment[pi].kmer_idx; // Specially handle skips // We only want to record the first k-mer skipped if multiple were skipped if(s == 'K') { transition_kmer_from = alignment[pi - 1].kmer_idx; transition_kmer_to = transition_kmer_from + 1; } assert(transition_kmer_from < n_kmers && transition_kmer_to < n_kmers); uint32_t rank_1 = sequence.get_kmer_rank(transition_kmer_from, k, data.rc); uint32_t rank_2 = sequence.get_kmer_rank(transition_kmer_to, k, data.rc); GaussianParameters level_1 = pm.get_scaled_parameters(rank_1); GaussianParameters level_2 = pm.get_scaled_parameters(rank_2); #ifdef PRINT_TRAINING_MESSAGES printf("TRAIN_SKIP\t%d\t%.3lf\t%.3lf\t%c\n", strand_idx, level_1.mean, level_2.mean, s); #endif KmerTransitionObservation to = { level_1.mean, level_2.mean, s }; training_data.kmer_transitions.push_back(to); } // State-to-state transition add_transition_observation(prev_s, s); // emission float level = data.read->get_drift_corrected_level(ei, data.strand); float sd = data.read->events[data.strand][ei].stdv; float duration = data.read->get_duration(ei, data.strand); if(ki >= n_kmers) printf("%zu %d %d %zu %.2lf %c\n", pi, ei, ki, n_kmers, alignment[pi].l_fm, s); assert(ki < n_kmers); uint32_t rank = sequence.get_kmer_rank(ki, k, data.rc); GaussianParameters model = pm.get_scaled_parameters(rank); float norm_level = (level - model.mean) / model.stdv; prev_s = s; } // summary training_data.n_matches += (s == 'M'); training_data.n_merges += (s == 'E'); training_data.n_skips += (s == 'K'); } } void TransitionParameters::train() { TransitionTrainingData& td = training_data; // // Profile HMM transitions // size_t sum_m_not_k = get(td.state_transitions, statechar2index('M'), statechar2index('M')) + get(td.state_transitions, statechar2index('M'), statechar2index('E')); size_t me = get(td.state_transitions, statechar2index('M'), statechar2index('E')); double p_me_not_k = (double)me / sum_m_not_k; size_t sum_e = 0; for(int j = 0; j < td.state_transitions.n_cols; ++j) { sum_e += get(td.state_transitions, statechar2index('E'), j); } size_t ee = get(td.state_transitions, statechar2index('E'), statechar2index('E')); double p_ee = (double)ee / sum_e; #ifdef SHOW_TRAINING_RESULT fprintf(stderr, "TRANSITIONS\n"); fprintf(stderr, "M->E|not_k: %lf\n", p_me_not_k); fprintf(stderr, "E->E: %lf\n", p_ee); for(int i = 0; i < td.state_transitions.n_rows; ++i) { fprintf(stderr, "\t%c: ", "MEK"[i]); for(int j = 0; j < td.state_transitions.n_cols; ++j) { fprintf(stderr, "%d ", get(td.state_transitions, i, j)); } fprintf(stderr, "\n"); } #endif if(sum_e == 0 || sum_m_not_k == 0) { // insufficient data to train, use defaults return; } trans_m_to_e_not_k = p_me_not_k; trans_e_to_e = p_ee; // // Signal-dependent skip probability // // Initialize observations with pseudocounts from the current model size_t num_bins = skip_probabilities.size(); uint32_t pseudocount = 100; std::vector total_observations(num_bins, 0.0f); std::vector skip_observations(num_bins, 0.0f); for(size_t bin = 0; bin < num_bins; bin++) { skip_observations[bin] = skip_probabilities[bin] * pseudocount; total_observations[bin] = pseudocount; } for(size_t oi = 0; oi < td.kmer_transitions.size(); ++oi) { const KmerTransitionObservation& to = td.kmer_transitions[oi]; bool is_skip = to.state == 'K'; size_t bin = get_skip_bin(to.level_1, to.level_2); skip_observations[bin] += is_skip; total_observations[bin] += 1; } // Update probabilities for(size_t bin = 0; bin < num_bins; bin++) { skip_probabilities[bin] = skip_observations[bin] / total_observations[bin]; #ifdef SHOW_TRAINING_RESULT fprintf(stderr, "SKIPLEARN -- %zu %.3lf %.3lf %.3lf\n", bin, skip_observations[bin], total_observations[bin], skip_probabilities[bin]); #endif } } nanopolish-0.4.0/src/hmm/nanopolish_transition_parameters.h000066400000000000000000000064141260522445600242700ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_transitions_parameters -- transition // parameters for profile HMM // #ifndef NANOPOLISH_TRANSITION_PARAMETERS #define NANOPOLISH_TRANSITION_PARAMETERS #include #include #include "nanopolish_matrix.h" #include "nanopolish_hmm_input_sequence.h" // struct KmerTransitionObservation { double level_1; double level_2; char state; }; // This struct holds observations used to learn the parameters struct TransitionTrainingData { uint32_t n_matches; uint32_t n_merges; uint32_t n_skips; std::vector kmer_transitions; UInt32Matrix state_transitions; }; // class TransitionParameters { public: // // functions // TransitionParameters(); ~TransitionParameters(); void initialize(const std::string& model_name); // update transition parameters from training data void train(); // Get the probability of skipping a kmer observation given the pair of expected levels double get_skip_probability(double k_level1, double k_level2) const; // add an observation of a state transition to the training data void add_transition_observation(char hmm_state_from, char hmm_state_to); // update the training data using the alignment void add_training_from_alignment(const HMMInputSequence& sequence, const HMMInputData& data, const std::vector& alignment, size_t ignore_edge_length = 5); // // data // double trans_m_to_e_not_k; double trans_e_to_e; double trans_start_to_clip; double trans_clip_self; bool is_initialized = false; // This is a vector that maps from discretized absolute difference // between expected signals to a probability that the transition // will be observed by the pore. Access to the skip probabilities // for a pair of k-mer levels is through get_skip_probability() std::vector skip_probabilities; double skip_bin_width; // Data used to train the model TransitionTrainingData training_data; private: // Model-specific transition initialization void initialize_sqkmap005(); void initialize_sqkmap006_template(); void initialize_sqkmap006_complement(); // Not allowed TransitionParameters(const TransitionParameters& other) {} // Calculate which bin of the skip probability table this level difference falls in inline size_t get_skip_bin(double k_level1, double k_level2) const { assert(!skip_probabilities.empty()); double d = fabs(k_level1 - k_level2); size_t bin = d / skip_bin_width; // clamp out-of-range to last value bin = bin >= skip_probabilities.size() ? skip_probabilities.size() - 1 : bin; return bin; } }; #endif nanopolish-0.4.0/src/main/000077500000000000000000000000001260522445600154065ustar00rootroot00000000000000nanopolish-0.4.0/src/main/nanopolish.cpp000066400000000000000000000034151260522445600202670ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish.cpp -- main driver program // #include #include #include "logsum.h" #include "nanopolish_call_variants.h" #include "nanopolish_consensus.h" #include "nanopolish_eventalign.h" #include "nanopolish_getmodel.h" #include "nanopolish_methyltrain.h" #include "nanopolish_methyltest.h" // This code needs to be run before any of the program logic // It sets up pre-computed values and caches void initialize() { p7_FLogsumInit(); } void print_usage() { printf("usage: nanopolish [command] [options]\n"); } int main(int argc, char** argv) { initialize(); if(argc <= 1) { printf("error: no command provided\n"); print_usage(); return 0; } else { std::string command(argv[1]); if(command == "help" || command == "--help") { print_usage(); return 0; } else if(command == "consensus") { consensus_main(argc - 1, argv + 1); return 0; } else if(command == "eventalign") { eventalign_main(argc - 1, argv + 1); return 0; } else if(command == "getmodel") { getmodel_main(argc - 1, argv + 1); return 0; } else if(command == "variants") { call_variants_main(argc - 1, argv + 1); return 0; } else if(command == "methyltrain") { methyltrain_main(argc - 1, argv + 1); return 0; } else if(command == "methyltest") { methyltest_main(argc - 1, argv + 1); return 0; } } } nanopolish-0.4.0/src/nanopolish_call_variants.cpp000066400000000000000000000356501260522445600222530ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_call_variants -- find variants wrt a reference // #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "htslib/faidx.h" #include "nanopolish_poremodel.h" #include "nanopolish_transition_parameters.h" #include "nanopolish_matrix.h" #include "nanopolish_klcs.h" #include "nanopolish_profile_hmm.h" #include "nanopolish_alignment_db.h" #include "nanopolish_anchor.h" #include "nanopolish_fast5_map.h" #include "nanopolish_variant.h" #include "nanopolish_haplotype.h" #include "profiler.h" #include "progress.h" #include "stdaln.h" // Macros #define max3(x,y,z) std::max(std::max(x,y), z) // Flags to turn on/off debugging information //#define DEBUG_HMM_UPDATE 1 //#define DEBUG_HMM_EMISSION 1 //#define DEBUG_TRANSITION 1 //#define DEBUG_PATH_SELECTION 1 //#define DEBUG_SINGLE_SEGMENT 1 //#define DEBUG_SHOW_TOP_TWO 1 //#define DEBUG_SEGMENT_ID 193 //#define DEBUG_BENCHMARK 1 // // Getopt // #define SUBPROGRAM "variants" static const char *CONSENSUS_VERSION_MESSAGE = SUBPROGRAM " Version " PACKAGE_VERSION "\n" "Written by Jared Simpson.\n" "\n" "Copyright 2015 Ontario Institute for Cancer Research\n"; static const char *CONSENSUS_USAGE_MESSAGE = "Usage: " PACKAGE_NAME " " SUBPROGRAM " [OPTIONS] --reads reads.fa --bam alignments.bam --genome genome.fa\n" "Find SNPs using a signal-level HMM\n" "\n" " -v, --verbose display verbose output\n" " --version display version\n" " --help display this help and exit\n" " --snps only call SNPs\n" " -w, --window=STR find variants in window STR (format: ctg:start-end)\n" " -r, --reads=FILE the 2D ONT reads are in fasta FILE\n" " -b, --bam=FILE the reads aligned to the reference genome are in bam FILE\n" " -e, --event-bam=FILE the events aligned to the reference genome are in bam FILE\n" " -g, --genome=FILE the reference genome is in FILE\n" " -o, --outfile=FILE write result to FILE [default: stdout]\n" " -t, --threads=NUM use NUM threads (default: 1)\n" " -m, --min-candidate-frequency=F alternative bases in F proporation of aligned reads are candidate variants (default 0.2)\n" " -c, --candidates=VCF read variant candidates from VCF, rather than discovering them from aligned reads\n" " --calculate-all-support when making a call, also calculate the support of the 3 other possible bases\n" "\nReport bugs to " PACKAGE_BUGREPORT "\n\n"; namespace opt { static unsigned int verbose; static std::string reads_file; static std::string bam_file; static std::string event_bam_file; static std::string genome_file; static std::string output_file; static std::string candidates_file; static std::string window; static double min_candidate_frequency = 0.2f; static int calculate_all_support = false; static int snps_only = 0; static int show_progress = 0; static int num_threads = 1; } static const char* shortopts = "r:b:g:t:w:o:e:m:c:v"; enum { OPT_HELP = 1, OPT_VERSION, OPT_VCF, OPT_PROGRESS, OPT_SNPS_ONLY, OPT_CALC_ALL_SUPPORT }; static const struct option longopts[] = { { "verbose", no_argument, NULL, 'v' }, { "reads", required_argument, NULL, 'r' }, { "bam", required_argument, NULL, 'b' }, { "event-bam", required_argument, NULL, 'e' }, { "genome", required_argument, NULL, 'g' }, { "window", required_argument, NULL, 'w' }, { "outfile", required_argument, NULL, 'o' }, { "threads", required_argument, NULL, 't' }, { "min-candidate-frequency", required_argument, NULL, 'm' }, { "candidates", required_argument, NULL, 'c' }, { "calculate-all-support", no_argument, NULL, OPT_CALC_ALL_SUPPORT }, { "snps", no_argument, NULL, OPT_SNPS_ONLY }, { "progress", no_argument, NULL, OPT_PROGRESS }, { "help", no_argument, NULL, OPT_HELP }, { "version", no_argument, NULL, OPT_VERSION }, { NULL, 0, NULL, 0 } }; int get_contig_length(const std::string& contig) { faidx_t *fai = fai_load(opt::genome_file.c_str()); int len = faidx_seq_len(fai, contig.c_str()); fai_destroy(fai); return len; } void annotate_with_all_support(std::vector& variants, Haplotype base_haplotype, const std::vector& input, const uint32_t alignment_flags) { for(size_t vi = 0; vi < variants.size(); vi++) { // Generate a haplotype containing every variant in the set except for vi Haplotype test_haplotype = base_haplotype; for(size_t vj = 0; vj < variants.size(); vj++) { // do not apply the variant we are testing if(vj == vi) { continue; } test_haplotype.apply_variant(variants[vj]); } // Make a vector of four haplotypes, one per base std::vector curr_haplotypes; Variant tmp_variant = variants[vi]; for(size_t bi = 0; bi < 4; ++bi) { tmp_variant.alt_seq = "ACGT"[bi]; Haplotype tmp = test_haplotype; tmp.apply_variant(tmp_variant); curr_haplotypes.push_back(tmp); } // Test all reads against the 4 haplotypes std::vector support_count(4, 0); for(size_t input_idx = 0; input_idx < input.size(); ++input_idx) { double best_score = -INFINITY; size_t best_hap_idx = 0; // calculate which haplotype this read supports best for(size_t hap_idx = 0; hap_idx < curr_haplotypes.size(); ++hap_idx) { double score = profile_hmm_score(curr_haplotypes[hap_idx].get_sequence(), input[input_idx], alignment_flags); if(score > best_score) { best_score = score; best_hap_idx = hap_idx; } } support_count[best_hap_idx] += 1; } std::stringstream ss; for(size_t bi = 0; bi < 4; ++bi) { ss << support_count[bi] / (double)input.size() << (bi != 3 ? "," : ""); } variants[vi].add_info("AllSupportFractions", ss.str()); } } std::vector get_variants_from_vcf(const std::string& filename, const std::string& contig, int region_start, int region_end) { std::vector out; std::ifstream infile(filename); std::string line; while(getline(infile, line)) { // skip headers if(line[0] == '#') { continue; } // parse variant Variant v(line); if(v.ref_name == contig && v.ref_position >= region_start && v.ref_position <= region_end) { out.push_back(v); } } return out; } Haplotype call_variants_for_region(const std::string& contig, int region_start, int region_end) { const int BUFFER = 20; uint32_t alignment_flags = HAF_ALLOW_PRE_CLIP | HAF_ALLOW_POST_CLIP; if(region_start < BUFFER) region_start = BUFFER; // load the region, accounting for the buffering AlignmentDB alignments(opt::reads_file, opt::genome_file, opt::bam_file, opt::event_bam_file); alignments.load_region(contig, region_start - BUFFER, region_end + BUFFER); Haplotype derived_haplotype(contig, alignments.get_region_start(), alignments.get_reference()); // Step 1. Discover putative variants across the whole region std::vector candidate_variants; if(opt::candidates_file.empty()) { candidate_variants = alignments.get_variants_in_region(contig, region_start, region_end, opt::min_candidate_frequency, 20); } else { candidate_variants = get_variants_from_vcf(opt::candidates_file, contig, region_start, region_end); } // Step 2. Add variants to the haplotypes size_t calling_span = 10; size_t curr_variant_idx = 0; while(curr_variant_idx < candidate_variants.size()) { // Group the variants that are within calling_span bases of each other size_t end_variant_idx = curr_variant_idx + 1; while(end_variant_idx < candidate_variants.size()) { int distance = candidate_variants[end_variant_idx].ref_position - candidate_variants[end_variant_idx - 1].ref_position; if(distance > calling_span) break; end_variant_idx++; } size_t num_variants = end_variant_idx - curr_variant_idx; int calling_start = candidate_variants[curr_variant_idx].ref_position - calling_span; int calling_end = candidate_variants[end_variant_idx - 1].ref_position + candidate_variants[end_variant_idx - 1].ref_seq.length() + calling_span; int calling_size = calling_end - calling_start; if(opt::verbose > 2) { fprintf(stderr, "%zu variants in span [%d %d]\n", num_variants, calling_start, calling_end); } // Only try to call variants if there is a reasonable amount and the window is not too large if(num_variants <= 10 && calling_size <= 100) { // Subset the haplotype to the region we are calling Haplotype calling_haplotype = derived_haplotype.substr_by_reference(calling_start, calling_end); // Get the events for the calling region std::vector event_sequences = alignments.get_event_subsequences(contig, calling_start, calling_end); // Subset the variants std::vector calling_variants(candidate_variants.begin() + curr_variant_idx, candidate_variants.begin() + end_variant_idx); // Select the best set of variants std::vector selected_variants = select_variant_set(calling_variants, calling_haplotype, event_sequences, alignment_flags); // optionally annotate each variant with fraction of reads supporting A,C,G,T at this position if(opt::calculate_all_support) { annotate_with_all_support(selected_variants, calling_haplotype, event_sequences, alignment_flags); } // Apply them to the final haplotype for(size_t vi = 0; vi < selected_variants.size(); vi++) { derived_haplotype.apply_variant(selected_variants[vi]); if(opt::verbose > 1) { selected_variants[vi].write_vcf(stderr); } } } // advance to start of next region curr_variant_idx = end_variant_idx; } return derived_haplotype; } void parse_call_variants_options(int argc, char** argv) { bool die = false; for (char c; (c = getopt_long(argc, argv, shortopts, longopts, NULL)) != -1;) { std::istringstream arg(optarg != NULL ? optarg : ""); switch (c) { case 'r': arg >> opt::reads_file; break; case 'g': arg >> opt::genome_file; break; case 'b': arg >> opt::bam_file; break; case 'e': arg >> opt::event_bam_file; break; case 'w': arg >> opt::window; break; case 'o': arg >> opt::output_file; break; case 'm': arg >> opt::min_candidate_frequency; break; case 'c': arg >> opt::candidates_file; break; case '?': die = true; break; case 't': arg >> opt::num_threads; break; case 'v': opt::verbose++; break; case OPT_CALC_ALL_SUPPORT: opt::calculate_all_support = 1; break; case OPT_SNPS_ONLY: opt::snps_only = 1; break; case OPT_PROGRESS: opt::show_progress = 1; break; case OPT_HELP: std::cout << CONSENSUS_USAGE_MESSAGE; exit(EXIT_SUCCESS); case OPT_VERSION: std::cout << CONSENSUS_VERSION_MESSAGE; exit(EXIT_SUCCESS); } } if (argc - optind < 0) { std::cerr << SUBPROGRAM ": missing arguments\n"; die = true; } else if (argc - optind > 0) { std::cerr << SUBPROGRAM ": too many arguments\n"; die = true; } if(opt::num_threads <= 0) { std::cerr << SUBPROGRAM ": invalid number of threads: " << opt::num_threads << "\n"; die = true; } if(opt::reads_file.empty()) { std::cerr << SUBPROGRAM ": a --reads file must be provided\n"; die = true; } if(opt::genome_file.empty()) { std::cerr << SUBPROGRAM ": a --genome file must be provided\n"; die = true; } if(opt::bam_file.empty()) { std::cerr << SUBPROGRAM ": a --bam file must be provided\n"; die = true; } if (die) { std::cout << "\n" << CONSENSUS_USAGE_MESSAGE; exit(EXIT_FAILURE); } } int call_variants_main(int argc, char** argv) { parse_call_variants_options(argc, argv); omp_set_num_threads(opt::num_threads); // Parse the window string // Replace ":" and "-" with spaces to make it parseable with stringstream std::replace(opt::window.begin(), opt::window.end(), ':', ' '); std::replace(opt::window.begin(), opt::window.end(), '-', ' '); std::stringstream parser(opt::window); std::string contig; int start_base; int end_base; parser >> contig >> start_base >> end_base; end_base = std::min(end_base, get_contig_length(contig) - 1); FILE* out_fp; if(!opt::output_file.empty()) { out_fp = fopen(opt::output_file.c_str(), "w"); } else { out_fp = stdout; } Variant::write_vcf_header(out_fp); fprintf(stderr, "TODO: train model\n"); fprintf(stderr, "TODO: filter data\n"); Haplotype haplotype = call_variants_for_region(contig, start_base, end_base); std::vector variants = haplotype.get_variants(); for(size_t vi = 0; vi < variants.size(); vi++) { variants[vi].write_vcf(out_fp); } if(out_fp != stdout) { fclose(out_fp); } } nanopolish-0.4.0/src/nanopolish_call_variants.h000066400000000000000000000006511260522445600217110ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_call_variants -- find variants wrt a reference // #ifndef NANOPOLISH_CALL_VARIANTS_H #define NANOPOLISH_CALL_VARIANTS_H void call_variants_main(int argc, char** argv); #endif nanopolish-0.4.0/src/nanopolish_consensus.cpp000066400000000000000000000712541260522445600214510ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_consensus.cpp -- entry point to consensus functions // #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "nanopolish_poremodel.h" #include "nanopolish_transition_parameters.h" #include "nanopolish_matrix.h" #include "nanopolish_klcs.h" #include "nanopolish_profile_hmm.h" #include "nanopolish_anchor.h" #include "nanopolish_fast5_map.h" #include "nanopolish_hmm_input_sequence.h" #include "profiler.h" #include "progress.h" #include "stdaln.h" // Macros #define max3(x,y,z) std::max(std::max(x,y), z) // Flags to turn on/off debugging information //#define DEBUG_HMM_UPDATE 1 //#define DEBUG_HMM_EMISSION 1 //#define DEBUG_TRANSITION 1 //#define DEBUG_PATH_SELECTION 1 //#define DEBUG_SINGLE_SEGMENT 1 //#define DEBUG_SHOW_TOP_TWO 1 //#define DEBUG_SEGMENT_ID 193 //#define DEBUG_BENCHMARK 1 // // Getopt // #define SUBPROGRAM "consensus" static const char *CONSENSUS_VERSION_MESSAGE = SUBPROGRAM " Version " PACKAGE_VERSION "\n" "Written by Jared Simpson.\n" "\n" "Copyright 2015 Ontario Institute for Cancer Research\n"; static const char *CONSENSUS_USAGE_MESSAGE = "Usage: " PACKAGE_NAME " " SUBPROGRAM " [OPTIONS] --reads reads.fa --bam alignments.bam --genome genome.fa\n" "Compute a new consensus sequence for an assembly using a signal-level HMM\n" "\n" " -v, --verbose display verbose output\n" " --version display version\n" " --help display this help and exit\n" " -w, --window=STR compute the consensus for window STR (format: ctg:start_id-end_id)\n" " -r, --reads=FILE the 2D ONT reads are in fasta FILE\n" " -b, --bam=FILE the reads aligned to the genome assembly are in bam FILE\n" " -g, --genome=FILE the genome we are computing a consensus for is in FILE\n" " -o, --outfile=FILE write result to FILE [default: stdout]\n" " -t, --threads=NUM use NUM threads (default: 1)\n" "\nReport bugs to " PACKAGE_BUGREPORT "\n\n"; namespace opt { static unsigned int verbose; static std::string reads_file; static std::string bam_file; static std::string genome_file; static std::string output_file; static std::string window; static int show_progress = 0; static int num_threads = 1; } static const char* shortopts = "r:b:g:t:w:o:v"; enum { OPT_HELP = 1, OPT_VERSION, OPT_VCF, OPT_PROGRESS }; static const struct option longopts[] = { { "verbose", no_argument, NULL, 'v' }, { "reads", required_argument, NULL, 'r' }, { "bam", required_argument, NULL, 'b' }, { "genome", required_argument, NULL, 'g' }, { "window", required_argument, NULL, 'w' }, { "outfile", required_argument, NULL, 'o' }, { "threads", required_argument, NULL, 't' }, { "progress", no_argument, NULL, OPT_PROGRESS }, { "help", no_argument, NULL, OPT_HELP }, { "version", no_argument, NULL, OPT_VERSION }, { NULL, 0, NULL, 0 } }; std::vector get_input_for_columns(HMMRealignmentInput& window, const HMMAnchoredColumn& start_column, const HMMAnchoredColumn& end_column) { assert(start_column.anchors.size() == end_column.anchors.size()); std::vector input; for(uint32_t rsi = 0; rsi < start_column.anchors.size(); ++rsi) { HMMStrandAnchor start_sa = start_column.anchors[rsi]; HMMStrandAnchor end_sa = end_column.anchors[rsi]; // sanity checks // This read strand does not have events at both anchors if(start_sa.event_idx == -1 || end_sa.event_idx == -1) continue; // require a minimum number of events uint32_t n_events = abs(start_sa.event_idx - end_sa.event_idx); if(n_events < 20 || n_events > 500) continue; if(start_sa.rc != end_sa.rc) continue; HMMInputData data; uint32_t read_idx = rsi / 2; assert(read_idx < window.reads.size()); data.anchor_index = rsi; data.read = window.reads[read_idx].get(); data.strand = rsi % 2; data.event_start_idx = start_sa.event_idx; data.event_stop_idx = end_sa.event_idx; if(data.event_start_idx < data.event_stop_idx) data.event_stride = 1; else data.event_stride = -1; data.rc = start_sa.rc; input.push_back(data); } return input; } // Handy wrappers for scoring/debugging functions // The consensus algorithms call into these so we can switch // scoring functions without writing a bunch of code double score_sequence(const std::string& sequence, const HMMInputData& data) { //return score_skip_merge(sequence, state); //return score_khmm_model_postmerge(sequence, state); //return khmm_score(sequence, state, AP_GLOBAL); return profile_hmm_score(sequence, data); //return score_emission_dp(sequence, state); } void debug_sequence(const std::string& name, uint32_t seq_id, uint32_t read_id, const HMMInputSequence& sequence, const HMMInputData& data) { std::vector alignment = profile_hmm_align(sequence, data); print_alignment(name, seq_id, read_id, sequence, data, alignment); } void update_training_with_segment(const HMMInputSequence& sequence, const HMMInputData& data) { std::vector alignment = profile_hmm_align(sequence, data); data.read->parameters[data.strand].add_training_from_alignment(sequence, data, alignment); } struct PathCons { // default constructor PathCons(const std::string& s) : path(s), score(0.0f), sum_rank(0) {} std::string path; double score; size_t sum_rank; size_t num_improved; size_t num_scored; std::string mutdesc; }; typedef std::vector PathConsVector; bool sortPathConsScoreDesc(const PathCons& a, const PathCons& b) { return a.score > b.score; } bool sortPathConsRankAsc(const PathCons& a, const PathCons& b) { return a.sum_rank < b.sum_rank; } bool sortPathConsRankDesc(const PathCons& a, const PathCons& b) { return a.sum_rank > b.sum_rank; } struct IndexedPathScore { double score; uint32_t path_index; }; bool sortIndexedPathScoreDesc(const IndexedPathScore& a, const IndexedPathScore& b) { return a.score > b.score; } // This scores each path using the HMM and // sorts the paths into ascending order by score void score_paths(PathConsVector& paths, const std::vector& input) { PROFILE_FUNC("score_paths") double MIN_FIT = INFINITY; size_t CULL_RATE = 5; double CULL_MIN_SCORE = -30.0f; double CULL_MIN_IMPROVED_FRACTION = 0.2f; // cache the initial sequence std::string first = paths[0].path; PathConsVector dedup_paths; // initialize and deduplicate paths to avoid redundant computation std::set path_string_set; for(size_t pi = 0; pi < paths.size(); ++pi) { if(path_string_set.find(paths[pi].path) == path_string_set.end()) { paths[pi].score = 0; paths[pi].sum_rank = 0; paths[pi].num_improved = 0; paths[pi].num_scored = 0; dedup_paths.push_back(paths[pi]); path_string_set.insert(paths[pi].path); } } paths.clear(); paths.swap(dedup_paths); // Score all reads for(uint32_t ri = 0; ri < input.size(); ++ri) { if(opt::verbose > 2) { fprintf(stderr, "Scoring %d\n", ri); } const HMMInputData& data = input[ri]; std::vector result(paths.size()); // Score all paths #pragma omp parallel for for(size_t pi = 0; pi < paths.size(); ++pi) { double curr = score_sequence(paths[pi].path, input[ri]); result[pi].score = curr; result[pi].path_index = pi; } // Save score of first path double first_path_score = result[0].score; // Sort result by score std::stable_sort(result.begin(), result.end(), sortIndexedPathScoreDesc); for(size_t pri = 0; pri < result.size(); ++pri) { size_t pi = result[pri].path_index; paths[pi].score += (result[pri].score - first_path_score); uint32_t rank_score = pri; paths[pi].sum_rank += rank_score; paths[pi].num_improved += (result[pri].score > first_path_score); paths[pi].num_scored += 1; } // Cull paths if(ri > 0 && ri % CULL_RATE == 0) { PathConsVector retained_paths; for(size_t pi = 0; pi < paths.size(); ++pi) { // We keep a path if any of these conditions are met: // 1) it is the original unmodified sequence // 2) its score is greater than CULL_MIN_SCORE // 3) the fraction of reads that score better on this // path compared to the original sequence is greater // than CULL_MIN_IMPROVED_FRACTION double f = (double)paths[pi].num_improved / (double)paths[pi].num_scored; if(pi == 0 || paths[pi].score > CULL_MIN_SCORE || f >= CULL_MIN_IMPROVED_FRACTION) { retained_paths.push_back(paths[pi]); } } paths.swap(retained_paths); } } // select new sequence //std::stable_sort(paths.begin(), paths.end(), sortPathConsRankAsc); std::stable_sort(paths.begin(), paths.end(), sortPathConsScoreDesc); #if DEBUG_PATH_SELECTION for(size_t pi = 0; pi < paths.size(); ++pi) { // Calculate the length of the matching prefix with the initial sequence const std::string& s = paths[pi].path; char initial = s == first ? 'I' : ' '; printf("%zu\t%s\t%.1lf\t%zu %c %s", pi, paths[pi].path.c_str(), paths[pi].score, paths[pi].sum_rank, initial, paths[pi].mutdesc.c_str()); // If this is the truth path or the best path, show the scores for all reads if(pi <= 1 || initial == 'I') { for(uint32_t ri = 0; ri < input.size(); ++ri) { const HMMInputData& data = input[ri]; const KHMMParameters& parameters = data.read->parameters[data.strand]; if( fabs(parameters.fit_quality) > MIN_FIT) continue; double curr = score_sequence(paths[pi].path, input[ri]); printf("%.1lf,%.2lf ", parameters.fit_quality, curr); } } printf("\n"); } #endif } void extend_paths(PathConsVector& paths, int maxk = 2) { // Insert all possible extensions into the path sequence // for k in 1 to maxk PathConsVector new_paths; for(int k = 1; k <= maxk; ++k) { for(int pi = 0; pi < paths.size(); ++pi) { std::string first(k, 'A'); std::string extension = first; do { std::string current = paths[pi].path; std::string ns = current.insert(current.size() - 5, extension); PathCons ps(ns); new_paths.push_back(ps); gDNAAlphabet.lexicographic_next(extension); } while(extension != first); } } paths.swap(new_paths); } PathConsVector generate_mutations(const std::string& sequence, const uint32_t k) { PathConsVector mutations; // Add the unmutated sequence { PathCons pc(sequence); mutations.push_back(pc); } // Mutate every base except for in the first/last k-mer for(size_t si = k; si < sequence.size() - k; ++si) { // All subs for(size_t bi = 0; bi < 4; bi++) { char b = "ACGT"[bi]; if(sequence[si] == b) continue; PathCons pc(sequence); pc.path[si] = b; std::stringstream ss; ss << "sub-" << si << "-" << b; pc.mutdesc = ss.str(); mutations.push_back(pc); } // 1bp del at this position { PathCons pc(sequence); pc.path.erase(si, 1); std::stringstream ss; ss << "del-" << si; pc.mutdesc = ss.str(); mutations.push_back(pc); } // All 1bp ins before this position for(size_t bi = 0; bi < 4; bi++) { char b = "ACGT"[bi]; PathCons pc(sequence); pc.path.insert(si, 1, b); std::stringstream ss; ss << "ins-" << si << "-" << b; pc.mutdesc = ss.str(); mutations.push_back(pc); } } return mutations; } // Run the mutation algorithm to generate an improved consensus sequence std::string run_mutation(const std::string& base, const std::vector& input) { PROFILE_FUNC("run_mutation") std::string result = base; // assume models for all the reads have the same k assert(!input.empty()); const uint32_t k = input[0].read->pore_model[input[0].strand].k; int iteration = 0; while(iteration++ < 10) { // Generate possible sequences PathConsVector paths = generate_mutations(result, k); // score them in the HMM score_paths(paths, input); // check if no improvement was made if(paths[0].path == result) break; result = paths[0].path; } return result; } void generate_alt_paths(PathConsVector& paths, const std::string& base, const std::vector& alts, const uint32_t k) { // Generate alternatives for(uint32_t ai = 0; ai < alts.size(); ++ai) { const std::string& alt = alts[ai]; if(alt.size() < k) continue; kLCSResult result = kLCS(base, alt, k); #ifdef DEBUG_ALT_GENERATION printf("Match to alt %s\n", alt.c_str()); for(size_t mi = 0; mi < result.size(); ++mi) { std::string extend = ""; if(mi < result.size() - 1 && result[mi].j + 1 != result[mi + 1].j) { extend = alt.substr(result[mi].j, result[mi + 1].j - result[mi].j + k); } printf("\t%zu %zu %s %s\n", result[mi].i, result[mi].j, base.substr(result[mi].i, k).c_str(), extend.c_str()); } #endif uint32_t match_idx = 0; while(match_idx < result.size()) { uint32_t last_idx = result.size() - 1; // advance the match to the next point of divergence while(match_idx != last_idx && result[match_idx].i == result[match_idx + 1].i - 1 && result[match_idx].j == result[match_idx + 1].j - 1) { match_idx++; } // no more divergences to process if(match_idx == last_idx) break; uint32_t bl = result[match_idx + 1].i - result[match_idx].i; uint32_t rl = result[match_idx + 1].j - result[match_idx].j; std::string base_subseq = base.substr(result[match_idx].i, bl); std::string alt_subseq = alt.substr(result[match_idx].j, rl); // Perform the splice PathCons new_path(base); new_path.path.replace(result[match_idx].i, bl, alt_subseq); paths.push_back(new_path); match_idx += 1; } } } // Run the block substitution algorithm to generate an improved consensus sequence std::string run_block_substitution(const std::string& base, const std::vector& input, const std::vector& alts) { std::string result = base; // assume models for all the reads have the same k assert(!input.empty()); const uint32_t k = input[0].read->pore_model[input[0].strand].k; uint32_t max_rounds = 6; uint32_t round = 0; while(round++ < max_rounds) { PathConsVector paths; PathCons initial_path(result); paths.push_back(initial_path); generate_alt_paths(paths, result, alts, k); score_paths(paths, input); if(paths[0].path == result) break; result = paths[0].path; } return result; } // // Outlier filtering // void filter_outlier_data(std::vector& input, const std::string& sequence) { std::vector out_rs; for(uint32_t ri = 0; ri < input.size(); ++ri) { const HMMInputData& rs = input[ri]; double curr = score_sequence(sequence, rs); double n_events = abs(rs.event_start_idx - rs.event_stop_idx) + 1.0f; double lp_per_event = curr / n_events; if(opt::verbose >= 1) { fprintf(stderr, "OUTLIER_FILTER %d %.2lf %.2lf %.2lf\n", ri, curr, n_events, lp_per_event); } if(fabs(lp_per_event) < 3.5f) { out_rs.push_back(rs); } } input.swap(out_rs); } std::string join_sequences_at_kmer(const std::string& a, const std::string& b, const uint32_t k) { // this is a special case to make the calling code cleaner if(a.empty()) return b; // These sequences must have a k-mer match at the start/end std::string a_last_kmer = a.substr(a.size() - k); std::string b_last_kmer = b.substr(0, k); assert(a_last_kmer == b_last_kmer); return a + b.substr(k); } void run_splice_segment(HMMRealignmentInput& window, uint32_t segment_id) { // The structure of the data looks like this: // -------------------------------------------------------- // S M E // where is the start column, M is the middle column and E // is the end column. We want to call a new consensus from S // to E. We do this by generating the base sequence from S to E // and then applying all of the alternatives indicated by the // start and middle column. We score these alternatives using // the read strands spanning from S to E. After a new consensus // has been selected, we re-calculate the alignments of events to // the middle anchor. // Get the segments assert(segment_id + 2 < window.anchored_columns.size()); HMMAnchoredColumn& start_column = window.anchored_columns[segment_id]; HMMAnchoredColumn& middle_column = window.anchored_columns[segment_id + 1]; HMMAnchoredColumn& end_column = window.anchored_columns[segment_id + 2]; std::string s_m_base = start_column.base_sequence; std::string m_e_base = middle_column.base_sequence; // The collection of alternative sequences std::vector alts; for(uint32_t ai = 0; ai < start_column.alt_sequences.size(); ++ai) { alts.push_back(start_column.alt_sequences[ai]); } // set up the input data for the HMM std::vector data = get_input_for_columns(window, start_column, end_column); // assume models for all the reads have the same k assert(!data.empty()); const uint32_t k = data[0].read->pore_model[data[0].strand].k; // The current consensus sequence std::string original = join_sequences_at_kmer(s_m_base, m_e_base, k); std::string base = original; // filter out poor quality reads filter_outlier_data(data, base); // Only attempt correction if there are any reads here if(!data.empty()) { std::string bs_result = run_block_substitution(base, data, alts); std::string mut_result = run_mutation(bs_result, data); base = mut_result; } if(opt::verbose > 0) { fprintf(stderr, "ORIGINAL[%d] %s\n", segment_id, original.c_str()); fprintf(stderr, "RESULT[%d] %s\n", segment_id, base.c_str()); } // Update the sequences for the start and middle segments // by cutting the new consensus in the middle // We maintain the k-mer match invariant by requiring the // sequences to overlap by k-bp assert(base.length() >= k); uint32_t midpoint_kmer = (base.length() - k + 1) / 2; std::string s_m_fixed = base.substr(0, midpoint_kmer + k); std::string m_e_fixed = base.substr(midpoint_kmer); assert(s_m_fixed.substr(s_m_fixed.size() - k) == m_e_fixed.substr(0, k)); start_column.base_sequence = s_m_fixed; middle_column.base_sequence = m_e_fixed; // Update the event indices in the first column to match for(uint32_t ri = 0; ri < data.size(); ++ri) { // Realign to the consensus sequence std::vector decodes = profile_hmm_align(base, data[ri]); // Get the closest event aligned to the target kmer int32_t min_k_dist = base.length(); uint32_t event_idx = 0; for(uint32_t di = 0; di < decodes.size(); ++di) { int32_t dist = abs(decodes[di].kmer_idx - midpoint_kmer); if(dist <= min_k_dist) { min_k_dist = dist; event_idx = decodes[di].event_idx; } } middle_column.anchors[data[ri].anchor_index].event_idx = event_idx; } } // update the training data on the current segment void train_segment(HMMRealignmentInput& window, uint32_t segment_id) { // Get the segments assert(segment_id + 2 < window.anchored_columns.size()); HMMAnchoredColumn& start_column = window.anchored_columns[segment_id]; HMMAnchoredColumn& middle_column = window.anchored_columns[segment_id + 1]; HMMAnchoredColumn& end_column = window.anchored_columns[segment_id + 2]; std::string s_m_base = start_column.base_sequence; std::string m_e_base = middle_column.base_sequence; // Set up the the input data for the HMM std::vector input = get_input_for_columns(window, start_column, end_column); // assume models for all the reads have the same k assert(!input.empty()); const uint32_t k = input[0].read->pore_model[input[0].strand].k; std::string segment_sequence = join_sequences_at_kmer(s_m_base, m_e_base, k); for(uint32_t ri = 0; ri < input.size(); ++ri) { std::vector decodes = profile_hmm_align(segment_sequence, input[ri]); update_training_with_segment(segment_sequence, input[ri]); } } void train(HMMRealignmentInput& window) { // train on current consensus uint32_t num_segments = window.anchored_columns.size(); for(uint32_t segment_id = 0; segment_id < num_segments - 2; ++segment_id) { train_segment(window, segment_id); } // Update model parameters for(uint32_t ri = 0; ri < window.reads.size(); ++ri) { window.reads[ri]->parameters[0].train(); window.reads[ri]->parameters[1].train(); } } std::string call_consensus_for_window(const Fast5Map& name_map, const std::string& contig, int start_base, int end_base) { const int minor_segment_stride = 50; HMMRealignmentInput window = build_input_for_region(opt::bam_file, opt::genome_file, name_map, contig, start_base, end_base, minor_segment_stride); if(window.reads.empty()) { // No data for this window, just return the original sequence as the consensus assert(!window.original_sequence.empty()); return window.original_sequence; } // // Train the HMM // train(window); // assume models for all the reads have the same k const uint32_t k = window.reads[0]->pore_model[T_IDX].k; // // Compute the new consensus sequence // std::string reference = ""; std::string consensus = ""; uint32_t num_segments = window.anchored_columns.size(); uint32_t start_segment_id = 0; // Copy the base segments before they are updated // by the consensus algorithm std::vector ref_segments; for(uint32_t segment_id = 0; segment_id < num_segments; ++segment_id) { ref_segments.push_back(window.anchored_columns[segment_id].base_sequence); } // Initialize progress status std::stringstream message; message << "[consensus] " << contig << ":" << start_base << "-" << end_base; Progress progress(message.str()); for(uint32_t segment_id = start_segment_id; segment_id < num_segments - 2; ++segment_id) { // update progress if(opt::show_progress) { progress.print((float)segment_id / (num_segments - 2)); } // run the consensus algorithm for this segment run_splice_segment(window, segment_id); // run_splice_segment updates the base_sequence of the current anchor, grab it and append std::string base = window.anchored_columns[segment_id].base_sequence; // append the new sequences in, respecting the K overlap reference = join_sequences_at_kmer(reference, ref_segments[segment_id], k); consensus = join_sequences_at_kmer(consensus, base, k); if(opt::verbose > 0) { fprintf(stderr, "UNCORRECT[%d]: %s\n", segment_id, reference.c_str()); fprintf(stderr, "CONSENSUS[%d]: %s\n", segment_id, consensus.c_str()); } } // Append segment that ends at the last anchor reference = join_sequences_at_kmer(reference, ref_segments[num_segments - 2], k); const std::string& last_segment = window.anchored_columns[num_segments - 2].base_sequence; consensus = join_sequences_at_kmer(consensus, last_segment, k); if(opt::show_progress) { progress.end(); } return consensus; } void parse_consensus_options(int argc, char** argv) { bool die = false; for (char c; (c = getopt_long(argc, argv, shortopts, longopts, NULL)) != -1;) { std::istringstream arg(optarg != NULL ? optarg : ""); switch (c) { case 'r': arg >> opt::reads_file; break; case 'g': arg >> opt::genome_file; break; case 'b': arg >> opt::bam_file; break; case 'w': arg >> opt::window; break; case 'o': arg >> opt::output_file; break; case '?': die = true; break; case 't': arg >> opt::num_threads; break; case 'v': opt::verbose++; break; case OPT_PROGRESS: opt::show_progress = 1; break; case OPT_HELP: std::cout << CONSENSUS_USAGE_MESSAGE; exit(EXIT_SUCCESS); case OPT_VERSION: std::cout << CONSENSUS_VERSION_MESSAGE; exit(EXIT_SUCCESS); } } if (argc - optind < 0) { std::cerr << SUBPROGRAM ": missing arguments\n"; die = true; } else if (argc - optind > 0) { std::cerr << SUBPROGRAM ": too many arguments\n"; die = true; } if(opt::num_threads <= 0) { std::cerr << SUBPROGRAM ": invalid number of threads: " << opt::num_threads << "\n"; die = true; } if(opt::reads_file.empty()) { std::cerr << SUBPROGRAM ": a --reads file must be provided\n"; die = true; } if(opt::genome_file.empty()) { std::cerr << SUBPROGRAM ": a --genome file must be provided\n"; die = true; } if(opt::bam_file.empty()) { std::cerr << SUBPROGRAM ": a --bam file must be provided\n"; die = true; } if (die) { std::cout << "\n" << CONSENSUS_USAGE_MESSAGE; exit(EXIT_FAILURE); } } int consensus_main(int argc, char** argv) { parse_consensus_options(argc, argv); omp_set_num_threads(opt::num_threads); Fast5Map name_map(opt::reads_file); // Parse the window string // Replace ":" and "-" with spaces to make it parseable with stringstream std::replace(opt::window.begin(), opt::window.end(), ':', ' '); std::replace(opt::window.begin(), opt::window.end(), '-', ' '); const int WINDOW_LENGTH = 10000; const int WINDOW_OVERLAP = 200; std::stringstream parser(opt::window); std::string contig; int start_window_id; int end_window_id; parser >> contig >> start_window_id >> end_window_id; FILE* out_fp = NULL; if(!opt::output_file.empty()) { out_fp = fopen(opt::output_file.c_str(), "w"); } else { out_fp = stdout; } for(int window_id = start_window_id; window_id < end_window_id; ++window_id) { int start_base = window_id * WINDOW_LENGTH; int end_base = start_base + WINDOW_LENGTH + WINDOW_OVERLAP; std::string window_consensus = call_consensus_for_window(name_map, contig, start_base, end_base); fprintf(out_fp, ">%s:%d\n%s\n", contig.c_str(), window_id, window_consensus.c_str()); } if(out_fp != stdout) { fclose(out_fp); } } nanopolish-0.4.0/src/nanopolish_consensus.h000066400000000000000000000006631260522445600211120ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_consensus.cpp -- compute a new consensus sequence // for an assembly // #ifndef NANOPOLISH_CONSENSUS_H #define NANOPOLISH_CONSENSUS_H void consensus_main(int argc, char** argv); #endif nanopolish-0.4.0/src/nanopolish_getmodel.cpp000066400000000000000000000066531260522445600212320ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_getmodel.h - write the pore model for a read // to stdout // #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "htslib/faidx.h" #include "nanopolish_poremodel.h" #include "nanopolish_squiggle_read.h" #include "profiler.h" // // Getopt // #define SUBPROGRAM "getmodel" static const char *GETMODEL_VERSION_MESSAGE = SUBPROGRAM " Version " PACKAGE_VERSION "\n" "Written by Jared Simpson.\n" "\n" "Copyright 2015 Ontario Institute for Cancer Research\n"; static const char *GETMODEL_USAGE_MESSAGE = "Usage: " PACKAGE_NAME " " SUBPROGRAM " [OPTIONS] read.fast5\n" "Write the pore models for the given read to stdout\n" "\n" " -v, --verbose display verbose output\n" " --version display version\n" " --help display this help and exit\n" "\nReport bugs to " PACKAGE_BUGREPORT "\n\n"; namespace opt { static unsigned int verbose; static std::string input_file; } static const char* shortopts = "v"; enum { OPT_HELP = 1, OPT_VERSION }; static const struct option longopts[] = { { "verbose", no_argument, NULL, 'v' }, { "help", no_argument, NULL, OPT_HELP }, { "version", no_argument, NULL, OPT_VERSION }, { NULL, 0, NULL, 0 } }; void parse_getmodel_options(int argc, char** argv) { bool die = false; for (char c; (c = getopt_long(argc, argv, shortopts, longopts, NULL)) != -1;) { std::istringstream arg(optarg != NULL ? optarg : ""); switch (c) { case '?': die = true; break; case 'v': opt::verbose++; break; case OPT_HELP: std::cout << GETMODEL_USAGE_MESSAGE; exit(EXIT_SUCCESS); case OPT_VERSION: std::cout << GETMODEL_VERSION_MESSAGE; exit(EXIT_SUCCESS); } } if (argc - optind < 1) { std::cerr << SUBPROGRAM ": not enough arguments\n"; die = true; } if (argc - optind > 1) { std::cerr << SUBPROGRAM ": too many arguments\n"; die = true; } opt::input_file = argv[optind++]; if (die) { std::cout << "\n" << GETMODEL_USAGE_MESSAGE; exit(EXIT_FAILURE); } } int getmodel_main(int argc, char** argv) { parse_getmodel_options(argc, argv); SquiggleRead sr("input", opt::input_file); printf("strand\tkmer\tmodel_mean\tmodel_stdv\n"); for(size_t si = 0; si < 2; ++si) { char strand = si == 0 ? 't' : 'c'; uint32_t k = sr.pore_model[si].k; std::string kmer(k, 'A'); assert(sr.pore_model[si].get_num_states() == gDNAAlphabet.get_num_strings(k)); for(size_t ki = 0; ki < sr.pore_model[si].get_num_states(); ++ki) { PoreModelStateParams params = sr.pore_model[si].get_parameters(ki); printf("%c\t%s\t%.2lf\t%.2lf\n", strand, kmer.c_str(), params.level_mean, params.level_stdv); gDNAAlphabet.lexicographic_next(kmer); // advance kmer } } } nanopolish-0.4.0/src/nanopolish_getmodel.h000066400000000000000000000006451260522445600206720ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_getmodel.h - write the pore model for a read // to stdout // #ifndef NANOPOLISH_GETMODEL_H #define NANOPOLISH_GETMODEL_H void getmodel_main(int argc, char** argv); #endif nanopolish-0.4.0/src/nanopolish_haplotype.cpp000066400000000000000000000103531260522445600214270ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_haplotype - a haplotype derived from // a reference sequence and a set of variants // #include "nanopolish_haplotype.h" // Definitions const size_t Haplotype::INSERTED_POSITION = std::string::npos; Haplotype::Haplotype(const std::string& ref_name, const size_t ref_position, const std::string& ref_sequence) : m_ref_name(ref_name), m_ref_position(ref_position), m_reference(ref_sequence) { m_sequence = m_reference; m_coordinate_map.resize(m_reference.size()); for(size_t i = 0; i < m_coordinate_map.size(); ++i) { m_coordinate_map[i] = m_ref_position + i; } } // void Haplotype::apply_variant(const Variant& v) { // Search the coordinate map for the reference position size_t derived_idx = _find_derived_index_by_ref_lower_bound(v.ref_position); // if we could not find the reference position in the map // this variant is incompatable with the haplotype, do nothing if(derived_idx == m_coordinate_map.size() || m_coordinate_map[derived_idx] != v.ref_position) { return; } // Check that the string matches size_t rl = v.ref_seq.length(); size_t al = v.alt_seq.length(); // no match, variant conflicts with haplotype sequence if(m_sequence.substr(derived_idx, rl) != v.ref_seq) { return; } // update sequence m_sequence.replace(derived_idx, rl, v.alt_seq); // update coordinate map // make a pair of iterators that bound the changed sequence std::vector::iterator fi = m_coordinate_map.begin() + derived_idx; std::vector::iterator li = fi + rl; // erase the positions of the changed bases std::vector::iterator ii = m_coordinate_map.erase(fi, li); // insert new positions for the alt bases with invalid indices m_coordinate_map.insert(ii, al, INSERTED_POSITION); // sanity check assert(m_coordinate_map.size() == m_sequence.size()); m_variants.push_back(v); } // return a new haplotype subsetted by reference coordinates Haplotype Haplotype::substr_by_reference(size_t start, size_t end) { assert(start >= m_ref_position); assert(start <= m_ref_position + m_reference.length()); assert(end >= m_ref_position); assert(end <= m_ref_position + m_reference.length()); size_t derived_base_start = _find_derived_index_by_ref_lower_bound(start); size_t derived_base_end = _find_derived_index_by_ref_lower_bound(end); // Bump out the reference coordinate to encompass the complete range (start, end) while(m_coordinate_map[derived_base_start] > start || m_coordinate_map[derived_base_start] == INSERTED_POSITION) { derived_base_start -= 1; } assert(derived_base_start != m_coordinate_map.size()); assert(derived_base_end != m_coordinate_map.size()); assert(m_coordinate_map[derived_base_start] <= start); assert(m_coordinate_map[derived_base_end] >= end); start = m_coordinate_map[derived_base_start]; end = m_coordinate_map[derived_base_end]; Haplotype ret(m_ref_name, start, m_reference.substr(start - m_ref_position, end - start + 1)); ret.m_sequence = m_sequence.substr(derived_base_start, derived_base_end - derived_base_start + 1); ret.m_coordinate_map = std::vector(m_coordinate_map.begin() + derived_base_start, m_coordinate_map.begin() + derived_base_end + 1); assert(ret.m_coordinate_map.front() == start); assert(ret.m_coordinate_map.back() == end); assert(ret.m_coordinate_map.size() == ret.m_sequence.size()); return ret; } size_t Haplotype::_find_derived_index_by_ref_lower_bound(size_t ref_index) { for(size_t i = 0; i < m_coordinate_map.size(); ++i) { if(m_coordinate_map[i] != INSERTED_POSITION && m_coordinate_map[i] >= ref_index) { return i; } } return m_coordinate_map.size(); } nanopolish-0.4.0/src/nanopolish_haplotype.h000066400000000000000000000045401260522445600210750ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_haplotype - a haplotype derived from // a reference sequence and a set of variants // #ifndef NANOPOLISH_HAPLOTYPE_H #define NANOPOLISH_HAPLOTYPE_H #include "nanopolish_variant.h" class Haplotype { public: // constructor Haplotype(const std::string& ref_name, const size_t ref_position, const std::string& ref_sequence); // get the sequence of the haplotype const std::string& get_sequence() const { return m_sequence; } // get the sequence of the reference const std::string& get_reference() const { return m_reference; } // add a variant into the haplotype void apply_variant(const Variant& v); // return all the variants on this haplotype std::vector get_variants() const { return m_variants; } // return a new haplotype subsetted by reference coordinates Haplotype substr_by_reference(size_t start, size_t end); private: // functions Haplotype(); // not allowed // Find the first derived index that has a corresponding // reference position which is not less than ref_index. // This mimics std::lower_bound size_t _find_derived_index_by_ref_lower_bound(size_t ref_index); // // data // // the name of the reference contig/chromosome this haplotype is from std::string m_ref_name; // the start position of the reference sequence on the ref contig/chromosome size_t m_ref_position; // the original sequence this haplotype is based on std::string m_reference; // the sequence of the haplotype std::string m_sequence; // the set of variants this haplotype contains std::vector m_variants; // a mapping from bases of the derived sequence // to their original reference position std::vector m_coordinate_map; // a constant value indicating inserted sequence in the coordinate map static const size_t INSERTED_POSITION; }; #endif nanopolish-0.4.0/src/nanopolish_methyltest.cpp000066400000000000000000000460241260522445600216300ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_methyltrain -- train a methylation model // #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "htslib/faidx.h" #include "nanopolish_eventalign.h" #include "nanopolish_iupac.h" #include "nanopolish_poremodel.h" #include "nanopolish_transition_parameters.h" #include "nanopolish_matrix.h" #include "nanopolish_profile_hmm.h" #include "nanopolish_anchor.h" #include "nanopolish_fast5_map.h" #include "nanopolish_methyltrain.h" #include "H5pubconf.h" #include "profiler.h" #include "progress.h" // // Structs // struct OutputHandles { FILE* site_writer; FILE* read_writer; FILE* strand_writer; }; struct ScoredSite { ScoredSite() { ll_unmethylated[0] = 0; ll_unmethylated[1] = 0; ll_methylated[0] = 0; ll_methylated[1] = 0; } std::string chromosome; int start_position; int end_position; int n_cpg; std::string sequence; // scores per strand double ll_unmethylated[2]; double ll_methylated[2]; // static bool sort_by_position(const ScoredSite& a, const ScoredSite& b) { return a.start_position < b.start_position; } }; // Alphabet* mtest_alphabet = &gMCpGAlphabet; // // Getopt // #define SUBPROGRAM "methyltest" static const char *METHYLTEST_VERSION_MESSAGE = SUBPROGRAM " Version " PACKAGE_VERSION "\n" "Written by Jared Simpson.\n" "\n" "Copyright 2015 Ontario Institute for Cancer Research\n"; static const char *METHYLTEST_USAGE_MESSAGE = "Usage: " PACKAGE_NAME " " SUBPROGRAM " [OPTIONS] --reads reads.fa --bam alignments.bam --genome genome.fa\n" "Train a methylation model\n" "\n" " -v, --verbose display verbose output\n" " --version display version\n" " --help display this help and exit\n" " -m, --models-fofn=FILE read the models from the FOFN\n" " -r, --reads=FILE the 2D ONT reads are in fasta FILE\n" " -b, --bam=FILE the reads aligned to the genome assembly are in bam FILE\n" " -g, --genome=FILE the genome we are computing a consensus for is in FILE\n" " -t, --threads=NUM use NUM threads (default: 1)\n" " --progress print out a progress message\n" "\nReport bugs to " PACKAGE_BUGREPORT "\n\n"; namespace opt { static unsigned int verbose; static std::string reads_file; static std::string bam_file; static std::string genome_file; static std::string models_fofn; static std::string region; static int progress = 0; static int num_threads = 1; static int batch_size = 128; } static const char* shortopts = "r:b:g:t:w:m:vn"; enum { OPT_HELP = 1, OPT_VERSION, OPT_PROGRESS }; static const struct option longopts[] = { { "verbose", no_argument, NULL, 'v' }, { "reads", required_argument, NULL, 'r' }, { "bam", required_argument, NULL, 'b' }, { "genome", required_argument, NULL, 'g' }, { "window", required_argument, NULL, 'w' }, { "threads", required_argument, NULL, 't' }, { "models-fofn", required_argument, NULL, 'm' }, { "progress", no_argument, NULL, OPT_PROGRESS }, { "help", no_argument, NULL, OPT_HELP }, { "version", no_argument, NULL, OPT_VERSION }, { NULL, 0, NULL, 0 } }; // Expand the event indices outwards void bump(HMMInputData& data, int amount) { if(data.event_start_idx < data.event_stop_idx) { data.event_start_idx -= amount; data.event_stop_idx += amount; } else { data.event_start_idx += amount; data.event_stop_idx -= amount; } } // Realign the read in event space void test_read(const ModelMap& model_map, const Fast5Map& name_map, const faidx_t* fai, const bam_hdr_t* hdr, const bam1_t* record, size_t read_idx, const OutputHandles& handles) { // Load a squiggle read for the mapped read std::string read_name = bam_get_qname(record); std::string fast5_path = name_map.get_path(read_name); // load read SquiggleRead sr(read_name, fast5_path); double read_score = 0.0f; size_t num_sites_tested = 0; std::map site_score_map; for(size_t strand_idx = 0; strand_idx < NUM_STRANDS; ++strand_idx) { std::vector site_scores; std::vector site_starts; std::vector site_ends; std::vector site_count; double strand_score = 0.0f; // replace model std::string curr_model = sr.pore_model[strand_idx].name; std::string methyl_model = curr_model + ".methyltrain"; auto model_iter = model_map.find(methyl_model); if(model_iter != model_map.end()) { sr.pore_model[strand_idx].update_states( model_iter->second ); } else { fprintf(stderr, "Error, methylated model %s not found\n", methyl_model.c_str()); exit(EXIT_FAILURE); } // Align to the new model EventAlignmentParameters params; params.sr = &sr; params.fai = fai; params.hdr = hdr; params.record = record; params.strand_idx = strand_idx; params.read_idx = read_idx; params.alphabet = mtest_alphabet; std::vector alignment_output = align_read_to_ref(params); if(alignment_output.empty()) continue; std::string contig = alignment_output.front().ref_name.c_str(); //emit_event_alignment_tsv(stdout, sr, params, alignment_output); // Convert the EventAlignment to a map between reference positions and events std::vector event_aligned_pairs; for(size_t i = 0; i < alignment_output.size(); ++i) { AlignedPair ap = { alignment_output[i].ref_position, alignment_output[i].event_idx }; event_aligned_pairs.push_back(ap); } int ref_start_pos = event_aligned_pairs.front().ref_pos; int ref_end_pos = event_aligned_pairs.back().ref_pos; int fetched_len = 0; assert(ref_end_pos >= ref_start_pos); // Extract the reference sequence for this region std::string ref_seq = get_reference_region_ts(params.fai, contig.c_str(), ref_start_pos, ref_end_pos, &fetched_len); ref_seq = gDNAAlphabet.disambiguate(ref_seq); // Scan the sequence for CpGs std::vector cpg_sites; assert(ref_seq.size() != 0); for(size_t i = 0; i < ref_seq.size() - 1; ++i) { if(ref_seq[i] == 'C' && ref_seq[i+1] == 'G') { cpg_sites.push_back(i); } } // Batch the CpGs together int min_separation = 10; size_t curr_idx = 0; while(curr_idx < cpg_sites.size()) { size_t end_idx = curr_idx + 1; while(end_idx < cpg_sites.size()) { if(cpg_sites[end_idx] - cpg_sites[end_idx - 1] > min_separation) break; end_idx += 1; } int sub_start_pos = cpg_sites[curr_idx] - min_separation; int sub_end_pos = cpg_sites[end_idx - 1] + min_separation; if(sub_start_pos > min_separation && cpg_sites[end_idx - 1] - cpg_sites[curr_idx] < 200) { std::string subseq = ref_seq.substr(sub_start_pos, sub_end_pos - sub_start_pos + 1); std::string rc_subseq = mtest_alphabet->reverse_complement(subseq); AlignedPairRefLBComp lb_comp; AlignedPairConstIter start_iter = std::lower_bound(event_aligned_pairs.begin(), event_aligned_pairs.end(), sub_start_pos + ref_start_pos, lb_comp); AlignedPairConstIter stop_iter = std::lower_bound(event_aligned_pairs.begin(), event_aligned_pairs.end(), sub_end_pos + ref_start_pos, lb_comp); if(start_iter != event_aligned_pairs.end() && stop_iter != event_aligned_pairs.end()) { std::string site_string = ref_seq.substr(cpg_sites[curr_idx] - 3, 5); uint32_t hmm_flags = HAF_ALLOW_PRE_CLIP | HAF_ALLOW_POST_CLIP; // Set up event data HMMInputData data; data.read = &sr; data.anchor_index = -1; // unused data.strand = strand_idx; data.rc = alignment_output.front().rc; data.event_start_idx = start_iter->read_pos; data.event_stop_idx = stop_iter->read_pos; data.event_stride = data.event_start_idx < data.event_stop_idx ? 1 : -1; HMMInputSequence unmethylated(subseq, rc_subseq, mtest_alphabet); double unmethylated_score = profile_hmm_score(unmethylated, data, hmm_flags); // Methylate the CpGs in the sequence and score again std::string mcpg_subseq = gMCpGAlphabet.methylate(subseq); std::string rc_mcpg_subseq = gMCpGAlphabet.reverse_complement(mcpg_subseq); //printf("m_subs: %s\n", mcpg_subseq.c_str()); //printf("m_rc_s: %s\n", rc_mcpg_subseq.c_str()); HMMInputSequence methylated(mcpg_subseq, rc_mcpg_subseq, mtest_alphabet); double methylated_score = profile_hmm_score(methylated, data, hmm_flags); double diff = methylated_score - unmethylated_score; ScoredSite ss; int start_position = cpg_sites[curr_idx] + ref_start_pos; auto iter = site_score_map.find(start_position); if(iter == site_score_map.end()) { // insert new score into the map ScoredSite ss; ss.chromosome = contig; ss.start_position = start_position; ss.end_position = cpg_sites[end_idx - 1] + ref_start_pos; ss.n_cpg = end_idx - curr_idx; ss.sequence = site_string; iter = site_score_map.insert(std::make_pair(start_position, ss)).first; } iter->second.ll_unmethylated[strand_idx] = unmethylated_score; iter->second.ll_methylated[strand_idx] = methylated_score; /* // Debug alignments printf("Forward unmethylated: %.2lf\n", unmethylated_score); printf("Forward methylated: %.2lf\n", methylated_score); std::vector um_align = profile_hmm_align(unmethylated, data, hmm_flags); print_alignment("unmethylated", start_position, 0, unmethylated, data, um_align); std::vector m_align = profile_hmm_align(methylated, data, hmm_flags); print_alignment("methylated", start_position, 0, methylated, data, m_align); */ } } curr_idx = end_idx; } } // for strands #pragma omp critical(methyltest_write) { double ll_ratio_sum_strand[2] = { 0.0f, 0.0f }; double ll_ratio_sum_both = 0; size_t num_positive = 0; for(auto iter = site_score_map.begin(); iter != site_score_map.end(); ++iter) { const ScoredSite& ss = iter->second; double sum_ll_m = ss.ll_methylated[0] + ss.ll_methylated[1]; double sum_ll_u = ss.ll_unmethylated[0] + ss.ll_unmethylated[1]; double diff = sum_ll_m - sum_ll_u; num_positive += diff > 0; fprintf(handles.site_writer, "%s\t%d\t%d\t", ss.chromosome.c_str(), ss.start_position, ss.end_position); fprintf(handles.site_writer, "LL_METH=%.2lf;LL_UNMETH=%.2lf;LL_RATIO=%.2lf;", sum_ll_m, sum_ll_u, diff); fprintf(handles.site_writer, "N_CPG=%d;SEQUENCE=%s\n", ss.n_cpg, ss.sequence.c_str()); ll_ratio_sum_strand[0] += ss.ll_methylated[0] - ss.ll_unmethylated[0]; ll_ratio_sum_strand[1] += ss.ll_methylated[1] - ss.ll_unmethylated[1]; ll_ratio_sum_both += diff; } std::string complement_model = sr.pore_model[C_IDX].name; fprintf(handles.read_writer, "%s\t%.2lf\t%zu\t%s\tNUM_POSITIVE=%zu\n", fast5_path.c_str(), ll_ratio_sum_both, site_score_map.size(), complement_model.c_str(), num_positive); for(size_t si = 0; si < NUM_STRANDS; ++si) { std::string model = sr.pore_model[si].name; fprintf(handles.strand_writer, "%s\t%.2lf\t%zu\t%s\n", fast5_path.c_str(), ll_ratio_sum_strand[si], site_score_map.size(), model.c_str()); } } } void parse_methyltest_options(int argc, char** argv) { bool die = false; for (char c; (c = getopt_long(argc, argv, shortopts, longopts, NULL)) != -1;) { std::istringstream arg(optarg != NULL ? optarg : ""); switch (c) { case 'r': arg >> opt::reads_file; break; case 'g': arg >> opt::genome_file; break; case 'b': arg >> opt::bam_file; break; case '?': die = true; break; case 't': arg >> opt::num_threads; break; case 'm': arg >> opt::models_fofn; break; case 'v': opt::verbose++; break; case OPT_PROGRESS: opt::progress = true; break; case OPT_HELP: std::cout << METHYLTEST_USAGE_MESSAGE; exit(EXIT_SUCCESS); case OPT_VERSION: std::cout << METHYLTEST_VERSION_MESSAGE; exit(EXIT_SUCCESS); } } if(argc - optind > 0) { opt::region = argv[optind++]; } if (argc - optind > 0) { std::cerr << SUBPROGRAM ": too many arguments\n"; die = true; } if(opt::num_threads <= 0) { std::cerr << SUBPROGRAM ": invalid number of threads: " << opt::num_threads << "\n"; die = true; } if(opt::reads_file.empty()) { std::cerr << SUBPROGRAM ": a --reads file must be provided\n"; die = true; } if(opt::genome_file.empty()) { std::cerr << SUBPROGRAM ": a --genome file must be provided\n"; die = true; } if(opt::bam_file.empty()) { std::cerr << SUBPROGRAM ": a --bam file must be provided\n"; die = true; } if(opt::models_fofn.empty()) { std::cerr << SUBPROGRAM ": a --models-fofn file must be provided\n"; die = true; } if (die) { std::cout << "\n" << METHYLTEST_USAGE_MESSAGE; exit(EXIT_FAILURE); } } int methyltest_main(int argc, char** argv) { parse_methyltest_options(argc, argv); omp_set_num_threads(opt::num_threads); Fast5Map name_map(opt::reads_file); ModelMap models = read_models_fofn(opt::models_fofn); // Open the BAM and iterate over reads // load bam file htsFile* bam_fh = sam_open(opt::bam_file.c_str(), "r"); assert(bam_fh != NULL); // load bam index file std::string index_filename = opt::bam_file + ".bai"; hts_idx_t* bam_idx = bam_index_load(index_filename.c_str()); assert(bam_idx != NULL); // read the bam header bam_hdr_t* hdr = sam_hdr_read(bam_fh); // load reference fai file faidx_t *fai = fai_load(opt::genome_file.c_str()); hts_itr_t* itr; // If processing a region of the genome, only emit events aligned to this window int clip_start = -1; int clip_end = -1; if(opt::region.empty()) { // TODO: is this valid? itr = sam_itr_queryi(bam_idx, HTS_IDX_START, 0, 0); } else { fprintf(stderr, "Region: %s\n", opt::region.c_str()); itr = sam_itr_querys(bam_idx, hdr, opt::region.c_str()); hts_parse_reg(opt::region.c_str(), &clip_start, &clip_end); } #ifndef H5_HAVE_THREADSAFE if(opt::num_threads > 1) { fprintf(stderr, "You enabled multi-threading but you do not have a threadsafe HDF5\n"); fprintf(stderr, "Please recompile nanopolish's built-in libhdf5 or run with -t 1\n"); exit(1); } #endif // Initialize writers OutputHandles handles; handles.site_writer = fopen(std::string(opt::bam_file + ".methyltest.sites.bed").c_str(), "w"); handles.read_writer = fopen(std::string(opt::bam_file + ".methyltest.reads.tsv").c_str(), "w"); handles.strand_writer = fopen(std::string(opt::bam_file + ".methyltest.strand.tsv").c_str(), "w"); // Write a header to the reads.tsv file fprintf(handles.read_writer, "name\tsum_ll_ratio\tn_cpg\tcomplement_model\ttags\n"); // strand header fprintf(handles.strand_writer, "name\tsum_ll_ratio\tn_cpg\tmodel\n"); // Initialize iteration std::vector records(opt::batch_size, NULL); for(size_t i = 0; i < records.size(); ++i) { records[i] = bam_init1(); } int result; size_t num_reads_processed = 0; size_t num_records_buffered = 0; Progress progress("[methyltest]"); do { assert(num_records_buffered < records.size()); // read a record into the next slot in the buffer result = sam_itr_next(bam_fh, itr, records[num_records_buffered]); num_records_buffered += result >= 0; // realign if we've hit the max buffer size or reached the end of file if(num_records_buffered == records.size() || result < 0) { #pragma omp parallel for for(size_t i = 0; i < num_records_buffered; ++i) { bam1_t* record = records[i]; size_t read_idx = num_reads_processed + i; if( (record->core.flag & BAM_FUNMAP) == 0) { test_read(models, name_map, fai, hdr, record, read_idx, handles); } } num_reads_processed += num_records_buffered; num_records_buffered = 0; } } while(result >= 0); assert(num_records_buffered == 0); progress.end(); // cleanup records for(size_t i = 0; i < records.size(); ++i) { bam_destroy1(records[i]); } // cleanup fclose(handles.site_writer); fclose(handles.read_writer); fclose(handles.strand_writer); sam_itr_destroy(itr); bam_hdr_destroy(hdr); fai_destroy(fai); sam_close(bam_fh); hts_idx_destroy(bam_idx); return EXIT_SUCCESS; } nanopolish-0.4.0/src/nanopolish_methyltest.h000066400000000000000000000006271260522445600212740ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_methyltest -- test a methylation model // #ifndef NANOPOLISH_METHYLTEST_H #define NANOPOLISH_METHYLTEST_H int methyltest_main(int argc, char** argv); #endif nanopolish-0.4.0/src/nanopolish_methyltrain.cpp000066400000000000000000000663701260522445600217740ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_methyltrain -- train a methylation model // #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "htslib/faidx.h" #include "nanopolish_methyltrain.h" #include "nanopolish_eventalign.h" #include "nanopolish_iupac.h" #include "nanopolish_poremodel.h" #include "nanopolish_transition_parameters.h" #include "nanopolish_matrix.h" #include "nanopolish_profile_hmm.h" #include "nanopolish_anchor.h" #include "nanopolish_fast5_map.h" #include "H5pubconf.h" #include "profiler.h" #include "progress.h" // // Structs // // The state training data comes in two different // sizes Full and Minimal. The model training functions // only actually need the Minimal data but for exploration // the Full data is useful so left as an option. struct FullStateTrainingData { // // Functions // FullStateTrainingData(const SquiggleRead& sr, const EventAlignment& ea, uint32_t rank, const std::string& prev_kmer, const std::string& next_kmer) { // scale the observation to the expected pore model this->level_mean = sr.get_fully_scaled_level(ea.event_idx, ea.strand_idx); //this->event_stdv = sr.events[strand_idx][ea.event_idx].stdv / sr.pore_model[strand_idx].scale_sd; this->level_stdv = 0; this->duration = sr.events[ea.strand_idx][ea.event_idx].duration; this->read_var = (float)sr.pore_model[ea.strand_idx].var; this->ref_position = ea.ref_position; this->ref_strand = ea.rc; GaussianParameters model = sr.pore_model[ea.strand_idx].get_scaled_parameters(rank); this->z = (sr.get_drift_corrected_level(ea.event_idx, ea.strand_idx) - model.mean ) / model.stdv; this->prev_kmer = prev_kmer; this->next_kmer = next_kmer; } static void write_header(FILE* fp) { fprintf(fp, "model\tmodel_kmer\tlevel_mean\tlevel_stdv\tduration\tref_pos\tref_strand\tz\tread_var\tprev_kmer\tnext_kmer\n"); } void write_tsv(FILE* fp, const std::string& model_name, const std::string& kmer) const { fprintf(fp, "%s\t%s\t%.2lf\t%.2lf\t%.3lf\t%d\t%d\t%.2lf\t%.2lf\t%s\t%s\n", model_name.c_str(), kmer.c_str(), level_mean, level_stdv, duration, ref_position, ref_strand, z, read_var, prev_kmer.c_str(), next_kmer.c_str()); } // // Data // float level_mean; float level_stdv; float duration; float read_var; int ref_position; int ref_strand; float z; std::string prev_kmer; std::string next_kmer; }; struct MinimalStateTrainingData { // // Functions // MinimalStateTrainingData(const SquiggleRead& sr, const EventAlignment& ea, uint32_t rank, const std::string& prev_kmer, const std::string& next_kmer) { // scale the observation to the expected pore model this->level_mean = sr.get_fully_scaled_level(ea.event_idx, ea.strand_idx); this->read_var = (float)sr.pore_model[ea.strand_idx].var; } static void write_header(FILE* fp) { fprintf(fp, "model\tmodel_kmer\tlevel_mean\tread_var\n"); } void write_tsv(FILE* fp, const std::string& model_name, const std::string& kmer) const { fprintf(fp, "%s\t%s\t%.2lf\t%.2lf\n", model_name.c_str(), kmer.c_str(), level_mean, read_var); } // // Data // float level_mean; float read_var; }; typedef MinimalStateTrainingData StateTrainingData; struct StateSummary { StateSummary() { num_matches = 0; num_skips = 0; num_stays = 0; } std::vector events; int num_matches; int num_skips; int num_stays; }; struct GaussianMixture { std::vector weights; std::vector params; }; // Alphabet* mtrain_alphabet = &gMCpGAlphabet; // // Typedefs // typedef std::map> ModelTrainingMap; // // Getopt // #define SUBPROGRAM "methyltrain" static const char *METHYLTRAIN_VERSION_MESSAGE = SUBPROGRAM " Version " PACKAGE_VERSION "\n" "Written by Jared Simpson.\n" "\n" "Copyright 2015 Ontario Institute for Cancer Research\n"; static const char *METHYLTRAIN_USAGE_MESSAGE = "Usage: " PACKAGE_NAME " " SUBPROGRAM " [OPTIONS] --reads reads.fa --bam alignments.bam --genome genome.fa\n" "Train a methylation model\n" "\n" " -v, --verbose display verbose output\n" " --version display version\n" " --help display this help and exit\n" " -m, --models-fofn=FILE read the models to be trained from the FOFN\n" " --train-unmethylated train unmethylated 5-mers instead of methylated\n" " --no-update-models do not write out trained models\n" " -r, --reads=FILE the 2D ONT reads are in fasta FILE\n" " -b, --bam=FILE the reads aligned to the genome assembly are in bam FILE\n" " -g, --genome=FILE the genome we are computing a consensus for is in FILE\n" " -t, --threads=NUM use NUM threads (default: 1)\n" " -s, --out-suffix=STR name output files like model.out_suffix\n" " --progress print out a progress message\n" "\nReport bugs to " PACKAGE_BUGREPORT "\n\n"; namespace opt { static unsigned int verbose; static std::string reads_file; static std::string bam_file; static std::string genome_file; static std::string models_fofn; static std::string region; static std::string out_suffix = ".methyltrain"; static bool write_models = true; static bool train_unmethylated = false; static int progress = 0; static int num_threads = 1; static int batch_size = 128; } static const char* shortopts = "r:b:g:t:m:vn"; enum { OPT_HELP = 1, OPT_VERSION, OPT_PROGRESS, OPT_NO_UPDATE_MODELS, OPT_TRAIN_UNMETHYLATED }; static const struct option longopts[] = { { "verbose", no_argument, NULL, 'v' }, { "reads", required_argument, NULL, 'r' }, { "bam", required_argument, NULL, 'b' }, { "genome", required_argument, NULL, 'g' }, { "window", required_argument, NULL, 'w' }, { "threads", required_argument, NULL, 't' }, { "models-fofn", required_argument, NULL, 'm' }, { "out-suffix", required_argument, NULL, 's' }, { "no-update-models", no_argument, NULL, OPT_NO_UPDATE_MODELS }, { "train-unmethylated", no_argument, NULL, OPT_TRAIN_UNMETHYLATED }, { "progress", no_argument, NULL, OPT_PROGRESS }, { "help", no_argument, NULL, OPT_HELP }, { "version", no_argument, NULL, OPT_VERSION }, { NULL, 0, NULL, 0 } }; GaussianMixture train_gaussian_mixture(const std::vector& data, const GaussianMixture& input_mixture) { size_t n_components = input_mixture.params.size(); size_t n_data = data.size(); assert(input_mixture.weights.size() == n_components); GaussianMixture curr_mixture = input_mixture; for(size_t iteration = 0; iteration < 10; ++iteration) { std::vector mean_sum(n_components, 0.0f); std::vector var_sum(n_components, 0.0f); GaussianMixture new_mixture = curr_mixture; for(size_t j = 0; j < n_components; ++j) { new_mixture.weights[j] = 0.0f; } std::vector > resp; for(size_t i = 0; i < n_data; ++i) { // Calculate the posterior probability that // data i came from each component of the mixture // P(data i | component j) P(component j) std::vector t(n_components, 0.0f); double t_sum = -INFINITY; for(size_t j = 0; j < n_components; ++j) { t[j] = log_normal_pdf(data[i].level_mean, curr_mixture.params[j]) + log(curr_mixture.weights[j]); if(t[j] != -INFINITY && ! std::isnan(t[j])) { t_sum = add_logs(t_sum, t[j]); } } // store P(component j | data i) for(size_t j = 0; j < n_components; ++j) { t[j] = exp(t[j] - t_sum); new_mixture.weights[j] += t[j]; } resp.push_back(t); } for(size_t j = 0; j < n_components; ++j) { new_mixture.weights[j] /= n_data; } // Calculate mean for(size_t i = 0; i < n_data; ++i) { for(size_t j = 0; j < n_components; ++j) { double w_ij = resp[i][j]; mean_sum[j] += w_ij * data[i].level_mean; } } std::vector new_mean(2); for(size_t j = 0; j < n_components; ++j) { new_mean[j] = mean_sum[j] / (n_data * new_mixture.weights[j]); } // Calculate variance for(size_t i = 0; i < n_data; ++i) { for(size_t j = 0; j < n_components; ++j) { double w_ij = resp[i][j]; var_sum[j] += w_ij * pow( (data[i].level_mean - new_mean[j]) / data[i].read_var, 2.0); } } std::vector new_var(2); for(size_t j = 0; j < n_components; ++j) { new_var[j] = var_sum[j] / (n_data * new_mixture.weights[j]); } for(size_t j = 0; j < n_components; ++j) { new_mixture.params[j] = GaussianParameters(new_mean[j], sqrt(new_var[j])); //fprintf(stderr, "MIXTURE\t%zu\t%.2lf\t%.2lf\t%.2lf\n", j, curr_mixture.weights[j], curr_mixture.params[j].mean, curr_mixture.params[j].stdv); } curr_mixture = new_mixture; } return curr_mixture; } // Realign the read in event space void train_read(const ModelMap& model_map, const Fast5Map& name_map, const faidx_t* fai, const bam_hdr_t* hdr, const bam1_t* record, size_t read_idx, int region_start, int region_end, size_t round, ModelTrainingMap& training) { // Load a squiggle read for the mapped read std::string read_name = bam_get_qname(record); std::string fast5_path = name_map.get_path(read_name); // load read SquiggleRead sr(read_name, fast5_path); for(size_t strand_idx = 0; strand_idx < NUM_STRANDS; ++strand_idx) { // replace model with the training model std::string curr_model = sr.pore_model[strand_idx].name; auto model_iter = model_map.find(curr_model); if(model_iter != model_map.end()) { sr.pore_model[strand_idx].update_states(model_iter->second); } else { printf("Error: model %s not found\n", curr_model.c_str()); assert(false && "Model not found"); } // set k uint32_t k = sr.pore_model[strand_idx].k; // Align to the new model EventAlignmentParameters params; params.sr = &sr; params.fai = fai; params.hdr = hdr; params.record = record; params.strand_idx = strand_idx; params.alphabet = mtrain_alphabet; params.read_idx = read_idx; params.region_start = region_start; params.region_end = region_end; std::vector alignment_output = align_read_to_ref(params); // Update model observations #pragma omp critical { //emit_event_alignment_tsv(stdout, sr, params, alignment_output); // Get the training data for this model auto& emission_map = training[curr_model]; for(size_t i = 0; i < alignment_output.size(); ++i) { const EventAlignment& ea = alignment_output[i]; std::string model_kmer = ea.model_kmer; // Grab the previous/next model kmer // If the read is from the same strand as the reference // the next kmer comes from the next alignment_output (and vice-versa) // other the indices are swapped int next_stride = ea.rc ? -1 : 1; std::string prev_kmer = ""; std::string next_kmer = ""; if(i > 0 && i < alignment_output.size() - 1) { assert(alignment_output[i + next_stride].event_idx - ea.event_idx == 1); assert(alignment_output[i - next_stride].event_idx - ea.event_idx == -1); // check for exactly one base of movement along the reference if( abs(alignment_output[i + next_stride].ref_position - ea.ref_position) == 1) { next_kmer = alignment_output[i + next_stride].model_kmer; } if( abs(alignment_output[i - next_stride].ref_position - ea.ref_position) == 1) { prev_kmer = alignment_output[i - next_stride].model_kmer; } } uint32_t rank = mtrain_alphabet->kmer_rank(model_kmer.c_str(), k); auto& kmer_summary = emission_map[rank]; // Should we use this event for training? bool use_for_training = i > 5 && i + 5 < alignment_output.size() && alignment_output[i].hmm_state == 'M' && prev_kmer != "" && next_kmer != ""; if(use_for_training) { StateTrainingData std(sr, ea, rank, prev_kmer, next_kmer); kmer_summary.events.push_back(std); } if(ea.hmm_state == 'M') { kmer_summary.num_matches += 1; } else if(ea.hmm_state == 'E') { kmer_summary.num_stays += 1; } } } } // for strands } ModelMap read_models_fofn(const std::string& fofn_name) { ModelMap out; std::ifstream fofn_reader(fofn_name); std::string model_filename; while(getline(fofn_reader, model_filename)) { printf("reading %s\n", model_filename.c_str()); PoreModel p(model_filename, *mtrain_alphabet); assert(!p.name.empty()); out[p.name] = p; } return out; } void parse_methyltrain_options(int argc, char** argv) { bool die = false; for (char c; (c = getopt_long(argc, argv, shortopts, longopts, NULL)) != -1;) { std::istringstream arg(optarg != NULL ? optarg : ""); switch (c) { case 'r': arg >> opt::reads_file; break; case 'g': arg >> opt::genome_file; break; case 'b': arg >> opt::bam_file; break; case '?': die = true; break; case 't': arg >> opt::num_threads; break; case 'm': arg >> opt::models_fofn; break; case 's': arg >> opt::out_suffix; break; case 'v': opt::verbose++; break; case OPT_TRAIN_UNMETHYLATED: opt::train_unmethylated = true; break; case OPT_NO_UPDATE_MODELS: opt::write_models = false; break; case OPT_PROGRESS: opt::progress = true; break; case OPT_HELP: std::cout << METHYLTRAIN_USAGE_MESSAGE; exit(EXIT_SUCCESS); case OPT_VERSION: std::cout << METHYLTRAIN_VERSION_MESSAGE; exit(EXIT_SUCCESS); } } if(argc - optind > 0) { opt::region = argv[optind++]; } if (argc - optind > 0) { std::cerr << SUBPROGRAM ": too many arguments\n"; die = true; } if(opt::num_threads <= 0) { std::cerr << SUBPROGRAM ": invalid number of threads: " << opt::num_threads << "\n"; die = true; } if(opt::reads_file.empty()) { std::cerr << SUBPROGRAM ": a --reads file must be provided\n"; die = true; } if(opt::genome_file.empty()) { std::cerr << SUBPROGRAM ": a --genome file must be provided\n"; die = true; } if(opt::bam_file.empty()) { std::cerr << SUBPROGRAM ": a --bam file must be provided\n"; die = true; } if(opt::models_fofn.empty()) { std::cerr << SUBPROGRAM ": a --models-fofn file must be provided\n"; die = true; } if (die) { std::cout << "\n" << METHYLTRAIN_USAGE_MESSAGE; exit(EXIT_FAILURE); } } ModelMap train_one_round(const ModelMap& models, const Fast5Map& name_map, size_t round) { // Initialize the training summary stats for each kmer for each model ModelTrainingMap model_training_data; for(auto model_iter = models.begin(); model_iter != models.end(); model_iter++) { std::vector summaries(model_iter->second.get_num_states()); // one per kmer in the model model_training_data[model_iter->first] = summaries; } // Open the BAM and iterate over reads // load bam file htsFile* bam_fh = sam_open(opt::bam_file.c_str(), "r"); assert(bam_fh != NULL); // load bam index file std::string index_filename = opt::bam_file + ".bai"; hts_idx_t* bam_idx = bam_index_load(index_filename.c_str()); assert(bam_idx != NULL); // read the bam header bam_hdr_t* hdr = sam_hdr_read(bam_fh); // load reference fai file faidx_t *fai = fai_load(opt::genome_file.c_str()); hts_itr_t* itr; // If processing a region of the genome, only emit events aligned to this window int clip_start = -1; int clip_end = -1; if(opt::region.empty()) { // TODO: is this valid? itr = sam_itr_queryi(bam_idx, HTS_IDX_START, 0, 0); } else { fprintf(stderr, "Region: %s\n", opt::region.c_str()); itr = sam_itr_querys(bam_idx, hdr, opt::region.c_str()); hts_parse_reg(opt::region.c_str(), &clip_start, &clip_end); } #ifndef H5_HAVE_THREADSAFE if(opt::num_threads > 1) { fprintf(stderr, "You enabled multi-threading but you do not have a threadsafe HDF5\n"); fprintf(stderr, "Please recompile nanopolish's built-in libhdf5 or run with -t 1\n"); exit(1); } #endif // Initialize iteration std::vector records(opt::batch_size, NULL); for(size_t i = 0; i < records.size(); ++i) { records[i] = bam_init1(); } int result; size_t num_reads_realigned = 0; size_t num_records_buffered = 0; Progress progress("[methyltrain]"); do { assert(num_records_buffered < records.size()); // read a record into the next slot in the buffer result = sam_itr_next(bam_fh, itr, records[num_records_buffered]); num_records_buffered += result >= 0; // realign if we've hit the max buffer size or reached the end of file if(num_records_buffered == records.size() || result < 0) { #pragma omp parallel for for(size_t i = 0; i < num_records_buffered; ++i) { bam1_t* record = records[i]; size_t read_idx = num_reads_realigned + i; if( (record->core.flag & BAM_FUNMAP) == 0) { train_read(models, name_map, fai, hdr, record, read_idx, clip_start, clip_end, round, model_training_data); } } num_reads_realigned += num_records_buffered; num_records_buffered = 0; } if(opt::progress) { fprintf(stderr, "Realigned %zu reads in %.1lfs\r", num_reads_realigned, progress.get_elapsed_seconds()); } } while(result >= 0); assert(num_records_buffered == 0); progress.end(); std::stringstream training_fn; training_fn << opt::bam_file << ".methyltrain.tsv"; std::stringstream summary_fn; summary_fn << opt::bam_file << ".methyltrain.summary"; FILE* summary_fp = fopen(summary_fn.str().c_str(), "w"); FILE* training_fp = fopen(training_fn.str().c_str(), "w"); // training header StateTrainingData::write_header(training_fp); // Process the training results ModelMap trained_models; for(auto model_training_iter = model_training_data.begin(); model_training_iter != model_training_data.end(); model_training_iter++) { // Initialize trained model from input model auto model_iter = models.find(model_training_iter->first); assert(model_iter != models.end()); std::string model_name = model_training_iter->first; std::string model_short_name = ""; if(model_name == "r7.3_template_median68pA.model") { model_short_name = "t"; } else if(model_name == "r7.3_complement_median68pA_pop1.model") { model_short_name = "c.p1"; } else if(model_name == "r7.3_complement_median68pA_pop2.model") { model_short_name = "c.p2"; } else if(model_name == "r7.3_e6_70bps_6mer_template_median68pA.model") { model_short_name = "t.006"; } else if(model_name == "r7.3_e6_70bps_6mer_complement_median68pA_pop1.model") { model_short_name = "c.p1.006"; } else if(model_name == "r7.3_e6_70bps_6mer_complement_median68pA_pop2.model") { model_short_name = "c.p2.006"; } else { printf("Unknown model: %s\n", model_name.c_str()); assert(false); } trained_models[model_training_iter->first] = model_iter->second; PoreModel& new_pm = trained_models[model_training_iter->first]; // Update means for each kmer uint32_t k = new_pm.k; std::string kmer(k, 'A'); const std::vector& summaries = model_training_iter->second; for(size_t ki = 0; ki < summaries.size(); ++ki) { // write a training file for(size_t ei = 0; ei < summaries[ki].events.size(); ++ei) { summaries[ki].events[ei].write_tsv(training_fp, model_short_name, kmer); } // write to the summary file fprintf(summary_fp, "%s\t%s\t%d\t%d\t%d\n", model_short_name.c_str(), kmer.c_str(), summaries[ki].num_matches, summaries[ki].num_skips, summaries[ki].num_stays); GaussianMixture mixture; // train a mixture model where a minority of k-mers aren't methylated // unmethylated component double um_rate = 0.05f; std::string um_kmer = gMCpGAlphabet.unmethylate(kmer); size_t um_ki = gMCpGAlphabet.kmer_rank(um_kmer.c_str(), k); GaussianParameters um_params(model_iter->second.get_parameters(um_ki).level_mean, model_iter->second.get_parameters(um_ki).level_stdv); mixture.weights.push_back(um_rate); mixture.params.push_back(um_params); GaussianParameters m_params(model_iter->second.get_parameters(ki).level_mean, model_iter->second.get_parameters(ki).level_stdv); mixture.weights.push_back(1 - um_rate); mixture.params.push_back(m_params); if(opt::verbose > 1) { fprintf(stderr, "INIT__MIX %s\t%s\t[%.2lf %.2lf %.2lf]\t[%.2lf %.2lf %.2lf]\n", model_training_iter->first.c_str(), kmer.c_str(), mixture.weights[0], mixture.params[0].mean, mixture.params[0].stdv, mixture.weights[1], mixture.params[1].mean, mixture.params[1].stdv); } GaussianMixture trained_mixture = train_gaussian_mixture(summaries[ki].events, mixture); if(opt::verbose > 1) { fprintf(stderr, "TRAIN_MIX %s\t%s\t[%.2lf %.2lf %.2lf]\t[%.2lf %.2lf %.2lf]\n", model_training_iter->first.c_str(), kmer.c_str(), trained_mixture.weights[0], trained_mixture.params[0].mean, trained_mixture.params[0].stdv, trained_mixture.weights[1], trained_mixture.params[1].mean, trained_mixture.params[1].stdv); } bool is_m_kmer = kmer.find('M') != std::string::npos; bool update_kmer = (is_m_kmer == !opt::train_unmethylated); if(update_kmer && summaries[ki].events.size() > 100) { new_pm.states[ki].level_mean = trained_mixture.params[1].mean; new_pm.states[ki].level_stdv = trained_mixture.params[1].stdv; } /* if(kmer.find("CG") != std::string::npos) { float mu_prime = summaries[ki].mean_sum / summaries[ki].n; float var_prime = summaries[ki].var_sum / summaries[ki].n; new_pm[ki].level_mean = mu_prime; new_pm[ki].level_stdv = sqrt(var_prime); fprintf(stderr, "%s %s %.2lf %.2lf\n", model_training_iter->first.c_str(), kmer.c_str(), new_pm[ki].level_mean, new_pm[ki].level_stdv); } */ mtrain_alphabet->lexicographic_next(kmer); } } // cleanup records for(size_t i = 0; i < records.size(); ++i) { bam_destroy1(records[i]); } // cleanup sam_itr_destroy(itr); bam_hdr_destroy(hdr); fai_destroy(fai); sam_close(bam_fh); hts_idx_destroy(bam_idx); fclose(training_fp); fclose(summary_fp); return trained_models; } void write_models(ModelMap& models) { // Write the model for(auto model_iter = models.begin(); model_iter != models.end(); model_iter++) { assert(!model_iter->second.model_filename.empty()); std::string outname = model_iter->second.model_filename + opt::out_suffix; std::string modelname = model_iter->first + (!opt::train_unmethylated ? opt::out_suffix : ""); models[model_iter->first].write( outname, *mtrain_alphabet, modelname ); } } int methyltrain_main(int argc, char** argv) { parse_methyltrain_options(argc, argv); omp_set_num_threads(opt::num_threads); Fast5Map name_map(opt::reads_file); ModelMap models = read_models_fofn(opt::models_fofn); static size_t TRAINING_ROUNDS = 10; for(size_t round = 0; round < TRAINING_ROUNDS; round++) { fprintf(stderr, "Starting round %zu\n", round); ModelMap trained_models = train_one_round(models, name_map, round); if(opt::write_models) { write_models(trained_models); } models = trained_models; } return EXIT_SUCCESS; } nanopolish-0.4.0/src/nanopolish_methyltrain.h000066400000000000000000000011731260522445600214270ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_methyltrain -- train a methylation model // #ifndef NANOPOLISH_METHYLTRAIN_H #define NANOPOLISH_METHYLTRAIN_H #include #include #include "nanopolish_poremodel.h" // // Typedefs // typedef std::map ModelMap; // read models from a file ModelMap read_models_fofn(const std::string& fofn_name); int methyltrain_main(int argc, char** argv); #endif nanopolish-0.4.0/src/nanopolish_poremodel.cpp000066400000000000000000000124331260522445600214110ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_poremodel -- Representation of the Oxford // Nanopore sequencing model, as described in a FAST5 file // #include "nanopolish_poremodel.h" #include #include #include #include #include "../fast5/src/fast5.hpp" void PoreModel::bake_gaussian_parameters() { scaled_params.resize(states.size()); for(int i = 0; i < states.size(); ++i) { // these functions are provided by ONT scaled_params[i].mean = states[i].level_mean * scale + shift; scaled_params[i].stdv = states[i].level_stdv * var; scaled_params[i].log_stdv = log(scaled_params[i].stdv); // pre-computed for efficiency // These are not used, for now //scaled_state[i].sd_mean = state[i].sd_mean * scale_sd; //scaled_state[i].sd_stdv = state[i].sd_stdv * sqrt(pow(scale_sd, 3.0) / var_sd); } is_scaled = true; } PoreModel::PoreModel(const std::string filename, const Alphabet& alphabet) { model_filename = filename; std::ifstream model_reader(filename); std::string model_line; bool firstKmer = true; int ninserted = 0; shift_offset = 0.0f; while (getline(model_reader, model_line)) { std::stringstream parser(model_line); // Extract the model name from the header if (model_line.find("#model_name") != std::string::npos) { std::string dummy; parser >> dummy >> name; } // Extract shift offset from the header // This will be applied to the per-read shift values // to allow switching between models with different averages if (model_line.find("#shift_offset") != std::string::npos) { std::string dummy; parser >> dummy >> shift_offset; printf("found shift offset of %.2lf\n", shift_offset); } // skip the rest of the header if (model_line[0] == '#' || model_line.find("kmer") == 0) { continue; } std::string kmer; PoreModelStateParams params; parser >> kmer >> params.level_mean >> params.level_stdv >> params.sd_mean >> params.sd_stdv; if (firstKmer) { k = kmer.length(); states.resize( alphabet.get_num_strings(k) ); firstKmer = false; } states[ alphabet.kmer_rank(kmer.c_str(), k) ] = params; ninserted++; } assert( ninserted == states.size() ); } PoreModel::PoreModel(fast5::File *f_p, const size_t strand, const Alphabet& alphabet) { std::vector model = f_p->get_model(strand); k = (uint32_t) strlen(model[0].kmer); states.resize( alphabet.get_num_strings(k) ); assert(states.size() == model.size()); // Copy into the pore model for this read for(size_t mi = 0; mi < model.size(); ++mi) { const fast5::Model_Entry& curr = model[mi]; size_t rank = alphabet.kmer_rank(curr.kmer, k); states[rank] = { static_cast(curr.level_mean), static_cast(curr.level_stdv), static_cast(curr.sd_mean), static_cast(curr.sd_stdv) }; } // Load the scaling parameters for the pore model fast5::Model_Parameters params = f_p->get_model_parameters(strand); drift = params.drift; scale = params.scale; scale_sd = params.scale_sd; shift = params.shift; var = params.var; var_sd = params.var_sd; // no offset needed when loading directly from the fast5 shift_offset = 0.0f; // apply shift/scale transformation to the pore model states bake_gaussian_parameters(); // Read and shorten the model name std::string temp_name = f_p->get_model_file(strand); std::string leader = "/opt/chimaera/model/"; size_t lp = temp_name.find(leader); // leader not found if(lp == std::string::npos) { name = temp_name; } else { name = temp_name.substr(leader.size()); } std::replace(name.begin(), name.end(), '/', '_'); } void PoreModel::write(const std::string filename, const Alphabet& alphabet, const std::string modelname) { std::string outmodelname = modelname; if(modelname.empty()) outmodelname = name; std::ofstream writer(filename); writer << "#model_name\t" << outmodelname << std::endl; printf("SHIFT OFFSET: %.lf\n", shift_offset); writer << "#shift_offset\t" << shift_offset << std::endl; std::string curr_kmer(k,alphabet.base(0)); for(size_t ki = 0; ki < states.size(); ++ki) { writer << curr_kmer << "\t" << states[ki].level_mean << "\t" << states[ki].level_stdv << "\t" << states[ki].sd_mean << "\t" << states[ki].sd_stdv << std::endl; alphabet.lexicographic_next(curr_kmer); } writer.close(); } void PoreModel::update_states( const PoreModel &other ) { k = other.k; shift += other.shift_offset; update_states( other.states ); } void PoreModel::update_states( const std::vector &otherstates ) { states = otherstates; if (is_scaled) { bake_gaussian_parameters(); } } nanopolish-0.4.0/src/nanopolish_poremodel.h000066400000000000000000000053241260522445600210570ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_poremodel -- Representation of the Oxford // Nanopore sequencing model, as described in a FAST5 file // #ifndef NANOPOLISH_POREMODEL_H #define NANOPOLISH_POREMODEL_H #include #include "nanopolish_common.h" #include #include #include "../fast5/src/fast5.hpp" // struct PoreModelStateParams { double level_mean; double level_stdv; double sd_mean; double sd_stdv; }; // class PoreModel { public: PoreModel(uint32_t _k=5) : is_scaled(false), k(_k) {} // These constructors and the output routine take an alphabet // so that kmers are inserted/written in order // nicer might be to store the states as a map from kmer -> state PoreModel(const std::string filename, const Alphabet& alphabet=gDNAAlphabet); PoreModel(fast5::File *f_p, const size_t strand, const Alphabet& alphabet=gDNAAlphabet); void write(const std::string filename, const Alphabet& alphabet, const std::string modelname=""); inline GaussianParameters get_scaled_parameters(const uint32_t kmer_rank) const { assert(is_scaled); return scaled_params[kmer_rank]; } inline PoreModelStateParams get_parameters(const uint32_t kmer_rank) const { return states[kmer_rank]; } inline size_t get_num_states() const { return states.size(); } // Pre-compute the GaussianParameters to avoid // taking numerous logs in the emission calculations void bake_gaussian_parameters(); // update states with those given, or from another model void update_states( const PoreModel &other ); void update_states( const std::vector &otherstates ); // // Data // // model metadata std::string model_filename; std::string name; uint32_t k; // per-read scaling parameters double scale; double shift; double drift; double var; double scale_sd; double var_sd; // to support swapping models, a .model file might contain a shift_offset field // which describes how to change the per-read shift values to match the incoming // model. This field stores this data, which might be 0. double shift_offset; // bool is_scaled; std::vector states; std::vector scaled_params; }; #endif nanopolish-0.4.0/src/nanopolish_squiggle_read.cpp000066400000000000000000000151751260522445600222440ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_squiggle_read -- Class holding a squiggle (event) // space nanopore read // #include #include "nanopolish_common.h" #include "nanopolish_squiggle_read.h" #include "src/fast5.hpp" // SquiggleRead::SquiggleRead(const std::string& name, const std::string& path) : read_name(name), drift_correction_performed(false) { load_from_fast5(path); // perform drift correction and other scalings transform(); } SquiggleRead::~SquiggleRead() { } // helper for get_closest_event_to int SquiggleRead::get_next_event(int start, int stop, int stride, uint32_t strand) const { while(start != stop) { int ei = base_to_event_map[start].indices[strand].start; if(ei != -1) return ei; start += stride; } return -1; } // int SquiggleRead::get_closest_event_to(int k_idx, uint32_t strand) const { uint32_t k = pore_model[T_IDX].k; int stop_before = std::max(0, k_idx - 1000); int stop_after = std::min(k_idx + 1000, (int32_t)read_sequence.size() - (int32_t)k + 1); int event_before = get_next_event(k_idx, stop_before, -1, strand); int event_after = get_next_event(k_idx, stop_after, 1, strand); // TODO: better selection of "best" event to return if(event_before == -1) return event_after; return event_before; } // void SquiggleRead::transform() { for (size_t si = 0; si < 2; ++si) { for(size_t ei = 0; ei < events[si].size(); ++ei) { SquiggleEvent& event = events[si][ei]; // correct level by drift double time = event.start_time - events[si][0].start_time; event.mean -= (time * pore_model[si].drift); } } drift_correction_performed = true; } // void SquiggleRead::load_from_fast5(const std::string& fast5_path) { fast5::File* f_p; this->fast5_path = fast5_path; f_p = new fast5::File(fast5_path); assert(f_p->is_open()); // Check if an alternative analysis group is present in the read name int group_id = -1; size_t bc_2d_pos = read_name.find("Basecall_2D"); if(bc_2d_pos != std::string::npos) { int ret = sscanf(read_name.substr(bc_2d_pos).c_str(), "Basecall_2D_%03d_2d", &group_id); } // default to 0 group if(group_id == -1) { group_id = 0; } f_p->set_basecalled_group_id(group_id); // Load PoreModel for both strands for (size_t si = 0; si < 2; ++si) { pore_model[si] = PoreModel( f_p, si ); // initialize transition parameters parameters[si].initialize(pore_model[si].name); } // Load events for both strands for (size_t si = 0; si < 2; ++si) { std::vector f5_events = f_p->get_events(si); // copy events events[si].resize(f5_events.size()); for(size_t ei = 0; ei < f5_events.size(); ++ei) { const fast5::Event_Entry& f5_event = f5_events[ei]; events[si][ei] = { static_cast(f5_event.mean), static_cast(f5_event.stdv), static_cast(f5_event.start), static_cast(f5_event.length) }; } } // // Load basecalled sequence // read_sequence = f_p->basecalled_2D(); // // Build the map from read k-mers to events // std::vector event_alignments = f_p->get_event_alignments(); assert(!read_sequence.empty()); const uint32_t k = pore_model[T_IDX].k; assert(pore_model[C_IDX].k == k); uint32_t n_read_kmers = read_sequence.size() - k + 1; base_to_event_map.resize(n_read_kmers); uint32_t read_kidx = 0; // The alignment format in the fast5 file is slightly bizarre in that it is // (template_idx, complement_idx, kmer) tuples. Some read kmers may not have a // tuple and some might have multiple tuples. We need to use the read kmer // sequences to work out which read base each entry is referring to uint32_t start_ea_idx = 0; uint32_t end_ea_idx = 0; while(start_ea_idx < event_alignments.size()) { hack: uint32_t prev_kidx = read_kidx; // Advance the kmer index until we have found the read kmer // this tuple refers to while(read_kidx < n_read_kmers && strncmp(event_alignments[start_ea_idx].kmer, read_sequence.c_str() + read_kidx, k) != 0) { read_kidx += 1; } // In the most recent version of metrichor occasionally // a kmer will be present in the alignment table // that is not in the 2D read. This awful hack // will skip such k-mers. It is not a long-term // solution, only until metrichor is fixed. if(read_kidx - prev_kidx > 10) { start_ea_idx += 1; read_kidx = prev_kidx; goto hack; } // Advance the event alignment end index to the last tuple // with the same kmer as the start of this range end_ea_idx = start_ea_idx; while(end_ea_idx < event_alignments.size() && strcmp(event_alignments[start_ea_idx].kmer, event_alignments[end_ea_idx].kmer) == 0) { end_ea_idx += 1; } //printf("Base-to-event map kidx: %d %s event_tuple [%d %d]\n", read_kidx, read_sequence.substr(read_kidx, k).c_str(), start_ea_idx, end_ea_idx); EventRangeForBase& erfb = base_to_event_map[read_kidx]; for(uint32_t i = start_ea_idx; i < end_ea_idx; ++i) { fast5::Event_Alignment_Entry& eae = event_alignments[i]; for(uint32_t si = 0; si <= 1; ++si) { uint32_t incoming_idx = si == 0 ? eae.template_index : eae.complement_index; // no event for this strand, nothing to update if(incoming_idx == -1) continue; if(erfb.indices[si].start == -1) { erfb.indices[si].start = incoming_idx; } erfb.indices[si].stop = incoming_idx; assert(erfb.indices[si].start < events[si].size()); assert(erfb.indices[si].stop < events[si].size()); } } //printf("\t[%d %d] [%d %d]\n", erfb.indices[0].start, erfb.indices[0].stop, erfb.indices[1].start, erfb.indices[1].stop); start_ea_idx = end_ea_idx; } delete f_p; } nanopolish-0.4.0/src/nanopolish_squiggle_read.h000066400000000000000000000076301260522445600217060ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_squiggle_read -- Class holding a squiggle (event) // space nanopore read // #ifndef NANOPOLISH_SQUIGGLE_READ_H #define NANOPOLISH_SQUIGGLE_READ_H #include "nanopolish_common.h" #include "nanopolish_poremodel.h" #include "nanopolish_transition_parameters.h" #include // The raw event data for a read struct SquiggleEvent { float mean; // current level mean in picoamps float stdv; // current level stdv float start_time; // start time of the event in seconds float duration; // duration of the event in seconds }; struct IndexPair { IndexPair() : start(-1), stop(-1) {} int32_t start; int32_t stop; // inclusive }; // This struct maps from base-space k-mers to the range of template/complement // events used to call it. struct EventRangeForBase { IndexPair indices[2]; // one per strand }; // class SquiggleRead { public: SquiggleRead() : drift_correction_performed(false) {} // legacy TODO remove SquiggleRead(const std::string& name, const std::string& path); ~SquiggleRead(); // // I/O // // Load all the read data from a fast5 file void load_from_fast5(const std::string& fast5_path); // // Access to data // // Return the duration of the specified event for one strand inline float get_duration(uint32_t event_idx, uint32_t strand) const { assert(event_idx < events[strand].size()); return events[strand][event_idx].duration; } // Return the observed current level after correcting for drift inline float get_drift_corrected_level(uint32_t event_idx, uint32_t strand) const { assert(drift_correction_performed); return events[strand][event_idx].mean; } // Return the observed current level after correcting for drift inline float get_event_stdv(uint32_t event_idx, uint32_t strand) const { return events[strand][event_idx].stdv; } // Return the observed current level after correcting for drift, shift and scale inline float get_fully_scaled_level(uint32_t event_idx, uint32_t strand) const { assert(drift_correction_performed); float level = get_drift_corrected_level(event_idx, strand); return (level - pore_model[strand].shift) / pore_model[strand].scale; } // Calculate the index of this k-mer on the other strand inline int32_t flip_k_strand(int32_t k_idx) const { assert(!read_sequence.empty()); return read_sequence.size() - k_idx - pore_model[T_IDX].k; } // Transform each event by correcting for current drift void transform(); // get the index of the event tht is nearest to the given kmer int get_closest_event_to(int k_idx, uint32_t strand) const; // // Data // // unique identifier of the read std::string read_name; std::string fast5_path; uint32_t read_id; std::string read_sequence; bool drift_correction_performed; // one model for each strand PoreModel pore_model[2]; // one event sequence for each strand std::vector events[2]; // std::vector base_to_event_map; // one set of parameters per strand TransitionParameters parameters[2]; private: SquiggleRead(const SquiggleRead& other) {} // helper for get_closest_event_to int get_next_event(int start, int stop, int stride, uint32_t strand) const; }; #endif nanopolish-0.4.0/src/test/000077500000000000000000000000001260522445600154415ustar00rootroot00000000000000nanopolish-0.4.0/src/test/catch.hpp000066400000000000000000012221431260522445600172410ustar00rootroot00000000000000/* * CATCH v1.1 build 3 (master branch) * Generated: 2015-05-21 06:16:00.388118 * ---------------------------------------------------------- * This file has been merged from multiple headers. Please don't edit it directly * Copyright (c) 2012 Two Blue Cubes Ltd. All rights reserved. * * Distributed under the Boost Software License, Version 1.0. (See accompanying * file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) */ #ifndef TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED #define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED #define TWOBLUECUBES_CATCH_HPP_INCLUDED #ifdef __clang__ # pragma clang system_header #elif defined __GNUC__ # pragma GCC system_header #endif // #included from: internal/catch_suppress_warnings.h #define TWOBLUECUBES_CATCH_SUPPRESS_WARNINGS_H_INCLUDED #ifdef __clang__ # ifdef __ICC // icpc defines the __clang__ macro # pragma warning(push) # pragma warning(disable: 161 1682) # else // __ICC # pragma clang diagnostic ignored "-Wglobal-constructors" # pragma clang diagnostic ignored "-Wvariadic-macros" # pragma clang diagnostic ignored "-Wc99-extensions" # pragma clang diagnostic ignored "-Wunused-variable" # pragma clang diagnostic push # pragma clang diagnostic ignored "-Wpadded" # pragma clang diagnostic ignored "-Wc++98-compat" # pragma clang diagnostic ignored "-Wc++98-compat-pedantic" # pragma clang diagnostic ignored "-Wswitch-enum" # endif #elif defined __GNUC__ # pragma GCC diagnostic ignored "-Wvariadic-macros" # pragma GCC diagnostic ignored "-Wunused-variable" # pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wpadded" #endif #if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER) # define CATCH_IMPL #endif #ifdef CATCH_IMPL # ifndef CLARA_CONFIG_MAIN # define CLARA_CONFIG_MAIN_NOT_DEFINED # define CLARA_CONFIG_MAIN # endif #endif // #included from: internal/catch_notimplemented_exception.h #define TWOBLUECUBES_CATCH_NOTIMPLEMENTED_EXCEPTION_H_INCLUDED // #included from: catch_common.h #define TWOBLUECUBES_CATCH_COMMON_H_INCLUDED #define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line #define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) #define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ ) #define INTERNAL_CATCH_STRINGIFY2( expr ) #expr #define INTERNAL_CATCH_STRINGIFY( expr ) INTERNAL_CATCH_STRINGIFY2( expr ) #include #include #include // #included from: catch_compiler_capabilities.h #define TWOBLUECUBES_CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED // Detect a number of compiler features - mostly C++11/14 conformance - by compiler // The following features are defined: // // CATCH_CONFIG_CPP11_NULLPTR : is nullptr supported? // CATCH_CONFIG_CPP11_NOEXCEPT : is noexcept supported? // CATCH_CONFIG_CPP11_GENERATED_METHODS : The delete and default keywords for compiler generated methods // CATCH_CONFIG_CPP11_IS_ENUM : std::is_enum is supported? // CATCH_CONFIG_CPP11_TUPLE : std::tuple is supported // CATCH_CONFIG_CPP11_OR_GREATER : Is C++11 supported? // CATCH_CONFIG_SFINAE : is basic (C++03) SFINAE supported? // CATCH_CONFIG_VARIADIC_MACROS : are variadic macros supported? // A lot of this code is based on Boost (1.53) #ifdef __clang__ # if __has_feature(cxx_nullptr) # define CATCH_CONFIG_CPP11_NULLPTR # endif # if __has_feature(cxx_noexcept) # define CATCH_CONFIG_CPP11_NOEXCEPT # endif #endif // __clang__ //////////////////////////////////////////////////////////////////////////////// // Borland #ifdef __BORLANDC__ #if (__BORLANDC__ > 0x582 ) //#define CATCH_CONFIG_SFINAE // Not confirmed #endif #endif // __BORLANDC__ //////////////////////////////////////////////////////////////////////////////// // EDG #ifdef __EDG_VERSION__ #if (__EDG_VERSION__ > 238 ) //#define CATCH_CONFIG_SFINAE // Not confirmed #endif #endif // __EDG_VERSION__ //////////////////////////////////////////////////////////////////////////////// // Digital Mars #ifdef __DMC__ #if (__DMC__ > 0x840 ) //#define CATCH_CONFIG_SFINAE // Not confirmed #endif #endif // __DMC__ //////////////////////////////////////////////////////////////////////////////// // GCC #ifdef __GNUC__ #if __GNUC__ < 3 #if (__GNUC_MINOR__ >= 96 ) //#define CATCH_CONFIG_SFINAE #endif #elif __GNUC__ >= 3 // #define CATCH_CONFIG_SFINAE // Taking this out completely for now #endif // __GNUC__ < 3 #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6 && defined(__GXX_EXPERIMENTAL_CXX0X__) ) #define CATCH_CONFIG_CPP11_NULLPTR #endif #endif // __GNUC__ //////////////////////////////////////////////////////////////////////////////// // Visual C++ #ifdef _MSC_VER #if (_MSC_VER >= 1310 ) // (VC++ 7.0+) //#define CATCH_CONFIG_SFINAE // Not confirmed #endif #if (_MSC_VER >= 1600) #define CATCH_CONFIG_CPP11_NULLPTR #endif #if (_MSC_VER >= 1900 ) // (VC++ 13 (VS2015)) #define CATCH_CONFIG_CPP11_NOEXCEPT #define CATCH_CONFIG_CPP11_GENERATED_METHODS #endif #endif // _MSC_VER // Use variadic macros if the compiler supports them #if ( defined _MSC_VER && _MSC_VER > 1400 && !defined __EDGE__) || \ ( defined __WAVE__ && __WAVE_HAS_VARIADICS ) || \ ( defined __GNUC__ && __GNUC__ >= 3 ) || \ ( !defined __cplusplus && __STDC_VERSION__ >= 199901L || __cplusplus >= 201103L ) #ifndef CATCH_CONFIG_NO_VARIADIC_MACROS #define CATCH_CONFIG_VARIADIC_MACROS #endif #endif //////////////////////////////////////////////////////////////////////////////// // C++ language feature support // catch all support for C++11 #if (__cplusplus >= 201103L) # define CATCH_CPP11_OR_GREATER # ifndef CATCH_CONFIG_CPP11_NULLPTR # define CATCH_CONFIG_CPP11_NULLPTR # endif # ifndef CATCH_CONFIG_CPP11_NOEXCEPT # define CATCH_CONFIG_CPP11_NOEXCEPT # endif # ifndef CATCH_CONFIG_CPP11_GENERATED_METHODS # define CATCH_CONFIG_CPP11_GENERATED_METHODS # endif # ifndef CATCH_CONFIG_CPP11_IS_ENUM # define CATCH_CONFIG_CPP11_IS_ENUM # endif # ifndef CATCH_CONFIG_CPP11_TUPLE # define CATCH_CONFIG_CPP11_TUPLE # endif # ifndef CATCH_CONFIG_SFINAE //# define CATCH_CONFIG_SFINAE // Don't use, for now # endif # ifndef CATCH_CONFIG_VARIADIC_MACROS # define CATCH_CONFIG_VARIADIC_MACROS # endif #endif // __cplusplus >= 201103L // noexcept support: #if defined(CATCH_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_NOEXCEPT) # define CATCH_NOEXCEPT noexcept # define CATCH_NOEXCEPT_IS(x) noexcept(x) #else # define CATCH_NOEXCEPT throw() # define CATCH_NOEXCEPT_IS(x) #endif namespace Catch { class NonCopyable { #ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS NonCopyable( NonCopyable const& ) = delete; NonCopyable( NonCopyable && ) = delete; NonCopyable& operator = ( NonCopyable const& ) = delete; NonCopyable& operator = ( NonCopyable && ) = delete; #else NonCopyable( NonCopyable const& info ); NonCopyable& operator = ( NonCopyable const& ); #endif protected: NonCopyable() {} virtual ~NonCopyable(); }; class SafeBool { public: typedef void (SafeBool::*type)() const; static type makeSafe( bool value ) { return value ? &SafeBool::trueValue : 0; } private: void trueValue() const {} }; template inline void deleteAll( ContainerT& container ) { typename ContainerT::const_iterator it = container.begin(); typename ContainerT::const_iterator itEnd = container.end(); for(; it != itEnd; ++it ) delete *it; } template inline void deleteAllValues( AssociativeContainerT& container ) { typename AssociativeContainerT::const_iterator it = container.begin(); typename AssociativeContainerT::const_iterator itEnd = container.end(); for(; it != itEnd; ++it ) delete it->second; } bool startsWith( std::string const& s, std::string const& prefix ); bool endsWith( std::string const& s, std::string const& suffix ); bool contains( std::string const& s, std::string const& infix ); void toLowerInPlace( std::string& s ); std::string toLower( std::string const& s ); std::string trim( std::string const& str ); bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ); struct pluralise { pluralise( std::size_t count, std::string const& label ); friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ); std::size_t m_count; std::string m_label; }; struct SourceLineInfo { SourceLineInfo(); SourceLineInfo( char const* _file, std::size_t _line ); SourceLineInfo( SourceLineInfo const& other ); # ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS SourceLineInfo( SourceLineInfo && ) = default; SourceLineInfo& operator = ( SourceLineInfo const& ) = default; SourceLineInfo& operator = ( SourceLineInfo && ) = default; # endif bool empty() const; bool operator == ( SourceLineInfo const& other ) const; bool operator < ( SourceLineInfo const& other ) const; std::string file; std::size_t line; }; std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ); // This is just here to avoid compiler warnings with macro constants and boolean literals inline bool isTrue( bool value ){ return value; } inline bool alwaysTrue() { return true; } inline bool alwaysFalse() { return false; } void throwLogicError( std::string const& message, SourceLineInfo const& locationInfo ); // Use this in variadic streaming macros to allow // >> +StreamEndStop // as well as // >> stuff +StreamEndStop struct StreamEndStop { std::string operator+() { return std::string(); } }; template T const& operator + ( T const& value, StreamEndStop ) { return value; } } #define CATCH_INTERNAL_LINEINFO ::Catch::SourceLineInfo( __FILE__, static_cast( __LINE__ ) ) #define CATCH_INTERNAL_ERROR( msg ) ::Catch::throwLogicError( msg, CATCH_INTERNAL_LINEINFO ); #include namespace Catch { class NotImplementedException : public std::exception { public: NotImplementedException( SourceLineInfo const& lineInfo ); NotImplementedException( NotImplementedException const& ) {} virtual ~NotImplementedException() CATCH_NOEXCEPT {} virtual const char* what() const CATCH_NOEXCEPT; private: std::string m_what; SourceLineInfo m_lineInfo; }; } // end namespace Catch /////////////////////////////////////////////////////////////////////////////// #define CATCH_NOT_IMPLEMENTED throw Catch::NotImplementedException( CATCH_INTERNAL_LINEINFO ) // #included from: internal/catch_context.h #define TWOBLUECUBES_CATCH_CONTEXT_H_INCLUDED // #included from: catch_interfaces_generators.h #define TWOBLUECUBES_CATCH_INTERFACES_GENERATORS_H_INCLUDED #include namespace Catch { struct IGeneratorInfo { virtual ~IGeneratorInfo(); virtual bool moveNext() = 0; virtual std::size_t getCurrentIndex() const = 0; }; struct IGeneratorsForTest { virtual ~IGeneratorsForTest(); virtual IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) = 0; virtual bool moveNext() = 0; }; IGeneratorsForTest* createGeneratorsForTest(); } // end namespace Catch // #included from: catch_ptr.hpp #define TWOBLUECUBES_CATCH_PTR_HPP_INCLUDED #ifdef __clang__ #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wpadded" #endif namespace Catch { // An intrusive reference counting smart pointer. // T must implement addRef() and release() methods // typically implementing the IShared interface template class Ptr { public: Ptr() : m_p( NULL ){} Ptr( T* p ) : m_p( p ){ if( m_p ) m_p->addRef(); } Ptr( Ptr const& other ) : m_p( other.m_p ){ if( m_p ) m_p->addRef(); } ~Ptr(){ if( m_p ) m_p->release(); } void reset() { if( m_p ) m_p->release(); m_p = NULL; } Ptr& operator = ( T* p ){ Ptr temp( p ); swap( temp ); return *this; } Ptr& operator = ( Ptr const& other ){ Ptr temp( other ); swap( temp ); return *this; } void swap( Ptr& other ) { std::swap( m_p, other.m_p ); } T* get() { return m_p; } const T* get() const{ return m_p; } T& operator*() const { return *m_p; } T* operator->() const { return m_p; } bool operator !() const { return m_p == NULL; } operator SafeBool::type() const { return SafeBool::makeSafe( m_p != NULL ); } private: T* m_p; }; struct IShared : NonCopyable { virtual ~IShared(); virtual void addRef() const = 0; virtual void release() const = 0; }; template struct SharedImpl : T { SharedImpl() : m_rc( 0 ){} virtual void addRef() const { ++m_rc; } virtual void release() const { if( --m_rc == 0 ) delete this; } mutable unsigned int m_rc; }; } // end namespace Catch #ifdef __clang__ #pragma clang diagnostic pop #endif #include #include #include namespace Catch { class TestCase; class Stream; struct IResultCapture; struct IRunner; struct IGeneratorsForTest; struct IConfig; struct IContext { virtual ~IContext(); virtual IResultCapture* getResultCapture() = 0; virtual IRunner* getRunner() = 0; virtual size_t getGeneratorIndex( std::string const& fileInfo, size_t totalSize ) = 0; virtual bool advanceGeneratorsForCurrentTest() = 0; virtual Ptr getConfig() const = 0; }; struct IMutableContext : IContext { virtual ~IMutableContext(); virtual void setResultCapture( IResultCapture* resultCapture ) = 0; virtual void setRunner( IRunner* runner ) = 0; virtual void setConfig( Ptr const& config ) = 0; }; IContext& getCurrentContext(); IMutableContext& getCurrentMutableContext(); void cleanUpContext(); Stream createStream( std::string const& streamName ); } // #included from: internal/catch_test_registry.hpp #define TWOBLUECUBES_CATCH_TEST_REGISTRY_HPP_INCLUDED // #included from: catch_interfaces_testcase.h #define TWOBLUECUBES_CATCH_INTERFACES_TESTCASE_H_INCLUDED #include namespace Catch { class TestSpec; struct ITestCase : IShared { virtual void invoke () const = 0; protected: virtual ~ITestCase(); }; class TestCase; struct IConfig; struct ITestCaseRegistry { virtual ~ITestCaseRegistry(); virtual std::vector const& getAllTests() const = 0; virtual void getFilteredTests( TestSpec const& testSpec, IConfig const& config, std::vector& matchingTestCases, bool negated = false ) const = 0; }; } namespace Catch { template class MethodTestCase : public SharedImpl { public: MethodTestCase( void (C::*method)() ) : m_method( method ) {} virtual void invoke() const { C obj; (obj.*m_method)(); } private: virtual ~MethodTestCase() {} void (C::*m_method)(); }; typedef void(*TestFunction)(); struct NameAndDesc { NameAndDesc( const char* _name = "", const char* _description= "" ) : name( _name ), description( _description ) {} const char* name; const char* description; }; struct AutoReg { AutoReg( TestFunction function, SourceLineInfo const& lineInfo, NameAndDesc const& nameAndDesc ); template AutoReg( void (C::*method)(), char const* className, NameAndDesc const& nameAndDesc, SourceLineInfo const& lineInfo ) { registerTestCase( new MethodTestCase( method ), className, nameAndDesc, lineInfo ); } void registerTestCase( ITestCase* testCase, char const* className, NameAndDesc const& nameAndDesc, SourceLineInfo const& lineInfo ); ~AutoReg(); private: AutoReg( AutoReg const& ); void operator= ( AutoReg const& ); }; } // end namespace Catch #ifdef CATCH_CONFIG_VARIADIC_MACROS /////////////////////////////////////////////////////////////////////////////// #define INTERNAL_CATCH_TESTCASE( ... ) \ static void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )(); \ namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( __VA_ARGS__ ) ); }\ static void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )() /////////////////////////////////////////////////////////////////////////////// #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \ namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); } /////////////////////////////////////////////////////////////////////////////// #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... )\ namespace{ \ struct INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ) : ClassName{ \ void test(); \ }; \ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )::test, #ClassName, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); \ } \ void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )::test() #else /////////////////////////////////////////////////////////////////////////////// #define INTERNAL_CATCH_TESTCASE( Name, Desc ) \ static void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )(); \ namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( Name, Desc ) ); }\ static void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )() /////////////////////////////////////////////////////////////////////////////// #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, Name, Desc ) \ namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( Name, Desc ), CATCH_INTERNAL_LINEINFO ); } /////////////////////////////////////////////////////////////////////////////// #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, TestName, Desc )\ namespace{ \ struct INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ) : ClassName{ \ void test(); \ }; \ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )::test, #ClassName, Catch::NameAndDesc( TestName, Desc ), CATCH_INTERNAL_LINEINFO ); \ } \ void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )::test() #endif // #included from: internal/catch_capture.hpp #define TWOBLUECUBES_CATCH_CAPTURE_HPP_INCLUDED // #included from: catch_result_builder.h #define TWOBLUECUBES_CATCH_RESULT_BUILDER_H_INCLUDED // #included from: catch_result_type.h #define TWOBLUECUBES_CATCH_RESULT_TYPE_H_INCLUDED namespace Catch { // ResultWas::OfType enum struct ResultWas { enum OfType { Unknown = -1, Ok = 0, Info = 1, Warning = 2, FailureBit = 0x10, ExpressionFailed = FailureBit | 1, ExplicitFailure = FailureBit | 2, Exception = 0x100 | FailureBit, ThrewException = Exception | 1, DidntThrowException = Exception | 2, FatalErrorCondition = 0x200 | FailureBit }; }; inline bool isOk( ResultWas::OfType resultType ) { return ( resultType & ResultWas::FailureBit ) == 0; } inline bool isJustInfo( int flags ) { return flags == ResultWas::Info; } // ResultDisposition::Flags enum struct ResultDisposition { enum Flags { Normal = 0x01, ContinueOnFailure = 0x02, // Failures fail test, but execution continues FalseTest = 0x04, // Prefix expression with ! SuppressFail = 0x08 // Failures are reported but do not fail the test }; }; inline ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs ) { return static_cast( static_cast( lhs ) | static_cast( rhs ) ); } inline bool shouldContinueOnFailure( int flags ) { return ( flags & ResultDisposition::ContinueOnFailure ) != 0; } inline bool isFalseTest( int flags ) { return ( flags & ResultDisposition::FalseTest ) != 0; } inline bool shouldSuppressFailure( int flags ) { return ( flags & ResultDisposition::SuppressFail ) != 0; } } // end namespace Catch // #included from: catch_assertionresult.h #define TWOBLUECUBES_CATCH_ASSERTIONRESULT_H_INCLUDED #include namespace Catch { struct AssertionInfo { AssertionInfo() {} AssertionInfo( std::string const& _macroName, SourceLineInfo const& _lineInfo, std::string const& _capturedExpression, ResultDisposition::Flags _resultDisposition ); std::string macroName; SourceLineInfo lineInfo; std::string capturedExpression; ResultDisposition::Flags resultDisposition; }; struct AssertionResultData { AssertionResultData() : resultType( ResultWas::Unknown ) {} std::string reconstructedExpression; std::string message; ResultWas::OfType resultType; }; class AssertionResult { public: AssertionResult(); AssertionResult( AssertionInfo const& info, AssertionResultData const& data ); ~AssertionResult(); # ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS AssertionResult( AssertionResult const& ) = default; AssertionResult( AssertionResult && ) = default; AssertionResult& operator = ( AssertionResult const& ) = default; AssertionResult& operator = ( AssertionResult && ) = default; # endif bool isOk() const; bool succeeded() const; ResultWas::OfType getResultType() const; bool hasExpression() const; bool hasMessage() const; std::string getExpression() const; std::string getExpressionInMacro() const; bool hasExpandedExpression() const; std::string getExpandedExpression() const; std::string getMessage() const; SourceLineInfo getSourceInfo() const; std::string getTestMacroName() const; protected: AssertionInfo m_info; AssertionResultData m_resultData; }; } // end namespace Catch namespace Catch { struct TestFailureException{}; template class ExpressionLhs; struct STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison; struct CopyableStream { CopyableStream() {} CopyableStream( CopyableStream const& other ) { oss << other.oss.str(); } CopyableStream& operator=( CopyableStream const& other ) { oss.str(""); oss << other.oss.str(); return *this; } std::ostringstream oss; }; class ResultBuilder { public: ResultBuilder( char const* macroName, SourceLineInfo const& lineInfo, char const* capturedExpression, ResultDisposition::Flags resultDisposition ); template ExpressionLhs operator->* ( T const& operand ); ExpressionLhs operator->* ( bool value ); template ResultBuilder& operator << ( T const& value ) { m_stream.oss << value; return *this; } template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator && ( RhsT const& ); template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator || ( RhsT const& ); ResultBuilder& setResultType( ResultWas::OfType result ); ResultBuilder& setResultType( bool result ); ResultBuilder& setLhs( std::string const& lhs ); ResultBuilder& setRhs( std::string const& rhs ); ResultBuilder& setOp( std::string const& op ); void endExpression(); std::string reconstructExpression() const; AssertionResult build() const; void useActiveException( ResultDisposition::Flags resultDisposition = ResultDisposition::Normal ); void captureResult( ResultWas::OfType resultType ); void captureExpression(); void react(); bool shouldDebugBreak() const; bool allowThrows() const; private: AssertionInfo m_assertionInfo; AssertionResultData m_data; struct ExprComponents { ExprComponents() : testFalse( false ) {} bool testFalse; std::string lhs, rhs, op; } m_exprComponents; CopyableStream m_stream; bool m_shouldDebugBreak; bool m_shouldThrow; }; } // namespace Catch // Include after due to circular dependency: // #included from: catch_expression_lhs.hpp #define TWOBLUECUBES_CATCH_EXPRESSION_LHS_HPP_INCLUDED // #included from: catch_evaluate.hpp #define TWOBLUECUBES_CATCH_EVALUATE_HPP_INCLUDED #ifdef _MSC_VER #pragma warning(push) #pragma warning(disable:4389) // '==' : signed/unsigned mismatch #endif #include namespace Catch { namespace Internal { enum Operator { IsEqualTo, IsNotEqualTo, IsLessThan, IsGreaterThan, IsLessThanOrEqualTo, IsGreaterThanOrEqualTo }; template struct OperatorTraits { static const char* getName(){ return "*error*"; } }; template<> struct OperatorTraits { static const char* getName(){ return "=="; } }; template<> struct OperatorTraits { static const char* getName(){ return "!="; } }; template<> struct OperatorTraits { static const char* getName(){ return "<"; } }; template<> struct OperatorTraits { static const char* getName(){ return ">"; } }; template<> struct OperatorTraits { static const char* getName(){ return "<="; } }; template<> struct OperatorTraits{ static const char* getName(){ return ">="; } }; template inline T& opCast(T const& t) { return const_cast(t); } // nullptr_t support based on pull request #154 from Konstantin Baumann #ifdef CATCH_CONFIG_CPP11_NULLPTR inline std::nullptr_t opCast(std::nullptr_t) { return nullptr; } #endif // CATCH_CONFIG_CPP11_NULLPTR // So the compare overloads can be operator agnostic we convey the operator as a template // enum, which is used to specialise an Evaluator for doing the comparison. template class Evaluator{}; template struct Evaluator { static bool evaluate( T1 const& lhs, T2 const& rhs) { return opCast( lhs ) == opCast( rhs ); } }; template struct Evaluator { static bool evaluate( T1 const& lhs, T2 const& rhs ) { return opCast( lhs ) != opCast( rhs ); } }; template struct Evaluator { static bool evaluate( T1 const& lhs, T2 const& rhs ) { return opCast( lhs ) < opCast( rhs ); } }; template struct Evaluator { static bool evaluate( T1 const& lhs, T2 const& rhs ) { return opCast( lhs ) > opCast( rhs ); } }; template struct Evaluator { static bool evaluate( T1 const& lhs, T2 const& rhs ) { return opCast( lhs ) >= opCast( rhs ); } }; template struct Evaluator { static bool evaluate( T1 const& lhs, T2 const& rhs ) { return opCast( lhs ) <= opCast( rhs ); } }; template bool applyEvaluator( T1 const& lhs, T2 const& rhs ) { return Evaluator::evaluate( lhs, rhs ); } // This level of indirection allows us to specialise for integer types // to avoid signed/ unsigned warnings // "base" overload template bool compare( T1 const& lhs, T2 const& rhs ) { return Evaluator::evaluate( lhs, rhs ); } // unsigned X to int template bool compare( unsigned int lhs, int rhs ) { return applyEvaluator( lhs, static_cast( rhs ) ); } template bool compare( unsigned long lhs, int rhs ) { return applyEvaluator( lhs, static_cast( rhs ) ); } template bool compare( unsigned char lhs, int rhs ) { return applyEvaluator( lhs, static_cast( rhs ) ); } // unsigned X to long template bool compare( unsigned int lhs, long rhs ) { return applyEvaluator( lhs, static_cast( rhs ) ); } template bool compare( unsigned long lhs, long rhs ) { return applyEvaluator( lhs, static_cast( rhs ) ); } template bool compare( unsigned char lhs, long rhs ) { return applyEvaluator( lhs, static_cast( rhs ) ); } // int to unsigned X template bool compare( int lhs, unsigned int rhs ) { return applyEvaluator( static_cast( lhs ), rhs ); } template bool compare( int lhs, unsigned long rhs ) { return applyEvaluator( static_cast( lhs ), rhs ); } template bool compare( int lhs, unsigned char rhs ) { return applyEvaluator( static_cast( lhs ), rhs ); } // long to unsigned X template bool compare( long lhs, unsigned int rhs ) { return applyEvaluator( static_cast( lhs ), rhs ); } template bool compare( long lhs, unsigned long rhs ) { return applyEvaluator( static_cast( lhs ), rhs ); } template bool compare( long lhs, unsigned char rhs ) { return applyEvaluator( static_cast( lhs ), rhs ); } // pointer to long (when comparing against NULL) template bool compare( long lhs, T* rhs ) { return Evaluator::evaluate( reinterpret_cast( lhs ), rhs ); } template bool compare( T* lhs, long rhs ) { return Evaluator::evaluate( lhs, reinterpret_cast( rhs ) ); } // pointer to int (when comparing against NULL) template bool compare( int lhs, T* rhs ) { return Evaluator::evaluate( reinterpret_cast( lhs ), rhs ); } template bool compare( T* lhs, int rhs ) { return Evaluator::evaluate( lhs, reinterpret_cast( rhs ) ); } #ifdef CATCH_CONFIG_CPP11_NULLPTR // pointer to nullptr_t (when comparing against nullptr) template bool compare( std::nullptr_t, T* rhs ) { return Evaluator::evaluate( NULL, rhs ); } template bool compare( T* lhs, std::nullptr_t ) { return Evaluator::evaluate( lhs, NULL ); } #endif // CATCH_CONFIG_CPP11_NULLPTR } // end of namespace Internal } // end of namespace Catch #ifdef _MSC_VER #pragma warning(pop) #endif // #included from: catch_tostring.h #define TWOBLUECUBES_CATCH_TOSTRING_H_INCLUDED // #included from: catch_sfinae.hpp #define TWOBLUECUBES_CATCH_SFINAE_HPP_INCLUDED // Try to detect if the current compiler supports SFINAE namespace Catch { struct TrueType { static const bool value = true; typedef void Enable; char sizer[1]; }; struct FalseType { static const bool value = false; typedef void Disable; char sizer[2]; }; #ifdef CATCH_CONFIG_SFINAE template struct NotABooleanExpression; template struct If : NotABooleanExpression {}; template<> struct If : TrueType {}; template<> struct If : FalseType {}; template struct SizedIf; template<> struct SizedIf : TrueType {}; template<> struct SizedIf : FalseType {}; #endif // CATCH_CONFIG_SFINAE } // end namespace Catch #include #include #include #include #include #ifdef __OBJC__ // #included from: catch_objc_arc.hpp #define TWOBLUECUBES_CATCH_OBJC_ARC_HPP_INCLUDED #import #ifdef __has_feature #define CATCH_ARC_ENABLED __has_feature(objc_arc) #else #define CATCH_ARC_ENABLED 0 #endif void arcSafeRelease( NSObject* obj ); id performOptionalSelector( id obj, SEL sel ); #if !CATCH_ARC_ENABLED inline void arcSafeRelease( NSObject* obj ) { [obj release]; } inline id performOptionalSelector( id obj, SEL sel ) { if( [obj respondsToSelector: sel] ) return [obj performSelector: sel]; return nil; } #define CATCH_UNSAFE_UNRETAINED #define CATCH_ARC_STRONG #else inline void arcSafeRelease( NSObject* ){} inline id performOptionalSelector( id obj, SEL sel ) { #ifdef __clang__ #pragma clang diagnostic push #pragma clang diagnostic ignored "-Warc-performSelector-leaks" #endif if( [obj respondsToSelector: sel] ) return [obj performSelector: sel]; #ifdef __clang__ #pragma clang diagnostic pop #endif return nil; } #define CATCH_UNSAFE_UNRETAINED __unsafe_unretained #define CATCH_ARC_STRONG __strong #endif #endif #ifdef CATCH_CONFIG_CPP11_TUPLE #include #endif #ifdef CATCH_CONFIG_CPP11_IS_ENUM #include #endif namespace Catch { // Why we're here. template std::string toString( T const& value ); // Built in overloads std::string toString( std::string const& value ); std::string toString( std::wstring const& value ); std::string toString( const char* const value ); std::string toString( char* const value ); std::string toString( const wchar_t* const value ); std::string toString( wchar_t* const value ); std::string toString( int value ); std::string toString( unsigned long value ); std::string toString( unsigned int value ); std::string toString( const double value ); std::string toString( const float value ); std::string toString( bool value ); std::string toString( char value ); std::string toString( signed char value ); std::string toString( unsigned char value ); #ifdef CATCH_CONFIG_CPP11_NULLPTR std::string toString( std::nullptr_t ); #endif #ifdef __OBJC__ std::string toString( NSString const * const& nsstring ); std::string toString( NSString * CATCH_ARC_STRONG const& nsstring ); std::string toString( NSObject* const& nsObject ); #endif namespace Detail { extern std::string unprintableString; // SFINAE is currently disabled by default for all compilers. // If the non SFINAE version of IsStreamInsertable is ambiguous for you // and your compiler supports SFINAE, try #defining CATCH_CONFIG_SFINAE #ifdef CATCH_CONFIG_SFINAE template class IsStreamInsertableHelper { template struct TrueIfSizeable : TrueType {}; template static TrueIfSizeable dummy(T2*); static FalseType dummy(...); public: typedef SizedIf type; }; template struct IsStreamInsertable : IsStreamInsertableHelper::type {}; #else struct BorgType { template BorgType( T const& ); }; TrueType& testStreamable( std::ostream& ); FalseType testStreamable( FalseType ); FalseType operator<<( std::ostream const&, BorgType const& ); template struct IsStreamInsertable { static std::ostream &s; static T const&t; enum { value = sizeof( testStreamable(s << t) ) == sizeof( TrueType ) }; }; #endif #if defined(CATCH_CONFIG_CPP11_IS_ENUM) template::value > struct EnumStringMaker { static std::string convert( T const& ) { return unprintableString; } }; template struct EnumStringMaker { static std::string convert( T const& v ) { return ::Catch::toString( static_cast::type>(v) ); } }; #endif template struct StringMakerBase { #if defined(CATCH_CONFIG_CPP11_IS_ENUM) template static std::string convert( T const& v ) { return EnumStringMaker::convert( v ); } #else template static std::string convert( T const& ) { return unprintableString; } #endif }; template<> struct StringMakerBase { template static std::string convert( T const& _value ) { std::ostringstream oss; oss << _value; return oss.str(); } }; std::string rawMemoryToString( const void *object, std::size_t size ); template inline std::string rawMemoryToString( const T& object ) { return rawMemoryToString( &object, sizeof(object) ); } } // end namespace Detail template struct StringMaker : Detail::StringMakerBase::value> {}; template struct StringMaker { template static std::string convert( U* p ) { if( !p ) return INTERNAL_CATCH_STRINGIFY( NULL ); else return Detail::rawMemoryToString( p ); } }; template struct StringMaker { static std::string convert( R C::* p ) { if( !p ) return INTERNAL_CATCH_STRINGIFY( NULL ); else return Detail::rawMemoryToString( p ); } }; namespace Detail { template std::string rangeToString( InputIterator first, InputIterator last ); } //template //struct StringMaker > { // static std::string convert( std::vector const& v ) { // return Detail::rangeToString( v.begin(), v.end() ); // } //}; template std::string toString( std::vector const& v ) { return Detail::rangeToString( v.begin(), v.end() ); } #ifdef CATCH_CONFIG_CPP11_TUPLE // toString for tuples namespace TupleDetail { template< typename Tuple, std::size_t N = 0, bool = (N < std::tuple_size::value) > struct ElementPrinter { static void print( const Tuple& tuple, std::ostream& os ) { os << ( N ? ", " : " " ) << Catch::toString(std::get(tuple)); ElementPrinter::print(tuple,os); } }; template< typename Tuple, std::size_t N > struct ElementPrinter { static void print( const Tuple&, std::ostream& ) {} }; } template struct StringMaker> { static std::string convert( const std::tuple& tuple ) { std::ostringstream os; os << '{'; TupleDetail::ElementPrinter>::print( tuple, os ); os << " }"; return os.str(); } }; #endif // CATCH_CONFIG_CPP11_TUPLE namespace Detail { template std::string makeString( T const& value ) { return StringMaker::convert( value ); } } // end namespace Detail /// \brief converts any type to a string /// /// The default template forwards on to ostringstream - except when an /// ostringstream overload does not exist - in which case it attempts to detect /// that and writes {?}. /// Overload (not specialise) this template for custom typs that you don't want /// to provide an ostream overload for. template std::string toString( T const& value ) { return StringMaker::convert( value ); } namespace Detail { template std::string rangeToString( InputIterator first, InputIterator last ) { std::ostringstream oss; oss << "{ "; if( first != last ) { oss << Catch::toString( *first ); for( ++first ; first != last ; ++first ) oss << ", " << Catch::toString( *first ); } oss << " }"; return oss.str(); } } } // end namespace Catch namespace Catch { // Wraps the LHS of an expression and captures the operator and RHS (if any) - // wrapping them all in a ResultBuilder object template class ExpressionLhs { ExpressionLhs& operator = ( ExpressionLhs const& ); # ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS ExpressionLhs& operator = ( ExpressionLhs && ) = delete; # endif public: ExpressionLhs( ResultBuilder& rb, T lhs ) : m_rb( rb ), m_lhs( lhs ) {} # ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS ExpressionLhs( ExpressionLhs const& ) = default; ExpressionLhs( ExpressionLhs && ) = default; # endif template ResultBuilder& operator == ( RhsT const& rhs ) { return captureExpression( rhs ); } template ResultBuilder& operator != ( RhsT const& rhs ) { return captureExpression( rhs ); } template ResultBuilder& operator < ( RhsT const& rhs ) { return captureExpression( rhs ); } template ResultBuilder& operator > ( RhsT const& rhs ) { return captureExpression( rhs ); } template ResultBuilder& operator <= ( RhsT const& rhs ) { return captureExpression( rhs ); } template ResultBuilder& operator >= ( RhsT const& rhs ) { return captureExpression( rhs ); } ResultBuilder& operator == ( bool rhs ) { return captureExpression( rhs ); } ResultBuilder& operator != ( bool rhs ) { return captureExpression( rhs ); } void endExpression() { bool value = m_lhs ? true : false; m_rb .setLhs( Catch::toString( value ) ) .setResultType( value ) .endExpression(); } // Only simple binary expressions are allowed on the LHS. // If more complex compositions are required then place the sub expression in parentheses template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator + ( RhsT const& ); template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator - ( RhsT const& ); template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator / ( RhsT const& ); template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator * ( RhsT const& ); template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator && ( RhsT const& ); template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator || ( RhsT const& ); private: template ResultBuilder& captureExpression( RhsT const& rhs ) { return m_rb .setResultType( Internal::compare( m_lhs, rhs ) ) .setLhs( Catch::toString( m_lhs ) ) .setRhs( Catch::toString( rhs ) ) .setOp( Internal::OperatorTraits::getName() ); } private: ResultBuilder& m_rb; T m_lhs; }; } // end namespace Catch namespace Catch { template inline ExpressionLhs ResultBuilder::operator->* ( T const& operand ) { return ExpressionLhs( *this, operand ); } inline ExpressionLhs ResultBuilder::operator->* ( bool value ) { return ExpressionLhs( *this, value ); } } // namespace Catch // #included from: catch_message.h #define TWOBLUECUBES_CATCH_MESSAGE_H_INCLUDED #include namespace Catch { struct MessageInfo { MessageInfo( std::string const& _macroName, SourceLineInfo const& _lineInfo, ResultWas::OfType _type ); std::string macroName; SourceLineInfo lineInfo; ResultWas::OfType type; std::string message; unsigned int sequence; bool operator == ( MessageInfo const& other ) const { return sequence == other.sequence; } bool operator < ( MessageInfo const& other ) const { return sequence < other.sequence; } private: static unsigned int globalCount; }; struct MessageBuilder { MessageBuilder( std::string const& macroName, SourceLineInfo const& lineInfo, ResultWas::OfType type ) : m_info( macroName, lineInfo, type ) {} template MessageBuilder& operator << ( T const& value ) { m_stream << value; return *this; } MessageInfo m_info; std::ostringstream m_stream; }; class ScopedMessage { public: ScopedMessage( MessageBuilder const& builder ); ScopedMessage( ScopedMessage const& other ); ~ScopedMessage(); MessageInfo m_info; }; } // end namespace Catch // #included from: catch_interfaces_capture.h #define TWOBLUECUBES_CATCH_INTERFACES_CAPTURE_H_INCLUDED #include namespace Catch { class TestCase; class AssertionResult; struct AssertionInfo; struct SectionInfo; struct MessageInfo; class ScopedMessageBuilder; struct Counts; struct IResultCapture { virtual ~IResultCapture(); virtual void assertionEnded( AssertionResult const& result ) = 0; virtual bool sectionStarted( SectionInfo const& sectionInfo, Counts& assertions ) = 0; virtual void sectionEnded( SectionInfo const& name, Counts const& assertions, double _durationInSeconds ) = 0; virtual void pushScopedMessage( MessageInfo const& message ) = 0; virtual void popScopedMessage( MessageInfo const& message ) = 0; virtual std::string getCurrentTestName() const = 0; virtual const AssertionResult* getLastResult() const = 0; virtual void handleFatalErrorCondition( std::string const& message ) = 0; }; IResultCapture& getResultCapture(); } // #included from: catch_debugger.h #define TWOBLUECUBES_CATCH_DEBUGGER_H_INCLUDED // #included from: catch_platform.h #define TWOBLUECUBES_CATCH_PLATFORM_H_INCLUDED #if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) #define CATCH_PLATFORM_MAC #elif defined(__IPHONE_OS_VERSION_MIN_REQUIRED) #define CATCH_PLATFORM_IPHONE #elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) #define CATCH_PLATFORM_WINDOWS #endif #include namespace Catch{ bool isDebuggerActive(); void writeToDebugConsole( std::string const& text ); } #ifdef CATCH_PLATFORM_MAC // The following code snippet based on: // http://cocoawithlove.com/2008/03/break-into-debugger.html #ifdef DEBUG #if defined(__ppc64__) || defined(__ppc__) #define CATCH_BREAK_INTO_DEBUGGER() \ if( Catch::isDebuggerActive() ) { \ __asm__("li r0, 20\nsc\nnop\nli r0, 37\nli r4, 2\nsc\nnop\n" \ : : : "memory","r0","r3","r4" ); \ } #else #define CATCH_BREAK_INTO_DEBUGGER() if( Catch::isDebuggerActive() ) {__asm__("int $3\n" : : );} #endif #endif #elif defined(_MSC_VER) #define CATCH_BREAK_INTO_DEBUGGER() if( Catch::isDebuggerActive() ) { __debugbreak(); } #elif defined(__MINGW32__) extern "C" __declspec(dllimport) void __stdcall DebugBreak(); #define CATCH_BREAK_INTO_DEBUGGER() if( Catch::isDebuggerActive() ) { DebugBreak(); } #endif #ifndef CATCH_BREAK_INTO_DEBUGGER #define CATCH_BREAK_INTO_DEBUGGER() Catch::alwaysTrue(); #endif // #included from: catch_interfaces_runner.h #define TWOBLUECUBES_CATCH_INTERFACES_RUNNER_H_INCLUDED namespace Catch { class TestCase; struct IRunner { virtual ~IRunner(); virtual bool aborting() const = 0; }; } /////////////////////////////////////////////////////////////////////////////// // In the event of a failure works out if the debugger needs to be invoked // and/or an exception thrown and takes appropriate action. // This needs to be done as a macro so the debugger will stop in the user // source code rather than in Catch library code #define INTERNAL_CATCH_REACT( resultBuilder ) \ if( resultBuilder.shouldDebugBreak() ) CATCH_BREAK_INTO_DEBUGGER(); \ resultBuilder.react(); /////////////////////////////////////////////////////////////////////////////// #define INTERNAL_CATCH_TEST( expr, resultDisposition, macroName ) \ do { \ Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition ); \ try { \ ( __catchResult->*expr ).endExpression(); \ } \ catch( ... ) { \ __catchResult.useActiveException( Catch::ResultDisposition::Normal ); \ } \ INTERNAL_CATCH_REACT( __catchResult ) \ } while( Catch::isTrue( false && (expr) ) ) // expr here is never evaluated at runtime but it forces the compiler to give it a look /////////////////////////////////////////////////////////////////////////////// #define INTERNAL_CATCH_IF( expr, resultDisposition, macroName ) \ INTERNAL_CATCH_TEST( expr, resultDisposition, macroName ); \ if( Catch::getResultCapture().getLastResult()->succeeded() ) /////////////////////////////////////////////////////////////////////////////// #define INTERNAL_CATCH_ELSE( expr, resultDisposition, macroName ) \ INTERNAL_CATCH_TEST( expr, resultDisposition, macroName ); \ if( !Catch::getResultCapture().getLastResult()->succeeded() ) /////////////////////////////////////////////////////////////////////////////// #define INTERNAL_CATCH_NO_THROW( expr, resultDisposition, macroName ) \ do { \ Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition ); \ try { \ expr; \ __catchResult.captureResult( Catch::ResultWas::Ok ); \ } \ catch( ... ) { \ __catchResult.useActiveException( resultDisposition ); \ } \ INTERNAL_CATCH_REACT( __catchResult ) \ } while( Catch::alwaysFalse() ) /////////////////////////////////////////////////////////////////////////////// #define INTERNAL_CATCH_THROWS( expr, resultDisposition, macroName ) \ do { \ Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition ); \ if( __catchResult.allowThrows() ) \ try { \ expr; \ __catchResult.captureResult( Catch::ResultWas::DidntThrowException ); \ } \ catch( ... ) { \ __catchResult.captureResult( Catch::ResultWas::Ok ); \ } \ else \ __catchResult.captureResult( Catch::ResultWas::Ok ); \ INTERNAL_CATCH_REACT( __catchResult ) \ } while( Catch::alwaysFalse() ) /////////////////////////////////////////////////////////////////////////////// #define INTERNAL_CATCH_THROWS_AS( expr, exceptionType, resultDisposition, macroName ) \ do { \ Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition ); \ if( __catchResult.allowThrows() ) \ try { \ expr; \ __catchResult.captureResult( Catch::ResultWas::DidntThrowException ); \ } \ catch( exceptionType ) { \ __catchResult.captureResult( Catch::ResultWas::Ok ); \ } \ catch( ... ) { \ __catchResult.useActiveException( resultDisposition ); \ } \ else \ __catchResult.captureResult( Catch::ResultWas::Ok ); \ INTERNAL_CATCH_REACT( __catchResult ) \ } while( Catch::alwaysFalse() ) /////////////////////////////////////////////////////////////////////////////// #ifdef CATCH_CONFIG_VARIADIC_MACROS #define INTERNAL_CATCH_MSG( messageType, resultDisposition, macroName, ... ) \ do { \ Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, "", resultDisposition ); \ __catchResult << __VA_ARGS__ + ::Catch::StreamEndStop(); \ __catchResult.captureResult( messageType ); \ INTERNAL_CATCH_REACT( __catchResult ) \ } while( Catch::alwaysFalse() ) #else #define INTERNAL_CATCH_MSG( messageType, resultDisposition, macroName, log ) \ do { \ Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, "", resultDisposition ); \ __catchResult << log + ::Catch::StreamEndStop(); \ __catchResult.captureResult( messageType ); \ INTERNAL_CATCH_REACT( __catchResult ) \ } while( Catch::alwaysFalse() ) #endif /////////////////////////////////////////////////////////////////////////////// #define INTERNAL_CATCH_INFO( log, macroName ) \ Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage ) = Catch::MessageBuilder( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log; /////////////////////////////////////////////////////////////////////////////// #define INTERNAL_CHECK_THAT( arg, matcher, resultDisposition, macroName ) \ do { \ Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #arg " " #matcher, resultDisposition ); \ try { \ std::string matcherAsString = ::Catch::Matchers::matcher.toString(); \ __catchResult \ .setLhs( Catch::toString( arg ) ) \ .setRhs( matcherAsString == Catch::Detail::unprintableString ? #matcher : matcherAsString ) \ .setOp( "matches" ) \ .setResultType( ::Catch::Matchers::matcher.match( arg ) ); \ __catchResult.captureExpression(); \ } catch( ... ) { \ __catchResult.useActiveException( resultDisposition | Catch::ResultDisposition::ContinueOnFailure ); \ } \ INTERNAL_CATCH_REACT( __catchResult ) \ } while( Catch::alwaysFalse() ) // #included from: internal/catch_section.h #define TWOBLUECUBES_CATCH_SECTION_H_INCLUDED // #included from: catch_section_info.h #define TWOBLUECUBES_CATCH_SECTION_INFO_H_INCLUDED namespace Catch { struct SectionInfo { SectionInfo ( SourceLineInfo const& _lineInfo, std::string const& _name, std::string const& _description = std::string() ); std::string name; std::string description; SourceLineInfo lineInfo; }; } // end namespace Catch // #included from: catch_totals.hpp #define TWOBLUECUBES_CATCH_TOTALS_HPP_INCLUDED #include namespace Catch { struct Counts { Counts() : passed( 0 ), failed( 0 ), failedButOk( 0 ) {} Counts operator - ( Counts const& other ) const { Counts diff; diff.passed = passed - other.passed; diff.failed = failed - other.failed; diff.failedButOk = failedButOk - other.failedButOk; return diff; } Counts& operator += ( Counts const& other ) { passed += other.passed; failed += other.failed; failedButOk += other.failedButOk; return *this; } std::size_t total() const { return passed + failed + failedButOk; } bool allPassed() const { return failed == 0 && failedButOk == 0; } bool allOk() const { return failed == 0; } std::size_t passed; std::size_t failed; std::size_t failedButOk; }; struct Totals { Totals operator - ( Totals const& other ) const { Totals diff; diff.assertions = assertions - other.assertions; diff.testCases = testCases - other.testCases; return diff; } Totals delta( Totals const& prevTotals ) const { Totals diff = *this - prevTotals; if( diff.assertions.failed > 0 ) ++diff.testCases.failed; else if( diff.assertions.failedButOk > 0 ) ++diff.testCases.failedButOk; else ++diff.testCases.passed; return diff; } Totals& operator += ( Totals const& other ) { assertions += other.assertions; testCases += other.testCases; return *this; } Counts assertions; Counts testCases; }; } // #included from: catch_timer.h #define TWOBLUECUBES_CATCH_TIMER_H_INCLUDED #ifdef CATCH_PLATFORM_WINDOWS typedef unsigned long long uint64_t; #else #include #endif namespace Catch { class Timer { public: Timer() : m_ticks( 0 ) {} void start(); unsigned int getElapsedMicroseconds() const; unsigned int getElapsedMilliseconds() const; double getElapsedSeconds() const; private: uint64_t m_ticks; }; } // namespace Catch #include namespace Catch { class Section : NonCopyable { public: Section( SectionInfo const& info ); ~Section(); // This indicates whether the section should be executed or not operator bool() const; private: SectionInfo m_info; std::string m_name; Counts m_assertions; bool m_sectionIncluded; Timer m_timer; }; } // end namespace Catch #ifdef CATCH_CONFIG_VARIADIC_MACROS #define INTERNAL_CATCH_SECTION( ... ) \ if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) ) #else #define INTERNAL_CATCH_SECTION( name, desc ) \ if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, name, desc ) ) #endif // #included from: internal/catch_generators.hpp #define TWOBLUECUBES_CATCH_GENERATORS_HPP_INCLUDED #include #include #include #include namespace Catch { template struct IGenerator { virtual ~IGenerator() {} virtual T getValue( std::size_t index ) const = 0; virtual std::size_t size () const = 0; }; template class BetweenGenerator : public IGenerator { public: BetweenGenerator( T from, T to ) : m_from( from ), m_to( to ){} virtual T getValue( std::size_t index ) const { return m_from+static_cast( index ); } virtual std::size_t size() const { return static_cast( 1+m_to-m_from ); } private: T m_from; T m_to; }; template class ValuesGenerator : public IGenerator { public: ValuesGenerator(){} void add( T value ) { m_values.push_back( value ); } virtual T getValue( std::size_t index ) const { return m_values[index]; } virtual std::size_t size() const { return m_values.size(); } private: std::vector m_values; }; template class CompositeGenerator { public: CompositeGenerator() : m_totalSize( 0 ) {} // *** Move semantics, similar to auto_ptr *** CompositeGenerator( CompositeGenerator& other ) : m_fileInfo( other.m_fileInfo ), m_totalSize( 0 ) { move( other ); } CompositeGenerator& setFileInfo( const char* fileInfo ) { m_fileInfo = fileInfo; return *this; } ~CompositeGenerator() { deleteAll( m_composed ); } operator T () const { size_t overallIndex = getCurrentContext().getGeneratorIndex( m_fileInfo, m_totalSize ); typename std::vector*>::const_iterator it = m_composed.begin(); typename std::vector*>::const_iterator itEnd = m_composed.end(); for( size_t index = 0; it != itEnd; ++it ) { const IGenerator* generator = *it; if( overallIndex >= index && overallIndex < index + generator->size() ) { return generator->getValue( overallIndex-index ); } index += generator->size(); } CATCH_INTERNAL_ERROR( "Indexed past end of generated range" ); return T(); // Suppress spurious "not all control paths return a value" warning in Visual Studio - if you know how to fix this please do so } void add( const IGenerator* generator ) { m_totalSize += generator->size(); m_composed.push_back( generator ); } CompositeGenerator& then( CompositeGenerator& other ) { move( other ); return *this; } CompositeGenerator& then( T value ) { ValuesGenerator* valuesGen = new ValuesGenerator(); valuesGen->add( value ); add( valuesGen ); return *this; } private: void move( CompositeGenerator& other ) { std::copy( other.m_composed.begin(), other.m_composed.end(), std::back_inserter( m_composed ) ); m_totalSize += other.m_totalSize; other.m_composed.clear(); } std::vector*> m_composed; std::string m_fileInfo; size_t m_totalSize; }; namespace Generators { template CompositeGenerator between( T from, T to ) { CompositeGenerator generators; generators.add( new BetweenGenerator( from, to ) ); return generators; } template CompositeGenerator values( T val1, T val2 ) { CompositeGenerator generators; ValuesGenerator* valuesGen = new ValuesGenerator(); valuesGen->add( val1 ); valuesGen->add( val2 ); generators.add( valuesGen ); return generators; } template CompositeGenerator values( T val1, T val2, T val3 ){ CompositeGenerator generators; ValuesGenerator* valuesGen = new ValuesGenerator(); valuesGen->add( val1 ); valuesGen->add( val2 ); valuesGen->add( val3 ); generators.add( valuesGen ); return generators; } template CompositeGenerator values( T val1, T val2, T val3, T val4 ) { CompositeGenerator generators; ValuesGenerator* valuesGen = new ValuesGenerator(); valuesGen->add( val1 ); valuesGen->add( val2 ); valuesGen->add( val3 ); valuesGen->add( val4 ); generators.add( valuesGen ); return generators; } } // end namespace Generators using namespace Generators; } // end namespace Catch #define INTERNAL_CATCH_LINESTR2( line ) #line #define INTERNAL_CATCH_LINESTR( line ) INTERNAL_CATCH_LINESTR2( line ) #define INTERNAL_CATCH_GENERATE( expr ) expr.setFileInfo( __FILE__ "(" INTERNAL_CATCH_LINESTR( __LINE__ ) ")" ) // #included from: internal/catch_interfaces_exception.h #define TWOBLUECUBES_CATCH_INTERFACES_EXCEPTION_H_INCLUDED #include // #included from: catch_interfaces_registry_hub.h #define TWOBLUECUBES_CATCH_INTERFACES_REGISTRY_HUB_H_INCLUDED #include namespace Catch { class TestCase; struct ITestCaseRegistry; struct IExceptionTranslatorRegistry; struct IExceptionTranslator; struct IReporterRegistry; struct IReporterFactory; struct IRegistryHub { virtual ~IRegistryHub(); virtual IReporterRegistry const& getReporterRegistry() const = 0; virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0; virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() = 0; }; struct IMutableRegistryHub { virtual ~IMutableRegistryHub(); virtual void registerReporter( std::string const& name, IReporterFactory* factory ) = 0; virtual void registerTest( TestCase const& testInfo ) = 0; virtual void registerTranslator( const IExceptionTranslator* translator ) = 0; }; IRegistryHub& getRegistryHub(); IMutableRegistryHub& getMutableRegistryHub(); void cleanUp(); std::string translateActiveException(); } namespace Catch { typedef std::string(*exceptionTranslateFunction)(); struct IExceptionTranslator { virtual ~IExceptionTranslator(); virtual std::string translate() const = 0; }; struct IExceptionTranslatorRegistry { virtual ~IExceptionTranslatorRegistry(); virtual std::string translateActiveException() const = 0; }; class ExceptionTranslatorRegistrar { template class ExceptionTranslator : public IExceptionTranslator { public: ExceptionTranslator( std::string(*translateFunction)( T& ) ) : m_translateFunction( translateFunction ) {} virtual std::string translate() const { try { throw; } catch( T& ex ) { return m_translateFunction( ex ); } } protected: std::string(*m_translateFunction)( T& ); }; public: template ExceptionTranslatorRegistrar( std::string(*translateFunction)( T& ) ) { getMutableRegistryHub().registerTranslator ( new ExceptionTranslator( translateFunction ) ); } }; } /////////////////////////////////////////////////////////////////////////////// #define INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) \ static std::string INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator )( signature ); \ namespace{ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ) ); }\ static std::string INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator )( signature ) // #included from: internal/catch_approx.hpp #define TWOBLUECUBES_CATCH_APPROX_HPP_INCLUDED #include #include namespace Catch { namespace Detail { class Approx { public: explicit Approx ( double value ) : m_epsilon( std::numeric_limits::epsilon()*100 ), m_scale( 1.0 ), m_value( value ) {} Approx( Approx const& other ) : m_epsilon( other.m_epsilon ), m_scale( other.m_scale ), m_value( other.m_value ) {} static Approx custom() { return Approx( 0 ); } Approx operator()( double value ) { Approx approx( value ); approx.epsilon( m_epsilon ); approx.scale( m_scale ); return approx; } friend bool operator == ( double lhs, Approx const& rhs ) { // Thanks to Richard Harris for his help refining this formula return fabs( lhs - rhs.m_value ) < rhs.m_epsilon * (rhs.m_scale + (std::max)( fabs(lhs), fabs(rhs.m_value) ) ); } friend bool operator == ( Approx const& lhs, double rhs ) { return operator==( rhs, lhs ); } friend bool operator != ( double lhs, Approx const& rhs ) { return !operator==( lhs, rhs ); } friend bool operator != ( Approx const& lhs, double rhs ) { return !operator==( rhs, lhs ); } Approx& epsilon( double newEpsilon ) { m_epsilon = newEpsilon; return *this; } Approx& scale( double newScale ) { m_scale = newScale; return *this; } std::string toString() const { std::ostringstream oss; oss << "Approx( " << Catch::toString( m_value ) << " )"; return oss.str(); } private: double m_epsilon; double m_scale; double m_value; }; } template<> inline std::string toString( Detail::Approx const& value ) { return value.toString(); } } // end namespace Catch // #included from: internal/catch_matchers.hpp #define TWOBLUECUBES_CATCH_MATCHERS_HPP_INCLUDED namespace Catch { namespace Matchers { namespace Impl { template struct Matcher : SharedImpl { typedef ExpressionT ExpressionType; virtual ~Matcher() {} virtual Ptr clone() const = 0; virtual bool match( ExpressionT const& expr ) const = 0; virtual std::string toString() const = 0; }; template struct MatcherImpl : Matcher { virtual Ptr > clone() const { return Ptr >( new DerivedT( static_cast( *this ) ) ); } }; namespace Generic { template class AllOf : public MatcherImpl, ExpressionT> { public: AllOf() {} AllOf( AllOf const& other ) : m_matchers( other.m_matchers ) {} AllOf& add( Matcher const& matcher ) { m_matchers.push_back( matcher.clone() ); return *this; } virtual bool match( ExpressionT const& expr ) const { for( std::size_t i = 0; i < m_matchers.size(); ++i ) if( !m_matchers[i]->match( expr ) ) return false; return true; } virtual std::string toString() const { std::ostringstream oss; oss << "( "; for( std::size_t i = 0; i < m_matchers.size(); ++i ) { if( i != 0 ) oss << " and "; oss << m_matchers[i]->toString(); } oss << " )"; return oss.str(); } private: std::vector > > m_matchers; }; template class AnyOf : public MatcherImpl, ExpressionT> { public: AnyOf() {} AnyOf( AnyOf const& other ) : m_matchers( other.m_matchers ) {} AnyOf& add( Matcher const& matcher ) { m_matchers.push_back( matcher.clone() ); return *this; } virtual bool match( ExpressionT const& expr ) const { for( std::size_t i = 0; i < m_matchers.size(); ++i ) if( m_matchers[i]->match( expr ) ) return true; return false; } virtual std::string toString() const { std::ostringstream oss; oss << "( "; for( std::size_t i = 0; i < m_matchers.size(); ++i ) { if( i != 0 ) oss << " or "; oss << m_matchers[i]->toString(); } oss << " )"; return oss.str(); } private: std::vector > > m_matchers; }; } namespace StdString { inline std::string makeString( std::string const& str ) { return str; } inline std::string makeString( const char* str ) { return str ? std::string( str ) : std::string(); } struct Equals : MatcherImpl { Equals( std::string const& str ) : m_str( str ){} Equals( Equals const& other ) : m_str( other.m_str ){} virtual ~Equals(); virtual bool match( std::string const& expr ) const { return m_str == expr; } virtual std::string toString() const { return "equals: \"" + m_str + "\""; } std::string m_str; }; struct Contains : MatcherImpl { Contains( std::string const& substr ) : m_substr( substr ){} Contains( Contains const& other ) : m_substr( other.m_substr ){} virtual ~Contains(); virtual bool match( std::string const& expr ) const { return expr.find( m_substr ) != std::string::npos; } virtual std::string toString() const { return "contains: \"" + m_substr + "\""; } std::string m_substr; }; struct StartsWith : MatcherImpl { StartsWith( std::string const& substr ) : m_substr( substr ){} StartsWith( StartsWith const& other ) : m_substr( other.m_substr ){} virtual ~StartsWith(); virtual bool match( std::string const& expr ) const { return expr.find( m_substr ) == 0; } virtual std::string toString() const { return "starts with: \"" + m_substr + "\""; } std::string m_substr; }; struct EndsWith : MatcherImpl { EndsWith( std::string const& substr ) : m_substr( substr ){} EndsWith( EndsWith const& other ) : m_substr( other.m_substr ){} virtual ~EndsWith(); virtual bool match( std::string const& expr ) const { return expr.find( m_substr ) == expr.size() - m_substr.size(); } virtual std::string toString() const { return "ends with: \"" + m_substr + "\""; } std::string m_substr; }; } // namespace StdString } // namespace Impl // The following functions create the actual matcher objects. // This allows the types to be inferred template inline Impl::Generic::AllOf AllOf( Impl::Matcher const& m1, Impl::Matcher const& m2 ) { return Impl::Generic::AllOf().add( m1 ).add( m2 ); } template inline Impl::Generic::AllOf AllOf( Impl::Matcher const& m1, Impl::Matcher const& m2, Impl::Matcher const& m3 ) { return Impl::Generic::AllOf().add( m1 ).add( m2 ).add( m3 ); } template inline Impl::Generic::AnyOf AnyOf( Impl::Matcher const& m1, Impl::Matcher const& m2 ) { return Impl::Generic::AnyOf().add( m1 ).add( m2 ); } template inline Impl::Generic::AnyOf AnyOf( Impl::Matcher const& m1, Impl::Matcher const& m2, Impl::Matcher const& m3 ) { return Impl::Generic::AnyOf().add( m1 ).add( m2 ).add( m3 ); } inline Impl::StdString::Equals Equals( std::string const& str ) { return Impl::StdString::Equals( str ); } inline Impl::StdString::Equals Equals( const char* str ) { return Impl::StdString::Equals( Impl::StdString::makeString( str ) ); } inline Impl::StdString::Contains Contains( std::string const& substr ) { return Impl::StdString::Contains( substr ); } inline Impl::StdString::Contains Contains( const char* substr ) { return Impl::StdString::Contains( Impl::StdString::makeString( substr ) ); } inline Impl::StdString::StartsWith StartsWith( std::string const& substr ) { return Impl::StdString::StartsWith( substr ); } inline Impl::StdString::StartsWith StartsWith( const char* substr ) { return Impl::StdString::StartsWith( Impl::StdString::makeString( substr ) ); } inline Impl::StdString::EndsWith EndsWith( std::string const& substr ) { return Impl::StdString::EndsWith( substr ); } inline Impl::StdString::EndsWith EndsWith( const char* substr ) { return Impl::StdString::EndsWith( Impl::StdString::makeString( substr ) ); } } // namespace Matchers using namespace Matchers; } // namespace Catch // #included from: internal/catch_interfaces_tag_alias_registry.h #define TWOBLUECUBES_CATCH_INTERFACES_TAG_ALIAS_REGISTRY_H_INCLUDED // #included from: catch_tag_alias.h #define TWOBLUECUBES_CATCH_TAG_ALIAS_H_INCLUDED #include namespace Catch { struct TagAlias { TagAlias( std::string _tag, SourceLineInfo _lineInfo ) : tag( _tag ), lineInfo( _lineInfo ) {} std::string tag; SourceLineInfo lineInfo; }; struct RegistrarForTagAliases { RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo ); }; } // end namespace Catch #define CATCH_REGISTER_TAG_ALIAS( alias, spec ) namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } // #included from: catch_option.hpp #define TWOBLUECUBES_CATCH_OPTION_HPP_INCLUDED namespace Catch { // An optional type template class Option { public: Option() : nullableValue( NULL ) {} Option( T const& _value ) : nullableValue( new( storage ) T( _value ) ) {} Option( Option const& _other ) : nullableValue( _other ? new( storage ) T( *_other ) : NULL ) {} ~Option() { reset(); } Option& operator= ( Option const& _other ) { if( &_other != this ) { reset(); if( _other ) nullableValue = new( storage ) T( *_other ); } return *this; } Option& operator = ( T const& _value ) { reset(); nullableValue = new( storage ) T( _value ); return *this; } void reset() { if( nullableValue ) nullableValue->~T(); nullableValue = NULL; } T& operator*() { return *nullableValue; } T const& operator*() const { return *nullableValue; } T* operator->() { return nullableValue; } const T* operator->() const { return nullableValue; } T valueOr( T const& defaultValue ) const { return nullableValue ? *nullableValue : defaultValue; } bool some() const { return nullableValue != NULL; } bool none() const { return nullableValue == NULL; } bool operator !() const { return nullableValue == NULL; } operator SafeBool::type() const { return SafeBool::makeSafe( some() ); } private: T* nullableValue; char storage[sizeof(T)]; }; } // end namespace Catch namespace Catch { struct ITagAliasRegistry { virtual ~ITagAliasRegistry(); virtual Option find( std::string const& alias ) const = 0; virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0; static ITagAliasRegistry const& get(); }; } // end namespace Catch // These files are included here so the single_include script doesn't put them // in the conditionally compiled sections // #included from: internal/catch_test_case_info.h #define TWOBLUECUBES_CATCH_TEST_CASE_INFO_H_INCLUDED #include #include #ifdef __clang__ #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wpadded" #endif namespace Catch { struct ITestCase; struct TestCaseInfo { enum SpecialProperties{ None = 0, IsHidden = 1 << 1, ShouldFail = 1 << 2, MayFail = 1 << 3, Throws = 1 << 4 }; TestCaseInfo( std::string const& _name, std::string const& _className, std::string const& _description, std::set const& _tags, SourceLineInfo const& _lineInfo ); TestCaseInfo( TestCaseInfo const& other ); bool isHidden() const; bool throws() const; bool okToFail() const; bool expectedToFail() const; std::string name; std::string className; std::string description; std::set tags; std::set lcaseTags; std::string tagsAsString; SourceLineInfo lineInfo; SpecialProperties properties; }; class TestCase : public TestCaseInfo { public: TestCase( ITestCase* testCase, TestCaseInfo const& info ); TestCase( TestCase const& other ); TestCase withName( std::string const& _newName ) const; void invoke() const; TestCaseInfo const& getTestCaseInfo() const; void swap( TestCase& other ); bool operator == ( TestCase const& other ) const; bool operator < ( TestCase const& other ) const; TestCase& operator = ( TestCase const& other ); private: Ptr test; }; TestCase makeTestCase( ITestCase* testCase, std::string const& className, std::string const& name, std::string const& description, SourceLineInfo const& lineInfo ); } #ifdef __clang__ #pragma clang diagnostic pop #endif #ifdef __OBJC__ // #included from: internal/catch_objc.hpp #define TWOBLUECUBES_CATCH_OBJC_HPP_INCLUDED #import #include // NB. Any general catch headers included here must be included // in catch.hpp first to make sure they are included by the single // header for non obj-usage /////////////////////////////////////////////////////////////////////////////// // This protocol is really only here for (self) documenting purposes, since // all its methods are optional. @protocol OcFixture @optional -(void) setUp; -(void) tearDown; @end namespace Catch { class OcMethod : public SharedImpl { public: OcMethod( Class cls, SEL sel ) : m_cls( cls ), m_sel( sel ) {} virtual void invoke() const { id obj = [[m_cls alloc] init]; performOptionalSelector( obj, @selector(setUp) ); performOptionalSelector( obj, m_sel ); performOptionalSelector( obj, @selector(tearDown) ); arcSafeRelease( obj ); } private: virtual ~OcMethod() {} Class m_cls; SEL m_sel; }; namespace Detail{ inline std::string getAnnotation( Class cls, std::string const& annotationName, std::string const& testCaseName ) { NSString* selStr = [[NSString alloc] initWithFormat:@"Catch_%s_%s", annotationName.c_str(), testCaseName.c_str()]; SEL sel = NSSelectorFromString( selStr ); arcSafeRelease( selStr ); id value = performOptionalSelector( cls, sel ); if( value ) return [(NSString*)value UTF8String]; return ""; } } inline size_t registerTestMethods() { size_t noTestMethods = 0; int noClasses = objc_getClassList( NULL, 0 ); Class* classes = (CATCH_UNSAFE_UNRETAINED Class *)malloc( sizeof(Class) * noClasses); objc_getClassList( classes, noClasses ); for( int c = 0; c < noClasses; c++ ) { Class cls = classes[c]; { u_int count; Method* methods = class_copyMethodList( cls, &count ); for( u_int m = 0; m < count ; m++ ) { SEL selector = method_getName(methods[m]); std::string methodName = sel_getName(selector); if( startsWith( methodName, "Catch_TestCase_" ) ) { std::string testCaseName = methodName.substr( 15 ); std::string name = Detail::getAnnotation( cls, "Name", testCaseName ); std::string desc = Detail::getAnnotation( cls, "Description", testCaseName ); const char* className = class_getName( cls ); getMutableRegistryHub().registerTest( makeTestCase( new OcMethod( cls, selector ), className, name.c_str(), desc.c_str(), SourceLineInfo() ) ); noTestMethods++; } } free(methods); } } return noTestMethods; } namespace Matchers { namespace Impl { namespace NSStringMatchers { template struct StringHolder : MatcherImpl{ StringHolder( NSString* substr ) : m_substr( [substr copy] ){} StringHolder( StringHolder const& other ) : m_substr( [other.m_substr copy] ){} StringHolder() { arcSafeRelease( m_substr ); } NSString* m_substr; }; struct Equals : StringHolder { Equals( NSString* substr ) : StringHolder( substr ){} virtual bool match( ExpressionType const& str ) const { return (str != nil || m_substr == nil ) && [str isEqualToString:m_substr]; } virtual std::string toString() const { return "equals string: " + Catch::toString( m_substr ); } }; struct Contains : StringHolder { Contains( NSString* substr ) : StringHolder( substr ){} virtual bool match( ExpressionType const& str ) const { return (str != nil || m_substr == nil ) && [str rangeOfString:m_substr].location != NSNotFound; } virtual std::string toString() const { return "contains string: " + Catch::toString( m_substr ); } }; struct StartsWith : StringHolder { StartsWith( NSString* substr ) : StringHolder( substr ){} virtual bool match( ExpressionType const& str ) const { return (str != nil || m_substr == nil ) && [str rangeOfString:m_substr].location == 0; } virtual std::string toString() const { return "starts with: " + Catch::toString( m_substr ); } }; struct EndsWith : StringHolder { EndsWith( NSString* substr ) : StringHolder( substr ){} virtual bool match( ExpressionType const& str ) const { return (str != nil || m_substr == nil ) && [str rangeOfString:m_substr].location == [str length] - [m_substr length]; } virtual std::string toString() const { return "ends with: " + Catch::toString( m_substr ); } }; } // namespace NSStringMatchers } // namespace Impl inline Impl::NSStringMatchers::Equals Equals( NSString* substr ){ return Impl::NSStringMatchers::Equals( substr ); } inline Impl::NSStringMatchers::Contains Contains( NSString* substr ){ return Impl::NSStringMatchers::Contains( substr ); } inline Impl::NSStringMatchers::StartsWith StartsWith( NSString* substr ){ return Impl::NSStringMatchers::StartsWith( substr ); } inline Impl::NSStringMatchers::EndsWith EndsWith( NSString* substr ){ return Impl::NSStringMatchers::EndsWith( substr ); } } // namespace Matchers using namespace Matchers; } // namespace Catch /////////////////////////////////////////////////////////////////////////////// #define OC_TEST_CASE( name, desc )\ +(NSString*) INTERNAL_CATCH_UNIQUE_NAME( Catch_Name_test ) \ {\ return @ name; \ }\ +(NSString*) INTERNAL_CATCH_UNIQUE_NAME( Catch_Description_test ) \ { \ return @ desc; \ } \ -(void) INTERNAL_CATCH_UNIQUE_NAME( Catch_TestCase_test ) #endif #ifdef CATCH_IMPL // #included from: internal/catch_impl.hpp #define TWOBLUECUBES_CATCH_IMPL_HPP_INCLUDED // Collect all the implementation files together here // These are the equivalent of what would usually be cpp files #ifdef __clang__ #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wweak-vtables" #endif // #included from: ../catch_runner.hpp #define TWOBLUECUBES_CATCH_RUNNER_HPP_INCLUDED // #included from: internal/catch_commandline.hpp #define TWOBLUECUBES_CATCH_COMMANDLINE_HPP_INCLUDED // #included from: catch_config.hpp #define TWOBLUECUBES_CATCH_CONFIG_HPP_INCLUDED // #included from: catch_test_spec_parser.hpp #define TWOBLUECUBES_CATCH_TEST_SPEC_PARSER_HPP_INCLUDED #ifdef __clang__ #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wpadded" #endif // #included from: catch_test_spec.hpp #define TWOBLUECUBES_CATCH_TEST_SPEC_HPP_INCLUDED #ifdef __clang__ #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wpadded" #endif #include #include namespace Catch { class TestSpec { struct Pattern : SharedImpl<> { virtual ~Pattern(); virtual bool matches( TestCaseInfo const& testCase ) const = 0; }; class NamePattern : public Pattern { enum WildcardPosition { NoWildcard = 0, WildcardAtStart = 1, WildcardAtEnd = 2, WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd }; public: NamePattern( std::string const& name ) : m_name( toLower( name ) ), m_wildcard( NoWildcard ) { if( startsWith( m_name, "*" ) ) { m_name = m_name.substr( 1 ); m_wildcard = WildcardAtStart; } if( endsWith( m_name, "*" ) ) { m_name = m_name.substr( 0, m_name.size()-1 ); m_wildcard = static_cast( m_wildcard | WildcardAtEnd ); } } virtual ~NamePattern(); virtual bool matches( TestCaseInfo const& testCase ) const { switch( m_wildcard ) { case NoWildcard: return m_name == toLower( testCase.name ); case WildcardAtStart: return endsWith( toLower( testCase.name ), m_name ); case WildcardAtEnd: return startsWith( toLower( testCase.name ), m_name ); case WildcardAtBothEnds: return contains( toLower( testCase.name ), m_name ); } #ifdef __clang__ #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wunreachable-code" #endif throw std::logic_error( "Unknown enum" ); #ifdef __clang__ #pragma clang diagnostic pop #endif } private: std::string m_name; WildcardPosition m_wildcard; }; class TagPattern : public Pattern { public: TagPattern( std::string const& tag ) : m_tag( toLower( tag ) ) {} virtual ~TagPattern(); virtual bool matches( TestCaseInfo const& testCase ) const { return testCase.lcaseTags.find( m_tag ) != testCase.lcaseTags.end(); } private: std::string m_tag; }; class ExcludedPattern : public Pattern { public: ExcludedPattern( Ptr const& underlyingPattern ) : m_underlyingPattern( underlyingPattern ) {} virtual ~ExcludedPattern(); virtual bool matches( TestCaseInfo const& testCase ) const { return !m_underlyingPattern->matches( testCase ); } private: Ptr m_underlyingPattern; }; struct Filter { std::vector > m_patterns; bool matches( TestCaseInfo const& testCase ) const { // All patterns in a filter must match for the filter to be a match for( std::vector >::const_iterator it = m_patterns.begin(), itEnd = m_patterns.end(); it != itEnd; ++it ) if( !(*it)->matches( testCase ) ) return false; return true; } }; public: bool hasFilters() const { return !m_filters.empty(); } bool matches( TestCaseInfo const& testCase ) const { // A TestSpec matches if any filter matches for( std::vector::const_iterator it = m_filters.begin(), itEnd = m_filters.end(); it != itEnd; ++it ) if( it->matches( testCase ) ) return true; return false; } private: std::vector m_filters; friend class TestSpecParser; }; } #ifdef __clang__ #pragma clang diagnostic pop #endif namespace Catch { class TestSpecParser { enum Mode{ None, Name, QuotedName, Tag }; Mode m_mode; bool m_exclusion; std::size_t m_start, m_pos; std::string m_arg; TestSpec::Filter m_currentFilter; TestSpec m_testSpec; ITagAliasRegistry const* m_tagAliases; public: TestSpecParser( ITagAliasRegistry const& tagAliases ) : m_tagAliases( &tagAliases ) {} TestSpecParser& parse( std::string const& arg ) { m_mode = None; m_exclusion = false; m_start = std::string::npos; m_arg = m_tagAliases->expandAliases( arg ); for( m_pos = 0; m_pos < m_arg.size(); ++m_pos ) visitChar( m_arg[m_pos] ); if( m_mode == Name ) addPattern(); return *this; } TestSpec testSpec() { addFilter(); return m_testSpec; } private: void visitChar( char c ) { if( m_mode == None ) { switch( c ) { case ' ': return; case '~': m_exclusion = true; return; case '[': return startNewMode( Tag, ++m_pos ); case '"': return startNewMode( QuotedName, ++m_pos ); default: startNewMode( Name, m_pos ); break; } } if( m_mode == Name ) { if( c == ',' ) { addPattern(); addFilter(); } else if( c == '[' ) { if( subString() == "exclude:" ) m_exclusion = true; else addPattern(); startNewMode( Tag, ++m_pos ); } } else if( m_mode == QuotedName && c == '"' ) addPattern(); else if( m_mode == Tag && c == ']' ) addPattern(); } void startNewMode( Mode mode, std::size_t start ) { m_mode = mode; m_start = start; } std::string subString() const { return m_arg.substr( m_start, m_pos - m_start ); } template void addPattern() { std::string token = subString(); if( startsWith( token, "exclude:" ) ) { m_exclusion = true; token = token.substr( 8 ); } if( !token.empty() ) { Ptr pattern = new T( token ); if( m_exclusion ) pattern = new TestSpec::ExcludedPattern( pattern ); m_currentFilter.m_patterns.push_back( pattern ); } m_exclusion = false; m_mode = None; } void addFilter() { if( !m_currentFilter.m_patterns.empty() ) { m_testSpec.m_filters.push_back( m_currentFilter ); m_currentFilter = TestSpec::Filter(); } } }; inline TestSpec parseTestSpec( std::string const& arg ) { return TestSpecParser( ITagAliasRegistry::get() ).parse( arg ).testSpec(); } } // namespace Catch #ifdef __clang__ #pragma clang diagnostic pop #endif // #included from: catch_interfaces_config.h #define TWOBLUECUBES_CATCH_INTERFACES_CONFIG_H_INCLUDED #include #include #include namespace Catch { struct Verbosity { enum Level { NoOutput = 0, Quiet, Normal }; }; struct WarnAbout { enum What { Nothing = 0x00, NoAssertions = 0x01 }; }; struct ShowDurations { enum OrNot { DefaultForReporter, Always, Never }; }; struct RunTests { enum InWhatOrder { InDeclarationOrder, InLexicographicalOrder, InRandomOrder }; }; class TestSpec; struct IConfig : IShared { virtual ~IConfig(); virtual bool allowThrows() const = 0; virtual std::ostream& stream() const = 0; virtual std::string name() const = 0; virtual bool includeSuccessfulResults() const = 0; virtual bool shouldDebugBreak() const = 0; virtual bool warnAboutMissingAssertions() const = 0; virtual int abortAfter() const = 0; virtual bool showInvisibles() const = 0; virtual ShowDurations::OrNot showDurations() const = 0; virtual TestSpec const& testSpec() const = 0; virtual RunTests::InWhatOrder runOrder() const = 0; virtual unsigned int rngSeed() const = 0; virtual bool forceColour() const = 0; }; } // #included from: catch_stream.h #define TWOBLUECUBES_CATCH_STREAM_H_INCLUDED #include #ifdef __clang__ #pragma clang diagnostic ignored "-Wpadded" #endif namespace Catch { class Stream { public: Stream(); Stream( std::streambuf* _streamBuf, bool _isOwned ); void release(); std::streambuf* streamBuf; private: bool isOwned; }; std::ostream& cout(); std::ostream& cerr(); } #include #include #include #include #include #ifndef CATCH_CONFIG_CONSOLE_WIDTH #define CATCH_CONFIG_CONSOLE_WIDTH 80 #endif namespace Catch { struct ConfigData { ConfigData() : listTests( false ), listTags( false ), listReporters( false ), listTestNamesOnly( false ), showSuccessfulTests( false ), shouldDebugBreak( false ), noThrow( false ), showHelp( false ), showInvisibles( false ), forceColour( false ), abortAfter( -1 ), rngSeed( 0 ), verbosity( Verbosity::Normal ), warnings( WarnAbout::Nothing ), showDurations( ShowDurations::DefaultForReporter ), runOrder( RunTests::InDeclarationOrder ) {} bool listTests; bool listTags; bool listReporters; bool listTestNamesOnly; bool showSuccessfulTests; bool shouldDebugBreak; bool noThrow; bool showHelp; bool showInvisibles; bool forceColour; int abortAfter; unsigned int rngSeed; Verbosity::Level verbosity; WarnAbout::What warnings; ShowDurations::OrNot showDurations; RunTests::InWhatOrder runOrder; std::string reporterName; std::string outputFilename; std::string name; std::string processName; std::vector testsOrTags; }; class Config : public SharedImpl { private: Config( Config const& other ); Config& operator = ( Config const& other ); virtual void dummy(); public: Config() : m_os( Catch::cout().rdbuf() ) {} Config( ConfigData const& data ) : m_data( data ), m_os( Catch::cout().rdbuf() ) { if( !data.testsOrTags.empty() ) { TestSpecParser parser( ITagAliasRegistry::get() ); for( std::size_t i = 0; i < data.testsOrTags.size(); ++i ) parser.parse( data.testsOrTags[i] ); m_testSpec = parser.testSpec(); } } virtual ~Config() { m_os.rdbuf( Catch::cout().rdbuf() ); m_stream.release(); } void setFilename( std::string const& filename ) { m_data.outputFilename = filename; } std::string const& getFilename() const { return m_data.outputFilename ; } bool listTests() const { return m_data.listTests; } bool listTestNamesOnly() const { return m_data.listTestNamesOnly; } bool listTags() const { return m_data.listTags; } bool listReporters() const { return m_data.listReporters; } std::string getProcessName() const { return m_data.processName; } bool shouldDebugBreak() const { return m_data.shouldDebugBreak; } void setStreamBuf( std::streambuf* buf ) { m_os.rdbuf( buf ? buf : Catch::cout().rdbuf() ); } void useStream( std::string const& streamName ) { Stream stream = createStream( streamName ); setStreamBuf( stream.streamBuf ); m_stream.release(); m_stream = stream; } std::string getReporterName() const { return m_data.reporterName; } int abortAfter() const { return m_data.abortAfter; } TestSpec const& testSpec() const { return m_testSpec; } bool showHelp() const { return m_data.showHelp; } bool showInvisibles() const { return m_data.showInvisibles; } // IConfig interface virtual bool allowThrows() const { return !m_data.noThrow; } virtual std::ostream& stream() const { return m_os; } virtual std::string name() const { return m_data.name.empty() ? m_data.processName : m_data.name; } virtual bool includeSuccessfulResults() const { return m_data.showSuccessfulTests; } virtual bool warnAboutMissingAssertions() const { return m_data.warnings & WarnAbout::NoAssertions; } virtual ShowDurations::OrNot showDurations() const { return m_data.showDurations; } virtual RunTests::InWhatOrder runOrder() const { return m_data.runOrder; } virtual unsigned int rngSeed() const { return m_data.rngSeed; } virtual bool forceColour() const { return m_data.forceColour; } private: ConfigData m_data; Stream m_stream; mutable std::ostream m_os; TestSpec m_testSpec; }; } // end namespace Catch // #included from: catch_clara.h #define TWOBLUECUBES_CATCH_CLARA_H_INCLUDED // Use Catch's value for console width (store Clara's off to the side, if present) #ifdef CLARA_CONFIG_CONSOLE_WIDTH #define CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH CLARA_CONFIG_CONSOLE_WIDTH #undef CLARA_CONFIG_CONSOLE_WIDTH #endif #define CLARA_CONFIG_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH // Declare Clara inside the Catch namespace #define STITCH_CLARA_OPEN_NAMESPACE namespace Catch { // #included from: ../external/clara.h // Only use header guard if we are not using an outer namespace #if !defined(TWOBLUECUBES_CLARA_H_INCLUDED) || defined(STITCH_CLARA_OPEN_NAMESPACE) #ifndef STITCH_CLARA_OPEN_NAMESPACE #define TWOBLUECUBES_CLARA_H_INCLUDED #define STITCH_CLARA_OPEN_NAMESPACE #define STITCH_CLARA_CLOSE_NAMESPACE #else #define STITCH_CLARA_CLOSE_NAMESPACE } #endif #define STITCH_TBC_TEXT_FORMAT_OPEN_NAMESPACE STITCH_CLARA_OPEN_NAMESPACE // ----------- #included from tbc_text_format.h ----------- // Only use header guard if we are not using an outer namespace #if !defined(TBC_TEXT_FORMAT_H_INCLUDED) || defined(STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE) #ifndef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE #define TBC_TEXT_FORMAT_H_INCLUDED #endif #include #include #include // Use optional outer namespace #ifdef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE namespace STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE { #endif namespace Tbc { #ifdef TBC_TEXT_FORMAT_CONSOLE_WIDTH const unsigned int consoleWidth = TBC_TEXT_FORMAT_CONSOLE_WIDTH; #else const unsigned int consoleWidth = 80; #endif struct TextAttributes { TextAttributes() : initialIndent( std::string::npos ), indent( 0 ), width( consoleWidth-1 ), tabChar( '\t' ) {} TextAttributes& setInitialIndent( std::size_t _value ) { initialIndent = _value; return *this; } TextAttributes& setIndent( std::size_t _value ) { indent = _value; return *this; } TextAttributes& setWidth( std::size_t _value ) { width = _value; return *this; } TextAttributes& setTabChar( char _value ) { tabChar = _value; return *this; } std::size_t initialIndent; // indent of first line, or npos std::size_t indent; // indent of subsequent lines, or all if initialIndent is npos std::size_t width; // maximum width of text, including indent. Longer text will wrap char tabChar; // If this char is seen the indent is changed to current pos }; class Text { public: Text( std::string const& _str, TextAttributes const& _attr = TextAttributes() ) : attr( _attr ) { std::string wrappableChars = " [({.,/|\\-"; std::size_t indent = _attr.initialIndent != std::string::npos ? _attr.initialIndent : _attr.indent; std::string remainder = _str; while( !remainder.empty() ) { if( lines.size() >= 1000 ) { lines.push_back( "... message truncated due to excessive size" ); return; } std::size_t tabPos = std::string::npos; std::size_t width = (std::min)( remainder.size(), _attr.width - indent ); std::size_t pos = remainder.find_first_of( '\n' ); if( pos <= width ) { width = pos; } pos = remainder.find_last_of( _attr.tabChar, width ); if( pos != std::string::npos ) { tabPos = pos; if( remainder[width] == '\n' ) width--; remainder = remainder.substr( 0, tabPos ) + remainder.substr( tabPos+1 ); } if( width == remainder.size() ) { spliceLine( indent, remainder, width ); } else if( remainder[width] == '\n' ) { spliceLine( indent, remainder, width ); if( width <= 1 || remainder.size() != 1 ) remainder = remainder.substr( 1 ); indent = _attr.indent; } else { pos = remainder.find_last_of( wrappableChars, width ); if( pos != std::string::npos && pos > 0 ) { spliceLine( indent, remainder, pos ); if( remainder[0] == ' ' ) remainder = remainder.substr( 1 ); } else { spliceLine( indent, remainder, width-1 ); lines.back() += "-"; } if( lines.size() == 1 ) indent = _attr.indent; if( tabPos != std::string::npos ) indent += tabPos; } } } void spliceLine( std::size_t _indent, std::string& _remainder, std::size_t _pos ) { lines.push_back( std::string( _indent, ' ' ) + _remainder.substr( 0, _pos ) ); _remainder = _remainder.substr( _pos ); } typedef std::vector::const_iterator const_iterator; const_iterator begin() const { return lines.begin(); } const_iterator end() const { return lines.end(); } std::string const& last() const { return lines.back(); } std::size_t size() const { return lines.size(); } std::string const& operator[]( std::size_t _index ) const { return lines[_index]; } std::string toString() const { std::ostringstream oss; oss << *this; return oss.str(); } inline friend std::ostream& operator << ( std::ostream& _stream, Text const& _text ) { for( Text::const_iterator it = _text.begin(), itEnd = _text.end(); it != itEnd; ++it ) { if( it != _text.begin() ) _stream << "\n"; _stream << *it; } return _stream; } private: std::string str; TextAttributes attr; std::vector lines; }; } // end namespace Tbc #ifdef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE } // end outer namespace #endif #endif // TBC_TEXT_FORMAT_H_INCLUDED // ----------- end of #include from tbc_text_format.h ----------- // ........... back in /Users/philnash/Dev/OSS/Clara/srcs/clara.h #undef STITCH_TBC_TEXT_FORMAT_OPEN_NAMESPACE #include #include #include #include // Use optional outer namespace #ifdef STITCH_CLARA_OPEN_NAMESPACE STITCH_CLARA_OPEN_NAMESPACE #endif namespace Clara { struct UnpositionalTag {}; extern UnpositionalTag _; #ifdef CLARA_CONFIG_MAIN UnpositionalTag _; #endif namespace Detail { #ifdef CLARA_CONSOLE_WIDTH const unsigned int consoleWidth = CLARA_CONFIG_CONSOLE_WIDTH; #else const unsigned int consoleWidth = 80; #endif using namespace Tbc; inline bool startsWith( std::string const& str, std::string const& prefix ) { return str.size() >= prefix.size() && str.substr( 0, prefix.size() ) == prefix; } template struct RemoveConstRef{ typedef T type; }; template struct RemoveConstRef{ typedef T type; }; template struct RemoveConstRef{ typedef T type; }; template struct RemoveConstRef{ typedef T type; }; template struct IsBool { static const bool value = false; }; template<> struct IsBool { static const bool value = true; }; template void convertInto( std::string const& _source, T& _dest ) { std::stringstream ss; ss << _source; ss >> _dest; if( ss.fail() ) throw std::runtime_error( "Unable to convert " + _source + " to destination type" ); } inline void convertInto( std::string const& _source, std::string& _dest ) { _dest = _source; } inline void convertInto( std::string const& _source, bool& _dest ) { std::string sourceLC = _source; std::transform( sourceLC.begin(), sourceLC.end(), sourceLC.begin(), ::tolower ); if( sourceLC == "y" || sourceLC == "1" || sourceLC == "true" || sourceLC == "yes" || sourceLC == "on" ) _dest = true; else if( sourceLC == "n" || sourceLC == "0" || sourceLC == "false" || sourceLC == "no" || sourceLC == "off" ) _dest = false; else throw std::runtime_error( "Expected a boolean value but did not recognise:\n '" + _source + "'" ); } inline void convertInto( bool _source, bool& _dest ) { _dest = _source; } template inline void convertInto( bool, T& ) { throw std::runtime_error( "Invalid conversion" ); } template struct IArgFunction { virtual ~IArgFunction() {} # ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS IArgFunction() = default; IArgFunction( IArgFunction const& ) = default; # endif virtual void set( ConfigT& config, std::string const& value ) const = 0; virtual void setFlag( ConfigT& config ) const = 0; virtual bool takesArg() const = 0; virtual IArgFunction* clone() const = 0; }; template class BoundArgFunction { public: BoundArgFunction() : functionObj( NULL ) {} BoundArgFunction( IArgFunction* _functionObj ) : functionObj( _functionObj ) {} BoundArgFunction( BoundArgFunction const& other ) : functionObj( other.functionObj ? other.functionObj->clone() : NULL ) {} BoundArgFunction& operator = ( BoundArgFunction const& other ) { IArgFunction* newFunctionObj = other.functionObj ? other.functionObj->clone() : NULL; delete functionObj; functionObj = newFunctionObj; return *this; } ~BoundArgFunction() { delete functionObj; } void set( ConfigT& config, std::string const& value ) const { functionObj->set( config, value ); } void setFlag( ConfigT& config ) const { functionObj->setFlag( config ); } bool takesArg() const { return functionObj->takesArg(); } bool isSet() const { return functionObj != NULL; } private: IArgFunction* functionObj; }; template struct NullBinder : IArgFunction{ virtual void set( C&, std::string const& ) const {} virtual void setFlag( C& ) const {} virtual bool takesArg() const { return true; } virtual IArgFunction* clone() const { return new NullBinder( *this ); } }; template struct BoundDataMember : IArgFunction{ BoundDataMember( M C::* _member ) : member( _member ) {} virtual void set( C& p, std::string const& stringValue ) const { convertInto( stringValue, p.*member ); } virtual void setFlag( C& p ) const { convertInto( true, p.*member ); } virtual bool takesArg() const { return !IsBool::value; } virtual IArgFunction* clone() const { return new BoundDataMember( *this ); } M C::* member; }; template struct BoundUnaryMethod : IArgFunction{ BoundUnaryMethod( void (C::*_member)( M ) ) : member( _member ) {} virtual void set( C& p, std::string const& stringValue ) const { typename RemoveConstRef::type value; convertInto( stringValue, value ); (p.*member)( value ); } virtual void setFlag( C& p ) const { typename RemoveConstRef::type value; convertInto( true, value ); (p.*member)( value ); } virtual bool takesArg() const { return !IsBool::value; } virtual IArgFunction* clone() const { return new BoundUnaryMethod( *this ); } void (C::*member)( M ); }; template struct BoundNullaryMethod : IArgFunction{ BoundNullaryMethod( void (C::*_member)() ) : member( _member ) {} virtual void set( C& p, std::string const& stringValue ) const { bool value; convertInto( stringValue, value ); if( value ) (p.*member)(); } virtual void setFlag( C& p ) const { (p.*member)(); } virtual bool takesArg() const { return false; } virtual IArgFunction* clone() const { return new BoundNullaryMethod( *this ); } void (C::*member)(); }; template struct BoundUnaryFunction : IArgFunction{ BoundUnaryFunction( void (*_function)( C& ) ) : function( _function ) {} virtual void set( C& obj, std::string const& stringValue ) const { bool value; convertInto( stringValue, value ); if( value ) function( obj ); } virtual void setFlag( C& p ) const { function( p ); } virtual bool takesArg() const { return false; } virtual IArgFunction* clone() const { return new BoundUnaryFunction( *this ); } void (*function)( C& ); }; template struct BoundBinaryFunction : IArgFunction{ BoundBinaryFunction( void (*_function)( C&, T ) ) : function( _function ) {} virtual void set( C& obj, std::string const& stringValue ) const { typename RemoveConstRef::type value; convertInto( stringValue, value ); function( obj, value ); } virtual void setFlag( C& obj ) const { typename RemoveConstRef::type value; convertInto( true, value ); function( obj, value ); } virtual bool takesArg() const { return !IsBool::value; } virtual IArgFunction* clone() const { return new BoundBinaryFunction( *this ); } void (*function)( C&, T ); }; } // namespace Detail struct Parser { Parser() : separators( " \t=:" ) {} struct Token { enum Type { Positional, ShortOpt, LongOpt }; Token( Type _type, std::string const& _data ) : type( _type ), data( _data ) {} Type type; std::string data; }; void parseIntoTokens( int argc, char const * const * argv, std::vector& tokens ) const { const std::string doubleDash = "--"; for( int i = 1; i < argc && argv[i] != doubleDash; ++i ) parseIntoTokens( argv[i] , tokens); } void parseIntoTokens( std::string arg, std::vector& tokens ) const { while( !arg.empty() ) { Parser::Token token( Parser::Token::Positional, arg ); arg = ""; if( token.data[0] == '-' ) { if( token.data.size() > 1 && token.data[1] == '-' ) { token = Parser::Token( Parser::Token::LongOpt, token.data.substr( 2 ) ); } else { token = Parser::Token( Parser::Token::ShortOpt, token.data.substr( 1 ) ); if( token.data.size() > 1 && separators.find( token.data[1] ) == std::string::npos ) { arg = "-" + token.data.substr( 1 ); token.data = token.data.substr( 0, 1 ); } } } if( token.type != Parser::Token::Positional ) { std::size_t pos = token.data.find_first_of( separators ); if( pos != std::string::npos ) { arg = token.data.substr( pos+1 ); token.data = token.data.substr( 0, pos ); } } tokens.push_back( token ); } } std::string separators; }; template struct CommonArgProperties { CommonArgProperties() {} CommonArgProperties( Detail::BoundArgFunction const& _boundField ) : boundField( _boundField ) {} Detail::BoundArgFunction boundField; std::string description; std::string detail; std::string placeholder; // Only value if boundField takes an arg bool takesArg() const { return !placeholder.empty(); } void validate() const { if( !boundField.isSet() ) throw std::logic_error( "option not bound" ); } }; struct OptionArgProperties { std::vector shortNames; std::string longName; bool hasShortName( std::string const& shortName ) const { return std::find( shortNames.begin(), shortNames.end(), shortName ) != shortNames.end(); } bool hasLongName( std::string const& _longName ) const { return _longName == longName; } }; struct PositionalArgProperties { PositionalArgProperties() : position( -1 ) {} int position; // -1 means non-positional (floating) bool isFixedPositional() const { return position != -1; } }; template class CommandLine { struct Arg : CommonArgProperties, OptionArgProperties, PositionalArgProperties { Arg() {} Arg( Detail::BoundArgFunction const& _boundField ) : CommonArgProperties( _boundField ) {} using CommonArgProperties::placeholder; // !TBD std::string dbgName() const { if( !longName.empty() ) return "--" + longName; if( !shortNames.empty() ) return "-" + shortNames[0]; return "positional args"; } std::string commands() const { std::ostringstream oss; bool first = true; std::vector::const_iterator it = shortNames.begin(), itEnd = shortNames.end(); for(; it != itEnd; ++it ) { if( first ) first = false; else oss << ", "; oss << "-" << *it; } if( !longName.empty() ) { if( !first ) oss << ", "; oss << "--" << longName; } if( !placeholder.empty() ) oss << " <" << placeholder << ">"; return oss.str(); } }; // NOTE: std::auto_ptr is deprecated in c++11/c++0x #if defined(__cplusplus) && __cplusplus > 199711L typedef std::unique_ptr ArgAutoPtr; #else typedef std::auto_ptr ArgAutoPtr; #endif friend void addOptName( Arg& arg, std::string const& optName ) { if( optName.empty() ) return; if( Detail::startsWith( optName, "--" ) ) { if( !arg.longName.empty() ) throw std::logic_error( "Only one long opt may be specified. '" + arg.longName + "' already specified, now attempting to add '" + optName + "'" ); arg.longName = optName.substr( 2 ); } else if( Detail::startsWith( optName, "-" ) ) arg.shortNames.push_back( optName.substr( 1 ) ); else throw std::logic_error( "option must begin with - or --. Option was: '" + optName + "'" ); } friend void setPositionalArg( Arg& arg, int position ) { arg.position = position; } class ArgBuilder { public: ArgBuilder( Arg* arg ) : m_arg( arg ) {} // Bind a non-boolean data member (requires placeholder string) template void bind( M C::* field, std::string const& placeholder ) { m_arg->boundField = new Detail::BoundDataMember( field ); m_arg->placeholder = placeholder; } // Bind a boolean data member (no placeholder required) template void bind( bool C::* field ) { m_arg->boundField = new Detail::BoundDataMember( field ); } // Bind a method taking a single, non-boolean argument (requires a placeholder string) template void bind( void (C::* unaryMethod)( M ), std::string const& placeholder ) { m_arg->boundField = new Detail::BoundUnaryMethod( unaryMethod ); m_arg->placeholder = placeholder; } // Bind a method taking a single, boolean argument (no placeholder string required) template void bind( void (C::* unaryMethod)( bool ) ) { m_arg->boundField = new Detail::BoundUnaryMethod( unaryMethod ); } // Bind a method that takes no arguments (will be called if opt is present) template void bind( void (C::* nullaryMethod)() ) { m_arg->boundField = new Detail::BoundNullaryMethod( nullaryMethod ); } // Bind a free function taking a single argument - the object to operate on (no placeholder string required) template void bind( void (* unaryFunction)( C& ) ) { m_arg->boundField = new Detail::BoundUnaryFunction( unaryFunction ); } // Bind a free function taking a single argument - the object to operate on (requires a placeholder string) template void bind( void (* binaryFunction)( C&, T ), std::string const& placeholder ) { m_arg->boundField = new Detail::BoundBinaryFunction( binaryFunction ); m_arg->placeholder = placeholder; } ArgBuilder& describe( std::string const& description ) { m_arg->description = description; return *this; } ArgBuilder& detail( std::string const& detail ) { m_arg->detail = detail; return *this; } protected: Arg* m_arg; }; class OptBuilder : public ArgBuilder { public: OptBuilder( Arg* arg ) : ArgBuilder( arg ) {} OptBuilder( OptBuilder& other ) : ArgBuilder( other ) {} OptBuilder& operator[]( std::string const& optName ) { addOptName( *ArgBuilder::m_arg, optName ); return *this; } }; public: CommandLine() : m_boundProcessName( new Detail::NullBinder() ), m_highestSpecifiedArgPosition( 0 ), m_throwOnUnrecognisedTokens( false ) {} CommandLine( CommandLine const& other ) : m_boundProcessName( other.m_boundProcessName ), m_options ( other.m_options ), m_positionalArgs( other.m_positionalArgs ), m_highestSpecifiedArgPosition( other.m_highestSpecifiedArgPosition ), m_throwOnUnrecognisedTokens( other.m_throwOnUnrecognisedTokens ) { if( other.m_floatingArg.get() ) m_floatingArg.reset( new Arg( *other.m_floatingArg ) ); } CommandLine& setThrowOnUnrecognisedTokens( bool shouldThrow = true ) { m_throwOnUnrecognisedTokens = shouldThrow; return *this; } OptBuilder operator[]( std::string const& optName ) { m_options.push_back( Arg() ); addOptName( m_options.back(), optName ); OptBuilder builder( &m_options.back() ); return builder; } ArgBuilder operator[]( int position ) { m_positionalArgs.insert( std::make_pair( position, Arg() ) ); if( position > m_highestSpecifiedArgPosition ) m_highestSpecifiedArgPosition = position; setPositionalArg( m_positionalArgs[position], position ); ArgBuilder builder( &m_positionalArgs[position] ); return builder; } // Invoke this with the _ instance ArgBuilder operator[]( UnpositionalTag ) { if( m_floatingArg.get() ) throw std::logic_error( "Only one unpositional argument can be added" ); m_floatingArg.reset( new Arg() ); ArgBuilder builder( m_floatingArg.get() ); return builder; } template void bindProcessName( M C::* field ) { m_boundProcessName = new Detail::BoundDataMember( field ); } template void bindProcessName( void (C::*_unaryMethod)( M ) ) { m_boundProcessName = new Detail::BoundUnaryMethod( _unaryMethod ); } void optUsage( std::ostream& os, std::size_t indent = 0, std::size_t width = Detail::consoleWidth ) const { typename std::vector::const_iterator itBegin = m_options.begin(), itEnd = m_options.end(), it; std::size_t maxWidth = 0; for( it = itBegin; it != itEnd; ++it ) maxWidth = (std::max)( maxWidth, it->commands().size() ); for( it = itBegin; it != itEnd; ++it ) { Detail::Text usage( it->commands(), Detail::TextAttributes() .setWidth( maxWidth+indent ) .setIndent( indent ) ); Detail::Text desc( it->description, Detail::TextAttributes() .setWidth( width - maxWidth - 3 ) ); for( std::size_t i = 0; i < (std::max)( usage.size(), desc.size() ); ++i ) { std::string usageCol = i < usage.size() ? usage[i] : ""; os << usageCol; if( i < desc.size() && !desc[i].empty() ) os << std::string( indent + 2 + maxWidth - usageCol.size(), ' ' ) << desc[i]; os << "\n"; } } } std::string optUsage() const { std::ostringstream oss; optUsage( oss ); return oss.str(); } void argSynopsis( std::ostream& os ) const { for( int i = 1; i <= m_highestSpecifiedArgPosition; ++i ) { if( i > 1 ) os << " "; typename std::map::const_iterator it = m_positionalArgs.find( i ); if( it != m_positionalArgs.end() ) os << "<" << it->second.placeholder << ">"; else if( m_floatingArg.get() ) os << "<" << m_floatingArg->placeholder << ">"; else throw std::logic_error( "non consecutive positional arguments with no floating args" ); } // !TBD No indication of mandatory args if( m_floatingArg.get() ) { if( m_highestSpecifiedArgPosition > 1 ) os << " "; os << "[<" << m_floatingArg->placeholder << "> ...]"; } } std::string argSynopsis() const { std::ostringstream oss; argSynopsis( oss ); return oss.str(); } void usage( std::ostream& os, std::string const& procName ) const { validate(); os << "usage:\n " << procName << " "; argSynopsis( os ); if( !m_options.empty() ) { os << " [options]\n\nwhere options are: \n"; optUsage( os, 2 ); } os << "\n"; } std::string usage( std::string const& procName ) const { std::ostringstream oss; usage( oss, procName ); return oss.str(); } ConfigT parse( int argc, char const * const * argv ) const { ConfigT config; parseInto( argc, argv, config ); return config; } std::vector parseInto( int argc, char const * const * argv, ConfigT& config ) const { std::string processName = argv[0]; std::size_t lastSlash = processName.find_last_of( "/\\" ); if( lastSlash != std::string::npos ) processName = processName.substr( lastSlash+1 ); m_boundProcessName.set( config, processName ); std::vector tokens; Parser parser; parser.parseIntoTokens( argc, argv, tokens ); return populate( tokens, config ); } std::vector populate( std::vector const& tokens, ConfigT& config ) const { validate(); std::vector unusedTokens = populateOptions( tokens, config ); unusedTokens = populateFixedArgs( unusedTokens, config ); unusedTokens = populateFloatingArgs( unusedTokens, config ); return unusedTokens; } std::vector populateOptions( std::vector const& tokens, ConfigT& config ) const { std::vector unusedTokens; std::vector errors; for( std::size_t i = 0; i < tokens.size(); ++i ) { Parser::Token const& token = tokens[i]; typename std::vector::const_iterator it = m_options.begin(), itEnd = m_options.end(); for(; it != itEnd; ++it ) { Arg const& arg = *it; try { if( ( token.type == Parser::Token::ShortOpt && arg.hasShortName( token.data ) ) || ( token.type == Parser::Token::LongOpt && arg.hasLongName( token.data ) ) ) { if( arg.takesArg() ) { if( i == tokens.size()-1 || tokens[i+1].type != Parser::Token::Positional ) errors.push_back( "Expected argument to option: " + token.data ); else arg.boundField.set( config, tokens[++i].data ); } else { arg.boundField.setFlag( config ); } break; } } catch( std::exception& ex ) { errors.push_back( std::string( ex.what() ) + "\n- while parsing: (" + arg.commands() + ")" ); } } if( it == itEnd ) { if( token.type == Parser::Token::Positional || !m_throwOnUnrecognisedTokens ) unusedTokens.push_back( token ); else if( errors.empty() && m_throwOnUnrecognisedTokens ) errors.push_back( "unrecognised option: " + token.data ); } } if( !errors.empty() ) { std::ostringstream oss; for( std::vector::const_iterator it = errors.begin(), itEnd = errors.end(); it != itEnd; ++it ) { if( it != errors.begin() ) oss << "\n"; oss << *it; } throw std::runtime_error( oss.str() ); } return unusedTokens; } std::vector populateFixedArgs( std::vector const& tokens, ConfigT& config ) const { std::vector unusedTokens; int position = 1; for( std::size_t i = 0; i < tokens.size(); ++i ) { Parser::Token const& token = tokens[i]; typename std::map::const_iterator it = m_positionalArgs.find( position ); if( it != m_positionalArgs.end() ) it->second.boundField.set( config, token.data ); else unusedTokens.push_back( token ); if( token.type == Parser::Token::Positional ) position++; } return unusedTokens; } std::vector populateFloatingArgs( std::vector const& tokens, ConfigT& config ) const { if( !m_floatingArg.get() ) return tokens; std::vector unusedTokens; for( std::size_t i = 0; i < tokens.size(); ++i ) { Parser::Token const& token = tokens[i]; if( token.type == Parser::Token::Positional ) m_floatingArg->boundField.set( config, token.data ); else unusedTokens.push_back( token ); } return unusedTokens; } void validate() const { if( m_options.empty() && m_positionalArgs.empty() && !m_floatingArg.get() ) throw std::logic_error( "No options or arguments specified" ); for( typename std::vector::const_iterator it = m_options.begin(), itEnd = m_options.end(); it != itEnd; ++it ) it->validate(); } private: Detail::BoundArgFunction m_boundProcessName; std::vector m_options; std::map m_positionalArgs; ArgAutoPtr m_floatingArg; int m_highestSpecifiedArgPosition; bool m_throwOnUnrecognisedTokens; }; } // end namespace Clara STITCH_CLARA_CLOSE_NAMESPACE #undef STITCH_CLARA_OPEN_NAMESPACE #undef STITCH_CLARA_CLOSE_NAMESPACE #endif // TWOBLUECUBES_CLARA_H_INCLUDED #undef STITCH_CLARA_OPEN_NAMESPACE // Restore Clara's value for console width, if present #ifdef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH #define CLARA_CONFIG_CONSOLE_WIDTH CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH #undef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH #endif #include namespace Catch { inline void abortAfterFirst( ConfigData& config ) { config.abortAfter = 1; } inline void abortAfterX( ConfigData& config, int x ) { if( x < 1 ) throw std::runtime_error( "Value after -x or --abortAfter must be greater than zero" ); config.abortAfter = x; } inline void addTestOrTags( ConfigData& config, std::string const& _testSpec ) { config.testsOrTags.push_back( _testSpec ); } inline void addWarning( ConfigData& config, std::string const& _warning ) { if( _warning == "NoAssertions" ) config.warnings = static_cast( config.warnings | WarnAbout::NoAssertions ); else throw std::runtime_error( "Unrecognised warning: '" + _warning + "'" ); } inline void setOrder( ConfigData& config, std::string const& order ) { if( startsWith( "declared", order ) ) config.runOrder = RunTests::InDeclarationOrder; else if( startsWith( "lexical", order ) ) config.runOrder = RunTests::InLexicographicalOrder; else if( startsWith( "random", order ) ) config.runOrder = RunTests::InRandomOrder; else throw std::runtime_error( "Unrecognised ordering: '" + order + "'" ); } inline void setRngSeed( ConfigData& config, std::string const& seed ) { if( seed == "time" ) { config.rngSeed = static_cast( std::time(0) ); } else { std::stringstream ss; ss << seed; ss >> config.rngSeed; if( ss.fail() ) throw std::runtime_error( "Argment to --rng-seed should be the word 'time' or a number" ); } } inline void setVerbosity( ConfigData& config, int level ) { // !TBD: accept strings? config.verbosity = static_cast( level ); } inline void setShowDurations( ConfigData& config, bool _showDurations ) { config.showDurations = _showDurations ? ShowDurations::Always : ShowDurations::Never; } inline void loadTestNamesFromFile( ConfigData& config, std::string const& _filename ) { std::ifstream f( _filename.c_str() ); if( !f.is_open() ) throw std::domain_error( "Unable to load input file: " + _filename ); std::string line; while( std::getline( f, line ) ) { line = trim(line); if( !line.empty() && !startsWith( line, "#" ) ) addTestOrTags( config, "\"" + line + "\"," ); } } inline Clara::CommandLine makeCommandLineParser() { using namespace Clara; CommandLine cli; cli.bindProcessName( &ConfigData::processName ); cli["-?"]["-h"]["--help"] .describe( "display usage information" ) .bind( &ConfigData::showHelp ); cli["-l"]["--list-tests"] .describe( "list all/matching test cases" ) .bind( &ConfigData::listTests ); cli["-t"]["--list-tags"] .describe( "list all/matching tags" ) .bind( &ConfigData::listTags ); cli["-s"]["--success"] .describe( "include successful tests in output" ) .bind( &ConfigData::showSuccessfulTests ); cli["-b"]["--break"] .describe( "break into debugger on failure" ) .bind( &ConfigData::shouldDebugBreak ); cli["-e"]["--nothrow"] .describe( "skip exception tests" ) .bind( &ConfigData::noThrow ); cli["-i"]["--invisibles"] .describe( "show invisibles (tabs, newlines)" ) .bind( &ConfigData::showInvisibles ); cli["-o"]["--out"] .describe( "output filename" ) .bind( &ConfigData::outputFilename, "filename" ); cli["-r"]["--reporter"] // .placeholder( "name[:filename]" ) .describe( "reporter to use (defaults to console)" ) .bind( &ConfigData::reporterName, "name" ); cli["-n"]["--name"] .describe( "suite name" ) .bind( &ConfigData::name, "name" ); cli["-a"]["--abort"] .describe( "abort at first failure" ) .bind( &abortAfterFirst ); cli["-x"]["--abortx"] .describe( "abort after x failures" ) .bind( &abortAfterX, "no. failures" ); cli["-w"]["--warn"] .describe( "enable warnings" ) .bind( &addWarning, "warning name" ); // - needs updating if reinstated // cli.into( &setVerbosity ) // .describe( "level of verbosity (0=no output)" ) // .shortOpt( "v") // .longOpt( "verbosity" ) // .placeholder( "level" ); cli[_] .describe( "which test or tests to use" ) .bind( &addTestOrTags, "test name, pattern or tags" ); cli["-d"]["--durations"] .describe( "show test durations" ) .bind( &setShowDurations, "yes/no" ); cli["-f"]["--input-file"] .describe( "load test names to run from a file" ) .bind( &loadTestNamesFromFile, "filename" ); // Less common commands which don't have a short form cli["--list-test-names-only"] .describe( "list all/matching test cases names only" ) .bind( &ConfigData::listTestNamesOnly ); cli["--list-reporters"] .describe( "list all reporters" ) .bind( &ConfigData::listReporters ); cli["--order"] .describe( "test case order (defaults to decl)" ) .bind( &setOrder, "decl|lex|rand" ); cli["--rng-seed"] .describe( "set a specific seed for random numbers" ) .bind( &setRngSeed, "'time'|number" ); cli["--force-colour"] .describe( "force colourised output" ) .bind( &ConfigData::forceColour ); return cli; } } // end namespace Catch // #included from: internal/catch_list.hpp #define TWOBLUECUBES_CATCH_LIST_HPP_INCLUDED // #included from: catch_text.h #define TWOBLUECUBES_CATCH_TEXT_H_INCLUDED #define TBC_TEXT_FORMAT_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH #define CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE Catch // #included from: ../external/tbc_text_format.h // Only use header guard if we are not using an outer namespace #ifndef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE # ifdef TWOBLUECUBES_TEXT_FORMAT_H_INCLUDED # ifndef TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED # define TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED # endif # else # define TWOBLUECUBES_TEXT_FORMAT_H_INCLUDED # endif #endif #ifndef TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED #include #include #include // Use optional outer namespace #ifdef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE namespace CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE { #endif namespace Tbc { #ifdef TBC_TEXT_FORMAT_CONSOLE_WIDTH const unsigned int consoleWidth = TBC_TEXT_FORMAT_CONSOLE_WIDTH; #else const unsigned int consoleWidth = 80; #endif struct TextAttributes { TextAttributes() : initialIndent( std::string::npos ), indent( 0 ), width( consoleWidth-1 ), tabChar( '\t' ) {} TextAttributes& setInitialIndent( std::size_t _value ) { initialIndent = _value; return *this; } TextAttributes& setIndent( std::size_t _value ) { indent = _value; return *this; } TextAttributes& setWidth( std::size_t _value ) { width = _value; return *this; } TextAttributes& setTabChar( char _value ) { tabChar = _value; return *this; } std::size_t initialIndent; // indent of first line, or npos std::size_t indent; // indent of subsequent lines, or all if initialIndent is npos std::size_t width; // maximum width of text, including indent. Longer text will wrap char tabChar; // If this char is seen the indent is changed to current pos }; class Text { public: Text( std::string const& _str, TextAttributes const& _attr = TextAttributes() ) : attr( _attr ) { std::string wrappableChars = " [({.,/|\\-"; std::size_t indent = _attr.initialIndent != std::string::npos ? _attr.initialIndent : _attr.indent; std::string remainder = _str; while( !remainder.empty() ) { if( lines.size() >= 1000 ) { lines.push_back( "... message truncated due to excessive size" ); return; } std::size_t tabPos = std::string::npos; std::size_t width = (std::min)( remainder.size(), _attr.width - indent ); std::size_t pos = remainder.find_first_of( '\n' ); if( pos <= width ) { width = pos; } pos = remainder.find_last_of( _attr.tabChar, width ); if( pos != std::string::npos ) { tabPos = pos; if( remainder[width] == '\n' ) width--; remainder = remainder.substr( 0, tabPos ) + remainder.substr( tabPos+1 ); } if( width == remainder.size() ) { spliceLine( indent, remainder, width ); } else if( remainder[width] == '\n' ) { spliceLine( indent, remainder, width ); if( width <= 1 || remainder.size() != 1 ) remainder = remainder.substr( 1 ); indent = _attr.indent; } else { pos = remainder.find_last_of( wrappableChars, width ); if( pos != std::string::npos && pos > 0 ) { spliceLine( indent, remainder, pos ); if( remainder[0] == ' ' ) remainder = remainder.substr( 1 ); } else { spliceLine( indent, remainder, width-1 ); lines.back() += "-"; } if( lines.size() == 1 ) indent = _attr.indent; if( tabPos != std::string::npos ) indent += tabPos; } } } void spliceLine( std::size_t _indent, std::string& _remainder, std::size_t _pos ) { lines.push_back( std::string( _indent, ' ' ) + _remainder.substr( 0, _pos ) ); _remainder = _remainder.substr( _pos ); } typedef std::vector::const_iterator const_iterator; const_iterator begin() const { return lines.begin(); } const_iterator end() const { return lines.end(); } std::string const& last() const { return lines.back(); } std::size_t size() const { return lines.size(); } std::string const& operator[]( std::size_t _index ) const { return lines[_index]; } std::string toString() const { std::ostringstream oss; oss << *this; return oss.str(); } inline friend std::ostream& operator << ( std::ostream& _stream, Text const& _text ) { for( Text::const_iterator it = _text.begin(), itEnd = _text.end(); it != itEnd; ++it ) { if( it != _text.begin() ) _stream << "\n"; _stream << *it; } return _stream; } private: std::string str; TextAttributes attr; std::vector lines; }; } // end namespace Tbc #ifdef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE } // end outer namespace #endif #endif // TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED #undef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE namespace Catch { using Tbc::Text; using Tbc::TextAttributes; } // #included from: catch_console_colour.hpp #define TWOBLUECUBES_CATCH_CONSOLE_COLOUR_HPP_INCLUDED namespace Catch { struct Colour { enum Code { None = 0, White, Red, Green, Blue, Cyan, Yellow, Grey, Bright = 0x10, BrightRed = Bright | Red, BrightGreen = Bright | Green, LightGrey = Bright | Grey, BrightWhite = Bright | White, // By intention FileName = LightGrey, Warning = Yellow, ResultError = BrightRed, ResultSuccess = BrightGreen, ResultExpectedFailure = Warning, Error = BrightRed, Success = Green, OriginalExpression = Cyan, ReconstructedExpression = Yellow, SecondaryText = LightGrey, Headers = White }; // Use constructed object for RAII guard Colour( Code _colourCode ); Colour( Colour const& other ); ~Colour(); // Use static method for one-shot changes static void use( Code _colourCode ); private: bool m_moved; }; inline std::ostream& operator << ( std::ostream& os, Colour const& ) { return os; } } // end namespace Catch // #included from: catch_interfaces_reporter.h #define TWOBLUECUBES_CATCH_INTERFACES_REPORTER_H_INCLUDED #include #include #include #include namespace Catch { struct ReporterConfig { explicit ReporterConfig( Ptr const& _fullConfig ) : m_stream( &_fullConfig->stream() ), m_fullConfig( _fullConfig ) {} ReporterConfig( Ptr const& _fullConfig, std::ostream& _stream ) : m_stream( &_stream ), m_fullConfig( _fullConfig ) {} std::ostream& stream() const { return *m_stream; } Ptr fullConfig() const { return m_fullConfig; } private: std::ostream* m_stream; Ptr m_fullConfig; }; struct ReporterPreferences { ReporterPreferences() : shouldRedirectStdOut( false ) {} bool shouldRedirectStdOut; }; template struct LazyStat : Option { LazyStat() : used( false ) {} LazyStat& operator=( T const& _value ) { Option::operator=( _value ); used = false; return *this; } void reset() { Option::reset(); used = false; } bool used; }; struct TestRunInfo { TestRunInfo( std::string const& _name ) : name( _name ) {} std::string name; }; struct GroupInfo { GroupInfo( std::string const& _name, std::size_t _groupIndex, std::size_t _groupsCount ) : name( _name ), groupIndex( _groupIndex ), groupsCounts( _groupsCount ) {} std::string name; std::size_t groupIndex; std::size_t groupsCounts; }; struct AssertionStats { AssertionStats( AssertionResult const& _assertionResult, std::vector const& _infoMessages, Totals const& _totals ) : assertionResult( _assertionResult ), infoMessages( _infoMessages ), totals( _totals ) { if( assertionResult.hasMessage() ) { // Copy message into messages list. // !TBD This should have been done earlier, somewhere MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() ); builder << assertionResult.getMessage(); builder.m_info.message = builder.m_stream.str(); infoMessages.push_back( builder.m_info ); } } virtual ~AssertionStats(); # ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS AssertionStats( AssertionStats const& ) = default; AssertionStats( AssertionStats && ) = default; AssertionStats& operator = ( AssertionStats const& ) = default; AssertionStats& operator = ( AssertionStats && ) = default; # endif AssertionResult assertionResult; std::vector infoMessages; Totals totals; }; struct SectionStats { SectionStats( SectionInfo const& _sectionInfo, Counts const& _assertions, double _durationInSeconds, bool _missingAssertions ) : sectionInfo( _sectionInfo ), assertions( _assertions ), durationInSeconds( _durationInSeconds ), missingAssertions( _missingAssertions ) {} virtual ~SectionStats(); # ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS SectionStats( SectionStats const& ) = default; SectionStats( SectionStats && ) = default; SectionStats& operator = ( SectionStats const& ) = default; SectionStats& operator = ( SectionStats && ) = default; # endif SectionInfo sectionInfo; Counts assertions; double durationInSeconds; bool missingAssertions; }; struct TestCaseStats { TestCaseStats( TestCaseInfo const& _testInfo, Totals const& _totals, std::string const& _stdOut, std::string const& _stdErr, bool _aborting ) : testInfo( _testInfo ), totals( _totals ), stdOut( _stdOut ), stdErr( _stdErr ), aborting( _aborting ) {} virtual ~TestCaseStats(); # ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS TestCaseStats( TestCaseStats const& ) = default; TestCaseStats( TestCaseStats && ) = default; TestCaseStats& operator = ( TestCaseStats const& ) = default; TestCaseStats& operator = ( TestCaseStats && ) = default; # endif TestCaseInfo testInfo; Totals totals; std::string stdOut; std::string stdErr; bool aborting; }; struct TestGroupStats { TestGroupStats( GroupInfo const& _groupInfo, Totals const& _totals, bool _aborting ) : groupInfo( _groupInfo ), totals( _totals ), aborting( _aborting ) {} TestGroupStats( GroupInfo const& _groupInfo ) : groupInfo( _groupInfo ), aborting( false ) {} virtual ~TestGroupStats(); # ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS TestGroupStats( TestGroupStats const& ) = default; TestGroupStats( TestGroupStats && ) = default; TestGroupStats& operator = ( TestGroupStats const& ) = default; TestGroupStats& operator = ( TestGroupStats && ) = default; # endif GroupInfo groupInfo; Totals totals; bool aborting; }; struct TestRunStats { TestRunStats( TestRunInfo const& _runInfo, Totals const& _totals, bool _aborting ) : runInfo( _runInfo ), totals( _totals ), aborting( _aborting ) {} virtual ~TestRunStats(); # ifndef CATCH_CONFIG_CPP11_GENERATED_METHODS TestRunStats( TestRunStats const& _other ) : runInfo( _other.runInfo ), totals( _other.totals ), aborting( _other.aborting ) {} # else TestRunStats( TestRunStats const& ) = default; TestRunStats( TestRunStats && ) = default; TestRunStats& operator = ( TestRunStats const& ) = default; TestRunStats& operator = ( TestRunStats && ) = default; # endif TestRunInfo runInfo; Totals totals; bool aborting; }; struct IStreamingReporter : IShared { virtual ~IStreamingReporter(); // Implementing class must also provide the following static method: // static std::string getDescription(); virtual ReporterPreferences getPreferences() const = 0; virtual void noMatchingTestCases( std::string const& spec ) = 0; virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0; virtual void testGroupStarting( GroupInfo const& groupInfo ) = 0; virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0; virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0; virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0; // The return value indicates if the messages buffer should be cleared: virtual bool assertionEnded( AssertionStats const& assertionStats ) = 0; virtual void sectionEnded( SectionStats const& sectionStats ) = 0; virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0; virtual void testGroupEnded( TestGroupStats const& testGroupStats ) = 0; virtual void testRunEnded( TestRunStats const& testRunStats ) = 0; virtual void skipTest( TestCaseInfo const& testInfo ) = 0; }; struct IReporterFactory { virtual ~IReporterFactory(); virtual IStreamingReporter* create( ReporterConfig const& config ) const = 0; virtual std::string getDescription() const = 0; }; struct IReporterRegistry { typedef std::map FactoryMap; virtual ~IReporterRegistry(); virtual IStreamingReporter* create( std::string const& name, Ptr const& config ) const = 0; virtual FactoryMap const& getFactories() const = 0; }; } #include #include namespace Catch { inline std::size_t listTests( Config const& config ) { TestSpec testSpec = config.testSpec(); if( config.testSpec().hasFilters() ) Catch::cout() << "Matching test cases:\n"; else { Catch::cout() << "All available test cases:\n"; testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec(); } std::size_t matchedTests = 0; TextAttributes nameAttr, tagsAttr; nameAttr.setInitialIndent( 2 ).setIndent( 4 ); tagsAttr.setIndent( 6 ); std::vector matchedTestCases; getRegistryHub().getTestCaseRegistry().getFilteredTests( testSpec, config, matchedTestCases ); for( std::vector::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end(); it != itEnd; ++it ) { matchedTests++; TestCaseInfo const& testCaseInfo = it->getTestCaseInfo(); Colour::Code colour = testCaseInfo.isHidden() ? Colour::SecondaryText : Colour::None; Colour colourGuard( colour ); Catch::cout() << Text( testCaseInfo.name, nameAttr ) << std::endl; if( !testCaseInfo.tags.empty() ) Catch::cout() << Text( testCaseInfo.tagsAsString, tagsAttr ) << std::endl; } if( !config.testSpec().hasFilters() ) Catch::cout() << pluralise( matchedTests, "test case" ) << "\n" << std::endl; else Catch::cout() << pluralise( matchedTests, "matching test case" ) << "\n" << std::endl; return matchedTests; } inline std::size_t listTestsNamesOnly( Config const& config ) { TestSpec testSpec = config.testSpec(); if( !config.testSpec().hasFilters() ) testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec(); std::size_t matchedTests = 0; std::vector matchedTestCases; getRegistryHub().getTestCaseRegistry().getFilteredTests( testSpec, config, matchedTestCases ); for( std::vector::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end(); it != itEnd; ++it ) { matchedTests++; TestCaseInfo const& testCaseInfo = it->getTestCaseInfo(); Catch::cout() << testCaseInfo.name << std::endl; } return matchedTests; } struct TagInfo { TagInfo() : count ( 0 ) {} void add( std::string const& spelling ) { ++count; spellings.insert( spelling ); } std::string all() const { std::string out; for( std::set::const_iterator it = spellings.begin(), itEnd = spellings.end(); it != itEnd; ++it ) out += "[" + *it + "]"; return out; } std::set spellings; std::size_t count; }; inline std::size_t listTags( Config const& config ) { TestSpec testSpec = config.testSpec(); if( config.testSpec().hasFilters() ) Catch::cout() << "Tags for matching test cases:\n"; else { Catch::cout() << "All available tags:\n"; testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec(); } std::map tagCounts; std::vector matchedTestCases; getRegistryHub().getTestCaseRegistry().getFilteredTests( testSpec, config, matchedTestCases ); for( std::vector::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end(); it != itEnd; ++it ) { for( std::set::const_iterator tagIt = it->getTestCaseInfo().tags.begin(), tagItEnd = it->getTestCaseInfo().tags.end(); tagIt != tagItEnd; ++tagIt ) { std::string tagName = *tagIt; std::string lcaseTagName = toLower( tagName ); std::map::iterator countIt = tagCounts.find( lcaseTagName ); if( countIt == tagCounts.end() ) countIt = tagCounts.insert( std::make_pair( lcaseTagName, TagInfo() ) ).first; countIt->second.add( tagName ); } } for( std::map::const_iterator countIt = tagCounts.begin(), countItEnd = tagCounts.end(); countIt != countItEnd; ++countIt ) { std::ostringstream oss; oss << " " << std::setw(2) << countIt->second.count << " "; Text wrapper( countIt->second.all(), TextAttributes() .setInitialIndent( 0 ) .setIndent( oss.str().size() ) .setWidth( CATCH_CONFIG_CONSOLE_WIDTH-10 ) ); Catch::cout() << oss.str() << wrapper << "\n"; } Catch::cout() << pluralise( tagCounts.size(), "tag" ) << "\n" << std::endl; return tagCounts.size(); } inline std::size_t listReporters( Config const& /*config*/ ) { Catch::cout() << "Available reporters:\n"; IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories(); IReporterRegistry::FactoryMap::const_iterator itBegin = factories.begin(), itEnd = factories.end(), it; std::size_t maxNameLen = 0; for(it = itBegin; it != itEnd; ++it ) maxNameLen = (std::max)( maxNameLen, it->first.size() ); for(it = itBegin; it != itEnd; ++it ) { Text wrapper( it->second->getDescription(), TextAttributes() .setInitialIndent( 0 ) .setIndent( 7+maxNameLen ) .setWidth( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen-8 ) ); Catch::cout() << " " << it->first << ":" << std::string( maxNameLen - it->first.size() + 2, ' ' ) << wrapper << "\n"; } Catch::cout() << std::endl; return factories.size(); } inline Option list( Config const& config ) { Option listedCount; if( config.listTests() ) listedCount = listedCount.valueOr(0) + listTests( config ); if( config.listTestNamesOnly() ) listedCount = listedCount.valueOr(0) + listTestsNamesOnly( config ); if( config.listTags() ) listedCount = listedCount.valueOr(0) + listTags( config ); if( config.listReporters() ) listedCount = listedCount.valueOr(0) + listReporters( config ); return listedCount; } } // end namespace Catch // #included from: internal/catch_runner_impl.hpp #define TWOBLUECUBES_CATCH_RUNNER_IMPL_HPP_INCLUDED // #included from: catch_test_case_tracker.hpp #define TWOBLUECUBES_CATCH_TEST_CASE_TRACKER_HPP_INCLUDED #include #include #include namespace Catch { namespace SectionTracking { class TrackedSection { typedef std::map TrackedSections; public: enum RunState { NotStarted, Executing, ExecutingChildren, Completed }; TrackedSection( std::string const& name, TrackedSection* parent ) : m_name( name ), m_runState( NotStarted ), m_parent( parent ) {} RunState runState() const { return m_runState; } TrackedSection* findChild( std::string const& childName ) { TrackedSections::iterator it = m_children.find( childName ); return it != m_children.end() ? &it->second : NULL; } TrackedSection* acquireChild( std::string const& childName ) { if( TrackedSection* child = findChild( childName ) ) return child; m_children.insert( std::make_pair( childName, TrackedSection( childName, this ) ) ); return findChild( childName ); } void enter() { if( m_runState == NotStarted ) m_runState = Executing; } void leave() { for( TrackedSections::const_iterator it = m_children.begin(), itEnd = m_children.end(); it != itEnd; ++it ) if( it->second.runState() != Completed ) { m_runState = ExecutingChildren; return; } m_runState = Completed; } TrackedSection* getParent() { return m_parent; } bool hasChildren() const { return !m_children.empty(); } private: std::string m_name; RunState m_runState; TrackedSections m_children; TrackedSection* m_parent; }; class TestCaseTracker { public: TestCaseTracker( std::string const& testCaseName ) : m_testCase( testCaseName, NULL ), m_currentSection( &m_testCase ), m_completedASectionThisRun( false ) {} bool enterSection( std::string const& name ) { TrackedSection* child = m_currentSection->acquireChild( name ); if( m_completedASectionThisRun || child->runState() == TrackedSection::Completed ) return false; m_currentSection = child; m_currentSection->enter(); return true; } void leaveSection() { m_currentSection->leave(); m_currentSection = m_currentSection->getParent(); assert( m_currentSection != NULL ); m_completedASectionThisRun = true; } bool currentSectionHasChildren() const { return m_currentSection->hasChildren(); } bool isCompleted() const { return m_testCase.runState() == TrackedSection::Completed; } class Guard { public: Guard( TestCaseTracker& tracker ) : m_tracker( tracker ) { m_tracker.enterTestCase(); } ~Guard() { m_tracker.leaveTestCase(); } private: Guard( Guard const& ); void operator = ( Guard const& ); TestCaseTracker& m_tracker; }; private: void enterTestCase() { m_currentSection = &m_testCase; m_completedASectionThisRun = false; m_testCase.enter(); } void leaveTestCase() { m_testCase.leave(); } TrackedSection m_testCase; TrackedSection* m_currentSection; bool m_completedASectionThisRun; }; } // namespace SectionTracking using SectionTracking::TestCaseTracker; } // namespace Catch // #included from: catch_fatal_condition.hpp #define TWOBLUECUBES_CATCH_FATAL_CONDITION_H_INCLUDED namespace Catch { // Report the error condition then exit the process inline void fatal( std::string const& message, int exitCode ) { IContext& context = Catch::getCurrentContext(); IResultCapture* resultCapture = context.getResultCapture(); resultCapture->handleFatalErrorCondition( message ); if( Catch::alwaysTrue() ) // avoids "no return" warnings exit( exitCode ); } } // namespace Catch #if defined ( CATCH_PLATFORM_WINDOWS ) ///////////////////////////////////////// namespace Catch { struct FatalConditionHandler { void reset() {} }; } // namespace Catch #else // Not Windows - assumed to be POSIX compatible ////////////////////////// #include namespace Catch { struct SignalDefs { int id; const char* name; }; extern SignalDefs signalDefs[]; SignalDefs signalDefs[] = { { SIGINT, "SIGINT - Terminal interrupt signal" }, { SIGILL, "SIGILL - Illegal instruction signal" }, { SIGFPE, "SIGFPE - Floating point error signal" }, { SIGSEGV, "SIGSEGV - Segmentation violation signal" }, { SIGTERM, "SIGTERM - Termination request signal" }, { SIGABRT, "SIGABRT - Abort (abnormal termination) signal" } }; struct FatalConditionHandler { static void handleSignal( int sig ) { for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i ) if( sig == signalDefs[i].id ) fatal( signalDefs[i].name, -sig ); fatal( "", -sig ); } FatalConditionHandler() : m_isSet( true ) { for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i ) signal( signalDefs[i].id, handleSignal ); } ~FatalConditionHandler() { reset(); } void reset() { if( m_isSet ) { for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i ) signal( signalDefs[i].id, SIG_DFL ); m_isSet = false; } } bool m_isSet; }; } // namespace Catch #endif // not Windows #include #include namespace Catch { class StreamRedirect { public: StreamRedirect( std::ostream& stream, std::string& targetString ) : m_stream( stream ), m_prevBuf( stream.rdbuf() ), m_targetString( targetString ) { stream.rdbuf( m_oss.rdbuf() ); } ~StreamRedirect() { m_targetString += m_oss.str(); m_stream.rdbuf( m_prevBuf ); } private: std::ostream& m_stream; std::streambuf* m_prevBuf; std::ostringstream m_oss; std::string& m_targetString; }; /////////////////////////////////////////////////////////////////////////// class RunContext : public IResultCapture, public IRunner { RunContext( RunContext const& ); void operator =( RunContext const& ); public: explicit RunContext( Ptr const& config, Ptr const& reporter ) : m_runInfo( config->name() ), m_context( getCurrentMutableContext() ), m_activeTestCase( NULL ), m_config( config ), m_reporter( reporter ), m_prevRunner( m_context.getRunner() ), m_prevResultCapture( m_context.getResultCapture() ), m_prevConfig( m_context.getConfig() ) { m_context.setRunner( this ); m_context.setConfig( m_config ); m_context.setResultCapture( this ); m_reporter->testRunStarting( m_runInfo ); } virtual ~RunContext() { m_reporter->testRunEnded( TestRunStats( m_runInfo, m_totals, aborting() ) ); m_context.setRunner( m_prevRunner ); m_context.setConfig( NULL ); m_context.setResultCapture( m_prevResultCapture ); m_context.setConfig( m_prevConfig ); } void testGroupStarting( std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount ) { m_reporter->testGroupStarting( GroupInfo( testSpec, groupIndex, groupsCount ) ); } void testGroupEnded( std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount ) { m_reporter->testGroupEnded( TestGroupStats( GroupInfo( testSpec, groupIndex, groupsCount ), totals, aborting() ) ); } Totals runTest( TestCase const& testCase ) { Totals prevTotals = m_totals; std::string redirectedCout; std::string redirectedCerr; TestCaseInfo testInfo = testCase.getTestCaseInfo(); m_reporter->testCaseStarting( testInfo ); m_activeTestCase = &testCase; m_testCaseTracker = TestCaseTracker( testInfo.name ); do { do { runCurrentTest( redirectedCout, redirectedCerr ); } while( !m_testCaseTracker->isCompleted() && !aborting() ); } while( getCurrentContext().advanceGeneratorsForCurrentTest() && !aborting() ); Totals deltaTotals = m_totals.delta( prevTotals ); m_totals.testCases += deltaTotals.testCases; m_reporter->testCaseEnded( TestCaseStats( testInfo, deltaTotals, redirectedCout, redirectedCerr, aborting() ) ); m_activeTestCase = NULL; m_testCaseTracker.reset(); return deltaTotals; } Ptr config() const { return m_config; } private: // IResultCapture virtual void assertionEnded( AssertionResult const& result ) { if( result.getResultType() == ResultWas::Ok ) { m_totals.assertions.passed++; } else if( !result.isOk() ) { m_totals.assertions.failed++; } if( m_reporter->assertionEnded( AssertionStats( result, m_messages, m_totals ) ) ) m_messages.clear(); // Reset working state m_lastAssertionInfo = AssertionInfo( "", m_lastAssertionInfo.lineInfo, "{Unknown expression after the reported line}" , m_lastAssertionInfo.resultDisposition ); m_lastResult = result; } virtual bool sectionStarted ( SectionInfo const& sectionInfo, Counts& assertions ) { std::ostringstream oss; oss << sectionInfo.name << "@" << sectionInfo.lineInfo; if( !m_testCaseTracker->enterSection( oss.str() ) ) return false; m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo; m_reporter->sectionStarting( sectionInfo ); assertions = m_totals.assertions; return true; } bool testForMissingAssertions( Counts& assertions ) { if( assertions.total() != 0 || !m_config->warnAboutMissingAssertions() || m_testCaseTracker->currentSectionHasChildren() ) return false; m_totals.assertions.failed++; assertions.failed++; return true; } virtual void sectionEnded( SectionInfo const& info, Counts const& prevAssertions, double _durationInSeconds ) { if( std::uncaught_exception() ) { m_unfinishedSections.push_back( UnfinishedSections( info, prevAssertions, _durationInSeconds ) ); return; } Counts assertions = m_totals.assertions - prevAssertions; bool missingAssertions = testForMissingAssertions( assertions ); m_testCaseTracker->leaveSection(); m_reporter->sectionEnded( SectionStats( info, assertions, _durationInSeconds, missingAssertions ) ); m_messages.clear(); } virtual void pushScopedMessage( MessageInfo const& message ) { m_messages.push_back( message ); } virtual void popScopedMessage( MessageInfo const& message ) { m_messages.erase( std::remove( m_messages.begin(), m_messages.end(), message ), m_messages.end() ); } virtual std::string getCurrentTestName() const { return m_activeTestCase ? m_activeTestCase->getTestCaseInfo().name : ""; } virtual const AssertionResult* getLastResult() const { return &m_lastResult; } virtual void handleFatalErrorCondition( std::string const& message ) { ResultBuilder resultBuilder = makeUnexpectedResultBuilder(); resultBuilder.setResultType( ResultWas::FatalErrorCondition ); resultBuilder << message; resultBuilder.captureExpression(); handleUnfinishedSections(); // Recreate section for test case (as we will lose the one that was in scope) TestCaseInfo const& testCaseInfo = m_activeTestCase->getTestCaseInfo(); SectionInfo testCaseSection( testCaseInfo.lineInfo, testCaseInfo.name, testCaseInfo.description ); Counts assertions; assertions.failed = 1; SectionStats testCaseSectionStats( testCaseSection, assertions, 0, false ); m_reporter->sectionEnded( testCaseSectionStats ); TestCaseInfo testInfo = m_activeTestCase->getTestCaseInfo(); Totals deltaTotals; deltaTotals.testCases.failed = 1; m_reporter->testCaseEnded( TestCaseStats( testInfo, deltaTotals, "", "", false ) ); m_totals.testCases.failed++; testGroupEnded( "", m_totals, 1, 1 ); m_reporter->testRunEnded( TestRunStats( m_runInfo, m_totals, false ) ); } public: // !TBD We need to do this another way! bool aborting() const { return m_totals.assertions.failed == static_cast( m_config->abortAfter() ); } private: void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr ) { TestCaseInfo const& testCaseInfo = m_activeTestCase->getTestCaseInfo(); SectionInfo testCaseSection( testCaseInfo.lineInfo, testCaseInfo.name, testCaseInfo.description ); m_reporter->sectionStarting( testCaseSection ); Counts prevAssertions = m_totals.assertions; double duration = 0; try { m_lastAssertionInfo = AssertionInfo( "TEST_CASE", testCaseInfo.lineInfo, "", ResultDisposition::Normal ); TestCaseTracker::Guard guard( *m_testCaseTracker ); Timer timer; timer.start(); if( m_reporter->getPreferences().shouldRedirectStdOut ) { StreamRedirect coutRedir( Catch::cout(), redirectedCout ); StreamRedirect cerrRedir( Catch::cerr(), redirectedCerr ); invokeActiveTestCase(); } else { invokeActiveTestCase(); } duration = timer.getElapsedSeconds(); } catch( TestFailureException& ) { // This just means the test was aborted due to failure } catch(...) { makeUnexpectedResultBuilder().useActiveException(); } handleUnfinishedSections(); m_messages.clear(); Counts assertions = m_totals.assertions - prevAssertions; bool missingAssertions = testForMissingAssertions( assertions ); if( testCaseInfo.okToFail() ) { std::swap( assertions.failedButOk, assertions.failed ); m_totals.assertions.failed -= assertions.failedButOk; m_totals.assertions.failedButOk += assertions.failedButOk; } SectionStats testCaseSectionStats( testCaseSection, assertions, duration, missingAssertions ); m_reporter->sectionEnded( testCaseSectionStats ); } void invokeActiveTestCase() { FatalConditionHandler fatalConditionHandler; // Handle signals m_activeTestCase->invoke(); fatalConditionHandler.reset(); } private: ResultBuilder makeUnexpectedResultBuilder() const { return ResultBuilder( m_lastAssertionInfo.macroName.c_str(), m_lastAssertionInfo.lineInfo, m_lastAssertionInfo.capturedExpression.c_str(), m_lastAssertionInfo.resultDisposition ); } void handleUnfinishedSections() { // If sections ended prematurely due to an exception we stored their // infos here so we can tear them down outside the unwind process. for( std::vector::const_reverse_iterator it = m_unfinishedSections.rbegin(), itEnd = m_unfinishedSections.rend(); it != itEnd; ++it ) sectionEnded( it->info, it->prevAssertions, it->durationInSeconds ); m_unfinishedSections.clear(); } struct UnfinishedSections { UnfinishedSections( SectionInfo const& _info, Counts const& _prevAssertions, double _durationInSeconds ) : info( _info ), prevAssertions( _prevAssertions ), durationInSeconds( _durationInSeconds ) {} SectionInfo info; Counts prevAssertions; double durationInSeconds; }; TestRunInfo m_runInfo; IMutableContext& m_context; TestCase const* m_activeTestCase; Option m_testCaseTracker; AssertionResult m_lastResult; Ptr m_config; Totals m_totals; Ptr m_reporter; std::vector m_messages; IRunner* m_prevRunner; IResultCapture* m_prevResultCapture; Ptr m_prevConfig; AssertionInfo m_lastAssertionInfo; std::vector m_unfinishedSections; }; IResultCapture& getResultCapture() { if( IResultCapture* capture = getCurrentContext().getResultCapture() ) return *capture; else throw std::logic_error( "No result capture instance" ); } } // end namespace Catch // #included from: internal/catch_version.h #define TWOBLUECUBES_CATCH_VERSION_H_INCLUDED namespace Catch { // Versioning information struct Version { Version( unsigned int _majorVersion, unsigned int _minorVersion, unsigned int _buildNumber, char const* const _branchName ) : majorVersion( _majorVersion ), minorVersion( _minorVersion ), buildNumber( _buildNumber ), branchName( _branchName ) {} unsigned int const majorVersion; unsigned int const minorVersion; unsigned int const buildNumber; char const* const branchName; private: void operator=( Version const& ); }; extern Version libraryVersion; } #include #include #include namespace Catch { class Runner { public: Runner( Ptr const& config ) : m_config( config ) { openStream(); makeReporter(); } Totals runTests() { RunContext context( m_config.get(), m_reporter ); Totals totals; context.testGroupStarting( "all tests", 1, 1 ); // deprecated? TestSpec testSpec = m_config->testSpec(); if( !testSpec.hasFilters() ) testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "~[.]" ).testSpec(); // All not hidden tests std::vector testCases; getRegistryHub().getTestCaseRegistry().getFilteredTests( testSpec, *m_config, testCases ); int testsRunForGroup = 0; for( std::vector::const_iterator it = testCases.begin(), itEnd = testCases.end(); it != itEnd; ++it ) { testsRunForGroup++; if( m_testsAlreadyRun.find( *it ) == m_testsAlreadyRun.end() ) { if( context.aborting() ) break; totals += context.runTest( *it ); m_testsAlreadyRun.insert( *it ); } } std::vector skippedTestCases; getRegistryHub().getTestCaseRegistry().getFilteredTests( testSpec, *m_config, skippedTestCases, true ); for( std::vector::const_iterator it = skippedTestCases.begin(), itEnd = skippedTestCases.end(); it != itEnd; ++it ) m_reporter->skipTest( *it ); context.testGroupEnded( "all tests", totals, 1, 1 ); return totals; } private: void openStream() { // Open output file, if specified if( !m_config->getFilename().empty() ) { m_ofs.open( m_config->getFilename().c_str() ); if( m_ofs.fail() ) { std::ostringstream oss; oss << "Unable to open file: '" << m_config->getFilename() << "'"; throw std::domain_error( oss.str() ); } m_config->setStreamBuf( m_ofs.rdbuf() ); } } void makeReporter() { std::string reporterName = m_config->getReporterName().empty() ? "console" : m_config->getReporterName(); m_reporter = getRegistryHub().getReporterRegistry().create( reporterName, m_config.get() ); if( !m_reporter ) { std::ostringstream oss; oss << "No reporter registered with name: '" << reporterName << "'"; throw std::domain_error( oss.str() ); } } private: Ptr m_config; std::ofstream m_ofs; Ptr m_reporter; std::set m_testsAlreadyRun; }; class Session : NonCopyable { static bool alreadyInstantiated; public: struct OnUnusedOptions { enum DoWhat { Ignore, Fail }; }; Session() : m_cli( makeCommandLineParser() ) { if( alreadyInstantiated ) { std::string msg = "Only one instance of Catch::Session can ever be used"; Catch::cerr() << msg << std::endl; throw std::logic_error( msg ); } alreadyInstantiated = true; } ~Session() { Catch::cleanUp(); } void showHelp( std::string const& processName ) { Catch::cout() << "\nCatch v" << libraryVersion.majorVersion << "." << libraryVersion.minorVersion << " build " << libraryVersion.buildNumber; if( libraryVersion.branchName != std::string( "master" ) ) Catch::cout() << " (" << libraryVersion.branchName << " branch)"; Catch::cout() << "\n"; m_cli.usage( Catch::cout(), processName ); Catch::cout() << "For more detail usage please see the project docs\n" << std::endl; } int applyCommandLine( int argc, char* const argv[], OnUnusedOptions::DoWhat unusedOptionBehaviour = OnUnusedOptions::Fail ) { try { m_cli.setThrowOnUnrecognisedTokens( unusedOptionBehaviour == OnUnusedOptions::Fail ); m_unusedTokens = m_cli.parseInto( argc, argv, m_configData ); if( m_configData.showHelp ) showHelp( m_configData.processName ); m_config.reset(); } catch( std::exception& ex ) { { Colour colourGuard( Colour::Red ); Catch::cerr() << "\nError(s) in input:\n" << Text( ex.what(), TextAttributes().setIndent(2) ) << "\n\n"; } m_cli.usage( Catch::cout(), m_configData.processName ); return (std::numeric_limits::max)(); } return 0; } void useConfigData( ConfigData const& _configData ) { m_configData = _configData; m_config.reset(); } int run( int argc, char* const argv[] ) { int returnCode = applyCommandLine( argc, argv ); if( returnCode == 0 ) returnCode = run(); return returnCode; } int run() { if( m_configData.showHelp ) return 0; try { config(); // Force config to be constructed std::srand( m_configData.rngSeed ); Runner runner( m_config ); // Handle list request if( Option listed = list( config() ) ) return static_cast( *listed ); return static_cast( runner.runTests().assertions.failed ); } catch( std::exception& ex ) { Catch::cerr() << ex.what() << std::endl; return (std::numeric_limits::max)(); } } Clara::CommandLine const& cli() const { return m_cli; } std::vector const& unusedTokens() const { return m_unusedTokens; } ConfigData& configData() { return m_configData; } Config& config() { if( !m_config ) m_config = new Config( m_configData ); return *m_config; } private: Clara::CommandLine m_cli; std::vector m_unusedTokens; ConfigData m_configData; Ptr m_config; }; bool Session::alreadyInstantiated = false; } // end namespace Catch // #included from: catch_registry_hub.hpp #define TWOBLUECUBES_CATCH_REGISTRY_HUB_HPP_INCLUDED // #included from: catch_test_case_registry_impl.hpp #define TWOBLUECUBES_CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED #include #include #include #include #include namespace Catch { class TestRegistry : public ITestCaseRegistry { struct LexSort { bool operator() (TestCase i,TestCase j) const { return (i const& getAllTests() const { return m_functionsInOrder; } virtual std::vector const& getAllNonHiddenTests() const { return m_nonHiddenFunctions; } virtual void getFilteredTests( TestSpec const& testSpec, IConfig const& config, std::vector& matchingTestCases, bool negated = false ) const { for( std::vector::const_iterator it = m_functionsInOrder.begin(), itEnd = m_functionsInOrder.end(); it != itEnd; ++it ) { bool includeTest = testSpec.matches( *it ) && ( config.allowThrows() || !it->throws() ); if( includeTest != negated ) matchingTestCases.push_back( *it ); } sortTests( config, matchingTestCases ); } private: static void sortTests( IConfig const& config, std::vector& matchingTestCases ) { switch( config.runOrder() ) { case RunTests::InLexicographicalOrder: std::sort( matchingTestCases.begin(), matchingTestCases.end(), LexSort() ); break; case RunTests::InRandomOrder: { RandomNumberGenerator rng; std::random_shuffle( matchingTestCases.begin(), matchingTestCases.end(), rng ); } break; case RunTests::InDeclarationOrder: // already in declaration order break; } } std::set m_functions; std::vector m_functionsInOrder; std::vector m_nonHiddenFunctions; size_t m_unnamedCount; }; /////////////////////////////////////////////////////////////////////////// class FreeFunctionTestCase : public SharedImpl { public: FreeFunctionTestCase( TestFunction fun ) : m_fun( fun ) {} virtual void invoke() const { m_fun(); } private: virtual ~FreeFunctionTestCase(); TestFunction m_fun; }; inline std::string extractClassName( std::string const& classOrQualifiedMethodName ) { std::string className = classOrQualifiedMethodName; if( startsWith( className, "&" ) ) { std::size_t lastColons = className.rfind( "::" ); std::size_t penultimateColons = className.rfind( "::", lastColons-1 ); if( penultimateColons == std::string::npos ) penultimateColons = 1; className = className.substr( penultimateColons, lastColons-penultimateColons ); } return className; } /////////////////////////////////////////////////////////////////////////// AutoReg::AutoReg( TestFunction function, SourceLineInfo const& lineInfo, NameAndDesc const& nameAndDesc ) { registerTestCase( new FreeFunctionTestCase( function ), "", nameAndDesc, lineInfo ); } AutoReg::~AutoReg() {} void AutoReg::registerTestCase( ITestCase* testCase, char const* classOrQualifiedMethodName, NameAndDesc const& nameAndDesc, SourceLineInfo const& lineInfo ) { getMutableRegistryHub().registerTest ( makeTestCase( testCase, extractClassName( classOrQualifiedMethodName ), nameAndDesc.name, nameAndDesc.description, lineInfo ) ); } } // end namespace Catch // #included from: catch_reporter_registry.hpp #define TWOBLUECUBES_CATCH_REPORTER_REGISTRY_HPP_INCLUDED #include namespace Catch { class ReporterRegistry : public IReporterRegistry { public: virtual ~ReporterRegistry() { deleteAllValues( m_factories ); } virtual IStreamingReporter* create( std::string const& name, Ptr const& config ) const { FactoryMap::const_iterator it = m_factories.find( name ); if( it == m_factories.end() ) return NULL; return it->second->create( ReporterConfig( config ) ); } void registerReporter( std::string const& name, IReporterFactory* factory ) { m_factories.insert( std::make_pair( name, factory ) ); } FactoryMap const& getFactories() const { return m_factories; } private: FactoryMap m_factories; }; } // #included from: catch_exception_translator_registry.hpp #define TWOBLUECUBES_CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED #ifdef __OBJC__ #import "Foundation/Foundation.h" #endif namespace Catch { class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry { public: ~ExceptionTranslatorRegistry() { deleteAll( m_translators ); } virtual void registerTranslator( const IExceptionTranslator* translator ) { m_translators.push_back( translator ); } virtual std::string translateActiveException() const { try { #ifdef __OBJC__ // In Objective-C try objective-c exceptions first @try { throw; } @catch (NSException *exception) { return Catch::toString( [exception description] ); } #else throw; #endif } catch( TestFailureException& ) { throw; } catch( std::exception& ex ) { return ex.what(); } catch( std::string& msg ) { return msg; } catch( const char* msg ) { return msg; } catch(...) { return tryTranslators( m_translators.begin() ); } } std::string tryTranslators( std::vector::const_iterator it ) const { if( it == m_translators.end() ) return "Unknown exception"; try { return (*it)->translate(); } catch(...) { return tryTranslators( it+1 ); } } private: std::vector m_translators; }; } namespace Catch { namespace { class RegistryHub : public IRegistryHub, public IMutableRegistryHub { RegistryHub( RegistryHub const& ); void operator=( RegistryHub const& ); public: // IRegistryHub RegistryHub() { } virtual IReporterRegistry const& getReporterRegistry() const { return m_reporterRegistry; } virtual ITestCaseRegistry const& getTestCaseRegistry() const { return m_testCaseRegistry; } virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() { return m_exceptionTranslatorRegistry; } public: // IMutableRegistryHub virtual void registerReporter( std::string const& name, IReporterFactory* factory ) { m_reporterRegistry.registerReporter( name, factory ); } virtual void registerTest( TestCase const& testInfo ) { m_testCaseRegistry.registerTest( testInfo ); } virtual void registerTranslator( const IExceptionTranslator* translator ) { m_exceptionTranslatorRegistry.registerTranslator( translator ); } private: TestRegistry m_testCaseRegistry; ReporterRegistry m_reporterRegistry; ExceptionTranslatorRegistry m_exceptionTranslatorRegistry; }; // Single, global, instance inline RegistryHub*& getTheRegistryHub() { static RegistryHub* theRegistryHub = NULL; if( !theRegistryHub ) theRegistryHub = new RegistryHub(); return theRegistryHub; } } IRegistryHub& getRegistryHub() { return *getTheRegistryHub(); } IMutableRegistryHub& getMutableRegistryHub() { return *getTheRegistryHub(); } void cleanUp() { delete getTheRegistryHub(); getTheRegistryHub() = NULL; cleanUpContext(); } std::string translateActiveException() { return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException(); } } // end namespace Catch // #included from: catch_notimplemented_exception.hpp #define TWOBLUECUBES_CATCH_NOTIMPLEMENTED_EXCEPTION_HPP_INCLUDED #include namespace Catch { NotImplementedException::NotImplementedException( SourceLineInfo const& lineInfo ) : m_lineInfo( lineInfo ) { std::ostringstream oss; oss << lineInfo << ": function "; oss << "not implemented"; m_what = oss.str(); } const char* NotImplementedException::what() const CATCH_NOEXCEPT { return m_what.c_str(); } } // end namespace Catch // #included from: catch_context_impl.hpp #define TWOBLUECUBES_CATCH_CONTEXT_IMPL_HPP_INCLUDED // #included from: catch_stream.hpp #define TWOBLUECUBES_CATCH_STREAM_HPP_INCLUDED // #included from: catch_streambuf.h #define TWOBLUECUBES_CATCH_STREAMBUF_H_INCLUDED #include namespace Catch { class StreamBufBase : public std::streambuf { public: virtual ~StreamBufBase() CATCH_NOEXCEPT; }; } #include #include #include namespace Catch { template class StreamBufImpl : public StreamBufBase { char data[bufferSize]; WriterF m_writer; public: StreamBufImpl() { setp( data, data + sizeof(data) ); } ~StreamBufImpl() CATCH_NOEXCEPT { sync(); } private: int overflow( int c ) { sync(); if( c != EOF ) { if( pbase() == epptr() ) m_writer( std::string( 1, static_cast( c ) ) ); else sputc( static_cast( c ) ); } return 0; } int sync() { if( pbase() != pptr() ) { m_writer( std::string( pbase(), static_cast( pptr() - pbase() ) ) ); setp( pbase(), epptr() ); } return 0; } }; /////////////////////////////////////////////////////////////////////////// struct OutputDebugWriter { void operator()( std::string const&str ) { writeToDebugConsole( str ); } }; Stream::Stream() : streamBuf( NULL ), isOwned( false ) {} Stream::Stream( std::streambuf* _streamBuf, bool _isOwned ) : streamBuf( _streamBuf ), isOwned( _isOwned ) {} void Stream::release() { if( isOwned ) { delete streamBuf; streamBuf = NULL; isOwned = false; } } #ifndef CATCH_CONFIG_NOSTDOUT // If you #define this you must implement this functions std::ostream& cout() { return std::cout; } std::ostream& cerr() { return std::cerr; } #endif } namespace Catch { class Context : public IMutableContext { Context() : m_config( NULL ), m_runner( NULL ), m_resultCapture( NULL ) {} Context( Context const& ); void operator=( Context const& ); public: // IContext virtual IResultCapture* getResultCapture() { return m_resultCapture; } virtual IRunner* getRunner() { return m_runner; } virtual size_t getGeneratorIndex( std::string const& fileInfo, size_t totalSize ) { return getGeneratorsForCurrentTest() .getGeneratorInfo( fileInfo, totalSize ) .getCurrentIndex(); } virtual bool advanceGeneratorsForCurrentTest() { IGeneratorsForTest* generators = findGeneratorsForCurrentTest(); return generators && generators->moveNext(); } virtual Ptr getConfig() const { return m_config; } public: // IMutableContext virtual void setResultCapture( IResultCapture* resultCapture ) { m_resultCapture = resultCapture; } virtual void setRunner( IRunner* runner ) { m_runner = runner; } virtual void setConfig( Ptr const& config ) { m_config = config; } friend IMutableContext& getCurrentMutableContext(); private: IGeneratorsForTest* findGeneratorsForCurrentTest() { std::string testName = getResultCapture()->getCurrentTestName(); std::map::const_iterator it = m_generatorsByTestName.find( testName ); return it != m_generatorsByTestName.end() ? it->second : NULL; } IGeneratorsForTest& getGeneratorsForCurrentTest() { IGeneratorsForTest* generators = findGeneratorsForCurrentTest(); if( !generators ) { std::string testName = getResultCapture()->getCurrentTestName(); generators = createGeneratorsForTest(); m_generatorsByTestName.insert( std::make_pair( testName, generators ) ); } return *generators; } private: Ptr m_config; IRunner* m_runner; IResultCapture* m_resultCapture; std::map m_generatorsByTestName; }; namespace { Context* currentContext = NULL; } IMutableContext& getCurrentMutableContext() { if( !currentContext ) currentContext = new Context(); return *currentContext; } IContext& getCurrentContext() { return getCurrentMutableContext(); } Stream createStream( std::string const& streamName ) { if( streamName == "stdout" ) return Stream( Catch::cout().rdbuf(), false ); if( streamName == "stderr" ) return Stream( Catch::cerr().rdbuf(), false ); if( streamName == "debug" ) return Stream( new StreamBufImpl, true ); throw std::domain_error( "Unknown stream: " + streamName ); } void cleanUpContext() { delete currentContext; currentContext = NULL; } } // #included from: catch_console_colour_impl.hpp #define TWOBLUECUBES_CATCH_CONSOLE_COLOUR_IMPL_HPP_INCLUDED namespace Catch { namespace { struct IColourImpl { virtual ~IColourImpl() {} virtual void use( Colour::Code _colourCode ) = 0; }; struct NoColourImpl : IColourImpl { void use( Colour::Code ) {} static IColourImpl* instance() { static NoColourImpl s_instance; return &s_instance; } }; } // anon namespace } // namespace Catch #if !defined( CATCH_CONFIG_COLOUR_NONE ) && !defined( CATCH_CONFIG_COLOUR_WINDOWS ) && !defined( CATCH_CONFIG_COLOUR_ANSI ) # ifdef CATCH_PLATFORM_WINDOWS # define CATCH_CONFIG_COLOUR_WINDOWS # else # define CATCH_CONFIG_COLOUR_ANSI # endif #endif #if defined ( CATCH_CONFIG_COLOUR_WINDOWS ) ///////////////////////////////////////// #ifndef NOMINMAX #define NOMINMAX #endif #ifdef __AFXDLL #include #else #include #endif namespace Catch { namespace { class Win32ColourImpl : public IColourImpl { public: Win32ColourImpl() : stdoutHandle( GetStdHandle(STD_OUTPUT_HANDLE) ) { CONSOLE_SCREEN_BUFFER_INFO csbiInfo; GetConsoleScreenBufferInfo( stdoutHandle, &csbiInfo ); originalAttributes = csbiInfo.wAttributes; } virtual void use( Colour::Code _colourCode ) { switch( _colourCode ) { case Colour::None: return setTextAttribute( originalAttributes ); case Colour::White: return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE ); case Colour::Red: return setTextAttribute( FOREGROUND_RED ); case Colour::Green: return setTextAttribute( FOREGROUND_GREEN ); case Colour::Blue: return setTextAttribute( FOREGROUND_BLUE ); case Colour::Cyan: return setTextAttribute( FOREGROUND_BLUE | FOREGROUND_GREEN ); case Colour::Yellow: return setTextAttribute( FOREGROUND_RED | FOREGROUND_GREEN ); case Colour::Grey: return setTextAttribute( 0 ); case Colour::LightGrey: return setTextAttribute( FOREGROUND_INTENSITY ); case Colour::BrightRed: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED ); case Colour::BrightGreen: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN ); case Colour::BrightWhite: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE ); case Colour::Bright: throw std::logic_error( "not a colour" ); } } private: void setTextAttribute( WORD _textAttribute ) { SetConsoleTextAttribute( stdoutHandle, _textAttribute ); } HANDLE stdoutHandle; WORD originalAttributes; }; IColourImpl* platformColourInstance() { static Win32ColourImpl s_instance; return &s_instance; } } // end anon namespace } // end namespace Catch #elif defined( CATCH_CONFIG_COLOUR_ANSI ) ////////////////////////////////////// #include namespace Catch { namespace { // use POSIX/ ANSI console terminal codes // Thanks to Adam Strzelecki for original contribution // (http://github.com/nanoant) // https://github.com/philsquared/Catch/pull/131 class PosixColourImpl : public IColourImpl { public: virtual void use( Colour::Code _colourCode ) { switch( _colourCode ) { case Colour::None: case Colour::White: return setColour( "[0m" ); case Colour::Red: return setColour( "[0;31m" ); case Colour::Green: return setColour( "[0;32m" ); case Colour::Blue: return setColour( "[0:34m" ); case Colour::Cyan: return setColour( "[0;36m" ); case Colour::Yellow: return setColour( "[0;33m" ); case Colour::Grey: return setColour( "[1;30m" ); case Colour::LightGrey: return setColour( "[0;37m" ); case Colour::BrightRed: return setColour( "[1;31m" ); case Colour::BrightGreen: return setColour( "[1;32m" ); case Colour::BrightWhite: return setColour( "[1;37m" ); case Colour::Bright: throw std::logic_error( "not a colour" ); } } static IColourImpl* instance() { static PosixColourImpl s_instance; return &s_instance; } private: void setColour( const char* _escapeCode ) { Catch::cout() << '\033' << _escapeCode; } }; IColourImpl* platformColourInstance() { Ptr config = getCurrentContext().getConfig(); return (config && config->forceColour()) || isatty(STDOUT_FILENO) ? PosixColourImpl::instance() : NoColourImpl::instance(); } } // end anon namespace } // end namespace Catch #else // not Windows or ANSI /////////////////////////////////////////////// namespace Catch { static IColourImpl* platformColourInstance() { return NoColourImpl::instance(); } } // end namespace Catch #endif // Windows/ ANSI/ None namespace Catch { Colour::Colour( Code _colourCode ) : m_moved( false ) { use( _colourCode ); } Colour::Colour( Colour const& _other ) : m_moved( false ) { const_cast( _other ).m_moved = true; } Colour::~Colour(){ if( !m_moved ) use( None ); } void Colour::use( Code _colourCode ) { static IColourImpl* impl = isDebuggerActive() ? NoColourImpl::instance() : platformColourInstance(); impl->use( _colourCode ); } } // end namespace Catch // #included from: catch_generators_impl.hpp #define TWOBLUECUBES_CATCH_GENERATORS_IMPL_HPP_INCLUDED #include #include #include namespace Catch { struct GeneratorInfo : IGeneratorInfo { GeneratorInfo( std::size_t size ) : m_size( size ), m_currentIndex( 0 ) {} bool moveNext() { if( ++m_currentIndex == m_size ) { m_currentIndex = 0; return false; } return true; } std::size_t getCurrentIndex() const { return m_currentIndex; } std::size_t m_size; std::size_t m_currentIndex; }; /////////////////////////////////////////////////////////////////////////// class GeneratorsForTest : public IGeneratorsForTest { public: ~GeneratorsForTest() { deleteAll( m_generatorsInOrder ); } IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) { std::map::const_iterator it = m_generatorsByName.find( fileInfo ); if( it == m_generatorsByName.end() ) { IGeneratorInfo* info = new GeneratorInfo( size ); m_generatorsByName.insert( std::make_pair( fileInfo, info ) ); m_generatorsInOrder.push_back( info ); return *info; } return *it->second; } bool moveNext() { std::vector::const_iterator it = m_generatorsInOrder.begin(); std::vector::const_iterator itEnd = m_generatorsInOrder.end(); for(; it != itEnd; ++it ) { if( (*it)->moveNext() ) return true; } return false; } private: std::map m_generatorsByName; std::vector m_generatorsInOrder; }; IGeneratorsForTest* createGeneratorsForTest() { return new GeneratorsForTest(); } } // end namespace Catch // #included from: catch_assertionresult.hpp #define TWOBLUECUBES_CATCH_ASSERTIONRESULT_HPP_INCLUDED namespace Catch { AssertionInfo::AssertionInfo( std::string const& _macroName, SourceLineInfo const& _lineInfo, std::string const& _capturedExpression, ResultDisposition::Flags _resultDisposition ) : macroName( _macroName ), lineInfo( _lineInfo ), capturedExpression( _capturedExpression ), resultDisposition( _resultDisposition ) {} AssertionResult::AssertionResult() {} AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data ) : m_info( info ), m_resultData( data ) {} AssertionResult::~AssertionResult() {} // Result was a success bool AssertionResult::succeeded() const { return Catch::isOk( m_resultData.resultType ); } // Result was a success, or failure is suppressed bool AssertionResult::isOk() const { return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition ); } ResultWas::OfType AssertionResult::getResultType() const { return m_resultData.resultType; } bool AssertionResult::hasExpression() const { return !m_info.capturedExpression.empty(); } bool AssertionResult::hasMessage() const { return !m_resultData.message.empty(); } std::string AssertionResult::getExpression() const { if( isFalseTest( m_info.resultDisposition ) ) return "!" + m_info.capturedExpression; else return m_info.capturedExpression; } std::string AssertionResult::getExpressionInMacro() const { if( m_info.macroName.empty() ) return m_info.capturedExpression; else return m_info.macroName + "( " + m_info.capturedExpression + " )"; } bool AssertionResult::hasExpandedExpression() const { return hasExpression() && getExpandedExpression() != getExpression(); } std::string AssertionResult::getExpandedExpression() const { return m_resultData.reconstructedExpression; } std::string AssertionResult::getMessage() const { return m_resultData.message; } SourceLineInfo AssertionResult::getSourceInfo() const { return m_info.lineInfo; } std::string AssertionResult::getTestMacroName() const { return m_info.macroName; } } // end namespace Catch // #included from: catch_test_case_info.hpp #define TWOBLUECUBES_CATCH_TEST_CASE_INFO_HPP_INCLUDED namespace Catch { inline TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) { if( startsWith( tag, "." ) || tag == "hide" || tag == "!hide" ) return TestCaseInfo::IsHidden; else if( tag == "!throws" ) return TestCaseInfo::Throws; else if( tag == "!shouldfail" ) return TestCaseInfo::ShouldFail; else if( tag == "!mayfail" ) return TestCaseInfo::MayFail; else return TestCaseInfo::None; } inline bool isReservedTag( std::string const& tag ) { return parseSpecialTag( tag ) == TestCaseInfo::None && tag.size() > 0 && !isalnum( tag[0] ); } inline void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) { if( isReservedTag( tag ) ) { { Colour colourGuard( Colour::Red ); Catch::cerr() << "Tag name [" << tag << "] not allowed.\n" << "Tag names starting with non alpha-numeric characters are reserved\n"; } { Colour colourGuard( Colour::FileName ); Catch::cerr() << _lineInfo << std::endl; } exit(1); } } TestCase makeTestCase( ITestCase* _testCase, std::string const& _className, std::string const& _name, std::string const& _descOrTags, SourceLineInfo const& _lineInfo ) { bool isHidden( startsWith( _name, "./" ) ); // Legacy support // Parse out tags std::set tags; std::string desc, tag; bool inTag = false; for( std::size_t i = 0; i < _descOrTags.size(); ++i ) { char c = _descOrTags[i]; if( !inTag ) { if( c == '[' ) inTag = true; else desc += c; } else { if( c == ']' ) { TestCaseInfo::SpecialProperties prop = parseSpecialTag( tag ); if( prop == TestCaseInfo::IsHidden ) isHidden = true; else if( prop == TestCaseInfo::None ) enforceNotReservedTag( tag, _lineInfo ); tags.insert( tag ); tag.clear(); inTag = false; } else tag += c; } } if( isHidden ) { tags.insert( "hide" ); tags.insert( "." ); } TestCaseInfo info( _name, _className, desc, tags, _lineInfo ); return TestCase( _testCase, info ); } TestCaseInfo::TestCaseInfo( std::string const& _name, std::string const& _className, std::string const& _description, std::set const& _tags, SourceLineInfo const& _lineInfo ) : name( _name ), className( _className ), description( _description ), tags( _tags ), lineInfo( _lineInfo ), properties( None ) { std::ostringstream oss; for( std::set::const_iterator it = _tags.begin(), itEnd = _tags.end(); it != itEnd; ++it ) { oss << "[" << *it << "]"; std::string lcaseTag = toLower( *it ); properties = static_cast( properties | parseSpecialTag( lcaseTag ) ); lcaseTags.insert( lcaseTag ); } tagsAsString = oss.str(); } TestCaseInfo::TestCaseInfo( TestCaseInfo const& other ) : name( other.name ), className( other.className ), description( other.description ), tags( other.tags ), lcaseTags( other.lcaseTags ), tagsAsString( other.tagsAsString ), lineInfo( other.lineInfo ), properties( other.properties ) {} bool TestCaseInfo::isHidden() const { return ( properties & IsHidden ) != 0; } bool TestCaseInfo::throws() const { return ( properties & Throws ) != 0; } bool TestCaseInfo::okToFail() const { return ( properties & (ShouldFail | MayFail ) ) != 0; } bool TestCaseInfo::expectedToFail() const { return ( properties & (ShouldFail ) ) != 0; } TestCase::TestCase( ITestCase* testCase, TestCaseInfo const& info ) : TestCaseInfo( info ), test( testCase ) {} TestCase::TestCase( TestCase const& other ) : TestCaseInfo( other ), test( other.test ) {} TestCase TestCase::withName( std::string const& _newName ) const { TestCase other( *this ); other.name = _newName; return other; } void TestCase::swap( TestCase& other ) { test.swap( other.test ); name.swap( other.name ); className.swap( other.className ); description.swap( other.description ); tags.swap( other.tags ); lcaseTags.swap( other.lcaseTags ); tagsAsString.swap( other.tagsAsString ); std::swap( TestCaseInfo::properties, static_cast( other ).properties ); std::swap( lineInfo, other.lineInfo ); } void TestCase::invoke() const { test->invoke(); } bool TestCase::operator == ( TestCase const& other ) const { return test.get() == other.test.get() && name == other.name && className == other.className; } bool TestCase::operator < ( TestCase const& other ) const { return name < other.name; } TestCase& TestCase::operator = ( TestCase const& other ) { TestCase temp( other ); swap( temp ); return *this; } TestCaseInfo const& TestCase::getTestCaseInfo() const { return *this; } } // end namespace Catch // #included from: catch_version.hpp #define TWOBLUECUBES_CATCH_VERSION_HPP_INCLUDED namespace Catch { // These numbers are maintained by a script Version libraryVersion( 1, 1, 3, "master" ); } // #included from: catch_message.hpp #define TWOBLUECUBES_CATCH_MESSAGE_HPP_INCLUDED namespace Catch { MessageInfo::MessageInfo( std::string const& _macroName, SourceLineInfo const& _lineInfo, ResultWas::OfType _type ) : macroName( _macroName ), lineInfo( _lineInfo ), type( _type ), sequence( ++globalCount ) {} // This may need protecting if threading support is added unsigned int MessageInfo::globalCount = 0; //////////////////////////////////////////////////////////////////////////// ScopedMessage::ScopedMessage( MessageBuilder const& builder ) : m_info( builder.m_info ) { m_info.message = builder.m_stream.str(); getResultCapture().pushScopedMessage( m_info ); } ScopedMessage::ScopedMessage( ScopedMessage const& other ) : m_info( other.m_info ) {} ScopedMessage::~ScopedMessage() { getResultCapture().popScopedMessage( m_info ); } } // end namespace Catch // #included from: catch_legacy_reporter_adapter.hpp #define TWOBLUECUBES_CATCH_LEGACY_REPORTER_ADAPTER_HPP_INCLUDED // #included from: catch_legacy_reporter_adapter.h #define TWOBLUECUBES_CATCH_LEGACY_REPORTER_ADAPTER_H_INCLUDED namespace Catch { // Deprecated struct IReporter : IShared { virtual ~IReporter(); virtual bool shouldRedirectStdout() const = 0; virtual void StartTesting() = 0; virtual void EndTesting( Totals const& totals ) = 0; virtual void StartGroup( std::string const& groupName ) = 0; virtual void EndGroup( std::string const& groupName, Totals const& totals ) = 0; virtual void StartTestCase( TestCaseInfo const& testInfo ) = 0; virtual void EndTestCase( TestCaseInfo const& testInfo, Totals const& totals, std::string const& stdOut, std::string const& stdErr ) = 0; virtual void StartSection( std::string const& sectionName, std::string const& description ) = 0; virtual void EndSection( std::string const& sectionName, Counts const& assertions ) = 0; virtual void NoAssertionsInSection( std::string const& sectionName ) = 0; virtual void NoAssertionsInTestCase( std::string const& testName ) = 0; virtual void Aborted() = 0; virtual void Result( AssertionResult const& result ) = 0; }; class LegacyReporterAdapter : public SharedImpl { public: LegacyReporterAdapter( Ptr const& legacyReporter ); virtual ~LegacyReporterAdapter(); virtual ReporterPreferences getPreferences() const; virtual void noMatchingTestCases( std::string const& ); virtual void testRunStarting( TestRunInfo const& ); virtual void testGroupStarting( GroupInfo const& groupInfo ); virtual void testCaseStarting( TestCaseInfo const& testInfo ); virtual void sectionStarting( SectionInfo const& sectionInfo ); virtual void assertionStarting( AssertionInfo const& ); virtual bool assertionEnded( AssertionStats const& assertionStats ); virtual void sectionEnded( SectionStats const& sectionStats ); virtual void testCaseEnded( TestCaseStats const& testCaseStats ); virtual void testGroupEnded( TestGroupStats const& testGroupStats ); virtual void testRunEnded( TestRunStats const& testRunStats ); virtual void skipTest( TestCaseInfo const& ); private: Ptr m_legacyReporter; }; } namespace Catch { LegacyReporterAdapter::LegacyReporterAdapter( Ptr const& legacyReporter ) : m_legacyReporter( legacyReporter ) {} LegacyReporterAdapter::~LegacyReporterAdapter() {} ReporterPreferences LegacyReporterAdapter::getPreferences() const { ReporterPreferences prefs; prefs.shouldRedirectStdOut = m_legacyReporter->shouldRedirectStdout(); return prefs; } void LegacyReporterAdapter::noMatchingTestCases( std::string const& ) {} void LegacyReporterAdapter::testRunStarting( TestRunInfo const& ) { m_legacyReporter->StartTesting(); } void LegacyReporterAdapter::testGroupStarting( GroupInfo const& groupInfo ) { m_legacyReporter->StartGroup( groupInfo.name ); } void LegacyReporterAdapter::testCaseStarting( TestCaseInfo const& testInfo ) { m_legacyReporter->StartTestCase( testInfo ); } void LegacyReporterAdapter::sectionStarting( SectionInfo const& sectionInfo ) { m_legacyReporter->StartSection( sectionInfo.name, sectionInfo.description ); } void LegacyReporterAdapter::assertionStarting( AssertionInfo const& ) { // Not on legacy interface } bool LegacyReporterAdapter::assertionEnded( AssertionStats const& assertionStats ) { if( assertionStats.assertionResult.getResultType() != ResultWas::Ok ) { for( std::vector::const_iterator it = assertionStats.infoMessages.begin(), itEnd = assertionStats.infoMessages.end(); it != itEnd; ++it ) { if( it->type == ResultWas::Info ) { ResultBuilder rb( it->macroName.c_str(), it->lineInfo, "", ResultDisposition::Normal ); rb << it->message; rb.setResultType( ResultWas::Info ); AssertionResult result = rb.build(); m_legacyReporter->Result( result ); } } } m_legacyReporter->Result( assertionStats.assertionResult ); return true; } void LegacyReporterAdapter::sectionEnded( SectionStats const& sectionStats ) { if( sectionStats.missingAssertions ) m_legacyReporter->NoAssertionsInSection( sectionStats.sectionInfo.name ); m_legacyReporter->EndSection( sectionStats.sectionInfo.name, sectionStats.assertions ); } void LegacyReporterAdapter::testCaseEnded( TestCaseStats const& testCaseStats ) { m_legacyReporter->EndTestCase ( testCaseStats.testInfo, testCaseStats.totals, testCaseStats.stdOut, testCaseStats.stdErr ); } void LegacyReporterAdapter::testGroupEnded( TestGroupStats const& testGroupStats ) { if( testGroupStats.aborting ) m_legacyReporter->Aborted(); m_legacyReporter->EndGroup( testGroupStats.groupInfo.name, testGroupStats.totals ); } void LegacyReporterAdapter::testRunEnded( TestRunStats const& testRunStats ) { m_legacyReporter->EndTesting( testRunStats.totals ); } void LegacyReporterAdapter::skipTest( TestCaseInfo const& ) { } } // #included from: catch_timer.hpp #ifdef __clang__ #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++11-long-long" #endif #ifdef CATCH_PLATFORM_WINDOWS #include #else #include #endif namespace Catch { namespace { #ifdef CATCH_PLATFORM_WINDOWS uint64_t getCurrentTicks() { static uint64_t hz=0, hzo=0; if (!hz) { QueryPerformanceFrequency( reinterpret_cast( &hz ) ); QueryPerformanceCounter( reinterpret_cast( &hzo ) ); } uint64_t t; QueryPerformanceCounter( reinterpret_cast( &t ) ); return ((t-hzo)*1000000)/hz; } #else uint64_t getCurrentTicks() { timeval t; gettimeofday(&t,NULL); return static_cast( t.tv_sec ) * 1000000ull + static_cast( t.tv_usec ); } #endif } void Timer::start() { m_ticks = getCurrentTicks(); } unsigned int Timer::getElapsedMicroseconds() const { return static_cast(getCurrentTicks() - m_ticks); } unsigned int Timer::getElapsedMilliseconds() const { return static_cast(getElapsedMicroseconds()/1000); } double Timer::getElapsedSeconds() const { return getElapsedMicroseconds()/1000000.0; } } // namespace Catch #ifdef __clang__ #pragma clang diagnostic pop #endif // #included from: catch_common.hpp #define TWOBLUECUBES_CATCH_COMMON_HPP_INCLUDED namespace Catch { bool startsWith( std::string const& s, std::string const& prefix ) { return s.size() >= prefix.size() && s.substr( 0, prefix.size() ) == prefix; } bool endsWith( std::string const& s, std::string const& suffix ) { return s.size() >= suffix.size() && s.substr( s.size()-suffix.size(), suffix.size() ) == suffix; } bool contains( std::string const& s, std::string const& infix ) { return s.find( infix ) != std::string::npos; } void toLowerInPlace( std::string& s ) { std::transform( s.begin(), s.end(), s.begin(), ::tolower ); } std::string toLower( std::string const& s ) { std::string lc = s; toLowerInPlace( lc ); return lc; } std::string trim( std::string const& str ) { static char const* whitespaceChars = "\n\r\t "; std::string::size_type start = str.find_first_not_of( whitespaceChars ); std::string::size_type end = str.find_last_not_of( whitespaceChars ); return start != std::string::npos ? str.substr( start, 1+end-start ) : ""; } bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) { bool replaced = false; std::size_t i = str.find( replaceThis ); while( i != std::string::npos ) { replaced = true; str = str.substr( 0, i ) + withThis + str.substr( i+replaceThis.size() ); if( i < str.size()-withThis.size() ) i = str.find( replaceThis, i+withThis.size() ); else i = std::string::npos; } return replaced; } pluralise::pluralise( std::size_t count, std::string const& label ) : m_count( count ), m_label( label ) {} std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) { os << pluraliser.m_count << " " << pluraliser.m_label; if( pluraliser.m_count != 1 ) os << "s"; return os; } SourceLineInfo::SourceLineInfo() : line( 0 ){} SourceLineInfo::SourceLineInfo( char const* _file, std::size_t _line ) : file( _file ), line( _line ) {} SourceLineInfo::SourceLineInfo( SourceLineInfo const& other ) : file( other.file ), line( other.line ) {} bool SourceLineInfo::empty() const { return file.empty(); } bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const { return line == other.line && file == other.file; } bool SourceLineInfo::operator < ( SourceLineInfo const& other ) const { return line < other.line || ( line == other.line && file < other.file ); } std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) { #ifndef __GNUG__ os << info.file << "(" << info.line << ")"; #else os << info.file << ":" << info.line; #endif return os; } void throwLogicError( std::string const& message, SourceLineInfo const& locationInfo ) { std::ostringstream oss; oss << locationInfo << ": Internal Catch error: '" << message << "'"; if( alwaysTrue() ) throw std::logic_error( oss.str() ); } } // #included from: catch_section.hpp #define TWOBLUECUBES_CATCH_SECTION_HPP_INCLUDED namespace Catch { SectionInfo::SectionInfo ( SourceLineInfo const& _lineInfo, std::string const& _name, std::string const& _description ) : name( _name ), description( _description ), lineInfo( _lineInfo ) {} Section::Section( SectionInfo const& info ) : m_info( info ), m_sectionIncluded( getResultCapture().sectionStarted( m_info, m_assertions ) ) { m_timer.start(); } Section::~Section() { if( m_sectionIncluded ) getResultCapture().sectionEnded( m_info, m_assertions, m_timer.getElapsedSeconds() ); } // This indicates whether the section should be executed or not Section::operator bool() const { return m_sectionIncluded; } } // end namespace Catch // #included from: catch_debugger.hpp #define TWOBLUECUBES_CATCH_DEBUGGER_HPP_INCLUDED #include #ifdef CATCH_PLATFORM_MAC #include #include #include #include #include namespace Catch{ // The following function is taken directly from the following technical note: // http://developer.apple.com/library/mac/#qa/qa2004/qa1361.html // Returns true if the current process is being debugged (either // running under the debugger or has a debugger attached post facto). bool isDebuggerActive(){ int mib[4]; struct kinfo_proc info; size_t size; // Initialize the flags so that, if sysctl fails for some bizarre // reason, we get a predictable result. info.kp_proc.p_flag = 0; // Initialize mib, which tells sysctl the info we want, in this case // we're looking for information about a specific process ID. mib[0] = CTL_KERN; mib[1] = KERN_PROC; mib[2] = KERN_PROC_PID; mib[3] = getpid(); // Call sysctl. size = sizeof(info); if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, NULL, 0) != 0 ) { Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n" << std::endl; return false; } // We're being debugged if the P_TRACED flag is set. return ( (info.kp_proc.p_flag & P_TRACED) != 0 ); } } // namespace Catch #elif defined(_MSC_VER) extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent(); namespace Catch { bool isDebuggerActive() { return IsDebuggerPresent() != 0; } } #elif defined(__MINGW32__) extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent(); namespace Catch { bool isDebuggerActive() { return IsDebuggerPresent() != 0; } } #else namespace Catch { inline bool isDebuggerActive() { return false; } } #endif // Platform #ifdef CATCH_PLATFORM_WINDOWS extern "C" __declspec(dllimport) void __stdcall OutputDebugStringA( const char* ); namespace Catch { void writeToDebugConsole( std::string const& text ) { ::OutputDebugStringA( text.c_str() ); } } #else namespace Catch { void writeToDebugConsole( std::string const& text ) { // !TBD: Need a version for Mac/ XCode and other IDEs Catch::cout() << text; } } #endif // Platform // #included from: catch_tostring.hpp #define TWOBLUECUBES_CATCH_TOSTRING_HPP_INCLUDED namespace Catch { namespace Detail { std::string unprintableString = "{?}"; namespace { struct Endianness { enum Arch { Big, Little }; static Arch which() { union _{ int asInt; char asChar[sizeof (int)]; } u; u.asInt = 1; return ( u.asChar[sizeof(int)-1] == 1 ) ? Big : Little; } }; } std::string rawMemoryToString( const void *object, std::size_t size ) { // Reverse order for little endian architectures int i = 0, end = static_cast( size ), inc = 1; if( Endianness::which() == Endianness::Little ) { i = end-1; end = inc = -1; } unsigned char const *bytes = static_cast(object); std::ostringstream os; os << "0x" << std::setfill('0') << std::hex; for( ; i != end; i += inc ) os << std::setw(2) << static_cast(bytes[i]); return os.str(); } } std::string toString( std::string const& value ) { std::string s = value; if( getCurrentContext().getConfig()->showInvisibles() ) { for(size_t i = 0; i < s.size(); ++i ) { std::string subs; switch( s[i] ) { case '\n': subs = "\\n"; break; case '\t': subs = "\\t"; break; default: break; } if( !subs.empty() ) { s = s.substr( 0, i ) + subs + s.substr( i+1 ); ++i; } } } return "\"" + s + "\""; } std::string toString( std::wstring const& value ) { std::string s; s.reserve( value.size() ); for(size_t i = 0; i < value.size(); ++i ) s += value[i] <= 0xff ? static_cast( value[i] ) : '?'; return Catch::toString( s ); } std::string toString( const char* const value ) { return value ? Catch::toString( std::string( value ) ) : std::string( "{null string}" ); } std::string toString( char* const value ) { return Catch::toString( static_cast( value ) ); } std::string toString( const wchar_t* const value ) { return value ? Catch::toString( std::wstring(value) ) : std::string( "{null string}" ); } std::string toString( wchar_t* const value ) { return Catch::toString( static_cast( value ) ); } std::string toString( int value ) { std::ostringstream oss; oss << value; if( value >= 255 ) oss << " (0x" << std::hex << value << ")"; return oss.str(); } std::string toString( unsigned long value ) { std::ostringstream oss; oss << value; if( value >= 255 ) oss << " (0x" << std::hex << value << ")"; return oss.str(); } std::string toString( unsigned int value ) { return Catch::toString( static_cast( value ) ); } template std::string fpToString( T value, int precision ) { std::ostringstream oss; oss << std::setprecision( precision ) << std::fixed << value; std::string d = oss.str(); std::size_t i = d.find_last_not_of( '0' ); if( i != std::string::npos && i != d.size()-1 ) { if( d[i] == '.' ) i++; d = d.substr( 0, i+1 ); } return d; } std::string toString( const double value ) { return fpToString( value, 10 ); } std::string toString( const float value ) { return fpToString( value, 5 ) + "f"; } std::string toString( bool value ) { return value ? "true" : "false"; } std::string toString( char value ) { return value < ' ' ? toString( static_cast( value ) ) : Detail::makeString( value ); } std::string toString( signed char value ) { return toString( static_cast( value ) ); } std::string toString( unsigned char value ) { return toString( static_cast( value ) ); } #ifdef CATCH_CONFIG_CPP11_NULLPTR std::string toString( std::nullptr_t ) { return "nullptr"; } #endif #ifdef __OBJC__ std::string toString( NSString const * const& nsstring ) { if( !nsstring ) return "nil"; return "@" + toString([nsstring UTF8String]); } std::string toString( NSString * CATCH_ARC_STRONG const& nsstring ) { if( !nsstring ) return "nil"; return "@" + toString([nsstring UTF8String]); } std::string toString( NSObject* const& nsObject ) { return toString( [nsObject description] ); } #endif } // end namespace Catch // #included from: catch_result_builder.hpp #define TWOBLUECUBES_CATCH_RESULT_BUILDER_HPP_INCLUDED namespace Catch { ResultBuilder::ResultBuilder( char const* macroName, SourceLineInfo const& lineInfo, char const* capturedExpression, ResultDisposition::Flags resultDisposition ) : m_assertionInfo( macroName, lineInfo, capturedExpression, resultDisposition ), m_shouldDebugBreak( false ), m_shouldThrow( false ) {} ResultBuilder& ResultBuilder::setResultType( ResultWas::OfType result ) { m_data.resultType = result; return *this; } ResultBuilder& ResultBuilder::setResultType( bool result ) { m_data.resultType = result ? ResultWas::Ok : ResultWas::ExpressionFailed; return *this; } ResultBuilder& ResultBuilder::setLhs( std::string const& lhs ) { m_exprComponents.lhs = lhs; return *this; } ResultBuilder& ResultBuilder::setRhs( std::string const& rhs ) { m_exprComponents.rhs = rhs; return *this; } ResultBuilder& ResultBuilder::setOp( std::string const& op ) { m_exprComponents.op = op; return *this; } void ResultBuilder::endExpression() { m_exprComponents.testFalse = isFalseTest( m_assertionInfo.resultDisposition ); captureExpression(); } void ResultBuilder::useActiveException( ResultDisposition::Flags resultDisposition ) { m_assertionInfo.resultDisposition = resultDisposition; m_stream.oss << Catch::translateActiveException(); captureResult( ResultWas::ThrewException ); } void ResultBuilder::captureResult( ResultWas::OfType resultType ) { setResultType( resultType ); captureExpression(); } void ResultBuilder::captureExpression() { AssertionResult result = build(); getResultCapture().assertionEnded( result ); if( !result.isOk() ) { if( getCurrentContext().getConfig()->shouldDebugBreak() ) m_shouldDebugBreak = true; if( getCurrentContext().getRunner()->aborting() || (m_assertionInfo.resultDisposition & ResultDisposition::Normal) ) m_shouldThrow = true; } } void ResultBuilder::react() { if( m_shouldThrow ) throw Catch::TestFailureException(); } bool ResultBuilder::shouldDebugBreak() const { return m_shouldDebugBreak; } bool ResultBuilder::allowThrows() const { return getCurrentContext().getConfig()->allowThrows(); } AssertionResult ResultBuilder::build() const { assert( m_data.resultType != ResultWas::Unknown ); AssertionResultData data = m_data; // Flip bool results if testFalse is set if( m_exprComponents.testFalse ) { if( data.resultType == ResultWas::Ok ) data.resultType = ResultWas::ExpressionFailed; else if( data.resultType == ResultWas::ExpressionFailed ) data.resultType = ResultWas::Ok; } data.message = m_stream.oss.str(); data.reconstructedExpression = reconstructExpression(); if( m_exprComponents.testFalse ) { if( m_exprComponents.op == "" ) data.reconstructedExpression = "!" + data.reconstructedExpression; else data.reconstructedExpression = "!(" + data.reconstructedExpression + ")"; } return AssertionResult( m_assertionInfo, data ); } std::string ResultBuilder::reconstructExpression() const { if( m_exprComponents.op == "" ) return m_exprComponents.lhs.empty() ? m_assertionInfo.capturedExpression : m_exprComponents.op + m_exprComponents.lhs; else if( m_exprComponents.op == "matches" ) return m_exprComponents.lhs + " " + m_exprComponents.rhs; else if( m_exprComponents.op != "!" ) { if( m_exprComponents.lhs.size() + m_exprComponents.rhs.size() < 40 && m_exprComponents.lhs.find("\n") == std::string::npos && m_exprComponents.rhs.find("\n") == std::string::npos ) return m_exprComponents.lhs + " " + m_exprComponents.op + " " + m_exprComponents.rhs; else return m_exprComponents.lhs + "\n" + m_exprComponents.op + "\n" + m_exprComponents.rhs; } else return "{can't expand - use " + m_assertionInfo.macroName + "_FALSE( " + m_assertionInfo.capturedExpression.substr(1) + " ) instead of " + m_assertionInfo.macroName + "( " + m_assertionInfo.capturedExpression + " ) for better diagnostics}"; } } // end namespace Catch // #included from: catch_tag_alias_registry.hpp #define TWOBLUECUBES_CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED // #included from: catch_tag_alias_registry.h #define TWOBLUECUBES_CATCH_TAG_ALIAS_REGISTRY_H_INCLUDED #include namespace Catch { class TagAliasRegistry : public ITagAliasRegistry { public: virtual ~TagAliasRegistry(); virtual Option find( std::string const& alias ) const; virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const; void add( char const* alias, char const* tag, SourceLineInfo const& lineInfo ); static TagAliasRegistry& get(); private: std::map m_registry; }; } // end namespace Catch #include #include namespace Catch { TagAliasRegistry::~TagAliasRegistry() {} Option TagAliasRegistry::find( std::string const& alias ) const { std::map::const_iterator it = m_registry.find( alias ); if( it != m_registry.end() ) return it->second; else return Option(); } std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const { std::string expandedTestSpec = unexpandedTestSpec; for( std::map::const_iterator it = m_registry.begin(), itEnd = m_registry.end(); it != itEnd; ++it ) { std::size_t pos = expandedTestSpec.find( it->first ); if( pos != std::string::npos ) { expandedTestSpec = expandedTestSpec.substr( 0, pos ) + it->second.tag + expandedTestSpec.substr( pos + it->first.size() ); } } return expandedTestSpec; } void TagAliasRegistry::add( char const* alias, char const* tag, SourceLineInfo const& lineInfo ) { if( !startsWith( alias, "[@" ) || !endsWith( alias, "]" ) ) { std::ostringstream oss; oss << "error: tag alias, \"" << alias << "\" is not of the form [@alias name].\n" << lineInfo; throw std::domain_error( oss.str().c_str() ); } if( !m_registry.insert( std::make_pair( alias, TagAlias( tag, lineInfo ) ) ).second ) { std::ostringstream oss; oss << "error: tag alias, \"" << alias << "\" already registered.\n" << "\tFirst seen at " << find(alias)->lineInfo << "\n" << "\tRedefined at " << lineInfo; throw std::domain_error( oss.str().c_str() ); } } TagAliasRegistry& TagAliasRegistry::get() { static TagAliasRegistry instance; return instance; } ITagAliasRegistry::~ITagAliasRegistry() {} ITagAliasRegistry const& ITagAliasRegistry::get() { return TagAliasRegistry::get(); } RegistrarForTagAliases::RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo ) { try { TagAliasRegistry::get().add( alias, tag, lineInfo ); } catch( std::exception& ex ) { Colour colourGuard( Colour::Red ); Catch::cerr() << ex.what() << std::endl; exit(1); } } } // end namespace Catch // #included from: ../reporters/catch_reporter_xml.hpp #define TWOBLUECUBES_CATCH_REPORTER_XML_HPP_INCLUDED // #included from: catch_reporter_bases.hpp #define TWOBLUECUBES_CATCH_REPORTER_BASES_HPP_INCLUDED #include namespace Catch { struct StreamingReporterBase : SharedImpl { StreamingReporterBase( ReporterConfig const& _config ) : m_config( _config.fullConfig() ), stream( _config.stream() ) {} virtual ~StreamingReporterBase(); virtual void noMatchingTestCases( std::string const& ) {} virtual void testRunStarting( TestRunInfo const& _testRunInfo ) { currentTestRunInfo = _testRunInfo; } virtual void testGroupStarting( GroupInfo const& _groupInfo ) { currentGroupInfo = _groupInfo; } virtual void testCaseStarting( TestCaseInfo const& _testInfo ) { currentTestCaseInfo = _testInfo; } virtual void sectionStarting( SectionInfo const& _sectionInfo ) { m_sectionStack.push_back( _sectionInfo ); } virtual void sectionEnded( SectionStats const& /* _sectionStats */ ) { m_sectionStack.pop_back(); } virtual void testCaseEnded( TestCaseStats const& /* _testCaseStats */ ) { currentTestCaseInfo.reset(); } virtual void testGroupEnded( TestGroupStats const& /* _testGroupStats */ ) { currentGroupInfo.reset(); } virtual void testRunEnded( TestRunStats const& /* _testRunStats */ ) { currentTestCaseInfo.reset(); currentGroupInfo.reset(); currentTestRunInfo.reset(); } virtual void skipTest( TestCaseInfo const& ) { // Don't do anything with this by default. // It can optionally be overridden in the derived class. } Ptr m_config; std::ostream& stream; LazyStat currentTestRunInfo; LazyStat currentGroupInfo; LazyStat currentTestCaseInfo; std::vector m_sectionStack; }; struct CumulativeReporterBase : SharedImpl { template struct Node : SharedImpl<> { explicit Node( T const& _value ) : value( _value ) {} virtual ~Node() {} typedef std::vector > ChildNodes; T value; ChildNodes children; }; struct SectionNode : SharedImpl<> { explicit SectionNode( SectionStats const& _stats ) : stats( _stats ) {} virtual ~SectionNode(); bool operator == ( SectionNode const& other ) const { return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo; } bool operator == ( Ptr const& other ) const { return operator==( *other ); } SectionStats stats; typedef std::vector > ChildSections; typedef std::vector Assertions; ChildSections childSections; Assertions assertions; std::string stdOut; std::string stdErr; }; struct BySectionInfo { BySectionInfo( SectionInfo const& other ) : m_other( other ) {} BySectionInfo( BySectionInfo const& other ) : m_other( other.m_other ) {} bool operator() ( Ptr const& node ) const { return node->stats.sectionInfo.lineInfo == m_other.lineInfo; } private: void operator=( BySectionInfo const& ); SectionInfo const& m_other; }; typedef Node TestCaseNode; typedef Node TestGroupNode; typedef Node TestRunNode; CumulativeReporterBase( ReporterConfig const& _config ) : m_config( _config.fullConfig() ), stream( _config.stream() ) {} ~CumulativeReporterBase(); virtual void testRunStarting( TestRunInfo const& ) {} virtual void testGroupStarting( GroupInfo const& ) {} virtual void testCaseStarting( TestCaseInfo const& ) {} virtual void sectionStarting( SectionInfo const& sectionInfo ) { SectionStats incompleteStats( sectionInfo, Counts(), 0, false ); Ptr node; if( m_sectionStack.empty() ) { if( !m_rootSection ) m_rootSection = new SectionNode( incompleteStats ); node = m_rootSection; } else { SectionNode& parentNode = *m_sectionStack.back(); SectionNode::ChildSections::const_iterator it = std::find_if( parentNode.childSections.begin(), parentNode.childSections.end(), BySectionInfo( sectionInfo ) ); if( it == parentNode.childSections.end() ) { node = new SectionNode( incompleteStats ); parentNode.childSections.push_back( node ); } else node = *it; } m_sectionStack.push_back( node ); m_deepestSection = node; } virtual void assertionStarting( AssertionInfo const& ) {} virtual bool assertionEnded( AssertionStats const& assertionStats ) { assert( !m_sectionStack.empty() ); SectionNode& sectionNode = *m_sectionStack.back(); sectionNode.assertions.push_back( assertionStats ); return true; } virtual void sectionEnded( SectionStats const& sectionStats ) { assert( !m_sectionStack.empty() ); SectionNode& node = *m_sectionStack.back(); node.stats = sectionStats; m_sectionStack.pop_back(); } virtual void testCaseEnded( TestCaseStats const& testCaseStats ) { Ptr node = new TestCaseNode( testCaseStats ); assert( m_sectionStack.size() == 0 ); node->children.push_back( m_rootSection ); m_testCases.push_back( node ); m_rootSection.reset(); assert( m_deepestSection ); m_deepestSection->stdOut = testCaseStats.stdOut; m_deepestSection->stdErr = testCaseStats.stdErr; } virtual void testGroupEnded( TestGroupStats const& testGroupStats ) { Ptr node = new TestGroupNode( testGroupStats ); node->children.swap( m_testCases ); m_testGroups.push_back( node ); } virtual void testRunEnded( TestRunStats const& testRunStats ) { Ptr node = new TestRunNode( testRunStats ); node->children.swap( m_testGroups ); m_testRuns.push_back( node ); testRunEndedCumulative(); } virtual void testRunEndedCumulative() = 0; virtual void skipTest( TestCaseInfo const& ) {} Ptr m_config; std::ostream& stream; std::vector m_assertions; std::vector > > m_sections; std::vector > m_testCases; std::vector > m_testGroups; std::vector > m_testRuns; Ptr m_rootSection; Ptr m_deepestSection; std::vector > m_sectionStack; }; template char const* getLineOfChars() { static char line[CATCH_CONFIG_CONSOLE_WIDTH] = {0}; if( !*line ) { memset( line, C, CATCH_CONFIG_CONSOLE_WIDTH-1 ); line[CATCH_CONFIG_CONSOLE_WIDTH-1] = 0; } return line; } } // end namespace Catch // #included from: ../internal/catch_reporter_registrars.hpp #define TWOBLUECUBES_CATCH_REPORTER_REGISTRARS_HPP_INCLUDED namespace Catch { template class LegacyReporterRegistrar { class ReporterFactory : public IReporterFactory { virtual IStreamingReporter* create( ReporterConfig const& config ) const { return new LegacyReporterAdapter( new T( config ) ); } virtual std::string getDescription() const { return T::getDescription(); } }; public: LegacyReporterRegistrar( std::string const& name ) { getMutableRegistryHub().registerReporter( name, new ReporterFactory() ); } }; template class ReporterRegistrar { class ReporterFactory : public IReporterFactory { // *** Please Note ***: // - If you end up here looking at a compiler error because it's trying to register // your custom reporter class be aware that the native reporter interface has changed // to IStreamingReporter. The "legacy" interface, IReporter, is still supported via // an adapter. Just use REGISTER_LEGACY_REPORTER to take advantage of the adapter. // However please consider updating to the new interface as the old one is now // deprecated and will probably be removed quite soon! // Please contact me via github if you have any questions at all about this. // In fact, ideally, please contact me anyway to let me know you've hit this - as I have // no idea who is actually using custom reporters at all (possibly no-one!). // The new interface is designed to minimise exposure to interface changes in the future. virtual IStreamingReporter* create( ReporterConfig const& config ) const { return new T( config ); } virtual std::string getDescription() const { return T::getDescription(); } }; public: ReporterRegistrar( std::string const& name ) { getMutableRegistryHub().registerReporter( name, new ReporterFactory() ); } }; } #define INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) \ namespace{ Catch::LegacyReporterRegistrar catch_internal_RegistrarFor##reporterType( name ); } #define INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType ) \ namespace{ Catch::ReporterRegistrar catch_internal_RegistrarFor##reporterType( name ); } // #included from: ../internal/catch_xmlwriter.hpp #define TWOBLUECUBES_CATCH_XMLWRITER_HPP_INCLUDED #include #include #include namespace Catch { class XmlWriter { public: class ScopedElement { public: ScopedElement( XmlWriter* writer ) : m_writer( writer ) {} ScopedElement( ScopedElement const& other ) : m_writer( other.m_writer ){ other.m_writer = NULL; } ~ScopedElement() { if( m_writer ) m_writer->endElement(); } ScopedElement& writeText( std::string const& text, bool indent = true ) { m_writer->writeText( text, indent ); return *this; } template ScopedElement& writeAttribute( std::string const& name, T const& attribute ) { m_writer->writeAttribute( name, attribute ); return *this; } private: mutable XmlWriter* m_writer; }; XmlWriter() : m_tagIsOpen( false ), m_needsNewline( false ), m_os( &Catch::cout() ) {} XmlWriter( std::ostream& os ) : m_tagIsOpen( false ), m_needsNewline( false ), m_os( &os ) {} ~XmlWriter() { while( !m_tags.empty() ) endElement(); } XmlWriter& startElement( std::string const& name ) { ensureTagClosed(); newlineIfNecessary(); stream() << m_indent << "<" << name; m_tags.push_back( name ); m_indent += " "; m_tagIsOpen = true; return *this; } ScopedElement scopedElement( std::string const& name ) { ScopedElement scoped( this ); startElement( name ); return scoped; } XmlWriter& endElement() { newlineIfNecessary(); m_indent = m_indent.substr( 0, m_indent.size()-2 ); if( m_tagIsOpen ) { stream() << "/>\n"; m_tagIsOpen = false; } else { stream() << m_indent << "\n"; } m_tags.pop_back(); return *this; } XmlWriter& writeAttribute( std::string const& name, std::string const& attribute ) { if( !name.empty() && !attribute.empty() ) { stream() << " " << name << "=\""; writeEncodedText( attribute ); stream() << "\""; } return *this; } XmlWriter& writeAttribute( std::string const& name, bool attribute ) { stream() << " " << name << "=\"" << ( attribute ? "true" : "false" ) << "\""; return *this; } template XmlWriter& writeAttribute( std::string const& name, T const& attribute ) { if( !name.empty() ) stream() << " " << name << "=\"" << attribute << "\""; return *this; } XmlWriter& writeText( std::string const& text, bool indent = true ) { if( !text.empty() ){ bool tagWasOpen = m_tagIsOpen; ensureTagClosed(); if( tagWasOpen && indent ) stream() << m_indent; writeEncodedText( text ); m_needsNewline = true; } return *this; } XmlWriter& writeComment( std::string const& text ) { ensureTagClosed(); stream() << m_indent << ""; m_needsNewline = true; return *this; } XmlWriter& writeBlankLine() { ensureTagClosed(); stream() << "\n"; return *this; } void setStream( std::ostream& os ) { m_os = &os; } private: XmlWriter( XmlWriter const& ); void operator=( XmlWriter const& ); std::ostream& stream() { return *m_os; } void ensureTagClosed() { if( m_tagIsOpen ) { stream() << ">\n"; m_tagIsOpen = false; } } void newlineIfNecessary() { if( m_needsNewline ) { stream() << "\n"; m_needsNewline = false; } } void writeEncodedText( std::string const& text ) { static const char* charsToEncode = "<&\""; std::string mtext = text; std::string::size_type pos = mtext.find_first_of( charsToEncode ); while( pos != std::string::npos ) { stream() << mtext.substr( 0, pos ); switch( mtext[pos] ) { case '<': stream() << "<"; break; case '&': stream() << "&"; break; case '\"': stream() << """; break; } mtext = mtext.substr( pos+1 ); pos = mtext.find_first_of( charsToEncode ); } stream() << mtext; } bool m_tagIsOpen; bool m_needsNewline; std::vector m_tags; std::string m_indent; std::ostream* m_os; }; } namespace Catch { class XmlReporter : public StreamingReporterBase { public: XmlReporter( ReporterConfig const& _config ) : StreamingReporterBase( _config ), m_sectionDepth( 0 ) {} virtual ~XmlReporter(); static std::string getDescription() { return "Reports test results as an XML document"; } public: // StreamingReporterBase virtual ReporterPreferences getPreferences() const { ReporterPreferences prefs; prefs.shouldRedirectStdOut = true; return prefs; } virtual void noMatchingTestCases( std::string const& s ) { StreamingReporterBase::noMatchingTestCases( s ); } virtual void testRunStarting( TestRunInfo const& testInfo ) { StreamingReporterBase::testRunStarting( testInfo ); m_xml.setStream( stream ); m_xml.startElement( "Catch" ); if( !m_config->name().empty() ) m_xml.writeAttribute( "name", m_config->name() ); } virtual void testGroupStarting( GroupInfo const& groupInfo ) { StreamingReporterBase::testGroupStarting( groupInfo ); m_xml.startElement( "Group" ) .writeAttribute( "name", groupInfo.name ); } virtual void testCaseStarting( TestCaseInfo const& testInfo ) { StreamingReporterBase::testCaseStarting(testInfo); m_xml.startElement( "TestCase" ).writeAttribute( "name", trim( testInfo.name ) ); if ( m_config->showDurations() == ShowDurations::Always ) m_testCaseTimer.start(); } virtual void sectionStarting( SectionInfo const& sectionInfo ) { StreamingReporterBase::sectionStarting( sectionInfo ); if( m_sectionDepth++ > 0 ) { m_xml.startElement( "Section" ) .writeAttribute( "name", trim( sectionInfo.name ) ) .writeAttribute( "description", sectionInfo.description ); } } virtual void assertionStarting( AssertionInfo const& ) { } virtual bool assertionEnded( AssertionStats const& assertionStats ) { const AssertionResult& assertionResult = assertionStats.assertionResult; // Print any info messages in tags. if( assertionStats.assertionResult.getResultType() != ResultWas::Ok ) { for( std::vector::const_iterator it = assertionStats.infoMessages.begin(), itEnd = assertionStats.infoMessages.end(); it != itEnd; ++it ) { if( it->type == ResultWas::Info ) { m_xml.scopedElement( "Info" ) .writeText( it->message ); } else if ( it->type == ResultWas::Warning ) { m_xml.scopedElement( "Warning" ) .writeText( it->message ); } } } // Drop out if result was successful but we're not printing them. if( !m_config->includeSuccessfulResults() && isOk(assertionResult.getResultType()) ) return true; // Print the expression if there is one. if( assertionResult.hasExpression() ) { m_xml.startElement( "Expression" ) .writeAttribute( "success", assertionResult.succeeded() ) .writeAttribute( "type", assertionResult.getTestMacroName() ) .writeAttribute( "filename", assertionResult.getSourceInfo().file ) .writeAttribute( "line", assertionResult.getSourceInfo().line ); m_xml.scopedElement( "Original" ) .writeText( assertionResult.getExpression() ); m_xml.scopedElement( "Expanded" ) .writeText( assertionResult.getExpandedExpression() ); } // And... Print a result applicable to each result type. switch( assertionResult.getResultType() ) { case ResultWas::ThrewException: m_xml.scopedElement( "Exception" ) .writeAttribute( "filename", assertionResult.getSourceInfo().file ) .writeAttribute( "line", assertionResult.getSourceInfo().line ) .writeText( assertionResult.getMessage() ); break; case ResultWas::FatalErrorCondition: m_xml.scopedElement( "Fatal Error Condition" ) .writeAttribute( "filename", assertionResult.getSourceInfo().file ) .writeAttribute( "line", assertionResult.getSourceInfo().line ) .writeText( assertionResult.getMessage() ); break; case ResultWas::Info: m_xml.scopedElement( "Info" ) .writeText( assertionResult.getMessage() ); break; case ResultWas::Warning: // Warning will already have been written break; case ResultWas::ExplicitFailure: m_xml.scopedElement( "Failure" ) .writeText( assertionResult.getMessage() ); break; default: break; } if( assertionResult.hasExpression() ) m_xml.endElement(); return true; } virtual void sectionEnded( SectionStats const& sectionStats ) { StreamingReporterBase::sectionEnded( sectionStats ); if( --m_sectionDepth > 0 ) { XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" ); e.writeAttribute( "successes", sectionStats.assertions.passed ); e.writeAttribute( "failures", sectionStats.assertions.failed ); e.writeAttribute( "expectedFailures", sectionStats.assertions.failedButOk ); if ( m_config->showDurations() == ShowDurations::Always ) e.writeAttribute( "durationInSeconds", sectionStats.durationInSeconds ); m_xml.endElement(); } } virtual void testCaseEnded( TestCaseStats const& testCaseStats ) { StreamingReporterBase::testCaseEnded( testCaseStats ); XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" ); e.writeAttribute( "success", testCaseStats.totals.assertions.allOk() ); if ( m_config->showDurations() == ShowDurations::Always ) e.writeAttribute( "durationInSeconds", m_testCaseTimer.getElapsedSeconds() ); m_xml.endElement(); } virtual void testGroupEnded( TestGroupStats const& testGroupStats ) { StreamingReporterBase::testGroupEnded( testGroupStats ); // TODO: Check testGroupStats.aborting and act accordingly. m_xml.scopedElement( "OverallResults" ) .writeAttribute( "successes", testGroupStats.totals.assertions.passed ) .writeAttribute( "failures", testGroupStats.totals.assertions.failed ) .writeAttribute( "expectedFailures", testGroupStats.totals.assertions.failedButOk ); m_xml.endElement(); } virtual void testRunEnded( TestRunStats const& testRunStats ) { StreamingReporterBase::testRunEnded( testRunStats ); m_xml.scopedElement( "OverallResults" ) .writeAttribute( "successes", testRunStats.totals.assertions.passed ) .writeAttribute( "failures", testRunStats.totals.assertions.failed ) .writeAttribute( "expectedFailures", testRunStats.totals.assertions.failedButOk ); m_xml.endElement(); } private: Timer m_testCaseTimer; XmlWriter m_xml; int m_sectionDepth; }; INTERNAL_CATCH_REGISTER_REPORTER( "xml", XmlReporter ) } // end namespace Catch // #included from: ../reporters/catch_reporter_junit.hpp #define TWOBLUECUBES_CATCH_REPORTER_JUNIT_HPP_INCLUDED #include namespace Catch { class JunitReporter : public CumulativeReporterBase { public: JunitReporter( ReporterConfig const& _config ) : CumulativeReporterBase( _config ), xml( _config.stream() ) {} ~JunitReporter(); static std::string getDescription() { return "Reports test results in an XML format that looks like Ant's junitreport target"; } virtual void noMatchingTestCases( std::string const& /*spec*/ ) {} virtual ReporterPreferences getPreferences() const { ReporterPreferences prefs; prefs.shouldRedirectStdOut = true; return prefs; } virtual void testRunStarting( TestRunInfo const& runInfo ) { CumulativeReporterBase::testRunStarting( runInfo ); xml.startElement( "testsuites" ); } virtual void testGroupStarting( GroupInfo const& groupInfo ) { suiteTimer.start(); stdOutForSuite.str(""); stdErrForSuite.str(""); unexpectedExceptions = 0; CumulativeReporterBase::testGroupStarting( groupInfo ); } virtual bool assertionEnded( AssertionStats const& assertionStats ) { if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException ) unexpectedExceptions++; return CumulativeReporterBase::assertionEnded( assertionStats ); } virtual void testCaseEnded( TestCaseStats const& testCaseStats ) { stdOutForSuite << testCaseStats.stdOut; stdErrForSuite << testCaseStats.stdErr; CumulativeReporterBase::testCaseEnded( testCaseStats ); } virtual void testGroupEnded( TestGroupStats const& testGroupStats ) { double suiteTime = suiteTimer.getElapsedSeconds(); CumulativeReporterBase::testGroupEnded( testGroupStats ); writeGroup( *m_testGroups.back(), suiteTime ); } virtual void testRunEndedCumulative() { xml.endElement(); } void writeGroup( TestGroupNode const& groupNode, double suiteTime ) { XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" ); TestGroupStats const& stats = groupNode.value; xml.writeAttribute( "name", stats.groupInfo.name ); xml.writeAttribute( "errors", unexpectedExceptions ); xml.writeAttribute( "failures", stats.totals.assertions.failed-unexpectedExceptions ); xml.writeAttribute( "tests", stats.totals.assertions.total() ); xml.writeAttribute( "hostname", "tbd" ); // !TBD if( m_config->showDurations() == ShowDurations::Never ) xml.writeAttribute( "time", "" ); else xml.writeAttribute( "time", suiteTime ); xml.writeAttribute( "timestamp", "tbd" ); // !TBD // Write test cases for( TestGroupNode::ChildNodes::const_iterator it = groupNode.children.begin(), itEnd = groupNode.children.end(); it != itEnd; ++it ) writeTestCase( **it ); xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite.str() ), false ); xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite.str() ), false ); } void writeTestCase( TestCaseNode const& testCaseNode ) { TestCaseStats const& stats = testCaseNode.value; // All test cases have exactly one section - which represents the // test case itself. That section may have 0-n nested sections assert( testCaseNode.children.size() == 1 ); SectionNode const& rootSection = *testCaseNode.children.front(); std::string className = stats.testInfo.className; if( className.empty() ) { if( rootSection.childSections.empty() ) className = "global"; } writeSection( className, "", rootSection ); } void writeSection( std::string const& className, std::string const& rootName, SectionNode const& sectionNode ) { std::string name = trim( sectionNode.stats.sectionInfo.name ); if( !rootName.empty() ) name = rootName + "/" + name; if( !sectionNode.assertions.empty() || !sectionNode.stdOut.empty() || !sectionNode.stdErr.empty() ) { XmlWriter::ScopedElement e = xml.scopedElement( "testcase" ); if( className.empty() ) { xml.writeAttribute( "classname", name ); xml.writeAttribute( "name", "root" ); } else { xml.writeAttribute( "classname", className ); xml.writeAttribute( "name", name ); } xml.writeAttribute( "time", Catch::toString( sectionNode.stats.durationInSeconds ) ); writeAssertions( sectionNode ); if( !sectionNode.stdOut.empty() ) xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), false ); if( !sectionNode.stdErr.empty() ) xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), false ); } for( SectionNode::ChildSections::const_iterator it = sectionNode.childSections.begin(), itEnd = sectionNode.childSections.end(); it != itEnd; ++it ) if( className.empty() ) writeSection( name, "", **it ); else writeSection( className, name, **it ); } void writeAssertions( SectionNode const& sectionNode ) { for( SectionNode::Assertions::const_iterator it = sectionNode.assertions.begin(), itEnd = sectionNode.assertions.end(); it != itEnd; ++it ) writeAssertion( *it ); } void writeAssertion( AssertionStats const& stats ) { AssertionResult const& result = stats.assertionResult; if( !result.isOk() ) { std::string elementName; switch( result.getResultType() ) { case ResultWas::ThrewException: case ResultWas::FatalErrorCondition: elementName = "error"; break; case ResultWas::ExplicitFailure: elementName = "failure"; break; case ResultWas::ExpressionFailed: elementName = "failure"; break; case ResultWas::DidntThrowException: elementName = "failure"; break; // We should never see these here: case ResultWas::Info: case ResultWas::Warning: case ResultWas::Ok: case ResultWas::Unknown: case ResultWas::FailureBit: case ResultWas::Exception: elementName = "internalError"; break; } XmlWriter::ScopedElement e = xml.scopedElement( elementName ); xml.writeAttribute( "message", result.getExpandedExpression() ); xml.writeAttribute( "type", result.getTestMacroName() ); std::ostringstream oss; if( !result.getMessage().empty() ) oss << result.getMessage() << "\n"; for( std::vector::const_iterator it = stats.infoMessages.begin(), itEnd = stats.infoMessages.end(); it != itEnd; ++it ) if( it->type == ResultWas::Info ) oss << it->message << "\n"; oss << "at " << result.getSourceInfo(); xml.writeText( oss.str(), false ); } } XmlWriter xml; Timer suiteTimer; std::ostringstream stdOutForSuite; std::ostringstream stdErrForSuite; unsigned int unexpectedExceptions; }; INTERNAL_CATCH_REGISTER_REPORTER( "junit", JunitReporter ) } // end namespace Catch // #included from: ../reporters/catch_reporter_console.hpp #define TWOBLUECUBES_CATCH_REPORTER_CONSOLE_HPP_INCLUDED namespace Catch { struct ConsoleReporter : StreamingReporterBase { ConsoleReporter( ReporterConfig const& _config ) : StreamingReporterBase( _config ), m_headerPrinted( false ) {} virtual ~ConsoleReporter(); static std::string getDescription() { return "Reports test results as plain lines of text"; } virtual ReporterPreferences getPreferences() const { ReporterPreferences prefs; prefs.shouldRedirectStdOut = false; return prefs; } virtual void noMatchingTestCases( std::string const& spec ) { stream << "No test cases matched '" << spec << "'" << std::endl; } virtual void assertionStarting( AssertionInfo const& ) { } virtual bool assertionEnded( AssertionStats const& _assertionStats ) { AssertionResult const& result = _assertionStats.assertionResult; bool printInfoMessages = true; // Drop out if result was successful and we're not printing those if( !m_config->includeSuccessfulResults() && result.isOk() ) { if( result.getResultType() != ResultWas::Warning ) return false; printInfoMessages = false; } lazyPrint(); AssertionPrinter printer( stream, _assertionStats, printInfoMessages ); printer.print(); stream << std::endl; return true; } virtual void sectionStarting( SectionInfo const& _sectionInfo ) { m_headerPrinted = false; StreamingReporterBase::sectionStarting( _sectionInfo ); } virtual void sectionEnded( SectionStats const& _sectionStats ) { if( _sectionStats.missingAssertions ) { lazyPrint(); Colour colour( Colour::ResultError ); if( m_sectionStack.size() > 1 ) stream << "\nNo assertions in section"; else stream << "\nNo assertions in test case"; stream << " '" << _sectionStats.sectionInfo.name << "'\n" << std::endl; } if( m_headerPrinted ) { if( m_config->showDurations() == ShowDurations::Always ) stream << "Completed in " << _sectionStats.durationInSeconds << "s" << std::endl; m_headerPrinted = false; } else { if( m_config->showDurations() == ShowDurations::Always ) stream << _sectionStats.sectionInfo.name << " completed in " << _sectionStats.durationInSeconds << "s" << std::endl; } StreamingReporterBase::sectionEnded( _sectionStats ); } virtual void testCaseEnded( TestCaseStats const& _testCaseStats ) { StreamingReporterBase::testCaseEnded( _testCaseStats ); m_headerPrinted = false; } virtual void testGroupEnded( TestGroupStats const& _testGroupStats ) { if( currentGroupInfo.used ) { printSummaryDivider(); stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n"; printTotals( _testGroupStats.totals ); stream << "\n" << std::endl; } StreamingReporterBase::testGroupEnded( _testGroupStats ); } virtual void testRunEnded( TestRunStats const& _testRunStats ) { printTotalsDivider( _testRunStats.totals ); printTotals( _testRunStats.totals ); stream << std::endl; StreamingReporterBase::testRunEnded( _testRunStats ); } private: class AssertionPrinter { void operator= ( AssertionPrinter const& ); public: AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages ) : stream( _stream ), stats( _stats ), result( _stats.assertionResult ), colour( Colour::None ), message( result.getMessage() ), messages( _stats.infoMessages ), printInfoMessages( _printInfoMessages ) { switch( result.getResultType() ) { case ResultWas::Ok: colour = Colour::Success; passOrFail = "PASSED"; //if( result.hasMessage() ) if( _stats.infoMessages.size() == 1 ) messageLabel = "with message"; if( _stats.infoMessages.size() > 1 ) messageLabel = "with messages"; break; case ResultWas::ExpressionFailed: if( result.isOk() ) { colour = Colour::Success; passOrFail = "FAILED - but was ok"; } else { colour = Colour::Error; passOrFail = "FAILED"; } if( _stats.infoMessages.size() == 1 ) messageLabel = "with message"; if( _stats.infoMessages.size() > 1 ) messageLabel = "with messages"; break; case ResultWas::ThrewException: colour = Colour::Error; passOrFail = "FAILED"; messageLabel = "due to unexpected exception with message"; break; case ResultWas::FatalErrorCondition: colour = Colour::Error; passOrFail = "FAILED"; messageLabel = "due to a fatal error condition"; break; case ResultWas::DidntThrowException: colour = Colour::Error; passOrFail = "FAILED"; messageLabel = "because no exception was thrown where one was expected"; break; case ResultWas::Info: messageLabel = "info"; break; case ResultWas::Warning: messageLabel = "warning"; break; case ResultWas::ExplicitFailure: passOrFail = "FAILED"; colour = Colour::Error; if( _stats.infoMessages.size() == 1 ) messageLabel = "explicitly with message"; if( _stats.infoMessages.size() > 1 ) messageLabel = "explicitly with messages"; break; // These cases are here to prevent compiler warnings case ResultWas::Unknown: case ResultWas::FailureBit: case ResultWas::Exception: passOrFail = "** internal error **"; colour = Colour::Error; break; } } void print() const { printSourceInfo(); if( stats.totals.assertions.total() > 0 ) { if( result.isOk() ) stream << "\n"; printResultType(); printOriginalExpression(); printReconstructedExpression(); } else { stream << "\n"; } printMessage(); } private: void printResultType() const { if( !passOrFail.empty() ) { Colour colourGuard( colour ); stream << passOrFail << ":\n"; } } void printOriginalExpression() const { if( result.hasExpression() ) { Colour colourGuard( Colour::OriginalExpression ); stream << " "; stream << result.getExpressionInMacro(); stream << "\n"; } } void printReconstructedExpression() const { if( result.hasExpandedExpression() ) { stream << "with expansion:\n"; Colour colourGuard( Colour::ReconstructedExpression ); stream << Text( result.getExpandedExpression(), TextAttributes().setIndent(2) ) << "\n"; } } void printMessage() const { if( !messageLabel.empty() ) stream << messageLabel << ":" << "\n"; for( std::vector::const_iterator it = messages.begin(), itEnd = messages.end(); it != itEnd; ++it ) { // If this assertion is a warning ignore any INFO messages if( printInfoMessages || it->type != ResultWas::Info ) stream << Text( it->message, TextAttributes().setIndent(2) ) << "\n"; } } void printSourceInfo() const { Colour colourGuard( Colour::FileName ); stream << result.getSourceInfo() << ": "; } std::ostream& stream; AssertionStats const& stats; AssertionResult const& result; Colour::Code colour; std::string passOrFail; std::string messageLabel; std::string message; std::vector messages; bool printInfoMessages; }; void lazyPrint() { if( !currentTestRunInfo.used ) lazyPrintRunInfo(); if( !currentGroupInfo.used ) lazyPrintGroupInfo(); if( !m_headerPrinted ) { printTestCaseAndSectionHeader(); m_headerPrinted = true; } } void lazyPrintRunInfo() { stream << "\n" << getLineOfChars<'~'>() << "\n"; Colour colour( Colour::SecondaryText ); stream << currentTestRunInfo->name << " is a Catch v" << libraryVersion.majorVersion << "." << libraryVersion.minorVersion << " b" << libraryVersion.buildNumber; if( libraryVersion.branchName != std::string( "master" ) ) stream << " (" << libraryVersion.branchName << ")"; stream << " host application.\n" << "Run with -? for options\n\n"; if( m_config->rngSeed() != 0 ) stream << "Randomness seeded to: " << m_config->rngSeed() << "\n\n"; currentTestRunInfo.used = true; } void lazyPrintGroupInfo() { if( !currentGroupInfo->name.empty() && currentGroupInfo->groupsCounts > 1 ) { printClosedHeader( "Group: " + currentGroupInfo->name ); currentGroupInfo.used = true; } } void printTestCaseAndSectionHeader() { assert( !m_sectionStack.empty() ); printOpenHeader( currentTestCaseInfo->name ); if( m_sectionStack.size() > 1 ) { Colour colourGuard( Colour::Headers ); std::vector::const_iterator it = m_sectionStack.begin()+1, // Skip first section (test case) itEnd = m_sectionStack.end(); for( ; it != itEnd; ++it ) printHeaderString( it->name, 2 ); } SourceLineInfo lineInfo = m_sectionStack.front().lineInfo; if( !lineInfo.empty() ){ stream << getLineOfChars<'-'>() << "\n"; Colour colourGuard( Colour::FileName ); stream << lineInfo << "\n"; } stream << getLineOfChars<'.'>() << "\n" << std::endl; } void printClosedHeader( std::string const& _name ) { printOpenHeader( _name ); stream << getLineOfChars<'.'>() << "\n"; } void printOpenHeader( std::string const& _name ) { stream << getLineOfChars<'-'>() << "\n"; { Colour colourGuard( Colour::Headers ); printHeaderString( _name ); } } // if string has a : in first line will set indent to follow it on // subsequent lines void printHeaderString( std::string const& _string, std::size_t indent = 0 ) { std::size_t i = _string.find( ": " ); if( i != std::string::npos ) i+=2; else i = 0; stream << Text( _string, TextAttributes() .setIndent( indent+i) .setInitialIndent( indent ) ) << "\n"; } struct SummaryColumn { SummaryColumn( std::string const& _label, Colour::Code _colour ) : label( _label ), colour( _colour ) {} SummaryColumn addRow( std::size_t count ) { std::ostringstream oss; oss << count; std::string row = oss.str(); for( std::vector::iterator it = rows.begin(); it != rows.end(); ++it ) { while( it->size() < row.size() ) *it = " " + *it; while( it->size() > row.size() ) row = " " + row; } rows.push_back( row ); return *this; } std::string label; Colour::Code colour; std::vector rows; }; void printTotals( Totals const& totals ) { if( totals.testCases.total() == 0 ) { stream << Colour( Colour::Warning ) << "No tests ran\n"; } else if( totals.assertions.total() > 0 && totals.assertions.allPassed() ) { stream << Colour( Colour::ResultSuccess ) << "All tests passed"; stream << " (" << pluralise( totals.assertions.passed, "assertion" ) << " in " << pluralise( totals.testCases.passed, "test case" ) << ")" << "\n"; } else { std::vector columns; columns.push_back( SummaryColumn( "", Colour::None ) .addRow( totals.testCases.total() ) .addRow( totals.assertions.total() ) ); columns.push_back( SummaryColumn( "passed", Colour::Success ) .addRow( totals.testCases.passed ) .addRow( totals.assertions.passed ) ); columns.push_back( SummaryColumn( "failed", Colour::ResultError ) .addRow( totals.testCases.failed ) .addRow( totals.assertions.failed ) ); columns.push_back( SummaryColumn( "failed as expected", Colour::ResultExpectedFailure ) .addRow( totals.testCases.failedButOk ) .addRow( totals.assertions.failedButOk ) ); printSummaryRow( "test cases", columns, 0 ); printSummaryRow( "assertions", columns, 1 ); } } void printSummaryRow( std::string const& label, std::vector const& cols, std::size_t row ) { for( std::vector::const_iterator it = cols.begin(); it != cols.end(); ++it ) { std::string value = it->rows[row]; if( it->label.empty() ) { stream << label << ": "; if( value != "0" ) stream << value; else stream << Colour( Colour::Warning ) << "- none -"; } else if( value != "0" ) { stream << Colour( Colour::LightGrey ) << " | "; stream << Colour( it->colour ) << value << " " << it->label; } } stream << "\n"; } static std::size_t makeRatio( std::size_t number, std::size_t total ) { std::size_t ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number/ total : 0; return ( ratio == 0 && number > 0 ) ? 1 : ratio; } static std::size_t& findMax( std::size_t& i, std::size_t& j, std::size_t& k ) { if( i > j && i > k ) return i; else if( j > k ) return j; else return k; } void printTotalsDivider( Totals const& totals ) { if( totals.testCases.total() > 0 ) { std::size_t failedRatio = makeRatio( totals.testCases.failed, totals.testCases.total() ); std::size_t failedButOkRatio = makeRatio( totals.testCases.failedButOk, totals.testCases.total() ); std::size_t passedRatio = makeRatio( totals.testCases.passed, totals.testCases.total() ); while( failedRatio + failedButOkRatio + passedRatio < CATCH_CONFIG_CONSOLE_WIDTH-1 ) findMax( failedRatio, failedButOkRatio, passedRatio )++; while( failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH-1 ) findMax( failedRatio, failedButOkRatio, passedRatio )--; stream << Colour( Colour::Error ) << std::string( failedRatio, '=' ); stream << Colour( Colour::ResultExpectedFailure ) << std::string( failedButOkRatio, '=' ); if( totals.testCases.allPassed() ) stream << Colour( Colour::ResultSuccess ) << std::string( passedRatio, '=' ); else stream << Colour( Colour::Success ) << std::string( passedRatio, '=' ); } else { stream << Colour( Colour::Warning ) << std::string( CATCH_CONFIG_CONSOLE_WIDTH-1, '=' ); } stream << "\n"; } void printSummaryDivider() { stream << getLineOfChars<'-'>() << "\n"; } private: bool m_headerPrinted; }; INTERNAL_CATCH_REGISTER_REPORTER( "console", ConsoleReporter ) } // end namespace Catch // #included from: ../reporters/catch_reporter_compact.hpp #define TWOBLUECUBES_CATCH_REPORTER_COMPACT_HPP_INCLUDED namespace Catch { struct CompactReporter : StreamingReporterBase { CompactReporter( ReporterConfig const& _config ) : StreamingReporterBase( _config ) {} virtual ~CompactReporter(); static std::string getDescription() { return "Reports test results on a single line, suitable for IDEs"; } virtual ReporterPreferences getPreferences() const { ReporterPreferences prefs; prefs.shouldRedirectStdOut = false; return prefs; } virtual void noMatchingTestCases( std::string const& spec ) { stream << "No test cases matched '" << spec << "'" << std::endl; } virtual void assertionStarting( AssertionInfo const& ) { } virtual bool assertionEnded( AssertionStats const& _assertionStats ) { AssertionResult const& result = _assertionStats.assertionResult; bool printInfoMessages = true; // Drop out if result was successful and we're not printing those if( !m_config->includeSuccessfulResults() && result.isOk() ) { if( result.getResultType() != ResultWas::Warning ) return false; printInfoMessages = false; } AssertionPrinter printer( stream, _assertionStats, printInfoMessages ); printer.print(); stream << std::endl; return true; } virtual void testRunEnded( TestRunStats const& _testRunStats ) { printTotals( _testRunStats.totals ); stream << "\n" << std::endl; StreamingReporterBase::testRunEnded( _testRunStats ); } private: class AssertionPrinter { void operator= ( AssertionPrinter const& ); public: AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages ) : stream( _stream ) , stats( _stats ) , result( _stats.assertionResult ) , messages( _stats.infoMessages ) , itMessage( _stats.infoMessages.begin() ) , printInfoMessages( _printInfoMessages ) {} void print() { printSourceInfo(); itMessage = messages.begin(); switch( result.getResultType() ) { case ResultWas::Ok: printResultType( Colour::ResultSuccess, passedString() ); printOriginalExpression(); printReconstructedExpression(); if ( ! result.hasExpression() ) printRemainingMessages( Colour::None ); else printRemainingMessages(); break; case ResultWas::ExpressionFailed: if( result.isOk() ) printResultType( Colour::ResultSuccess, failedString() + std::string( " - but was ok" ) ); else printResultType( Colour::Error, failedString() ); printOriginalExpression(); printReconstructedExpression(); printRemainingMessages(); break; case ResultWas::ThrewException: printResultType( Colour::Error, failedString() ); printIssue( "unexpected exception with message:" ); printMessage(); printExpressionWas(); printRemainingMessages(); break; case ResultWas::FatalErrorCondition: printResultType( Colour::Error, failedString() ); printIssue( "fatal error condition with message:" ); printMessage(); printExpressionWas(); printRemainingMessages(); break; case ResultWas::DidntThrowException: printResultType( Colour::Error, failedString() ); printIssue( "expected exception, got none" ); printExpressionWas(); printRemainingMessages(); break; case ResultWas::Info: printResultType( Colour::None, "info" ); printMessage(); printRemainingMessages(); break; case ResultWas::Warning: printResultType( Colour::None, "warning" ); printMessage(); printRemainingMessages(); break; case ResultWas::ExplicitFailure: printResultType( Colour::Error, failedString() ); printIssue( "explicitly" ); printRemainingMessages( Colour::None ); break; // These cases are here to prevent compiler warnings case ResultWas::Unknown: case ResultWas::FailureBit: case ResultWas::Exception: printResultType( Colour::Error, "** internal error **" ); break; } } private: // Colour::LightGrey static Colour::Code dimColour() { return Colour::FileName; } #ifdef CATCH_PLATFORM_MAC static const char* failedString() { return "FAILED"; } static const char* passedString() { return "PASSED"; } #else static const char* failedString() { return "failed"; } static const char* passedString() { return "passed"; } #endif void printSourceInfo() const { Colour colourGuard( Colour::FileName ); stream << result.getSourceInfo() << ":"; } void printResultType( Colour::Code colour, std::string passOrFail ) const { if( !passOrFail.empty() ) { { Colour colourGuard( colour ); stream << " " << passOrFail; } stream << ":"; } } void printIssue( std::string issue ) const { stream << " " << issue; } void printExpressionWas() { if( result.hasExpression() ) { stream << ";"; { Colour colour( dimColour() ); stream << " expression was:"; } printOriginalExpression(); } } void printOriginalExpression() const { if( result.hasExpression() ) { stream << " " << result.getExpression(); } } void printReconstructedExpression() const { if( result.hasExpandedExpression() ) { { Colour colour( dimColour() ); stream << " for: "; } stream << result.getExpandedExpression(); } } void printMessage() { if ( itMessage != messages.end() ) { stream << " '" << itMessage->message << "'"; ++itMessage; } } void printRemainingMessages( Colour::Code colour = dimColour() ) { if ( itMessage == messages.end() ) return; // using messages.end() directly yields compilation error: std::vector::const_iterator itEnd = messages.end(); const std::size_t N = static_cast( std::distance( itMessage, itEnd ) ); { Colour colourGuard( colour ); stream << " with " << pluralise( N, "message" ) << ":"; } for(; itMessage != itEnd; ) { // If this assertion is a warning ignore any INFO messages if( printInfoMessages || itMessage->type != ResultWas::Info ) { stream << " '" << itMessage->message << "'"; if ( ++itMessage != itEnd ) { Colour colourGuard( dimColour() ); stream << " and"; } } } } private: std::ostream& stream; AssertionStats const& stats; AssertionResult const& result; std::vector messages; std::vector::const_iterator itMessage; bool printInfoMessages; }; // Colour, message variants: // - white: No tests ran. // - red: Failed [both/all] N test cases, failed [both/all] M assertions. // - white: Passed [both/all] N test cases (no assertions). // - red: Failed N tests cases, failed M assertions. // - green: Passed [both/all] N tests cases with M assertions. std::string bothOrAll( std::size_t count ) const { return count == 1 ? "" : count == 2 ? "both " : "all " ; } void printTotals( const Totals& totals ) const { if( totals.testCases.total() == 0 ) { stream << "No tests ran."; } else if( totals.testCases.failed == totals.testCases.total() ) { Colour colour( Colour::ResultError ); const std::string qualify_assertions_failed = totals.assertions.failed == totals.assertions.total() ? bothOrAll( totals.assertions.failed ) : ""; stream << "Failed " << bothOrAll( totals.testCases.failed ) << pluralise( totals.testCases.failed, "test case" ) << ", " "failed " << qualify_assertions_failed << pluralise( totals.assertions.failed, "assertion" ) << "."; } else if( totals.assertions.total() == 0 ) { stream << "Passed " << bothOrAll( totals.testCases.total() ) << pluralise( totals.testCases.total(), "test case" ) << " (no assertions)."; } else if( totals.assertions.failed ) { Colour colour( Colour::ResultError ); stream << "Failed " << pluralise( totals.testCases.failed, "test case" ) << ", " "failed " << pluralise( totals.assertions.failed, "assertion" ) << "."; } else { Colour colour( Colour::ResultSuccess ); stream << "Passed " << bothOrAll( totals.testCases.passed ) << pluralise( totals.testCases.passed, "test case" ) << " with " << pluralise( totals.assertions.passed, "assertion" ) << "."; } } }; INTERNAL_CATCH_REGISTER_REPORTER( "compact", CompactReporter ) } // end namespace Catch namespace Catch { NonCopyable::~NonCopyable() {} IShared::~IShared() {} StreamBufBase::~StreamBufBase() CATCH_NOEXCEPT {} IContext::~IContext() {} IResultCapture::~IResultCapture() {} ITestCase::~ITestCase() {} ITestCaseRegistry::~ITestCaseRegistry() {} IRegistryHub::~IRegistryHub() {} IMutableRegistryHub::~IMutableRegistryHub() {} IExceptionTranslator::~IExceptionTranslator() {} IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() {} IReporter::~IReporter() {} IReporterFactory::~IReporterFactory() {} IReporterRegistry::~IReporterRegistry() {} IStreamingReporter::~IStreamingReporter() {} AssertionStats::~AssertionStats() {} SectionStats::~SectionStats() {} TestCaseStats::~TestCaseStats() {} TestGroupStats::~TestGroupStats() {} TestRunStats::~TestRunStats() {} CumulativeReporterBase::SectionNode::~SectionNode() {} CumulativeReporterBase::~CumulativeReporterBase() {} StreamingReporterBase::~StreamingReporterBase() {} ConsoleReporter::~ConsoleReporter() {} CompactReporter::~CompactReporter() {} IRunner::~IRunner() {} IMutableContext::~IMutableContext() {} IConfig::~IConfig() {} XmlReporter::~XmlReporter() {} JunitReporter::~JunitReporter() {} TestRegistry::~TestRegistry() {} FreeFunctionTestCase::~FreeFunctionTestCase() {} IGeneratorInfo::~IGeneratorInfo() {} IGeneratorsForTest::~IGeneratorsForTest() {} TestSpec::Pattern::~Pattern() {} TestSpec::NamePattern::~NamePattern() {} TestSpec::TagPattern::~TagPattern() {} TestSpec::ExcludedPattern::~ExcludedPattern() {} Matchers::Impl::StdString::Equals::~Equals() {} Matchers::Impl::StdString::Contains::~Contains() {} Matchers::Impl::StdString::StartsWith::~StartsWith() {} Matchers::Impl::StdString::EndsWith::~EndsWith() {} void Config::dummy() {} } #ifdef __clang__ #pragma clang diagnostic pop #endif #endif #ifdef CATCH_CONFIG_MAIN // #included from: internal/catch_default_main.hpp #define TWOBLUECUBES_CATCH_DEFAULT_MAIN_HPP_INCLUDED #ifndef __OBJC__ // Standard C/C++ main entry point int main (int argc, char * const argv[]) { return Catch::Session().run( argc, argv ); } #else // __OBJC__ // Objective-C entry point int main (int argc, char * const argv[]) { #if !CATCH_ARC_ENABLED NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; #endif Catch::registerTestMethods(); int result = Catch::Session().run( argc, (char* const*)argv ); #if !CATCH_ARC_ENABLED [pool drain]; #endif return result; } #endif // __OBJC__ #endif #ifdef CLARA_CONFIG_MAIN_NOT_DEFINED # undef CLARA_CONFIG_MAIN #endif ////// // If this config identifier is defined then all CATCH macros are prefixed with CATCH_ #ifdef CATCH_CONFIG_PREFIX_ALL #define CATCH_REQUIRE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal, "CATCH_REQUIRE" ) #define CATCH_REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, "CATCH_REQUIRE_FALSE" ) #define CATCH_REQUIRE_THROWS( expr ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_THROWS" ) #define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_THROWS_AS" ) #define CATCH_REQUIRE_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_NOTHROW" ) #define CATCH_CHECK( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK" ) #define CATCH_CHECK_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, "CATCH_CHECK_FALSE" ) #define CATCH_CHECKED_IF( expr ) INTERNAL_CATCH_IF( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECKED_IF" ) #define CATCH_CHECKED_ELSE( expr ) INTERNAL_CATCH_ELSE( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECKED_ELSE" ) #define CATCH_CHECK_NOFAIL( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, "CATCH_CHECK_NOFAIL" ) #define CATCH_CHECK_THROWS( expr ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_THROWS" ) #define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_THROWS_AS" ) #define CATCH_CHECK_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_NOTHROW" ) #define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_THAT" ) #define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_THAT" ) #define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( msg, "CATCH_INFO" ) #define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, "CATCH_WARN", msg ) #define CATCH_SCOPED_INFO( msg ) INTERNAL_CATCH_INFO( msg, "CATCH_INFO" ) #define CATCH_CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CATCH_CAPTURE" ) #define CATCH_SCOPED_CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CATCH_CAPTURE" ) #ifdef CATCH_CONFIG_VARIADIC_MACROS #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ ) #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ ) #define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ ) #define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ ) #define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "CATCH_FAIL", __VA_ARGS__ ) #define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "CATCH_SUCCEED", __VA_ARGS__ ) #else #define CATCH_TEST_CASE( name, description ) INTERNAL_CATCH_TESTCASE( name, description ) #define CATCH_TEST_CASE_METHOD( className, name, description ) INTERNAL_CATCH_TEST_CASE_METHOD( className, name, description ) #define CATCH_METHOD_AS_TEST_CASE( method, name, description ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, name, description ) #define CATCH_SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description ) #define CATCH_FAIL( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "CATCH_FAIL", msg ) #define CATCH_SUCCEED( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "CATCH_SUCCEED", msg ) #endif #define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "" ) #define CATCH_REGISTER_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType ) #define CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) #define CATCH_GENERATE( expr) INTERNAL_CATCH_GENERATE( expr ) // "BDD-style" convenience wrappers #ifdef CATCH_CONFIG_VARIADIC_MACROS #define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ ) #define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ ) #else #define CATCH_SCENARIO( name, tags ) CATCH_TEST_CASE( "Scenario: " name, tags ) #define CATCH_SCENARIO_METHOD( className, name, tags ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " name, tags ) #endif #define CATCH_GIVEN( desc ) CATCH_SECTION( "Given: " desc, "" ) #define CATCH_WHEN( desc ) CATCH_SECTION( " When: " desc, "" ) #define CATCH_AND_WHEN( desc ) CATCH_SECTION( " And: " desc, "" ) #define CATCH_THEN( desc ) CATCH_SECTION( " Then: " desc, "" ) #define CATCH_AND_THEN( desc ) CATCH_SECTION( " And: " desc, "" ) // If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required #else #define REQUIRE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal, "REQUIRE" ) #define REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, "REQUIRE_FALSE" ) #define REQUIRE_THROWS( expr ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::Normal, "REQUIRE_THROWS" ) #define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::Normal, "REQUIRE_THROWS_AS" ) #define REQUIRE_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::Normal, "REQUIRE_NOTHROW" ) #define CHECK( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECK" ) #define CHECK_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, "CHECK_FALSE" ) #define CHECKED_IF( expr ) INTERNAL_CATCH_IF( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECKED_IF" ) #define CHECKED_ELSE( expr ) INTERNAL_CATCH_ELSE( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECKED_ELSE" ) #define CHECK_NOFAIL( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, "CHECK_NOFAIL" ) #define CHECK_THROWS( expr ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECK_THROWS" ) #define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::ContinueOnFailure, "CHECK_THROWS_AS" ) #define CHECK_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECK_NOTHROW" ) #define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::ContinueOnFailure, "CHECK_THAT" ) #define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::Normal, "REQUIRE_THAT" ) #define INFO( msg ) INTERNAL_CATCH_INFO( msg, "INFO" ) #define WARN( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, "WARN", msg ) #define SCOPED_INFO( msg ) INTERNAL_CATCH_INFO( msg, "INFO" ) #define CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CAPTURE" ) #define SCOPED_CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CAPTURE" ) #ifdef CATCH_CONFIG_VARIADIC_MACROS #define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ ) #define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ ) #define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ ) #define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ ) #define FAIL( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "FAIL", __VA_ARGS__ ) #define SUCCEED( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "SUCCEED", __VA_ARGS__ ) #else #define TEST_CASE( name, description ) INTERNAL_CATCH_TESTCASE( name, description ) #define TEST_CASE_METHOD( className, name, description ) INTERNAL_CATCH_TEST_CASE_METHOD( className, name, description ) #define METHOD_AS_TEST_CASE( method, name, description ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, name, description ) #define SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description ) #define FAIL( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "FAIL", msg ) #define SUCCEED( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "SUCCEED", msg ) #endif #define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "" ) #define REGISTER_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType ) #define REGISTER_LEGACY_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) #define GENERATE( expr) INTERNAL_CATCH_GENERATE( expr ) #endif #define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) // "BDD-style" convenience wrappers #ifdef CATCH_CONFIG_VARIADIC_MACROS #define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ ) #define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ ) #else #define SCENARIO( name, tags ) TEST_CASE( "Scenario: " name, tags ) #define SCENARIO_METHOD( className, name, tags ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " name, tags ) #endif #define GIVEN( desc ) SECTION( " Given: " desc, "" ) #define WHEN( desc ) SECTION( " When: " desc, "" ) #define AND_WHEN( desc ) SECTION( "And when: " desc, "" ) #define THEN( desc ) SECTION( " Then: " desc, "" ) #define AND_THEN( desc ) SECTION( " And: " desc, "" ) using Catch::Detail::Approx; // #included from: internal/catch_reenable_warnings.h #define TWOBLUECUBES_CATCH_REENABLE_WARNINGS_H_INCLUDED #ifdef __clang__ # ifdef __ICC // icpc defines the __clang__ macro # pragma warning(pop) # else # pragma clang diagnostic pop # endif #elif defined __GNUC__ # pragma GCC diagnostic pop #endif #endif // TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED nanopolish-0.4.0/src/test/nanopolish_test.cpp000066400000000000000000000133221260522445600213570ustar00rootroot00000000000000//--------------------------------------------------------- // Copyright 2015 Ontario Institute for Cancer Research // Written by Jared Simpson (jared.simpson@oicr.on.ca) //--------------------------------------------------------- // // nanopolish_test -- test driver program // #define CATCH_CONFIG_MAIN #include #include #include "logsum.h" #include "catch.hpp" #include "nanopolish_common.h" #include "nanopolish_alphabet.h" #include "nanopolish_emissions.h" #include "nanopolish_profile_hmm.h" // This code needs to be run before any of the program logic // It sets up pre-computed values and caches void initialize() { p7_FLogsumInit(); } TEST_CASE( "alphabet", "[alphabet]" ) { // DNA alphabet DNAAlphabet dna_alphabet; MethylCpGAlphabet mc_alphabet; REQUIRE( dna_alphabet.rank('A') == 0 ); REQUIRE( dna_alphabet.rank('C') == 1 ); REQUIRE( dna_alphabet.rank('G') == 2 ); REQUIRE( dna_alphabet.rank('T') == 3 ); REQUIRE( dna_alphabet.base(0) == 'A' ); REQUIRE( dna_alphabet.base(1) == 'C' ); REQUIRE( dna_alphabet.base(2) == 'G' ); REQUIRE( dna_alphabet.base(3) == 'T' ); // MethylCpG alphabet REQUIRE( mc_alphabet.rank('A') == 0 ); REQUIRE( mc_alphabet.rank('C') == 1 ); REQUIRE( mc_alphabet.rank('G') == 2 ); REQUIRE( mc_alphabet.rank('M') == 3 ); REQUIRE( mc_alphabet.rank('T') == 4 ); REQUIRE( mc_alphabet.base(0) == 'A' ); REQUIRE( mc_alphabet.base(1) == 'C' ); REQUIRE( mc_alphabet.base(2) == 'G' ); REQUIRE( mc_alphabet.base(3) == 'M' ); REQUIRE( mc_alphabet.base(4) == 'T' ); // Collectively test lexicographic_next and kmer_rank uint8_t k = 3; uint32_t num_strings = pow((double)mc_alphabet.size(), (double)k); std::string kmer(k, 'A'); for(size_t i = 0; i < num_strings - 1; ++i) { // check lexicographic next std::string next = kmer; mc_alphabet.lexicographic_next(next); REQUIRE( next > kmer ); int rank_diff = mc_alphabet.kmer_rank(next.c_str(), k) - mc_alphabet.kmer_rank(kmer.c_str(), k); REQUIRE( rank_diff == 1); kmer = next; } REQUIRE(kmer == "TTT"); // Test the special reverse complement model // for the CpG alphabet REQUIRE( mc_alphabet.reverse_complement("M") == "G"); REQUIRE( mc_alphabet.reverse_complement("C") == "G"); REQUIRE( mc_alphabet.reverse_complement("MG") == "MG"); REQUIRE( mc_alphabet.reverse_complement("AM") == "GT"); REQUIRE( mc_alphabet.reverse_complement("AMG") == "MGT"); REQUIRE( mc_alphabet.reverse_complement("GTACATG") == dna_alphabet.reverse_complement("GTACATG")); } TEST_CASE( "string functions", "[string_functions]" ) { DNAAlphabet dna_alphabet; // kmer rank REQUIRE( dna_alphabet.kmer_rank("AAAAA", 5) == 0 ); REQUIRE( dna_alphabet.kmer_rank("GATGA", 5) == 568 ); REQUIRE( dna_alphabet.kmer_rank("TTTTT", 5) == 1023 ); // lexicographic increment std::string str = "AAAAA"; dna_alphabet.lexicographic_next(str); REQUIRE( str == "AAAAC" ); str = "AAAAT"; dna_alphabet.lexicographic_next(str); REQUIRE( str == "AAACA" ); // complement, reverse complement REQUIRE( dna_alphabet.reverse_complement("GATGA") == "TCATC" ); } TEST_CASE( "math", "[math]") { GaussianParameters params; params.mean = 4; params.stdv = 2; params.log_stdv = log(params.stdv); REQUIRE( normal_pdf(2.25, params) == Approx(0.1360275) ); REQUIRE( log_normal_pdf(2.25, params) == Approx(log(normal_pdf(2.25, params))) ); } std::string event_alignment_to_string(const std::vector& alignment) { std::string out; for(size_t i = 0; i < alignment.size(); ++i) { out.append(1, alignment[i].state); } return out; } TEST_CASE( "hmm", "[hmm]") { // read the FAST5 SquiggleRead sr("test_read", "test/data/LomanLabz_PC_Ecoli_K12_R7.3_2549_1_ch8_file30_strand.fast5"); sr.transform(); // The reference sequence to align to: std::string ref_subseq = "ATCAGTAAAATAACGTAGAGCGGTAACCTTGCCATAAAGGTCGAGTTTA" "TTACCATCCTTGTTATAGACTTCGGCAGCGTGTGCTACGTTCGCAGCT"; // Generate a HMMInputData structure to tell the HMM // which part of the read to align HMMInputData input[2]; // template strand input[0].read = &sr; input[0].event_start_idx = 3; input[0].event_stop_idx = 88; input[0].event_stride = 1; input[0].rc = false; input[0].strand = 0; // complement strand input[1].read = &sr; input[1].event_start_idx = 6788; input[1].event_stop_idx = 6697; input[1].event_stride = -1; input[1].rc = true; input[1].strand = 1; // expected output std::string expected_alignment[2]; expected_alignment[0] = "MMMMMEMKMKMMMMMMMKMMMKMMMKMMMMMMMMMKKMMEEEMMMMMMKMMMM" "MMMKMMMMMKMKMKMEMKKMKMKKMMMMMMEMMMMKMKMEEMMMMKMEEEEEM"; expected_alignment[1] = "MMKMMMKMEEMMKMKMKMEMMMKMMMKMEMMMKMMMKMMMMMMMMMKKMEMMMM" "EMMMMMMMMKMKKMMMMMMMEMMMMMKMMMMMKMEMMMMMKMMMMMEEEEEEEEM"; double expected_viterbi_last_state[2] = { -237.7690734863, -266.2348022461 }; double expected_forward[2] = { -221.1331481934, -262.7491455078 }; for(int si = 0; si <= 1; ++si) { // viterbi align std::vector event_alignment = profile_hmm_align(ref_subseq, input[si]); std::string ea_str = event_alignment_to_string(event_alignment); // check REQUIRE( ea_str == expected_alignment[si]); REQUIRE( event_alignment.back().l_fm == Approx(expected_viterbi_last_state[si])); // forward algorithm double lp = profile_hmm_score(ref_subseq, input[si]); REQUIRE(lp == Approx(expected_forward[si])); } } nanopolish-0.4.0/src/thirdparty/000077500000000000000000000000001260522445600166545ustar00rootroot00000000000000nanopolish-0.4.0/src/thirdparty/stdaln.c000066400000000000000000001066561260522445600203230ustar00rootroot00000000000000/* The MIT License Copyright (c) 2003-2006, 2008, 2009, by Heng Li Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #include #include #include #include #include "stdaln.h" /* char -> 17 (=16+1) nucleotides */ unsigned char aln_nt16_table[256] = { 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,16 /*'-'*/,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15, 1,14, 4, 11,15,15, 2, 13,15,15,10, 15, 5,15,15, 15,15, 3, 6, 8,15, 7, 9, 0,12,15,15, 15,15,15,15, 15, 1,14, 4, 11,15,15, 2, 13,15,15,10, 15, 5,15,15, 15,15, 3, 6, 8,15, 7, 9, 0,12,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15 }; char *aln_nt16_rev_table = "XAGRCMSVTWKDYHBN-"; /* char -> 5 (=4+1) nucleotides */ unsigned char aln_nt4_table[256] = { 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5 /*'-'*/, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 4, 2, 4, 4, 4, 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 4, 2, 4, 4, 4, 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4 }; char *aln_nt4_rev_table = "AGCTN-"; /* char -> 22 (=20+1+1) amino acids */ unsigned char aln_aa_table[256] = { 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,20,21, 21,22 /*'-'*/,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21, 0,21, 4, 3, 6,13, 7, 8, 9,21,11, 10,12, 2,21, 14, 5, 1,15, 16,21,19,17, 21,18,21,21, 21,21,21,21, 21, 0,21, 4, 3, 6,13, 7, 8, 9,21,11, 10,12, 2,21, 14, 5, 1,15, 16,21,19,17, 21,18,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21, 21,21,21,21 }; char *aln_aa_rev_table = "ARNDCQEGHILKMFPSTWYV*X-"; /* 01234567890123456789012 */ /* translation table. They are useless in stdaln.c, but when you realize you need it, you need not write the table again. */ unsigned char aln_trans_table_eu[66] = { 11,11, 2, 2, 1, 1,15,15, 16,16,16,16, 9,12, 9, 9, 6, 6, 3, 3, 7, 7, 7, 7, 0, 0, 0, 0, 19,19,19,19, 5, 5, 8, 8, 1, 1, 1, 1, 14,14,14,14, 10,10,10,10, 20,20,18,18, 20,17, 4, 4, 15,15,15,15, 10,10,13,13, 21, 22 }; char *aln_trans_table_eu_char = "KKNNRRSSTTTTIMIIEEDDGGGGAAAAVVVVQQHHRRRRPPPPLLLL**YY*WCCSSSSLLFFX"; /* 01234567890123456789012345678901234567890123456789012345678901234 */ int aln_sm_blosum62[] = { /* A R N D C Q E G H I L K M F P S T W Y V * X */ 4,-1,-2,-2, 0,-1,-1, 0,-2,-1,-1,-1,-1,-2,-1, 1, 0,-3,-2, 0,-4, 0, -1, 5, 0,-2,-3, 1, 0,-2, 0,-3,-2, 2,-1,-3,-2,-1,-1,-3,-2,-3,-4,-1, -2, 0, 6, 1,-3, 0, 0, 0, 1,-3,-3, 0,-2,-3,-2, 1, 0,-4,-2,-3,-4,-1, -2,-2, 1, 6,-3, 0, 2,-1,-1,-3,-4,-1,-3,-3,-1, 0,-1,-4,-3,-3,-4,-1, 0,-3,-3,-3, 9,-3,-4,-3,-3,-1,-1,-3,-1,-2,-3,-1,-1,-2,-2,-1,-4,-2, -1, 1, 0, 0,-3, 5, 2,-2, 0,-3,-2, 1, 0,-3,-1, 0,-1,-2,-1,-2,-4,-1, -1, 0, 0, 2,-4, 2, 5,-2, 0,-3,-3, 1,-2,-3,-1, 0,-1,-3,-2,-2,-4,-1, 0,-2, 0,-1,-3,-2,-2, 6,-2,-4,-4,-2,-3,-3,-2, 0,-2,-2,-3,-3,-4,-1, -2, 0, 1,-1,-3, 0, 0,-2, 8,-3,-3,-1,-2,-1,-2,-1,-2,-2, 2,-3,-4,-1, -1,-3,-3,-3,-1,-3,-3,-4,-3, 4, 2,-3, 1, 0,-3,-2,-1,-3,-1, 3,-4,-1, -1,-2,-3,-4,-1,-2,-3,-4,-3, 2, 4,-2, 2, 0,-3,-2,-1,-2,-1, 1,-4,-1, -1, 2, 0,-1,-3, 1, 1,-2,-1,-3,-2, 5,-1,-3,-1, 0,-1,-3,-2,-2,-4,-1, -1,-1,-2,-3,-1, 0,-2,-3,-2, 1, 2,-1, 5, 0,-2,-1,-1,-1,-1, 1,-4,-1, -2,-3,-3,-3,-2,-3,-3,-3,-1, 0, 0,-3, 0, 6,-4,-2,-2, 1, 3,-1,-4,-1, -1,-2,-2,-1,-3,-1,-1,-2,-2,-3,-3,-1,-2,-4, 7,-1,-1,-4,-3,-2,-4,-2, 1,-1, 1, 0,-1, 0, 0, 0,-1,-2,-2, 0,-1,-2,-1, 4, 1,-3,-2,-2,-4, 0, 0,-1, 0,-1,-1,-1,-1,-2,-2,-1,-1,-1,-1,-2,-1, 1, 5,-2,-2, 0,-4, 0, -3,-3,-4,-4,-2,-2,-3,-2,-2,-3,-2,-3,-1, 1,-4,-3,-2,11, 2,-3,-4,-2, -2,-2,-2,-3,-2,-1,-2,-3, 2,-1,-1,-2,-1, 3,-3,-2,-2, 2, 7,-1,-4,-1, 0,-3,-3,-3,-1,-2,-2,-3,-3, 3, 1,-2, 1,-1,-2,-2, 0,-3,-1, 4,-4,-1, -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4, 1,-4, 0,-1,-1,-1,-2,-1,-1,-1,-1,-1,-1,-1,-1,-1,-2, 0, 0,-2,-1,-1,-4,-1 }; int aln_sm_blosum45[] = { /* A R N D C Q E G H I L K M F P S T W Y V * X */ 5,-2,-1,-2,-1,-1,-1, 0,-2,-1,-1,-1,-1,-2,-1, 1, 0,-2,-2, 0,-5, 0, -2, 7, 0,-1,-3, 1, 0,-2, 0,-3,-2, 3,-1,-2,-2,-1,-1,-2,-1,-2,-5,-1, -1, 0, 6, 2,-2, 0, 0, 0, 1,-2,-3, 0,-2,-2,-2, 1, 0,-4,-2,-3,-5,-1, -2,-1, 2, 7,-3, 0, 2,-1, 0,-4,-3, 0,-3,-4,-1, 0,-1,-4,-2,-3,-5,-1, -1,-3,-2,-3,12,-3,-3,-3,-3,-3,-2,-3,-2,-2,-4,-1,-1,-5,-3,-1,-5,-2, -1, 1, 0, 0,-3, 6, 2,-2, 1,-2,-2, 1, 0,-4,-1, 0,-1,-2,-1,-3,-5,-1, -1, 0, 0, 2,-3, 2, 6,-2, 0,-3,-2, 1,-2,-3, 0, 0,-1,-3,-2,-3,-5,-1, 0,-2, 0,-1,-3,-2,-2, 7,-2,-4,-3,-2,-2,-3,-2, 0,-2,-2,-3,-3,-5,-1, -2, 0, 1, 0,-3, 1, 0,-2,10,-3,-2,-1, 0,-2,-2,-1,-2,-3, 2,-3,-5,-1, -1,-3,-2,-4,-3,-2,-3,-4,-3, 5, 2,-3, 2, 0,-2,-2,-1,-2, 0, 3,-5,-1, -1,-2,-3,-3,-2,-2,-2,-3,-2, 2, 5,-3, 2, 1,-3,-3,-1,-2, 0, 1,-5,-1, -1, 3, 0, 0,-3, 1, 1,-2,-1,-3,-3, 5,-1,-3,-1,-1,-1,-2,-1,-2,-5,-1, -1,-1,-2,-3,-2, 0,-2,-2, 0, 2, 2,-1, 6, 0,-2,-2,-1,-2, 0, 1,-5,-1, -2,-2,-2,-4,-2,-4,-3,-3,-2, 0, 1,-3, 0, 8,-3,-2,-1, 1, 3, 0,-5,-1, -1,-2,-2,-1,-4,-1, 0,-2,-2,-2,-3,-1,-2,-3, 9,-1,-1,-3,-3,-3,-5,-1, 1,-1, 1, 0,-1, 0, 0, 0,-1,-2,-3,-1,-2,-2,-1, 4, 2,-4,-2,-1,-5, 0, 0,-1, 0,-1,-1,-1,-1,-2,-2,-1,-1,-1,-1,-1,-1, 2, 5,-3,-1, 0,-5, 0, -2,-2,-4,-4,-5,-2,-3,-2,-3,-2,-2,-2,-2, 1,-3,-4,-3,15, 3,-3,-5,-2, -2,-1,-2,-2,-3,-1,-2,-3, 2, 0, 0,-1, 0, 3,-3,-2,-1, 3, 8,-1,-5,-1, 0,-2,-3,-3,-1,-3,-3,-3,-3, 3, 1,-2, 1, 0,-3,-1, 0,-3,-1, 5,-5,-1, -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5, 1,-5, 0,-1,-1,-1,-2,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 0, 0,-2,-1,-1,-5,-1 }; int aln_sm_nt[] = { /* X A G R C M S V T W K D Y H B N */ -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2, -2, 2,-1, 1,-2, 1,-2, 0,-2, 1,-2, 0,-2, 0,-2, 0, -2,-1, 2, 1,-2,-2, 1, 0,-2,-2, 1, 0,-2,-2, 0, 0, -2, 1, 1, 1,-2,-1,-1, 0,-2,-1,-1, 0,-2, 0, 0, 0, -2,-2,-2,-2, 2, 1, 1, 0,-1,-2,-2,-2, 1, 0, 0, 0, -2, 1,-2,-1, 1, 1,-1, 0,-2,-1,-2, 0,-1, 0, 0, 0, -2,-2, 1,-1, 1,-1, 1, 0,-2,-2,-1, 0,-1, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0, 0,-2, 0, 0, 0, 0, 0, 0, 0, -2,-2,-2,-2,-1,-2,-2,-2, 2, 1, 1, 0, 1, 0, 0, 0, -2, 1,-2,-1,-2,-1,-2, 0, 1, 1,-1, 0,-1, 0, 0, 0, -2,-2, 1,-1,-2,-2,-1, 0, 1,-1, 1, 0,-1, 0, 0, 0, -2, 0, 0, 0,-2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2,-2,-2,-2, 1,-1,-1, 0, 1,-1,-1, 0, 1, 0, 0, 0, -2, 0,-2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2,-2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; int aln_sm_read[] = { /* X A G R C M S V T W K D Y H B N */ -17,-17,-17,-17,-17,-17,-17,-17,-17,-17,-17,-17,-17,-17,-17,-17, -17, 2,-17, 1,-17, 1,-17, 0,-17, 1,-17, 0,-17, 0,-17, 0, -17,-17, 2, 1,-17,-17, 1, 0,-17,-17, 1, 0,-17,-17, 0, 0, -17, 1, 1, 1,-17,-17,-17, 0,-17,-17,-17, 0,-17, 0, 0, 0, -17,-17,-17,-17, 2, 1, 1, 0,-17,-17,-17,-17, 1, 0, 0, 0, -17, 1,-17,-17, 1, 1,-17, 0,-17,-17,-17, 0,-17, 0, 0, 0, -17,-17, 1,-17, 1,-17, 1, 0,-17,-17,-17, 0,-17, 0, 0, 0, -17, 0, 0, 0, 0, 0, 0, 0,-17, 0, 0, 0, 0, 0, 0, 0, -17,-17,-17,-17,-17,-17,-17,-17, 2, 1, 1, 0, 1, 0, 0, 0, -17, 1,-17,-17,-17,-17,-17, 0, 1, 1,-17, 0,-17, 0, 0, 0, -17,-17, 1,-17,-17,-17,-17, 0, 1,-17, 1, 0,-17, 0, 0, 0, -17, 0, 0, 0,-17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -17,-17,-17,-17, 1,-17,-17, 0, 1,-17,-17, 0, 1, 0, 0, 0, -17, 0,-17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -17,-17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; int aln_sm_hs[] = { /* A G C T N */ 91, -31,-114,-123, -44, -31, 100,-125,-114, -42, -123,-125, 100, -31, -42, -114,-114, -31, 91, -42, -44, -42, -42, -42, -43 }; int aln_sm_maq[] = { 11, -19, -19, -19, -13, -19, 11, -19, -19, -13, -19, -19, 11, -19, -13, -19, -19, -19, 11, -13, -13, -13, -13, -13, -13 }; int aln_sm_blast[] = { 1, -3, -3, -3, -2, -3, 1, -3, -3, -2, -3, -3, 1, -3, -2, -3, -3, -3, 1, -2, -2, -2, -2, -2, -2 }; /********************/ /* START OF align.c */ /********************/ AlnParam aln_param_blast = { 5, 2, 2, aln_sm_blast, 5, 50 }; AlnParam aln_param_bwa = { 26, 9, 5, aln_sm_maq, 5, 50 }; AlnParam aln_param_nt2nt = { 8, 2, 2, aln_sm_nt, 16, 75 }; AlnParam aln_param_rd2rd = { 1, 19, 19, aln_sm_read, 16, 75 }; AlnParam aln_param_aa2aa = { 10, 2, 2, aln_sm_blosum62, 22, 50 }; AlnAln *aln_init_AlnAln() { AlnAln *aa; aa = (AlnAln*)malloc(sizeof(AlnAln)); aa->path = 0; aa->out1 = aa->out2 = aa->outm = 0; aa->path_len = 0; return aa; } void aln_free_AlnAln(AlnAln *aa) { free(aa->path); free(aa->cigar32); free(aa->out1); free(aa->out2); free(aa->outm); free(aa); } /***************************/ /* START OF common_align.c */ /***************************/ #define LOCAL_OVERFLOW_THRESHOLD 32000 #define LOCAL_OVERFLOW_REDUCE 16000 #define NT_LOCAL_SCORE int #define NT_LOCAL_SHIFT 16 #define NT_LOCAL_MASK 0xffff #define SET_INF(s) (s).M = (s).I = (s).D = MINOR_INF; #define set_M(MM, cur, p, sc) \ { \ if ((p)->M >= (p)->I) { \ if ((p)->M >= (p)->D) { \ (MM) = (p)->M + (sc); (cur)->Mt = FROM_M; \ } else { \ (MM) = (p)->D + (sc); (cur)->Mt = FROM_D; \ } \ } else { \ if ((p)->I > (p)->D) { \ (MM) = (p)->I + (sc); (cur)->Mt = FROM_I; \ } else { \ (MM) = (p)->D + (sc); (cur)->Mt = FROM_D; \ } \ } \ } #define set_I(II, cur, p) \ { \ if ((p)->M - gap_open > (p)->I) { \ (cur)->It = FROM_M; \ (II) = (p)->M - gap_open - gap_ext; \ } else { \ (cur)->It = FROM_I; \ (II) = (p)->I - gap_ext; \ } \ } #define set_end_I(II, cur, p) \ { \ if (gap_end >= 0) { \ if ((p)->M - gap_open > (p)->I) { \ (cur)->It = FROM_M; \ (II) = (p)->M - gap_open - gap_end; \ } else { \ (cur)->It = FROM_I; \ (II) = (p)->I - gap_end; \ } \ } else set_I(II, cur, p); \ } #define set_D(DD, cur, p) \ { \ if ((p)->M - gap_open > (p)->D) { \ (cur)->Dt = FROM_M; \ (DD) = (p)->M - gap_open - gap_ext; \ } else { \ (cur)->Dt = FROM_D; \ (DD) = (p)->D - gap_ext; \ } \ } #define set_end_D(DD, cur, p) \ { \ if (gap_end >= 0) { \ if ((p)->M - gap_open > (p)->D) { \ (cur)->Dt = FROM_M; \ (DD) = (p)->M - gap_open - gap_end; \ } else { \ (cur)->Dt = FROM_D; \ (DD) = (p)->D - gap_end; \ } \ } else set_D(DD, cur, p); \ } typedef struct { unsigned char Mt:3, It:2, Dt:2; } dpcell_t; typedef struct { int M, I, D; } dpscore_t; /* build score profile for accelerating alignment, in theory */ void aln_init_score_array(unsigned char *seq, int len, int row, int *score_matrix, int **s_array) { int *tmp, *tmp2, i, k; for (i = 0; i != row; ++i) { tmp = score_matrix + i * row; tmp2 = s_array[i]; for (k = 0; k != len; ++k) tmp2[k] = tmp[seq[k]]; } } /*************************** * banded global alignment * ***************************/ int aln_global_core(unsigned char *seq1, int len1, unsigned char *seq2, int len2, const AlnParam *ap, path_t *path, int *path_len) { register int i, j; dpcell_t **dpcell, *q; dpscore_t *curr, *last, *s; path_t *p; int b1, b2, tmp_end; int *mat, end, max; unsigned char type, ctype; int gap_open, gap_ext, gap_end, b; int *score_matrix, N_MATRIX_ROW; /* initialize some align-related parameters. just for compatibility */ gap_open = ap->gap_open; gap_ext = ap->gap_ext; gap_end = ap->gap_end; b = ap->band_width; score_matrix = ap->matrix; N_MATRIX_ROW = ap->row; if (len1 == 0 || len2 == 0) { *path_len = 0; return 0; } /* calculate b1 and b2 */ if (len1 > len2) { b1 = len1 - len2 + b; b2 = b; } else { b1 = b; b2 = len2 - len1 + b; } if (b1 > len1) b1 = len1; if (b2 > len2) b2 = len2; --seq1; --seq2; /* allocate memory */ end = (b1 + b2 <= len1)? (b1 + b2 + 1) : (len1 + 1); dpcell = (dpcell_t**)malloc(sizeof(dpcell_t*) * (len2 + 1)); for (j = 0; j <= len2; ++j) dpcell[j] = (dpcell_t*)malloc(sizeof(dpcell_t) * end); for (j = b2 + 1; j <= len2; ++j) dpcell[j] -= j - b2; curr = (dpscore_t*)malloc(sizeof(dpscore_t) * (len1 + 1)); last = (dpscore_t*)malloc(sizeof(dpscore_t) * (len1 + 1)); /* set first row */ SET_INF(*curr); curr->M = 0; for (i = 1, s = curr + 1; i < b1; ++i, ++s) { SET_INF(*s); set_end_D(s->D, dpcell[0] + i, s - 1); } s = curr; curr = last; last = s; /* core dynamic programming, part 1 */ tmp_end = (b2 < len2)? b2 : len2 - 1; for (j = 1; j <= tmp_end; ++j) { q = dpcell[j]; s = curr; SET_INF(*s); set_end_I(s->I, q, last); end = (j + b1 <= len1 + 1)? (j + b1 - 1) : len1; mat = score_matrix + seq2[j] * N_MATRIX_ROW; ++s; ++q; for (i = 1; i != end; ++i, ++s, ++q) { set_M(s->M, q, last + i - 1, mat[seq1[i]]); /* this will change s->M ! */ set_I(s->I, q, last + i); set_D(s->D, q, s - 1); } set_M(s->M, q, last + i - 1, mat[seq1[i]]); set_D(s->D, q, s - 1); if (j + b1 - 1 > len1) { /* bug fixed, 040227 */ set_end_I(s->I, q, last + i); } else s->I = MINOR_INF; s = curr; curr = last; last = s; } /* last row for part 1, use set_end_D() instead of set_D() */ if (j == len2 && b2 != len2 - 1) { q = dpcell[j]; s = curr; SET_INF(*s); set_end_I(s->I, q, last); end = (j + b1 <= len1 + 1)? (j + b1 - 1) : len1; mat = score_matrix + seq2[j] * N_MATRIX_ROW; ++s; ++q; for (i = 1; i != end; ++i, ++s, ++q) { set_M(s->M, q, last + i - 1, mat[seq1[i]]); /* this will change s->M ! */ set_I(s->I, q, last + i); set_end_D(s->D, q, s - 1); } set_M(s->M, q, last + i - 1, mat[seq1[i]]); set_end_D(s->D, q, s - 1); if (j + b1 - 1 > len1) { /* bug fixed, 040227 */ set_end_I(s->I, q, last + i); } else s->I = MINOR_INF; s = curr; curr = last; last = s; ++j; } /* core dynamic programming, part 2 */ for (; j <= len2 - b2 + 1; ++j) { SET_INF(curr[j - b2]); mat = score_matrix + seq2[j] * N_MATRIX_ROW; end = j + b1 - 1; for (i = j - b2 + 1, q = dpcell[j] + i, s = curr + i; i != end; ++i, ++s, ++q) { set_M(s->M, q, last + i - 1, mat[seq1[i]]); set_I(s->I, q, last + i); set_D(s->D, q, s - 1); } set_M(s->M, q, last + i - 1, mat[seq1[i]]); set_D(s->D, q, s - 1); s->I = MINOR_INF; s = curr; curr = last; last = s; } /* core dynamic programming, part 3 */ for (; j < len2; ++j) { SET_INF(curr[j - b2]); mat = score_matrix + seq2[j] * N_MATRIX_ROW; for (i = j - b2 + 1, q = dpcell[j] + i, s = curr + i; i < len1; ++i, ++s, ++q) { set_M(s->M, q, last + i - 1, mat[seq1[i]]); set_I(s->I, q, last + i); set_D(s->D, q, s - 1); } set_M(s->M, q, last + len1 - 1, mat[seq1[i]]); set_end_I(s->I, q, last + i); set_D(s->D, q, s - 1); s = curr; curr = last; last = s; } /* last row */ if (j == len2) { SET_INF(curr[j - b2]); mat = score_matrix + seq2[j] * N_MATRIX_ROW; for (i = j - b2 + 1, q = dpcell[j] + i, s = curr + i; i < len1; ++i, ++s, ++q) { set_M(s->M, q, last + i - 1, mat[seq1[i]]); set_I(s->I, q, last + i); set_end_D(s->D, q, s - 1); } set_M(s->M, q, last + len1 - 1, mat[seq1[i]]); set_end_I(s->I, q, last + i); set_end_D(s->D, q, s - 1); s = curr; curr = last; last = s; } /* backtrace */ i = len1; j = len2; q = dpcell[j] + i; s = last + len1; max = s->M; type = q->Mt; ctype = FROM_M; if (s->I > max) { max = s->I; type = q->It; ctype = FROM_I; } if (s->D > max) { max = s->D; type = q->Dt; ctype = FROM_D; } p = path; p->ctype = ctype; p->i = i; p->j = j; /* bug fixed 040408 */ ++p; do { switch (ctype) { case FROM_M: --i; --j; break; case FROM_I: --j; break; case FROM_D: --i; break; } q = dpcell[j] + i; ctype = type; switch (type) { case FROM_M: type = q->Mt; break; case FROM_I: type = q->It; break; case FROM_D: type = q->Dt; break; } p->ctype = ctype; p->i = i; p->j = j; ++p; } while (i || j); *path_len = p - path - 1; /* free memory */ for (j = b2 + 1; j <= len2; ++j) dpcell[j] += j - b2; for (j = 0; j <= len2; ++j) free(dpcell[j]); free(dpcell); free(curr); free(last); return max; } /************************************************* * local alignment combined with banded strategy * *************************************************/ int aln_local_core(unsigned char *seq1, int len1, unsigned char *seq2, int len2, const AlnParam *ap, path_t *path, int *path_len, int _thres, int *_subo) { register NT_LOCAL_SCORE *s; register int i; int q, r, qr, tmp_len, qr_shift; int **s_array, *score_array; int e, f; int is_overflow, of_base; NT_LOCAL_SCORE *eh, curr_h, last_h, curr_last_h; int j, start_i, start_j, end_i, end_j; path_t *p; int score_f, score_r, score_g; int start, end, max_score; int thres, *suba, *ss; int gap_open, gap_ext, b; int *score_matrix, N_MATRIX_ROW; /* initialize some align-related parameters. just for compatibility */ gap_open = ap->gap_open; gap_ext = ap->gap_ext; b = ap->band_width; score_matrix = ap->matrix; N_MATRIX_ROW = ap->row; thres = _thres > 0? _thres : -_thres; if (len1 == 0 || len2 == 0) return -1; /* allocate memory */ suba = (int*)malloc(sizeof(int) * (len2 + 1)); eh = (NT_LOCAL_SCORE*)malloc(sizeof(NT_LOCAL_SCORE) * (len1 + 1)); s_array = (int**)malloc(sizeof(int*) * N_MATRIX_ROW); for (i = 0; i != N_MATRIX_ROW; ++i) s_array[i] = (int*)malloc(sizeof(int) * len1); /* initialization */ aln_init_score_array(seq1, len1, N_MATRIX_ROW, score_matrix, s_array); q = gap_open; r = gap_ext; qr = q + r; qr_shift = (qr+1) << NT_LOCAL_SHIFT; tmp_len = len1 + 1; start_i = start_j = end_i = end_j = 0; for (i = 0, max_score = 0; i != N_MATRIX_ROW * N_MATRIX_ROW; ++i) if (max_score < score_matrix[i]) max_score = score_matrix[i]; /* convert the coordinate */ --seq1; --seq2; for (i = 0; i != N_MATRIX_ROW; ++i) --s_array[i]; /* forward dynamic programming */ for (i = 0, s = eh; i != tmp_len; ++i, ++s) *s = 0; score_f = 0; is_overflow = of_base = 0; suba[0] = 0; for (j = 1, ss = suba + 1; j <= len2; ++j, ++ss) { int subo = 0; last_h = f = 0; score_array = s_array[seq2[j]]; if (is_overflow) { /* adjust eh[] array if overflow occurs. */ /* If LOCAL_OVERFLOW_REDUCE is too small, optimal alignment might be missed. * If it is too large, this block will be excuted frequently and therefore * slow down the whole program. * Acually, smaller LOCAL_OVERFLOW_REDUCE might also help to reduce the * number of assignments because it sets some cells to zero when overflow * happens. */ int tmp, tmp2; score_f -= LOCAL_OVERFLOW_REDUCE; of_base += LOCAL_OVERFLOW_REDUCE; is_overflow = 0; for (i = 1, s = eh; i <= tmp_len; ++i, ++s) { tmp = *s >> NT_LOCAL_SHIFT; tmp2 = *s & NT_LOCAL_MASK; if (tmp2 < LOCAL_OVERFLOW_REDUCE) tmp2 = 0; else tmp2 -= LOCAL_OVERFLOW_REDUCE; if (tmp < LOCAL_OVERFLOW_REDUCE) tmp = 0; else tmp -= LOCAL_OVERFLOW_REDUCE; *s = (tmp << NT_LOCAL_SHIFT) | tmp2; } } for (i = 1, s = eh; i != tmp_len; ++i, ++s) { /* prepare for calculate current h */ curr_h = (*s >> NT_LOCAL_SHIFT) + score_array[i]; if (curr_h < 0) curr_h = 0; if (last_h > 0) { /* initialize f */ f = (f > last_h - q)? f - r : last_h - qr; if (curr_h < f) curr_h = f; } if (*(s+1) >= qr_shift) { /* initialize e */ curr_last_h = *(s+1) >> NT_LOCAL_SHIFT; e = ((*s & NT_LOCAL_MASK) > curr_last_h - q)? (*s & NT_LOCAL_MASK) - r : curr_last_h - qr; if (curr_h < e) curr_h = e; *s = (last_h << NT_LOCAL_SHIFT) | e; } else *s = last_h << NT_LOCAL_SHIFT; /* e = 0 */ last_h = curr_h; if (subo < curr_h) subo = curr_h; if (score_f < curr_h) { score_f = curr_h; end_i = i; end_j = j; if (score_f > LOCAL_OVERFLOW_THRESHOLD) is_overflow = 1; } } *s = last_h << NT_LOCAL_SHIFT; *ss = subo + of_base; } score_f += of_base; if (score_f < thres) { /* no matching residue at all, 090218 */ *path_len = 0; goto end_func; } if (path == 0) goto end_func; /* skip path-filling */ /* reverse dynamic programming */ for (i = end_i, s = eh + end_i; i >= 0; --i, --s) *s = 0; if (end_i == 0 || end_j == 0) goto end_func; /* no local match */ score_r = score_matrix[seq1[end_i] * N_MATRIX_ROW + seq2[end_j]]; is_overflow = of_base = 0; start_i = end_i; start_j = end_j; eh[end_i] = ((NT_LOCAL_SCORE)(qr + score_r)) << NT_LOCAL_SHIFT; /* in order to initialize f and e, 040408 */ start = end_i - 1; end = end_i - 3; if (end <= 0) end = 0; /* second pass DP can be done in a band, speed will thus be enhanced */ for (j = end_j - 1; j != 0; --j) { last_h = f = 0; score_array = s_array[seq2[j]]; if (is_overflow) { /* adjust eh[] array if overflow occurs. */ int tmp, tmp2; score_r -= LOCAL_OVERFLOW_REDUCE; of_base += LOCAL_OVERFLOW_REDUCE; is_overflow = 0; for (i = start, s = eh + start + 1; i >= end; --i, --s) { tmp = *s >> NT_LOCAL_SHIFT; tmp2 = *s & NT_LOCAL_MASK; if (tmp2 < LOCAL_OVERFLOW_REDUCE) tmp2 = 0; else tmp2 -= LOCAL_OVERFLOW_REDUCE; if (tmp < LOCAL_OVERFLOW_REDUCE) tmp = 0; else tmp -= LOCAL_OVERFLOW_REDUCE; *s = (tmp << NT_LOCAL_SHIFT) | tmp2; } } for (i = start, s = eh + start + 1; i != end; --i, --s) { /* prepare for calculate current h */ curr_h = (*s >> NT_LOCAL_SHIFT) + score_array[i]; if (curr_h < 0) curr_h = 0; if (last_h > 0) { /* initialize f */ f = (f > last_h - q)? f - r : last_h - qr; if (curr_h < f) curr_h = f; } curr_last_h = *(s-1) >> NT_LOCAL_SHIFT; e = ((*s & NT_LOCAL_MASK) > curr_last_h - q)? (*s & NT_LOCAL_MASK) - r : curr_last_h - qr; if (e < 0) e = 0; if (curr_h < e) curr_h = e; *s = (last_h << NT_LOCAL_SHIFT) | e; last_h = curr_h; if (score_r < curr_h) { score_r = curr_h; start_i = i; start_j = j; if (score_r + of_base - qr == score_f) { j = 1; break; } if (score_r > LOCAL_OVERFLOW_THRESHOLD) is_overflow = 1; } } *s = last_h << NT_LOCAL_SHIFT; /* recalculate start and end, the boundaries of the band */ if ((eh[start] >> NT_LOCAL_SHIFT) <= qr) --start; if (start <= 0) start = 0; end = start_i - (start_j - j) - (score_r + of_base + (start_j - j) * max_score) / r - 1; if (end <= 0) end = 0; } if (_subo) { int tmp2 = 0, tmp = (int)(start_j - .33 * (end_j - start_j) + .499); for (j = 1; j <= tmp; ++j) if (tmp2 < suba[j]) tmp2 = suba[j]; tmp = (int)(end_j + .33 * (end_j - start_j) + .499); for (j = tmp; j <= len2; ++j) if (tmp2 < suba[j]) tmp2 = suba[j]; *_subo = tmp2; } if (path_len == 0) { path[0].i = start_i; path[0].j = start_j; path[1].i = end_i; path[1].j = end_j; goto end_func; } score_r += of_base; score_r -= qr; #ifdef DEBUG /* this seems not a bug */ if (score_f != score_r) fprintf(stderr, "[aln_local_core] unknown flaw occurs: score_f(%d) != score_r(%d)\n", score_f, score_r); #endif if (_thres > 0) { /* call global alignment to fill the path */ score_g = 0; j = (end_i - start_i > end_j - start_j)? end_i - start_i : end_j - start_j; ++j; /* j is the maximum band_width */ for (i = ap->band_width;; i <<= 1) { AlnParam ap_real = *ap; ap_real.gap_end = -1; ap_real.band_width = i; score_g = aln_global_core(seq1 + start_i, end_i - start_i + 1, seq2 + start_j, end_j - start_j + 1, &ap_real, path, path_len); if (score_g == score_r || score_f == score_g) break; if (i > j) break; } if (score_r > score_g && score_f > score_g) { fprintf(stderr, "[aln_local_core] Potential bug: (%d,%d) > %d\n", score_f, score_r, score_g); score_f = score_r = -1; } else score_f = score_g; /* convert coordinate */ for (p = path + *path_len - 1; p >= path; --p) { p->i += start_i - 1; p->j += start_j - 1; } } else { /* just store the start and end */ *path_len = 2; path[1].i = start_i; path[1].j = start_j; path->i = end_i; path->j = end_j; } end_func: /* free */ free(eh); free(suba); for (i = 0; i != N_MATRIX_ROW; ++i) { ++s_array[i]; free(s_array[i]); } free(s_array); return score_f; } AlnAln *aln_stdaln_aux(const char *seq1, const char *seq2, const AlnParam *ap, int type, int thres, int len1, int len2) { unsigned char *seq11, *seq22; int score; int i, j, l; path_t *p; char *out1, *out2, *outm; AlnAln *aa; if (len1 < 0) len1 = strlen(seq1); if (len2 < 0) len2 = strlen(seq2); aa = aln_init_AlnAln(); seq11 = (unsigned char*)malloc(sizeof(unsigned char) * len1); seq22 = (unsigned char*)malloc(sizeof(unsigned char) * len2); aa->path = (path_t*)malloc(sizeof(path_t) * (len1 + len2 + 1)); if (ap->row < 10) { /* 4-nucleotide alignment */ for (i = 0; i < len1; ++i) seq11[i] = aln_nt4_table[(int)seq1[i]]; for (j = 0; j < len2; ++j) seq22[j] = aln_nt4_table[(int)seq2[j]]; } else if (ap->row < 20) { /* 16-nucleotide alignment */ for (i = 0; i < len1; ++i) seq11[i] = aln_nt16_table[(int)seq1[i]]; for (j = 0; j < len2; ++j) seq22[j] = aln_nt16_table[(int)seq2[j]]; } else { /* amino acids */ for (i = 0; i < len1; ++i) seq11[i] = aln_aa_table[(int)seq1[i]]; for (j = 0; j < len2; ++j) seq22[j] = aln_aa_table[(int)seq2[j]]; } if (type == ALN_TYPE_GLOBAL) score = aln_global_core(seq11, len1, seq22, len2, ap, aa->path, &aa->path_len); else if (type == ALN_TYPE_LOCAL) score = aln_local_core(seq11, len1, seq22, len2, ap, aa->path, &aa->path_len, thres, &aa->subo); else if (type == ALN_TYPE_EXTEND) score = aln_extend_core(seq11, len1, seq22, len2, ap, aa->path, &aa->path_len, 1, 0); else { free(seq11); free(seq22); free(aa->path); aln_free_AlnAln(aa); return 0; } aa->score = score; if (thres > 0) { out1 = aa->out1 = (char*)malloc(sizeof(char) * (aa->path_len + 1)); out2 = aa->out2 = (char*)malloc(sizeof(char) * (aa->path_len + 1)); outm = aa->outm = (char*)malloc(sizeof(char) * (aa->path_len + 1)); --seq1; --seq2; --seq11; --seq22; p = aa->path + aa->path_len - 1; for (l = 0; p >= aa->path; --p, ++l) { switch (p->ctype) { case FROM_M: out1[l] = seq1[p->i]; out2[l] = seq2[p->j]; outm[l] = (seq11[p->i] == seq22[p->j] && seq11[p->i] != ap->row)? '|' : ' '; break; case FROM_I: out1[l] = '-'; out2[l] = seq2[p->j]; outm[l] = ' '; break; case FROM_D: out1[l] = seq1[p->i]; out2[l] = '-'; outm[l] = ' '; break; } } out1[l] = out2[l] = outm[l] = '\0'; ++seq11; ++seq22; } free(seq11); free(seq22); p = aa->path + aa->path_len - 1; aa->start1 = p->i? p->i : 1; aa->end1 = aa->path->i; aa->start2 = p->j? p->j : 1; aa->end2 = aa->path->j; aa->cigar32 = aln_path2cigar32(aa->path, aa->path_len, &aa->n_cigar); return aa; } AlnAln *aln_stdaln(const char *seq1, const char *seq2, const AlnParam *ap, int type, int thres) { return aln_stdaln_aux(seq1, seq2, ap, type, thres, -1, -1); } /* for backward compatibility */ uint16_t *aln_path2cigar(const path_t *path, int path_len, int *n_cigar) { uint32_t *cigar32; uint16_t *cigar; int i; cigar32 = aln_path2cigar32(path, path_len, n_cigar); cigar = (uint16_t*)cigar32; for (i = 0; i < *n_cigar; ++i) cigar[i] = (cigar32[i]&0xf)<<14 | (cigar32[i]>>4&0x3fff); return cigar; } /* newly added functions (2009-07-21) */ int aln_extend_core(unsigned char *seq1, int len1, unsigned char *seq2, int len2, const AlnParam *ap, path_t *path, int *path_len, int G0, uint8_t *_mem) { int q, r, qr, tmp_len; int32_t **s_array, *score_array; int is_overflow, of_base; uint32_t *eh; int i, j, end_i, end_j; int score, start, end; int *score_matrix, N_MATRIX_ROW; uint8_t *mem, *_p; /* initialize some align-related parameters. just for compatibility */ q = ap->gap_open; r = ap->gap_ext; qr = q + r; score_matrix = ap->matrix; N_MATRIX_ROW = ap->row; if (len1 == 0 || len2 == 0) return -1; /* allocate memory */ mem = _mem? _mem : calloc((len1 + 2) * (N_MATRIX_ROW + 1), 4); _p = mem; eh = (uint32_t*)_p, _p += 4 * (len1 + 2); s_array = calloc(N_MATRIX_ROW, sizeof(void*)); for (i = 0; i != N_MATRIX_ROW; ++i) s_array[i] = (int32_t*)_p, _p += 4 * len1; /* initialization */ aln_init_score_array(seq1, len1, N_MATRIX_ROW, score_matrix, s_array); tmp_len = len1 + 1; start = 1; end = 2; end_i = end_j = 0; score = 0; is_overflow = of_base = 0; /* convert the coordinate */ --seq1; --seq2; for (i = 0; i != N_MATRIX_ROW; ++i) --s_array[i]; /* dynamic programming */ memset(eh, 0, 4 * (len1 + 2)); eh[1] = (uint32_t)G0<<16; for (j = 1; j <= len2; ++j) { int _start, _end; int h1 = 0, f = 0; score_array = s_array[seq2[j]]; /* set start and end */ _start = j - ap->band_width; if (_start < 1) _start = 1; if (_start > start) start = _start; _end = j + ap->band_width; if (_end > len1 + 1) _end = len1 + 1; if (_end < end) end = _end; if (start == end) break; /* adjust eh[] array if overflow occurs. */ if (is_overflow) { int tmp, tmp2; score -= LOCAL_OVERFLOW_REDUCE; of_base += LOCAL_OVERFLOW_REDUCE; is_overflow = 0; for (i = start; i <= end; ++i) { uint32_t *s = &eh[i]; tmp = *s >> 16; tmp2 = *s & 0xffff; if (tmp2 < LOCAL_OVERFLOW_REDUCE) tmp2 = 0; else tmp2 -= LOCAL_OVERFLOW_REDUCE; if (tmp < LOCAL_OVERFLOW_REDUCE) tmp = 0; else tmp -= LOCAL_OVERFLOW_REDUCE; *s = (tmp << 16) | tmp2; } } _start = _end = 0; /* the inner loop */ for (i = start; i < end; ++i) { /* At the beginning of each cycle: eh[i] -> h[j-1,i-1]<<16 | e[j,i] f -> f[j,i] h1 -> h[j,i-1] */ uint32_t *s = &eh[i]; int h = (int)(*s >> 16); int e = *s & 0xffff; /* this is e[j,i] */ *s = (uint32_t)h1 << 16; /* eh[i] now stores h[j,i-1]<<16 */ h += h? score_array[i] : 0; /* this is left_core() specific */ /* calculate h[j,i]; don't need to test 0, as {e,f}>=0 */ h = h > e? h : e; h = h > f? h : f; /* h now is h[j,i] */ h1 = h; if (h > 0) { if (_start == 0) _start = i; _end = i; if (score < h) { score = h; end_i = i; end_j = j; if (score > LOCAL_OVERFLOW_THRESHOLD) is_overflow = 1; } } /* calculate e[j+1,i] and f[j,i+1] */ h -= qr; h = h > 0? h : 0; e -= r; e = e > h? e : h; f -= r; f = f > h? f : h; *s |= e; } eh[end] = h1 << 16; /* recalculate start and end, the boundaries of the band */ if (_end <= 0) break; /* no cell in this row has a positive score */ start = _start; end = _end + 3; } score += of_base - 1; if (score <= 0) { if (path_len) *path_len = 0; goto end_left_func; } if (path == 0) goto end_left_func; if (path_len == 0) { path[0].i = end_i; path[0].j = end_j; goto end_left_func; } { /* call global alignment to fill the path */ int score_g = 0; j = (end_i - 1 > end_j - 1)? end_i - 1 : end_j - 1; ++j; /* j is the maximum band_width */ for (i = ap->band_width;; i <<= 1) { AlnParam ap_real = *ap; ap_real.gap_end = -1; ap_real.band_width = i; score_g = aln_global_core(seq1 + 1, end_i, seq2 + 1, end_j, &ap_real, path, path_len); if (score == score_g) break; if (i > j) break; } if (score > score_g) fprintf(stderr, "[aln_left_core] no suitable bandwidth: %d < %d\n", score_g, score); score = score_g; } end_left_func: /* free */ free(s_array); if (!_mem) free(mem); return score; } uint32_t *aln_path2cigar32(const path_t *path, int path_len, int *n_cigar) { int i, n; uint32_t *cigar; unsigned char last_type; if (path_len == 0 || path == 0) { *n_cigar = 0; return 0; } last_type = path->ctype; for (i = n = 1; i < path_len; ++i) { if (last_type != path[i].ctype) ++n; last_type = path[i].ctype; } *n_cigar = n; cigar = (uint32_t*)malloc(*n_cigar * 4); cigar[0] = 1u << 4 | path[path_len-1].ctype; last_type = path[path_len-1].ctype; for (i = path_len - 2, n = 0; i >= 0; --i) { if (path[i].ctype == last_type) cigar[n] += 1u << 4; else { cigar[++n] = 1u << 4 | path[i].ctype; last_type = path[i].ctype; } } return cigar; } #ifdef STDALN_MAIN int main() { AlnAln *aln_local, *aln_global, *aln_left; int i; aln_local = aln_stdaln("CGTGCGATGCactgCATACGGCTCGCCTAGATCA", "AAGGGATGCTCTGCATCgCTCGGCTAGCTGT", &aln_param_blast, 0, 1); aln_global = aln_stdaln("CGTGCGATGCactgCATACGGCTCGCCTAGATCA", "AAGGGATGCTCTGCATCGgCTCGGCTAGCTGT", &aln_param_blast, 1, 1); // aln_left = aln_stdaln( "GATGCACTGCATACGGCTCGCCTAGATCA", "GATGCTCTGCATCGgCTCGGCTAGCTGT", &aln_param_blast, 2, 1); aln_left = aln_stdaln("CACCTTCGACTCACGTCTCATTCTCGGAGTCGAGTGGACGGTCCCTCATACACGAACAGGTTC", "CACCTTCGACTTTCACCTCTCATTCTCGGACTCGAGTGGACGGTCCCTCATCCAAGAACAGGGTCTGTGAAA", &aln_param_blast, 2, 1); printf(">%d,%d\t%d,%d\n", aln_local->start1, aln_local->end1, aln_local->start2, aln_local->end2); printf("%s\n%s\n%s\n", aln_local->out1, aln_local->outm, aln_local->out2); printf(">%d,%d\t%d,%d\t", aln_global->start1, aln_global->end1, aln_global->start2, aln_global->end2); for (i = 0; i != aln_global->n_cigar; ++i) printf("%d%c", aln_global->cigar32[i]>>4, "MID"[aln_global->cigar32[i]&0xf]); printf("\n%s\n%s\n%s\n", aln_global->out1, aln_global->outm, aln_global->out2); printf(">%d\t%d,%d\t%d,%d\t", aln_left->score, aln_left->start1, aln_left->end1, aln_left->start2, aln_left->end2); for (i = 0; i != aln_left->n_cigar; ++i) printf("%d%c", aln_left->cigar32[i]>>4, "MID"[aln_left->cigar32[i]&0xf]); printf("\n%s\n%s\n%s\n", aln_left->out1, aln_left->outm, aln_left->out2); aln_free_AlnAln(aln_local); aln_free_AlnAln(aln_global); aln_free_AlnAln(aln_left); return 0; } #endif nanopolish-0.4.0/src/thirdparty/stdaln.h000066400000000000000000000111611260522445600203120ustar00rootroot00000000000000/* The MIT License Copyright (c) 2003-2006, 2008, by Heng Li Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /* 2009-07-23, 0.10.0 - Use 32-bit to store CIGAR - Report suboptimal aligments - Implemented half-fixed-half-open DP 2009-04-26, 0.9.10 - Allow to set a threshold for local alignment 2009-02-18, 0.9.9 - Fixed a bug when no residue matches 2008-08-04, 0.9.8 - Fixed the wrong declaration of aln_stdaln_aux() - Avoid 0 coordinate for global alignment 2008-08-01, 0.9.7 - Change gap_end penalty to 5 in aln_param_bwa - Add function to convert path_t to the CIGAR format 2008-08-01, 0.9.6 - The first gap now costs (gap_open+gap_ext), instead of gap_open. Scoring systems are modified accordingly. - Gap end is now correctly handled. Previously it is not correct. - Change license to MIT. */ #ifndef LH3_STDALN_H_ #define LH3_STDALN_H_ #define STDALN_VERSION 0.11.0 #include #define FROM_M 0 #define FROM_I 1 #define FROM_D 2 #define FROM_S 3 #define ALN_TYPE_LOCAL 0 #define ALN_TYPE_GLOBAL 1 #define ALN_TYPE_EXTEND 2 /* This is the smallest integer. It might be CPU-dependent in very RARE cases. */ #define MINOR_INF -1073741823 typedef struct { int gap_open; int gap_ext; int gap_end; int *matrix; int row; int band_width; } AlnParam; typedef struct { int i, j; unsigned char ctype; } path_t; typedef struct { path_t *path; /* for advanced users... :-) */ int path_len; /* for advanced users... :-) */ int start1, end1; /* start and end of the first sequence, coordinations are 1-based */ int start2, end2; /* start and end of the second sequence, coordinations are 1-based */ int score, subo; /* score */ char *out1, *out2; /* print them, and then you will know */ char *outm; int n_cigar; uint32_t *cigar32; } AlnAln; #ifdef __cplusplus extern "C" { #endif AlnAln *aln_stdaln_aux(const char *seq1, const char *seq2, const AlnParam *ap, int type, int do_align, int len1, int len2); AlnAln *aln_stdaln(const char *seq1, const char *seq2, const AlnParam *ap, int type, int do_align); void aln_free_AlnAln(AlnAln *aa); int aln_global_core(unsigned char *seq1, int len1, unsigned char *seq2, int len2, const AlnParam *ap, path_t *path, int *path_len); int aln_local_core(unsigned char *seq1, int len1, unsigned char *seq2, int len2, const AlnParam *ap, path_t *path, int *path_len, int _thres, int *_subo); int aln_extend_core(unsigned char *seq1, int len1, unsigned char *seq2, int len2, const AlnParam *ap, path_t *path, int *path_len, int G0, uint8_t *_mem); uint16_t *aln_path2cigar(const path_t *path, int path_len, int *n_cigar); uint32_t *aln_path2cigar32(const path_t *path, int path_len, int *n_cigar); #ifdef __cplusplus } #endif /******************** * global variables * ********************/ extern AlnParam aln_param_bwa; /* = { 37, 9, 0, aln_sm_maq, 5, 50 }; */ extern AlnParam aln_param_blast; /* = { 5, 2, 2, aln_sm_blast, 5, 50 }; */ extern AlnParam aln_param_nt2nt; /* = { 10, 2, 2, aln_sm_nt, 16, 75 }; */ extern AlnParam aln_param_aa2aa; /* = { 20, 19, 19, aln_sm_read, 16, 75 }; */ extern AlnParam aln_param_rd2rd; /* = { 12, 2, 2, aln_sm_blosum62, 22, 50 }; */ /* common nucleotide score matrix for 16 bases */ extern int aln_sm_nt[], aln_sm_bwa[]; /* BLOSUM62 and BLOSUM45 */ extern int aln_sm_blosum62[], aln_sm_blosum45[]; /* common read for 16 bases. note that read alignment is quite different from common nucleotide alignment */ extern int aln_sm_read[]; /* human-mouse score matrix for 4 bases */ extern int aln_sm_hs[]; #endif nanopolish-0.4.0/test/000077500000000000000000000000001260522445600146525ustar00rootroot00000000000000nanopolish-0.4.0/test/data/000077500000000000000000000000001260522445600155635ustar00rootroot00000000000000nanopolish-0.4.0/test/data/LomanLabz_PC_Ecoli_K12_R7.3_2549_1_ch8_file30_strand.fast5000077500000000000000000070365071260522445600274400ustar00rootroot00000000000000HDF  G=`%9`TREE(HEAPX8SequencesAnalysesUniqueGlobalKey HhTREE HEAPXMetaHSNOD   Hh(99;0 `TREE HEAPX PSNOD(Pp Pp 8versionFAST4:2 Xtool!ONTFAST5TOOLS REVISION: windows/0 H precision uint_16bit Pnumerical_encoding-1000log10(1-p) TREEHEAPX0EventDetection_000Basecall_2D_000(`TREEHEAPX ReadsConfiguration8SNOD HPxTREE HEAPXRead_24HSNOD,,.X6TREE%HEAPXEventsHSNOD`p mean ?@4 4stdv ?@4 4start@length@&0 deflate  uTTREE 1`&GEldJD>CF B U5  ? ^3}K+KCv6 5 9%$>X?cw:(Bܵ&,!/"D50$s%2/4'Q=(p,8*(%+TB<-yC.. SNODhx^]yfx߾N^xwt[~`c19>䠇# ߫VLr.+I CRWvh ~B ˜Ao?D%vskNv4~=b2y%] bL" 2totCKPƁkTyS;+ާ[ٞKftsX诘M}{i">T OFOzI_ǵxNFH`̏\fj2rſ44 U|=( љ='V-х3(FU&rÕ ȀH}zD,YFw- B>]r%KWQ:uQ 9zIgסVP.tE:W9/ft:'CX{K5GG{Rt_yw=c>LeMV:M>ng|@'N'_?|B~Xj,pսwj{1YGҶ?G"Чۏ.PP^'N|o7m7 լD1)E{2GZ޺t_~ƽv ^q`#&h1 I-u)9>//sޝy\(<:gm;yvK7ڮnbue2z/I'VD.}&՛ak %+ru{9æ{BgOܚ/ #CE؅xke &3^&"B9G[,Ņ;.j)E/GΕv>?# nrUDvjT=ZU1F%5LDV(&ss2ϣqGw8}C#y:lIB_PMeC덇JxyIGEx +篊/kc=u#4UҞm,OgmULy~YE=+AIUONjjCѫ m|U=k:HI 2)ySEsibvfߒ">ԛ#%m:˃ $dWڙoA]b.ħ9%%ڵGmן`[ZH:Q#mQuyB[T z["$';8wrv (g9Utwړ0(^~|\XL~О~aY&eJJ3_`#>.oDed/ڙ&=dD@?4| 4),"i٘DAѬm}S0Ut3o3J*&hY#p)_]B8GKޝā*u8~I]`}SoCYNLjݹn&.ݱ̳&WLA޷B%b.Ew{L͆_$A3x}fDL~dt&ce%nVڇ6|h oN .:s]vwdž_Ə"ED/G uu3c ux~g("uN)G9q@@;S?rW7pcD^DG#ru:Ey3#Ťr4(Pzq;1GEo)B]QK4pg3 :S_,$;)X^$_Lϳqo KJvfgPq'Z JmFfnfך\%8N8cD~T=u[H/D?zì\Sgr8 }&R}X7UDr;4-?/|!"}hOGhW{'LZ<^)A a^y@^Dލjtpu`4~W%"sUiߧ<O,UBPz- Mj33l<8ڱ/#ʺE9 _) љN8[(_C "N;<"FPPn%>줈x3kT7 _+NScvsR,6䟷+ya\x||Ƙsf7ĘY@I&!!!3}ʹJL4i@/-PQ`>0c\p=Uٟvf|*+s-s*zI*:S_4]!MYs,{?{Lٷ7u,@; =5ˮ?{3,EƯ;L OZ[c|{GקWM9Gv'Oh]x1/K?XТ$} G.rۨiWvAeϴŹAEA:W] &'EA"x F_bi{lx&^M;Gml+֖]_sw~!'L5s!7 J z?Qf-!L6@53BmuhFm֔cs}Y}Oj& BݨO/F;>vIrpEÇ-L4Dp# oEo61ԟu^ Oڶ]/|(hNlǣJ&!oЧ,>)MoI*)cgpa|NC\@[x=d.߼6WDCr3kt8]D hg~1SYGk30C:9=u.Â[>n;mmp.*O/nU-!u^*쑲ꍪ3+}Ǒΰ1yB?[q|v̷I[?>V@G l= =xdyMP{v$L~tF>zMvvkDlfcv$ߗR %۸aR*"עK߼u&3+#] 3L?_Z< 9 hGNJ&-۔3sGtfR|8`>L׾)!chg+wB4.u E*љ'>⁶O_D/:#n{ͧ/{l3ڙ 3'[E'nE]d+z$:α,p>mw];7W?9:/F5q8;'YJ4.xPbki 0~YCC^ǾÅcZ%. 9nP ;J~ߘ[/%}уc3ƞ]Qd̛J;-'7mhqz|ظNWJ~ZC~{џ x}uŗ=`L~V%d&:3 Nq`q}7EM)IF7FWx` Gz+*Kt^&1L*JK] GqQe!7=.?%mhgNYy[6TLfL_oagg ɪgb԰Amħg{KN=R.dڙ_g>M1촵֊aVRc>vd3a +9gpK{zϛx[7,-r̛GA%W&*b]@Lvpig\gts!}ҋKΔZGbDͧ;<~ƃ赡fP0BUiBgY7WksTvEJhgt$G犠㬔FwFoS9 iޣLp6_\˃MwFK;-蹙>imxc;,'$OЙ WF^YkAg*R^՝NRBNtY\ni#!љn6ϖH]7)1fGW>P"`C1Dg/<ݾɁ]3$ 2jwgsHI&1}*vTa <l>NpLF,]ig/ݝ 9}6vwt|CQvjs$]^IG m865+tj_:N3w"~Ӓ< O( Й9h+k(sh/Dw]5!P Fe}>! ЙouOyWi\ڙkiSlY)Ttf~z%zp^mЙ Q\:IQyn/Y@;b]7w~H7>$l~u:0hgoY<4:HLtoNUnY CW7<0B :Wnn8x>{h>, T0ㅴx?1::PҬ9pN7dNF4qDϻI"/z,T(@7:{^8ZP^?2K!& =igRUkdF:s~?o{!Ny7LLF//7y /]HoڙT׶5CEZ4g` '- NKhg#|>Dg޿!_ s ]-~qլ; yJ_|eCKE B҆?4U_+ Ö˅Ȍb9ܣTYPx6uR O{\?}KLnaxDÑOhYK4?`C٧z7tUW1t3gݵRtS+8""\Nn_ţ`䌐^A^|Q..m~c y\_3ED31Qø05լ^/"wY5*/nK٠]d_1xe 6Vp\t8f|p+^^\c'"@/+u{6Ws~/!Aoܶ7<^Ш !BLƮ6 帀YקIڙm!w2 v뤹\&FE YlEȅf}f3\X^XђN3S]wys)qEZ}dd:ڙcl+ X`+ALDLȠnz6$,$ΜUvDޤ`Q7:ɹ 3=4(NB&ۋH.z jj#}*(DsW5f>vƕRP~o؍/׍hD$>p 9o?; _uiKI9zCTL[魜zKDr6> /5@8AwR'%?boAlvn1E0v yַ%Vڷ`,ySgtۿןbK>ID yCj)=%5vWgi Vn$пIAV+e 94WhƂɖ[xe ЀMuTsin1N;s|@ b/!KљN` _.ɏ/~ ڈnΩےҌ Ą8䋣,/Tm*"A{>Ʒ[]MA[մ:bmSRV9p^tGgo.AHe6ҌO-~fU0aԥ3tUZ^oC<Ҟ ]H 2E{ѥͪX#ov /Ֆ\MszΆv3O ڧx^]yXM]c" IeT@k|973"2$!)S2ED$ތ2D(4cgyq=s>{>*k]18LXV[5Ըy`XxQ JnA^zh[FT xy7m%0ޣ4x7&LR䶆X/Ia |r>< iM>zIߑ]gwg_3n}  W3Xkkg!w.2*A$5+ZԤ,:&&.JTCrwZԦ3)_zٵ՛%x}`eOJ Z(s{Xɡv޽-c۾%3zM:jssuontroA{'W$ 4M&&{lBIے oe񌿆,fa Ʌ7\M F#|G :t6Gd~RY~;9l!ޏhq{nщfih`U!:O\?YZd,vi!?@Jw[>DҞENU2( Enq",.|4o_?aoMo&S䏮 8r"?L>΍Yܥ9$^EBś=U>`^=&|j=*V䰋|$EZ\ny[A >"!i1Z/j} ^CtvP$طFۨZĸJvB[? H}=!gw_voxG>\ͱ#ku-}g`{ m4H3wT^>ڗb7:_+Ã'飯W\7lZ^w_ !KfbȦ7ʡ|/yXa>O7|ƞ}(Rט{ӪN;[ |3 ιAq0*w\~-?F ,QsgRz,`eͻ0>w4Q.BV O``ExڅӤ|t".?Q>б{󼇑O\{)Q]C9VA'Nd`m/!cfG> Vl {sƇ,˰rrT񾘼ʐY4/ 06O&2p`u1X3XeB}"p1:* ϻKcWK0,r ?Iں'n7ߠޅ.^_T1H\ȯ*3@?9p\ RotsS $TؽMCu)=]<eݻ Bd돨A ']+i;?=|T* ~η`"?xΠ'Z;wݶdzCB I.92yW#lrz=V>Oǔ};=OoqwHpI#Nrz{jͬl_âGE3_>jMj,Wܳ;E xC.[squ Fy=h$ߤo :bexT_צe ^ LQȡ9 qFvCKޅv1ˠy xBޟ|b̈́y,[-5t}}\K˗PV0-~dsdKAqYJ8H.&1+H׋M\X94 fWkT鲢E9ON )K7Xm}S׿5uڿƆ_dp1`[ޅ(}n g |S[w28B(]ɅK̯jOm3>Ŕ' D80+:{OG/_'By9,_`s_Fw>>%~ms |y.w!AA|SA,voVhŷJޅk44C.~J:OK d\~Q.j!dk 8{gVE>x#7(%5 OPc\z7ʽ__`ѯ,!?Jm^3G-\S˻1Q5W}zaGת`) n%Fh76r!?rX'm/Y؇۞iyBS <+1a1.A' Ԟ{=e1xy&$#c|d3|4kS;/ܙ"cF]Nu1@ፃ] a]a6Uu5yv,FT STj`r Z.Q4T 6.Ƶ{ňwώ|!ȇdYgq;?\|#۳k:fp{ $BXCQ.BIy?@ϝâՋ?p<:ϸn |. xywK$7pۤ9 {e,s<E޷R6 ͣi#[po6Uqra~]dV&O<*X{ ȟ/kJ fp}9ĶK.%8pTΙRڎw!Q?7Y>Ok'r/߹\Wz7;k9 ^1`1^[i qD#z,Vf /nFZwo^+g=~7=PYPv6Ty82Xj8fy Ȼ 5cpjLoC!YCvZ#l!\Ӵv6ƿ+-Md7%Dߥ4nc \cuojDO4Ʌyٯ}{J|pz2%Й{% X{>v̻0?zE\6iG~@rN\$M5pfp$ꓦ1 'TKN7&6:K$m)0U]xSs0®+q=AZ : Kdz_l`i͹fu퇖|La eTC^)腀&xD.7!N \~غ#vƻP?s5Ν,C~PL~'=PV/bx ɋqѣ}ޅ~㒚_. .fwg),V1(DwRڏ_[{ OH.\+rO$Kl I~’->ԷuiݍQ]8GnTAgNbva2Xϻ0w*?P13b,5ar$ߘ_ss&4{ra}qZέ$9Q-WyIt({M? ?"۷8=ǜ>}x7b >,>d` 8o.fG;-;\}ڹE?ˡH  X),n>! *π~}GFDàl^6 I]@KRw1|X[(raJ}LUaſ. S+w[YT(-6?ZS$B Rr!3MbNӂJ)x ]Xq|=թAג׉.4btN3݄g/۬j }qb #WtIkC3;+r!~+9ss(m{.:+c>k)By2ra~ .y)@k( S,dF{'( \F+bDBㇴr~x毙Vf}nnLd\a1 ]V)F#+7JBD5seG*aλra||Z&DĜwa|[6ֳז6OwmsWymȅVAib>U&kc^ ӥjŻ71Yn*-oV/`Bda]Tdenb} 28X q?:XiboZ.|SU44?R7ʶUB9{ %#yGjo6A˽^8i 4wa9k j# 6BgbKЧ(ot98.w\^g|p 4y3zTBÓ⮶C˨36~q?#B|I-<K9'9Fr·bcB彂|Ϋڒ{aW')ǻq-syi.#g\{B-jH]_q<4_\ >fZ] Kۢ'.|!CHjE*XO.o0ubns ;.63zm2C.ߩ]C8AVn;.mUt=9fJrac哂,)B]j 7Eyyc>xQ.+ =ìH33*Wޅ㊽J2wa*xJ>_&8`^A5|Bb:@M̻}mHm6݆J' mRv`T>K)3G5lXĩ\|0 (jO,?YbXހ7R6W Ůc{f5[ra@Jʴ V )M]VTc0W0\X=ʓR 6@)6>i ->y@ޓyO'OӻXpkA一\>c֪3xqɊ&h7wa}{'ysSk8w}/Kd5n )R|.T:LM>_T]'xF./:Wh{W"i 8b`ȅDVfaPvx^Uw\N"22*$ d2HgHF (*#!JTFfV!dƽ[}^u|uδk+'W %UB y5 g~ J.IISEYeL5&B,=b &P/FϝؘUW<`"%3RD7oMKɃa+ݷKr Qz"~VziD.8Y<ܸZAE[m7W(i8ZD,~_[rw_)I36VxS}UEA}jx3_|1v~@;yG݌ʜp6O!YLIW[lNBA]bן?jc~\xJ}o;yzb*`pFRYB}2ZpR7C:lF/A i՞VB}}^<&6Uqo"XR+yOVE0wϙ H}eSy6j^|1sOĵAyjs5Bd0N@) }z鎅g{xхͤw`TYOo __w|SzEHY0ow5X`&^B1MI:TF2jrӖ_8x=^U;>j^np9 !E;տ瞎HI"z"PcXZ$#BG?M@ue}~'9>gr Mȱ 3v+ %v8/*%z s?縹BRRǞǕZY fެn_ɚR‡QI;&4M:K,[Hp8;"p=1K?h|/ܮqF2Ϡ4Q*sy]%=:e!cWco'm9.m^4^HZuP\HIl/!{9f$O߳gs ?hQymr]v] ѳV}7LbCeRk7`J2tus&_'KoJ1qDw@>`L>GIn%;O%M8G5 =)&[$qx~&+0cVss$n'u e} pNA1 E/z4eC!JEKJb_BWx,!岼g۽%dD,#UFi l1;7#&пG5Y jB҇bG\f~ \IqL}{2ru6 ;H';BBvUQgo Ч2{ iG ^d̚]r]JNSޕq0rףKJ҆Ύ7^3\CGx;Q (9X^Iӛc{t+7//Iw^!!;:+m4ޜ%&A?=._dA.2ׂVr= 屌{A?V?L~}U?q).(_!#}Q/]Wu6>n ߶Xwm0F&Sg_͙'/xAsǦ便5Ktvρ8Vj:6`]'+I;^AQDo4#MQc#%:IWyLߖcK{OiɁ1bpٹ [/|"%OPIYW ˇ] RA^nV|yZ?*w /зw^ 5"!^ǨV ~}&x;aW"-q}~.SHatB_Lmjd)x*j#72 ѧRbE.*I ehV :qxӨ$nԏ?h} o7t2/lmqɡNoZ)4'ԟГѹZ@/͂W^.Yv>7$e&^N?Kފ}wߑ[;Ȏsl%1 =c(<VLj%g_>1pB+<$} ;:hji_kz熦Ov۬C t):pa,wXc]3%YH vU\.'p[+Eu}ѲO} {w#U&-c҇tKI0誥OVo2:t)6,#s.R`"wnvZ榒vrtv7Isl|9[3A;6EI z-:۸Qj9XN* o\#He#qgkcbVkh]n_* #Ӑ^6K/?M>f_=NQ_*wSgF}׸75u0 ~ et+rkln*>2=e1Lb/"CљXQ+1:^SI\OO.|#/J$:u6? uåDuv~e9[v/^gtvפq<Љ0nMk%>w.>t*x|'#ֽEIS%2)?}f Q)laotv}J,paS5bOV8b,m22َ\w!$FCLBэ ;lO`i]Cgu.Y {8|XPgR}(5>Lߦ֯ EOv 2$%l,Pg6m~Y[Jf7ΏpĺY2}|"0a[2uv|yr>h8z8}^:U#edcl}lxF>Ĭ/Si%A:}iื&BgOt1T/ɔ'ߢ^:*Qӛߛ"62<ϭOz'!Y^+`GuvgrKCL6MTA'g62ge9u6ą+U#t' @c2vq~d> Jt8Ks8>J(%-%/oEa@h;?u1i;LK'/'3M0?zru?E;Vi%)HkS(l>fW7l~Ixߓ$=%lZ edx=8GO`f] ήj+7ʉ* &~x7Гڷ~*O'}UEѭ'JruB!8\z%%勉S4x +nk!iCo<kx e})k%EVҫF~51S®3'JH{l~yUBoDvNj}WC~>QRRc>茻񰘬GwA׫KǸg% [_oV·_Y]U8S=~LF} qTY+KRξ?q9,BK3弔 Emv] vɒԵKl4Sf_9Y:~Q.t/u[IT~R:նÙ7|ޮ-zj`<?&箑8tv}~qm= Co|d E&9+10Eo/3?G\=Ch`/!ExfՅ0[s XP_==ˤW497&t6[8# $D:XmTWg%}==,In1LBދu譈u;?c S (>W2-g)_U؋^|I2pi.)io>!&6fZ ~rFF#z~n`t*SA?+ȅ^KMn%wз0xpt-&C[mz JtO.b8i| F_~llkQ|2kпeҀo#\Ʉ}N=KvvSZf:3nwM[o, |}TZoטή4Wny;'z|2 &;OC8+o:$_u=QJѹp}[&?vu1'uC%G4X˜VBԩAD} raȱJl ۛzU_<ȜGӦܭɅ.$)Hx|/%༠%םf9&?΢"9ɏE3}/@4.бf2]{uwX[6MGBSgׇ3M)0.u/G ۵)@/GW}"v0H:~pjj:w[wb,Eg o Z핋3Q:cLw8m ;֧ߖg̕n`_%Pl$j=V:$ul|:ωآ~٪Єw?2gNo@}Of’>EI: Rµ bC6X/HCgOmV{B7Clz+;\]JVWcbn!5M/'/4{QV^L̍>-0޽1&]I|5p~[ǃ4KH1!n}q Wai)k3Ct_l8|6:FI6 ܀y]{ڞRlB_^p44Q~#eHn|r{ᅘ${/yqtl#{R b9<մ&F@g`UV80bWW5_F,qeT/1#c5?)]Ml)2҅>@3s!8p5ַj}/#ubUoIH9u6/=,+rv{ ^X(U'Ml#п6$óF;}4>6K-evu_RblIϷy|} QH. }&%]k0U-Ejմ<[v{e 5z2nc8wKHRYbS>'iK@ \hh5@C6fqrm$ÖW zqW ݡ)Fu|xkv4mˋ*zč02:~pzGr\*!]я-m<3P=.-K(H4C '!vNnL1`:uv}qgT|$vuzN".m] ЗxCyM|~_s$(B ;PgB?GZfe9%Aj%Prԏoson4+|AS+.x+}\OWG/~ʗB"vK-{OuC8tŢ!+%fu#-xB?y>}kL^w UI#W ÆL> (2ݮql?^k>AwCo~~ a]/G%BfieEO[Bb'ٵm)X~e,\Cz(SՑ{w H8z$pGM4gOXѾ]wBbnX=3-)KAnEoHra1 C݄#:GTp?7)OY43w6o "l0MNQ0EuOѣѷY6w^k \|1.Bxܧƒ_&˸T* T?]_B9W$}<^/WN~lբ!yL~kjq>G1_\37w DT zϑZկFvklXxgc];t҂PTT{ul _:0o҇ze}\(TD֖і*ڹ`xpA$+qs,w|rk1lEWX*=!i?]K(\W,:AD|W?-LMB˸>r_r)ӵ>vz,T@MCڙsMҨ1 9?~N =yLH0i VڙsGm~1(KޡOF.֍アk{= }ꅶ(].gGZtРS=jtF_ s{22tW,JaH;~}y?,ӟ$}9Ng,@+,:iF/@7ȼ"nm" sЧn|/&?)ާ9;(xS!$KhoD;O{I#Ug h>L5 z_>{ٷ,(=nyw,lΦMEѽѣ6o /TsBDigdzmHvuG:4D<~^,+ g} vqaGe-}j GJA y>91rymc^C*ѝ#8v ligTZ+ shWC~@t6[kK,UЕ$Op!U` :~=X/]%jiGW\qυbǎ{]qqO]s^`Ӄ};{#.0[!V@iEWyȄ 3&~"ѯZ+? yڙͩ|nt g-3c8p%""2|'wUz[+{yL:}'z\ls+Ygq`Eg|9-\=5]@eV_S9^jjI{,__Pٳnv'P+a]2dh.\sMD[{=Åe~ƣDϔcKcHn5ѧI6rAMZ_HЧn{eDoOԔ=+W_g :=l^⍾yIs $6o>=H3㗛t#_s<˟dϮBnƶ]EcE h;xli_RP.Ã7r%d\ϰWp^mi,5,4T"Wq|ӌ9ݬ`ׯN*)<@M~e&.k!"ig/'6~ϟ+qx|;]d -l\fIik #U{k] GFO "l恾t}Mb7 C߅~gb.lZxQ$"x[yzi=e}DL~=uXƃ oo,p"Й~/ KԺ zUt&?d +u_f;5ԙR1c#>qrƅ/'(YJH-FtePy{lY'B; .FsLY =pZXύs 4 z1ot}._'Ȉ{CUnpj(0Z;bLQ }y g,_uѷ'3U/n%cn[Bx}_Xo*f&) ;|r"3# x*^)Aߍ<$r?ٓBbt3%R։"zxwM}l;('i@P0+m n[}Kan~zt<8:@w^s$οgײLƁGE=c7v>pV6|: x@,_ȅkţ;H$zz9VPYyv #KSae1Axg|1}:zR=qQVCJ@'+Iڙgc1ss{W?)kQ0ܶ{= }+lxPe )Bg?ךּqBԌ"^\НF_%<@]}'}8`4Z9t-K]}MR!~ ʥ]:OZ&hdA*ݸ21GNqns|p'h#k('gs\DLiD?hj5=k[Hz%Jx0bcE^#vf~MSzZsaOKp|-<ɨrv~7z_ALrK'(]*sye!B"L;_^eɅ)'T Y_F)/WVv$ GraR5e|2ρI/7݄?o?\6"Kt&?ɸ2K&M|Rh7\;b68ZfMu*Үe^ZsR0?hs!y^n#*- k',̪YTb."Rigߧ7XqKS9O&@JsDΌOZﬓFYAm|vv3{>ܶ"K(~ȑzvPt+V dbL&7h>蜶9~*yKס8L~/6 .)%fx{sWPpfRlGI;%5 .'$L췉 eO,ڙNB.I:ӿ3qSGOkæ ̍ DP6j}KHL}7oȅ۴a|ݿʹ2tؽdڙ^fcvu\ڙ@zhMWXl=VTM"9)3h:Sd|L~wzV9 f$|:S_d׏ߩ̓և3]Mfp3'u)Goܫ<*mK|ڙY]ܕ4VFtfC}[\ExeGj'`F}ĺkjjڢ$| Ŵ37o܋9 >`5`w>߫8k_OW:ȁǴ3 z[C\w9|ľ]=T^jQ|+_CcQ0~#gE>]zIx\-1zMm^hJu 3t6n/ÓXrinOi_b>0Bf$4VX }Ug_f GЙ{2FWM p!z{A?ڬ0{.d11U@ho@,P[oM :e, AbWw\3 .KMMjЯw8ݧ< M4ʺ;}X'~\5H~cE1@ë݅f -N,ڴG^D3m\x8L˱q~_wLZ◴3` KY [Z( Й> jSH<:8Ժ.Uj_t4RSC3tCMe2\o6_@T_gĊש^UzQ:BgiJ/ x_\x(t-@pYC`v>4S nԝ=n5,tR#i""0}]" &~YbKά 6@8|s>z׌` DUQ -rv;Y6x}<@\ig/+GN`AOR7H4:ܟm% V;O g{ql!ύ':d}9݊L;Gx GW{丝鯺B C$ }y>Ptf~8oTtlzI::W?P?1Pe?yoПhFX\~};ԧa RFqi}/f[ q <@>ח2Kי2OѭoPbs!T#FHo-矽΁ \6m0>.6vdW'z>Ȋo3'=9 rY`f׸3G/A,H2љc\f/yFѿ7Wr5}Q\_D/FIC":1V?.$RP<rڲ {vw굂 p!oɳ-n2x`2IA{;z2. ?Йꂻ=7Ab;{_%Qm̭$*?i~I{|XR|K|3_@ý7n'SD72 B8ߴǣ<$?\'oDӗ m:\XMwHdƅN5!}KHޝU6!4~Oixe UyPnq;n>D>~LwK ڙ]4ao&~.$oڙw}ڶ3GU"3)maΆ޼Bμ?NQZÅoΎ#Laby=8wdtuk_/V]yL8d7:x}l`nϗ=$WWSI'=Gl^q~ mp8hAڙWV&-}'hgQSbِX͉~Ҏn]K%`PKDH,%L}#Tja/Lᑔ'BODŽHfOd)B) n[/qbC]pTI0FfG_X wx3RЙT(YN H 8 R;˖ S=EF^?t < SwFܜ d 8B_a&{6g]V? 4Ҥ _U(8q,Y>zEA~6+TDЙuQa{ Bt?qBL:jS- hgA̵pNG>![ЙK ̃2iigCˏUlrt%?ǵ]dEnqog=X$9+#:S bs$aTe_v~3D.(}>cˣ ͖`o07<*+$cMH{p!:8[OљDcßaK+H5I ic8?֧l)!R@;~V;YI4NhJ$0wXOEdXڙ}۾>rI8:?;aS&YtF9l5rC#Nk "ѫ7':b=#{<,083'xˆÖĞznҪJ }g :ڙY392u]P{ .xƥo"gGAC<1SO TӔGrQyZcd+5aUP%i텣;I:=d 4EI3.~΂׿jmD `^8/ <;ED*ѷQwl ,AfLY߸ G+P;sBء3b$x^]y\M8PDBQQD(h{TJEz ) IIhLQI!%ELps^9g}^kwFNU"n:#7v\zd Pa#96Y;R"~t%)'JBb= CNtWA^ˡ z~k2}o{v 7S#"ѳ źM,ZS{ 1f\s*np{X^EߌnW"+ 8BvޘeM?ǣ޶O&/kM!+ .u!t;u(byJHNMe|,/܏כo.rfVopMT\W:dM">H-=tƧٴg׌ ٢ r?CbylG &)*duϙ̽cw~K_@'=㬣i(Қt-,g|?zٳyIDJug KCI/[I3h7eL/ˢDfoJ]u{ۉ&:8">ln FB<]{fPP6_in~H{Sʃʟ7 I3z\S-$zٌg>{_1:T`288tҏnb? lgm[C6|$Fga$ϥZsd69W'WBa# Co$KWVFj'ƌ[c ^@v!GB\Ечt\|biB/Qq4OmGu̷ =&oDYj5?m{F>g|݂3MPwWZD n>̲ lҿ]%"zܗWBZ(3;qt#!"Ч?|:c.$s{"z T)2`f8?׮lHCAua"~}b\m> $"oɸ)[XJ el^8ue5w"2(AH4; :ZɴeK>yw~ ءB?t ɗo%S]#wB1 Ǔ)1z9am.:i6 w\y{GY (i>26bΎشhm6>tKWk4 +3!&7. giYmd p,[4lS{Z]DN['Рa ;[9=#@N܀jƖ}0p$ i)0hy%%!:\'u1@=$}6zbәuP_a@ߊ1ϐւ[$= }v<-SkK1]E7a/ɀ!q6/P [ktMԑnFN<(- %BgKW(7E"G1~.Wm@3ITЌiNs`GD _Vז!.]z4v;<2ƞqE<իߗqXfKbbJQxMN~E_.I*_qdzɕk_Uz:gvJuӍKOაu:"&VN DAaК/aDcluaONXrzr1@ߍi|{j_s8+tF@Q;W9?̖A$$]ՋGy!͆F@=3J:?l[A^2>eĢ  &&н7_5O{QNJv9qv~ P7 z+4t yFg8PQKUNGR0f=#h㔫liNb8%;X6DHz:A@ jx0~7vܮ90rl}wu‰@2 އܸPνVUmf|q!1 #Cut]lŚ|(79d lgxkH]($<߆NS;K9Э2gI8QHA0ukŤq T/^4]Lnme}~\}ml/o"&l}FWt<3}K_dr487$q?sf] lWW}?I}ț5od>q?CK|[|(m#l}>$B(g1Bx߉~s5 KҕfƳ=3(ؠ4&ha|^C^\h qUO~l~m>E :.]NKI7r·mR`yb]تNdN/92r ucهoREFB砏=>zt4]_j_Np|Υ]dqWgYTɃIOU+&sq|MPSS).Q_j|yyok[B"sgW˹b2џ?۵t% =eE;: !FF|mWI{-Mь_ImvG1mDW./'=uFɷN4}+%Naba\ӓi,F0֏b]/z!њ&!Z羚<-s*eǏMhmμtA?4b W't~"9gG\ @ epcFKzt~N;R/FOhNZz]Zy3/ODFc~:qg` mh;Þ|x[@LrЗ~ii-i'q7?s{iZtY !pՋnOtcHn#;t[}E:ZթHy}0l |\-gn W?b,/|p&/?3B9ǯ7m 3?vί#8'aϳg9%;':nK`Vɵ6qqS?8t?u)'!);e'W̔fbxq~2r j^INXt ~/M[M2>_7&ﱃCg=,/]%ã*A Std1Ui?sO/]z.}q6Eo_oMdM(PvnY*8I2߉qvQk;KtC}ƵQn'LvtP,,}\q;W?jB?X9` RGL_X[v_|aO?h]=<6DU\?tV@_UԡkijjK>Uqd9[ OϾ"^Tnk' 9M? tϲ=T+2f<PJ<hş4F6t!4̷wom;tSYZ6h}9足 ̶ 0#mH ;O!M~ \kj/:N-T wg?OvtvM3M(Itj%A>n-&kI,e|5%+tu(>}F,gI栳:5b gkƍwn!V2qM4iX7f[} I OAeo~w'Z Ay2Q'qH7z8>ev-b"S5UkRbczI:A/VQY:[*"[_NYh "IJb2 ]];360aC^m!y8[~HVQZ?o':.]j?lt#匳//l~;>N(tv?-2mX1in]C?[ؐ\AgGg Զ O>nBoD,tؾG}k+˽XD=[9axiWYxx)i5`ڄ}^ }o A6WK:I?:mi?d;fF_ q+tq-b.Ddn%?/zq 0e?d:?hsrQGstv}߇{ IST$Do)ff tv+ڕzʷ{ZoU4|'KL_ifŴUC:/B,13rCqF+I%SpGbB0/h>RS %dn- S[>A}QE$=>`XR^9}};yξ?}T8YZ *։G]3RX7׻S7IZ_'?Cn$SU7E[uG㭴]e卭҂ojlS9($S>c<03i':ORԔt^t<3=54TS#^HN50>iY4(g%>_fN>3.= ޱ%dƇKn|xZRsFqv~zۂU GgߏT%]?i@5 ZAUgoxi ~utEĺ59+0W]K2ǡ2-}ʃ_v464Y:~1𙄌Ƹ?z%U𾬨/&Gчtjce)Y^CC|us.UٰԻ9q4T qu.q:˄Χ$}1zrW\ yԠ7p\k.DYOJb"qo,U񗟸G>)f|>%Lw.XYm" 팳}ǢAv++vr_Y8R5W;~.t:/T:~`lM"(v0 AڋʓƉ!tU)6`w/z`u]yxw4i͇j2Id_Σx.a d%īqvT8U}d?ڄ$xy!]&"l{0rn>O̷'F[hgYtvวs)[88B2%N#rl}F v%l~cU;C,_ZNϣkQƑ[hbj-OD&3is4 gRpjA Uivteǒ'sa቞Wqvg睜3|TL{.V/)@W㻧G<$.t ‹{UNn >T@kAz 9_mMR~<[?do:2oR2118~uR0 -ltZP}ÀcbG3EJ_jYxfx^]iº!rxqi e< 5Go~2pיzۖg55utY7Y-{ڃ!){h?"ߧ5{P^庘KƩ3?b]dITM$$4z߻` $|gP1`Msg.`G661G?hK[#T+$5/AVqtQ+OO@qҖQBލy. sYCQ<3"A_nnl( 4қ 4tW{9Ps_DSqMtZ<ga1FziϢBoVWtk3 xN(!ѧos}3zw'HfN֗a|b= !~t+u! U%6+Х14+_bR>}®V-V\pXFgȫaKNSDSF nuE3JLMp}p={XRV)"{0~ #znrfbY˸ gfdd ENII]GY:eQ0zU̠rewFIb/H}zpPP- ܿh,hc\ ];cU-(l9P/1BD|yؒe0u@wB\;FM1jȹP~/@#7Yїȫ>IxƓѻf=.ζ)wvv}HHs=SEݿNݠ"}+CF@Q~T[/~Q<* m}wa+翞*&Ы_sR)]V\S{ 4`}aO)f^IB@_=`9sky~\D0~b#oR7E*עھ-ہ^醌砯NgnrʇzI+z zxSCm (iIJ88E>VS[L[C.1>ӽfowEe-bR3Ppg,9brԘq +02ȃWn$$} 5]}IdVvr͓aF7g_@CϢH.zP^J2 3eܦx\Lf Q|<1)#>sd 诗i\-4Cֽ%Kf_L П~T+Յ͐E٠r8YGooDCY}d1ى>h"%&JVJj''gw pӲ,[@*gxzY.1l7gG Р7+]@,f0~W' ql]Ʋyx;SD*Z aCDdn,e t}8"}t8{wz賞]׼%ImBZy.GS2-- yװgoArrG#w!`&Va LS+yb2-G11·Bf|ECߦsŝuZ|y2slޤٗr;/H:>j -~B҈.{>..%&̺9|dq/gKh[vV/{V\?Ŏي }zj

%Y9q!R%הwg>GNrjƙDc߿_ai:;xe_?=d51^_kXzE ܠۭI%w\(?Qm2G]0(cm:Bg7`Xtet| n /S0&Gi}껌}y~ZZߨ!&Jo2ޫiDt~ysC΃6 ;I:[T}4&Ɲ(/z/ ]umzL(PZ=gC]cJxh},aiFF Hd=,qa0nO>ͼ7ofpS8;.WV79Eѧc|j4i}\L}J;IubWͽ"߷տZ*Ɋ3(اйgA_˅5tJg_Sf`iStE3ήo5i;jc05󏾄]}6}>@[n ٽq6pO}NcF#r|Qx'jU#T٤gO({E+y͟*|/&!Ѝ{ *k4ѡAl 2~ C_D^UKze`: ? c޳Օb>BJf\wo'>I@%L6C 7-3\PS!0}lsa^E8pco~N҄ޟ7_ MӤZ_W釙!.Խ5kNUZٝ40z?,EgT^4jR*"1{`t:򼼽82?>U޹z>![Aqfq$U'BrjS*\ dVӬvRt%Ї)?аs;ɐm{{[-}?X ]ÁsU 7~nQ^BC}KrBRo}!σ~A}g=ϧz;#$M^&2zui੣}'z}y) ~4|vRΎn[i~x*ETa;o9$ = ǯ62W(:ͫDf'~lavhVQH*g= wG&bUT 7-XDgcI@_Z^T aٶxG[5WZmUh?۴SNDgUJwdA}+'qi}q(e<:T]asL 3&5,&t/Q#|<|mPgw#zGyrAfoٍ~ w_rh(Uk'0>_=+P7q[/qFgwB> PX6I '7Џسw󣌫˪X|0,YC*آoqu4lK .tnqB.%!䡳d%fTs ХɫQc@oִ_8N)+KH):ac\z5$7^IM?W8Io E?'p\X8h??8.7Y*&WƟ8?mh07ԬR=Ddh4b·cpj;]܌:/}[=={ޡ4Q^A0>}JaX_) =-"18>!e}rMdeS8M~ƒęub^ɱkd9m/ҰdVvlFvIϤ"B27)}&c֏_`A?Ov.tv&<^?]t1?ľ^gn1:2R3=nthnl~^)5b(;&3a;[Se{q1C7B얽`Còn^EџT@tfwb~>#mQ'.2rUo.c{dPi:߽I;RU(mDž'  $vƗ/lICOCǺ1tkm<8?˥]m]~] 'zggt.hVH :[dHk 6*wIE˦@,,G+;mH dEmS0`)o_Ԡ#7O'yR 6-tTD|R߇.~}m#2S~HgtV]AqS\y_514<Ę=':|ΉxXQGAVIr0:-;MfSwY@֡Ӱ#4~Y$Ϳ1O<˼i_fSIO}49N*}/MO㳹տc~A/ٚx. ypž/m0qvWEsf$&m?{*͟*obxq|"[UFOS:BJkvjLyWs[W5]e͖!Y<9``y RD?D,м0֧$tSICa0 Ub:;t _{qFWb?Fŝ=dcwwh99U8[w!Ac{@ή?S-,h<*38-3OKSȯƯSHNAbʩʻ$)QjDžK$]_/Ac^^2{<=Է"/qv`>Gc')Fgߏ;'7?gS3V `81q Z}q8t+t'LhHhM{ H :?7~4W_%&_2g&gRx$9V T7&GO3[ڄU a$/=Jpͱc[qGVBȣ<6=o0&>Im-"UqxwSKěb2={ǣ}F"Ξ- RI_;iGP*!9V,"4:?L4:4PLb=k&IPvx" BSF4p`Rg|=E^6敄[wEݙg_6t~1k~(Ĭ7=1\?3>"5)ඟ|u,B#":90fqW2^DSglAZ-SPPl(8;[ύ6_ͅg#wOtď;Ύßüd7:wڰАsxYj%$s0ξ?Kht{:'SpvaBRtCԚ3B71>7F:F6PYΞ_V/F%9"ϟWx^]y8U]C4*c! (S%E+p}hJBʬARQ4g(RD9)hp&=[]~z}|u(!,9+1iov]Ń'>Z _C<-_yЛw.Hw9{++fiUWmd)?oZQƀoZsKjs41 Yf҉XSU9'$7o[!9?x:<+=r8|+Df8!cÍa|UPIDDךnܥF.ڔu,ftK/r纀$qH1CsӅe%|X9i ۠[wrG봴@.3N~bSHAwI)P^=8͌P.7nR/z:gX|fk}^40 bO _H}7<0I<#&32;_pw/>m֙ .{1@@MpV3(z<ΟvMQ x7%@HԫpD|H8}PwCSqbUT֊^#"ЋЕ|m}qlQv$~ #뫷᫚cG}$3׎Y!^џo;#x-9%[7})0a*|A~I1 ʼ*ZIAugt& Y5zp:A?ƹ}(تQCΠ\!ùG=ck0ZFtQߊ~Q祉! 8K?qvxL!J] ZV11^ix((h~pK/:>w-``C@PC=}ט)|Hi3b8Drf 1 YT?lwdtzy9383ZY`)Kpo<8RHfNWGDus+*`A76%V[^":'$g]h*u7Å$}nݎ@` )9&G}v.s?cW)-tvW[{Iv}=*%}Wj` s0zt|/}Vg`][s?wDtvYKoԙf)"E ч:`i 6h C} lpᕉcV>Gy#yL{}P_1@pZXe]L%K[Xl35KD]Э+V@Y;A_>1RW+CV\+dxI`;QB=ݴeo7><\6$Dߍngg͛nyyDJl!e:E:;n%6~K_te| ]R㏥1P[1Ih/yF}̷vmyGkc 1N}.Wukk,%;x>(r!y~cyP.y/:QL8kx2fxG}Vs T oḂQB/aR>==啅$ =ɞi<30CBFPg>e` ]J ݷ75Y7VE;9IKS2[jQgǛߘ+R|5GDwl|>=!ZZN,GRg~WiKxFy  >l!聹o֚|@tMtYz]Q2f ᯗVJ>ѭ}_g8 4nףn>xqE i8ϿEL\kЫ7|¼uay"b8>&ea55R> ][q2tB,m;Ɲ${ uG۫/Cgңhi+iCfwceX+ROGhďA@g+ +; wKqI$N2nESgۥ7e0fGs'~}Y\X'uKF'C v5pIHO1;;GLFRg[]JZm!}-D(-BL#=LlH=:IͯxKB2w<8dkʲOM5]HWq^Tח! oE| t8W_g 6͏xn*Vy\/3 `gp(Y~0TJn}?IӏsO^cq|>$W&ۮi*oR4+涑TS= L.o|I6|A.|uB/D_U5ޱ T?f, Ɵ0͇:ƴƉ>̧p(YB4'weOۭ\!VsR?Nv ]#/t;G )9>h#]?iK%s\l~v* b҉>o dܠLDP_{i3}%$}G珒>A\n'Rwت"Cǟl-%QɳT?j%/Br%u>qQ'M1zNGgfdd|Ã3lVԧ4,3TWi7:[_N)sfV}؏xֳQ*t5(H?o87NJޠ{?~>^*XΠ֧.OHB>bW3U>8Cq՝:R?ʌ+^\LΤܫIn#]zLA] Ez.u5pYC((&ѣOJ;k9ý 7:[?iq̀a}Ed=uv-z_$˯#m<4*9=EG&b tnLOR $/_8/өYyG7jBTrJ]6KПybvhooO/۞d`D$ԑ:NYVo& Qt6vk%JZѕ(;pӏKHuuM: py!y~bo=:dwѿF:SWkJ@'v{?P \qyfmW>Li\_|@gO);*QJP^&w)jTtuw0(U܌u3W&@䨰qmĈ/F!?UDRߴ)u+ĵko+}O( Y$qȧƗ;/,e`zFB_,3M:ᴓ<Tӊ6ua5Zacd+u6&z3Ct~iLF<Ӳ~|#@kaFϖ.k[g(2}tH7qɃ XL]s傈DS_~DQAO_<9fx}Og^'$Rg9nNaڔ]R2iu~3Vg]l}$ F;'t]c±۶GEv1 tnp?y7C1w8,S2/9B@eA?j(Cvtԭ7M1; X?@J|e*S$zhSgؿ)O;uAOZI:_e\`ڭZcU{H**iBP,?jVݳ\@gnz\XP˦} Tik,AvzSgۗIq;e{ԨVo[jzsl^qw9O!3o?TCڕ__8ySx["wϷs-s3,9b_l|\3̺`?lֆ(?S3g޻)ї!AUo߃B"Ag۹9f+Q|ua+Y:ǀ|6Rn>+nc<0bd4ELѳjnks+'t\Snv?60BDU֙.0d{ζR>y) 4g,&Qg 헂e{~R;IF7:Y^V)'&Sg}|c9 2\*&Ql|v*[Gk$pW~XXET6s>|>x{ -q8WX rtv~ w=r8mFβb`šUd%z?wݗkܧ:b/&zNSɑQz)z7S]5_vث$+[ӇVߖ?~(L5-҃mlKp%xIEc/AxuQVlgPՍ߉Bo?SOpR19UQ3".t/MИ0F>JX/~:@{AȅQg7Y:zgCo*()kt3`j $zcKJN $ii}pATubط<8J66GnKHBS^wB; 6v“cO&L3\ʃ!~6]ԯRnOywގauח&Of6 <r^`K|8.XPX$P/_^ƒ4].:[Řf#K'qg(`m$<\y(>&jCere7^Cm<SDFSc \鞲/;7.$o7M38gʇpzej=hՈ!P 83PI~o%Ӧ֐? LSF,owLYV _iCmp3`gm7@Б tpJDB@y 5>oj9.!ZߗOHMZ3ܮ~hG#4V2wŤ;:.ys25=J$ ?I%# jzX{=B} 0}fOIfou-X"!&T~I\d.=CD͋bg cm?`cNPNjѯA|X9Ѷ!?N} ^+Ʋ=HiRp;IG~/Bݥ;::X`\h)% liHu=|0ސ'&OQFOj66r }8;U$N&p]\Fg_n{Kl>5ǠTK\!jD/fz3Toz|P% *%d?hl)iE#jVy})[Fi,XǀPKfYmӸ0ErX‘6n ,"nmi!9N}D&Ý`ɣ+dmuD}0-s2ͼ\8<0Z6h.=xH8KBޣFl,GMn%稳\xԨn7VL_>={h:!:OFW/o"|ؼY9AgvZ+ H^|VEVo~K}#%uvI8ʼnӼ0ex6c{FE:[?;V^)J]I%BrzF\n 9\Dkw|к$t!^py+ߵש{pgÃJww=b+U a|oS")2{gvОhlxgFg5C* Vo D$aYK-0ݵѕ"r }uèKX=-7SVi(Èͻ$DuLz⍈DA-7rd\9^IC1WO;~}3-B:nx:S.'*U9F;`wnHa~ W(}Fxݳx^]y߯6\H5e(f}4VR0hyҎ}  &L߼$]_uGft##gex df"2~2/30<z֦"2 OgL{·_\z5:W.}1z oK ԩMf-,C_;h);85NLW0nSh-NXGYMB71{?tEU}"qɈR}KͶN~Fn^fF$KV%&g|S7za_?"0Y/9>:.$.5o}i!yNGLb]u/OhP\ t }܏p``7yV t`5`>rq6_IIY#;t>xKw85q|g3c;|ߘ\g|*׺{pbYDzY+]~?Fo!^خ=" =Y_ zcE =-v.|7yatq@[=ާ)b 8~O onRۃﺖ@͈'9d/Ɨ*h;鎒;q&tAzhpxh[$!Mtv #7lu4ЇGxf T{k5 :L-v,k%$͌߻{wnt ըIbr}!q]=MSn7p71yJf|JVd?? =y^6ttaul(x b|Ncۣ'2_n}Σ2rX7M{+ݰ $dq;+rD#vXَ=]>wQ%"'Cidt~f=T$oJIևqv~ ^+ygNuIE^.$f-$$EW^ǃ-W  EaD kHCn*:>ȅ<"n:ȎvumaX4 z= InY*#(8:me:x{4 =BHxjoAW8l&n1$$OaQs(規=pG?}"~ TM4){& z~[@~j2aΰMcwh]T 8!y8;bK->:;[Lw,I4N/ g)zurrI$s~\1i@Y1S^rwm(s`5蛧>zDƛ; xuqْhGgš쮳5u]uYfxN3P+>-Id'[^/i:flj'ugkͭ4ܜYSC0xiL>.T~ 9]Q[S6:PQCDݙ9}{ Oth-/QZMe]zqΚ~<Qc|%r?c49vbB,7ђYzB"Bgs[jIkug>o:\5u r'vu9u}D)EVrxY43YK 2qv+eGCMbҌNЧ}KZLn72={CL֣g,rQpBvr2zjhm>}4YL(#+Ci Lj$ I7wӰ}%($Iߍ)__!Qɸ*TɅ yv"2 U3{m)cŤ͓W_aE )0f| [_-8%6lI0'E^8hVM2.Nf!# + yLevR5%FoS"f16)8upa|0g|1y GLFf[0>xņ3oPܯlC侒(.ZL0G>\T4Q`fDنvh;q}|DD4nc{bȡ*gy.5$_\yikP!$;_8Z7`, Cn, 'C=,:ea6/a?x`Kwf}^>7AAή ;uj1:[zw0\6x{;:JBiɀWMMF4G%WZ< 6=+?Y?z9Glb_s@\f ;-|JY2yZ?Wu>W[Bz?Y}-+Kuq] ׎.۳I4LڽAH-`|3ƏL(Au˫mn3?j,4dE4-k'voѳC?GVg,>ޒBV~,i%1'؉i>xn M.<=֌g8Jw+Bpcug"o:N{n{(WHn W,m"5F]Du1~OfPb: l 3[ƍqP`b+ kg_;lؑHő۽w$؞q/9YE$%$-z%:}76pos\D/oo#& )Ƶ1^3{"!]ary&6s i~ܢmk|b`^$eZ ~WUO=,zaR9T,D;5'pN7H z6@4CiYw`HYfV .=4p7GMsc=߉?hU!J_6Dbo!I@gGyzya-8Ό./\v7yl8G>19] Z;DŽ4ίn+jFԊLk~ 2!)^{.c?r*dvt5Pwe4M̓^JSGZ't͑+T%F_'$Mh-SI3c֔{v\m7ʏ]_Q=rd@Ýqldr?/&Q_ЏN lWG.ʕg3͗AF['_l&'^ w~F,g*ғy0$_qoCB-Tnͬ83gϷ}$WK~d$ʯBz9r|7Oݴl9 R>Ÿ~dn[8lO4`c5yJ]d?l_< cy3}EC88?<*ڃRݤ !ƫh?;ĝuj|{IZvh5 ȝlZ( 7Q #^IjO~Va ]uiq/6kؐOC۾y nߪ@4^v廝Q2q|p]ooOMnY&xQZߪ }[~N 0ǿ.HHB$T~᮸ۇdFUðkC?aN!)@gE*犊#>vpgks%.t@q2#_//B߉s"b8_jYNUKƪEH7|>drpn!iUK,Q岀Ϝ)H=Meu b qnI^S#H:;G' ┽St:I :{| KKݫ/9Ј>_#ڤ1s@H0}? |cubb ] SWItycڕKnRPG8θ.;x/ne?\}8πA#/DWQڟ>e{9p~C߸ɇP+V6;M.,U`N;C߀x^~B.]`g8[ߖvYI3WNJW-ƫ ΦV!1D>~iȫoX סjaw?YGDΡ{<%ow]7\B`|Ki8pUܐ/W+LM4[;|YtpSD vY7m+[><Ѯ2߯Fz )pT#![1[΃%V =?zq|yv͸ ίV k'DdW 7ϴ20}'io}ߜ+£]~f'𡃼Lxm)${"? o%"k"Ķn:I8ƣOTP_b͉k[lecЈwuoO[B^Lgoچۿi2PR5a^e#{lY ԡlݬl@2 qviXUh3Nt6-/e"Ҍ^^ug;LkPN3 1A!-tLM`ݟFY>\bN&6>Кhi~l8uMdݿ\^L{0zC^_ ;VY΃'CH/:x+,`ON0Cg/2]t ׹aVWwnvd6QNf=?iU}Ʌb{!ه޿YC)ML*!:cӮCU_i탫h\,hMvܜ7XыxQ['1FODoRKCv(~v28qs>~Û- o''sl,8W\_pP* ҳUx`5uޑ8ͽ⪖4\3|e8{y"2? s,9`G\ZV)-!m2U#~\YARԹфߋ :hhoʺ0E.CF澵I:{G]);iC7w7hzckI:~=\;T)yq,򣁄L98U40S GWa$S-DZAgMp$7:QƻejW@ڢ7|ZdjsPZفΞ[xx J|ڿiiâl[(ut$0<8?XfJєk,ݺt΃gPφT!rq^vDÌɆ dz2J-fФ8O0Ξ/̵^W*çV61:[my1$v\&O'gOqsr >pL"l#Oḵ2KKسWSE}t,rE.uprv$ =}(P6}=ϢZu8 7%AbF}*՚ȅ%~*v:tp,<#9:ȖӌGn aW*s}dx^]yXMHe Q!W|[D$\dJB%3%3)IERB2P H$ݩ{}y}Y{}IOix/2+ ɣv*J;(M9f~iԇ.}%%sc-+!+ҨG:b?8*#*Q9sApY>NJөǣ;ys eD># s/''#2ۣ,:aȀI}sYCzrRL,rY!':s"&x=:8i/v$OBv'9vRݞ42v!V5豍L~\<׳ ӯ|؜lgQH{r]X,R= }^ū Cy0[8GQB$('(?W%rm^/ȉ ʞ8q{i,]=?ғCKJjw'nNCţeK2;D ]ǯ y d/M|Ϟ=sz>N\JnQg G_W! (蛺Q_k >-%GaRux%&:ԵzOY%:#k'CQxhá|1ijS6ƒTe+gSNh?{ N93XJܧ^^}>4oy9QgH 63@J4PB߬6۷~8[9&|R6Xִ# 0~\(>X/TX 'Ż F'pd:] q=*L1}w*3t̏1na4*6ND%LQՓUU/.nzŇW{܅D1uty~8Wbbb^~ˆHhFA%z RvUl/~a|\$ĠB}N zj!J$™"E7G?wZ՗NkK6JXK/]N| ]Q XfEgǿYU0SsKo6 o*+ݝk _ed%Oςl1y>{B&3BWnkVp +HO@$O]=R8\N 'nvON #K;7{㤐EǿLDQ|Gm\ދ24ϫQBbXQ-C}֕!{ȮԽ0~G6D.j(Mn%C;9gcHR=9)Bn} e|=回CKÂ~&6jCxе$3Ϭv$|ǹtiDg뫟fUoC$OZ$uW'FO>%-EeE32P=oCE_3j?򒑦p^ss"7X?M~O 䞻dqln/_?A*C:[d[]?LVKѻ-{iʆy//8##[7[|g̝}5zni8oE7`ԽghҿEDR߆^i[G~zoBߌ6EMJ?W@unb}7fc);b1QgofYYKkjEgt骶/Q Kc4SLR1Y`&S^sBmoY|V'ǑngD J \%FǠLJ[_,R%Ќ-1dRyYX |;~h`:Tf>mԝK^@|>*w(LtN#׵2l2zt?jZBG_s9E~X]0]Bg'Tbv^ߡWE^M"urvV=B;UG7+N5パ:5: fU􏫋3K荳2(1>rή zfǓOF G19Uъ6W_UJ~1!<(f"OoƩ|8TqAOHR7p6Y5R&\VG;x {V4I.y {u3õ66'GEӡx- Lk|ڵV{h)SgGyp;[n9_K75jpY :ʎ}X0~5B^:BN;v[aHC1?vx;A=w~ 8\P5=&@~Egן/`pR2A Ϗ~'+D[+Wo=ieW KC5ҠՍf/ e}K=tBW};g;}d9Ag?nK'v3#DB]}UO}' G&CM-sz7ð.!iC^A{S=͚+W `L_[W:|3ׯ}ɇohJ OCO{'-Lpt?p&N+ ЧݝgYŅ Q⠿:;?ƩFIɀ^)Oȃ0#iHUG>oڷAgЙ!xkSgzmp q钄VS:~lq 7;HH%o#_Xˇ.j"7u>ْf/=˅'KȈ>ԋ/r-<wl€Kޟwї:Y n཮f]A?UwZ;Y>slnz6^,jR;ߟWWZAJý} zO7]? OmQ]L1><ٿ?ĊȧQԏc|ET-V 'tfx Ԝ1w˔?E'Ro\\]:?^e?+[ur rݫaBKr.lMTE6z !Oua(18z#;7LH2#fT{PCgƜG^􀄴4Qpsfp8QgOÒUM0G2-jXnnU|g]>x\Kgt=gee+vs ehnІϽ)9Mt7O',6$ թ%..8{ge8I:{SN7 ^ܒ:uT\e&>~,!E*W.=@lhjo1 >LF"%I:[_|V>l+稤:O]HNKH*I_wq*J>aX-qn6({DL#ԩ]a|uS OJ@R_SYtI/U "G쨳rݭvbx2ŀ6>~ :>z?` p*Wb2wsIait/ٷ1/-UCƮfb2 &̻.m1k[hϤϤA&BļBGg2$z~_ݱ n+*^Y;*!`%]Ѝ?΀& &'>jm/dJRt.?)l7hcACR@:7zH2z3#rBI27p5xġf7bOrAzޛwrrQg |uV*tH_y0q!$Qeύ><6c]of"\X`|^Hh!O=\!& nsы?Qgٳ7*ϝt7-w 5 5@ξish}8>DX<Mq~V6;db׃zƇ):qnK[kE¥ξ=VEx4IRt_c*s}g\h%`-;m@GcjJ %Zk8E_4rw_ƁA]BjgγdIk%RPgׯ$i>H1و]Q_ 0»rOSdj%ήDK+dNO@tk!=LtcvOo}n%<`Wc_9Pڛo!&]}a pȖ^+c0<2dse(Ag5mG/pl2TI~SI z_ԑi!!l4jw!&CS` 40t-R;x ,I%hoX+JFL|续OÂ4ӝtƏkv^ fK!be![nXwe"e|XPg?Ui>˖ok!|uvq|< >ZN./@6T3{OJzD|w!LB,f\֭7&4tQ壳;PBΡK-ZcyP?w~b}YIƑϟ z .H\{s9y p"_Dgufun Go Egקɼdg DD9gU6Zlrk[?.HLE -õW_F}?q+u>vooyY2DJ-ۼ힑دtU^E6ONt^1rB Itm9Χ޳9"ydKm|\;&.GB-8u 60m"ri?Mv>*o;ۈm1yKǺutv}93/RS3&GGsu鸐n~iu- 3McSW8/G^MHEPg릠YyӐkRW@LɅGbZ%k5?~_v+-91;9G3rGByC\x6T:v9I,gW=jAD?nՐ5SьOBs)CP. x=3w+"$=rvlN:73y W!.f0 0 )4?_jaƛDƃ4EC#B_[%ąOpTA G1X:ptRYA= 0 Z2n5r1ܩҎc|.SBo[-kn_tbXËwqdPk\}Ƴ>#%3/(8>cg LǜXAc:s 6>j]WJ衣]ͅ\kB[A}Nz;TI.j)'xk 9Pxj̹!j?-#Jϝ9l(1߾}^j `bѻNO)Z,d}&-ƅy7zq%]x0oTgUA@8ep ?:GfFoto tQ>dϊس@ΐ*_B!@ӑ>̿?}&hIĬ.<,\>?@>8U–;{]bA#uYx@ntL|iZȸ<{.<8 f(CSS,Nڞ3Dj uQ='MaƢnU~7SiD'WsZ.``;YUn]0G/l.u71d]z?5-qU!:ADPVD7@p{/䝜9FM"mT:Gg9:ɟ wа_(Oaćv\84,B߆sܪ*7~v3cS|]E_w^1H?VtvBYO9 S_ʚR[cdӄ@\^|I zvQ5QۥoJZg GmPՂMTo u ;sl!}1Ihz.ɏ[ RyW~y\Cfh`sR3q]&ltwe{Sp`TlaNpku,_?$QoI}S,j=8%8K3NWÁف2~twah@20*|BTS;?SYrR@7CMuuD ?+PDgRAjz rJ\h*z#P;́VS>9e^?/Ne}IaAƭ YNp8dH*t33274yN? _udP&'R[ѷnQ ^ISy7:Y;nAcAՊMZşR:"GwFm7&4 q TfP)4|?)ߡXP.1)xxDxQf`ZK(+H1$F/6M3nj':Kg;c{@2:YⷅOI;i9濆M \`IBF+ pηo=|B NrJ{ ЅtoF~g,G'IzYs_I6H&qr/v7k$bD /[-|k#T6:>N]OC]>bm{ ]wa˺9u'!fRʸc0A\p]f G4)ڊ^sssMe8Y_+Sm)Eϯ!Px&|NE7E*nӐrO'QA'gMfSKTdwWp nkO0Z!'b0c.r(sзpKJQ~ϸ ~5Ý_YFq"h}`R*`r7ށ%Qn78 ?2]Us#לiF$@&/hDqqoa>rF,pa Ӗ}os@1S jF:&zY;}{̞zʂ:? d$ oVV0kSjϊiag3˟cj#P"pk~ds!eƽ{,0Nhڱ;QA^+Yͅ/\daYNi`}שn 5$~^6pU/ſsoS]B>84j PF_$Oڻ@)QC'翁. YW." t, \0ٮ,3KPauTjԗ??IͲwin]hb[k54e"saXN(F^UZi~0tR_]W;^Җ|tRr,;Yߥ>604<~*WH'!vASVEf󟦩i/E!hC'?9$J.ܯWIP6MAX0/(^JlrQ).\M]fM5WPY} CS'ӧkTAʣq@_b};<k w_Sk<N}-4F ?rŒu`r+$GlVf)lU J;:>>yY\H_nvU4/DwMӇYݣoJm7=8p3vҟҠWK6<|N_go 7i8Սt?#; łtR_nejzNocRW:'ߡ&Hn U:wj ӆ٧5'X,^u"뻥|i2HWRt) FR.ܞg%'ͽfl(?8)~t/}XpWQg7 ^[)~7dk1 +GeIТYv'lO+A3gOvlKbhATt&ZT {B5TDqdˆ(Gtr_;yyLk.w@kn7a})/;$qttTeN}ݓ4L5Lh3iQOy y E; lN.Am`KBze\Ynv󑤔Rs0wF|To]ɹ.0lQK!Xzcqi/A=:y>8nGTk֟Ujq|bM~&AA'i-j@v߾̽,8NL9îeB:9?;}ch8h3F1>һ,՞ k5E.S'XͅJ+å]}yȗ6w%7zyU?eA}zYtd6890zZy''η!;h;MP`>q+2zGDظqa%+аض{LNCrvf4ؤ<65>oX({6w7bh8_iCLD'>Kې2 I|g7typ/~SG'݆c =Ypc<_ yDa%:OaY>hsV 'p都SipKԠ#jJbLw']nT%'My^gx]0s]ׄAGLr8KWQp7BZ›sξ=O] 2ЏFڸA|gB0Gq_7.Yqr!*3Nnːr 7T'u-IC :y)b~"̮T!5B92N ɫ3sP_ϋ6HEj ?;UմZ>(1C!rlTz-&pX/V+ZȳB]b?,7-bU;mz*Y$.4-'7ہ4~eP3 |'ZpS7X'߽{GnpAMD{PN/O<ѠC7hǂ&?.阒ƃ}Q,d<i4-;pC']ߒ :48M{őBtҟ [Lg;˗# ÎIXH{&W'cK N 4!}̸2FAsK$+U ;pnϯH" qdɷOy(…q+&tkP|ņ';ꛣipzCz(}gq"KNXʆ Cgi2C);;\1U o-颲2Nw?N,$x?饾0 ] 4:A}{?o;(otRκx?GӧvMqiƌsx0Ih͐0lC'KSߐ~ Ng3oRP_R-s7%y=~@M'gDik_ HjI}0.x0elx4Uuߴ: ;Z)򦌓R%&s+v?I~h*A|1rr$ux^]y%2f(dR}'ZJE!BvZ$m2o?uΜ{g9g l)#0DJjߛu<{>.VT< h_^ 1o蛵Fk5wnܽFOCYSrg0ljcFk৩E@Ϝ:H /əIOGsvĂsQ'7ҾPiPX%gWnTkXMAnJC13:Kہӕ d2}86To~5G/zoVU],%Hs^}\Po}xJθ0. U֖ڡ|Ҵ?kv #NΊۻIDUއ?)>q{*ŴB׵><˘+&ms#7(@mRno𑵥’玿ˀ98~|@]F#.] o+e=L8:C5BЮ.˅k{zGԛ[z\NL2iJ`1t(MDvg`n5vϺ=(@FOYu :70-y)b6Khߏ\ac/v[S%sҞ~Gjӫ[ӫbl$ Uy.ͅ2suP]F"&y`х|)XxfNkb;uo huQE P[8UY>}|X]`~v\FBsc8lHlף G3}~`؃=rP~rGȎYVv.Ӳ74* "t@LlQgpP={ϓ]>R\wMħ)SJE=>}.;g>%v&>\mZ#j[EovN7(?tt#mI8``yBCӍM (ȟXԻd̷{#4]΁K5t|͟j?X@og@yW,rL- lhx^H"6(*,|xj&ud нbT+>CDo?C7T룊r(xlS8]z׆'؁dR`nϯs}\}?)e i_.C-: %;;0yث~ ǛIV023g"ۮV/:Йb++Z;[4 븯=py>cM-`a}Tk #VN}=yk侌dwW_>p XW⸢rO(!Id P^#ӵa}=zNL$nXa4_@X8ჃceC7[ae8;X@(b4C7ծm.EAGw]M9~gU &6ʗʂ-4|9 ^FfPt&sgRpߎ] }k.ZoY0b\A{߮2vy }(5pЙc@[ɱUrk49؃@r~Yv+Ph 1Fb ]ǓaGt}b1OGoZcZ~wIMI`ո1^2ՙv&jL.+7h@";d>]ڍ諳9byQEgOOؐ\!T@N Tel}}ەv.ʾ.k"wti&oBfq`S/H;#HGNQ3n3gZ\ys+43I(QosN;}5ےO.qW;&td~RLXHhs-[)@tG>[˟]ā&M!Bc#+q`scldăPx`tҁ`~ ]QYn.䧤 /53-Nʻ MN9 %" U_zm$>$]9g猔ԷE<2ًv&>:^ uihEBO|[!}sy޴3: {T?nU%!8i/ΞQ?df՟Mpdձ;OWj@O룘===,׿n Lqb^@lcPmTyɗ?vP_ڙgP"WBLX!p4d'\w| 85 H:s\mvTk-$ѾPu)s90g>VD} ~{}*IҊ{~sN7@ h*~E(g#_r@DO-v3Q nqou^+"Lj0Izvb[x,8;?'^~|{$H ~;\[ZD'k%5,eeL~8BcR;* G?=ܽ8v *Y?O)8450a3YɳE"I|2bҀO$M&=Ť)ؐ6Y'߇~G"Dg:S%RiЗ:Ȥ㴏BsvZ4>;ǢsO|{ iW,)O< w0py NMro/w%I=/ꎡ >?^v٬L8A;S_hM[8):/;KD.葷7ZVXgH6KC!OWHh7& (lHC\$99-#kf[' AgTW6<.XGЙ)&XZvӴ.N{MFcy|G9kNOt~6i0~Y!)BC_rH0 =A@ѵџY;NaPD1| ބ[мĄ"tfGuES"[b҇ć- cll`TU?/~2|d ٗiG=" Ƒ悔=d-tIe~>?rVDїv n^u+#L&.cb,B&Ώ'ʦYVDڙ{~l,w^}>ak70:;9D}93$ڙGtCZ-H.:_uOn z(z$*OI۟Z#i_zX ή N>OD?W)л$$"t~TI~RƁC<=MoL\^H]G]8N~k\X7m{Mٟ7 hif竲!>~)0=B%Կ8߭?_*TqD9о p $ϧuگW)g=AEɈQ'ֈIzQJ-\ey$Mo'#Sя*X5^ٟ9FMVꙿ}N%/љocÅ G' Hz:zV)rMiI$>)+\<-sAh~?ґklM>]obyS .b>@9/ }v8pRGLߠvU]v{ңK\ڙv!,OIί 3$~pl .~Fi\ 77>s~;**uLGcJ6To'љׯ*cx)2ԣD!R_j,hIOG_rjYL6[%:S.Lrw AE&L7/:w@:sZzdx.)1whgVwE "$J9Jv ._C Ӟ^T@,X5DR|E+ ؁>[pRS}[YDЙQa߾l{U0ÓG3!c F9l3&{hWx9;n HSڙ<3)j #eպI3ڙ'l6fZ3m6eeL/?z:6q;nl!~Aq^s*TO_DǙ~/N|}gqEggc[rCn@ߊ;Hl\QzљA?͙@-uח3?8W筶KCad [\eǂ$do@޻,ƒ H+ڙ6qS.sd kt\Xt=,q}uֻ~[J9](b䄱_S1zC;ӟfW=Um cOtC3*+(6ͱi(Ͱ6䟊eۿɨJk/d4a@H%iάCO^%BJ$z4e~=O;_w/r38 3*R֦ぐԣGo`Is<8oU^>[Jlhm]4,9Y2nsqB-'Йwz^l &fGѣEɻDdn ?+|K91b]>yNvjuuQN5}&Q@;s>{=AWP-/.- t/3 q&<Μ9ڭՙ6hH%jXR?%Q"zi(d =6\_W!ЙbTF ISOMNjX]D3coCs*ǝ/ϴϗ{x4T6͝Mėػ~SHKtfP±~FNiG_בۖm/jo>zw,Xs/GgsTiݤ1zA]_9N@67 SfsA|:'h,U"Oʍd9 eLO1vJ62Yr}w)_GAvWo*>hU}̉{73;hXKb-i*lڙ?H0߯(D] }*)m&= }B[>aytC@arp=WOd[igV %~s>CgrcY8\~"F;s~s2= ق_稢=\HZw_A^^Va˵skɉ~]Mn |SkI9:V'o7ـ_쳞=DiZQ?6}5v hgwܯ<RPYRߣl[΁/kM%˥c!Zvﯥ۠# Ҵq_yx^]y\M8!!'eJQ̕Jx9$"!HD49i07)e*ɐ9%=eHDOugM}:9Zk.1v$bh 'fU oL9VymWu9H~%Wa]c.ځkD3AQ3]\hV(!Dw`JF(Xt/~Hr/E \Z5qIH`/|z2P@ (քm$d1~׋W6q-_鐐X0 ɣ] AL"#Щ;Ru54$'VEvI7>o8pLJm,ʸ_Cal.MX.߄AƾC8D`E*# )t=)5jcD5tCi6pi,Ueݦ9s!#nP9i}ZTۜA~6k@X;qc⪙:pF>lEߊ>Ѣӫ\S~tPOGOC>~t!qD_>a %{ノH,?$|Y[o"c?(o-Q!4]>% },>FߙS@?|+%١OkGP΂ּnU.syf= }TOʕAJO CՆh- 9ރ&ٝ=豁& ^BRE=+&S[(H |^@'2n2‹h8<9傃]x'ĸEа£ౘdOC84^)푒jeOD_ 7%oDsfhq-D9"?OMJ;ǁoTv!;wOHêrn;q6i΅)b5d1:[~̧brߟgV<5PU*!6kc"O#*!UgׯOuvA O,=? 5Jޕ+'}W`|!=vs$nt *-3TOB_6ǒ¦ I;:^빑E_|u8(`| q~@,& bo={( DDːqm=5H:;~כjjᥙm]A s,\5b{=[?[HF1/IڱBa#[VqP@ht-b?RHJզa4wOL>Ǣ78~LGP%>Gt˞+b?,`*/s`Hèn6y&P?>Ȓqv۾UÞۆހOҜ#4Ls}B&OKoC|hcOýzo/&V[5O([#]Dy)l,x/JC;e^tFS0tS:cPwY3nٳ^!$A_fޟh֟=ot}Q{'8-`Ó͟! ZcF\ަB2}"=c%4|;30~] h.zD|'7G/ݎ7YBCԛ.|rŞdt Zc9Ю`2u`<rJr{P3ZGgQ:K.QAQk[i"]_t4}vsWH8Nl8LnJC hvt##^r!/xU?$ݡ}/% y.隆[foV}ۅx9>?7P5rpwj́Eۏݴt } K܌{ 3uò0dejTper5UUAB[a1=$ q0TVo%O8*/A`u٫hLW_6LD΢@~m* R}7$d [83Nʺ_] h^5ff7T?W=Ƀ-#l:şEWtv}sT.eDG-Lk1M<~c SCIJЗ9 ia?hZeGGp1+.:yw~h 4n'!wӼ(\o=H%+:`S> / I2t3l[iOI?nВ` L?ƩOn`3,HzdFƍ͜`[A͇8 4ꎴGtmύNl 2mbXK1U`wMB>eTvj3\ng ,{oz;:&IIx}x S|鬐>b5TxOw zvVß4qSn1^UV_J2w 安/6UҐm|7?,_3}Y܇9r=}s;uՏU??EDlcO.|iAwD=?%ҳ GJdIGGU恾M~"҄n>G(}j6gN yy4qgyR8c]K萑W}j%HTc ź9 @v2?֐3)wS~EwZWѠ9gs,$BgdcBy`& !yށWs\Oп:pˊ!3gkt~v Z |~ɍ bQ~x1>㿭ޞ(G@ Ag [7wC]6zْ9R`5>R]^{'8Ӑ{2䳐X3W >RͿ wSVv@tvzP`/vTtvܺ7՜ 7Ldf.HYYd%=9? ՝M[G aõ d[П+ zn^ة@1oCoh;co :w/w"Cz>;wvcp4)v,лD{xb<)Brԛ#}hv9[M7#߃N]}+o ')-AGNCuYrsN}8Bw+[+{H|2㭻6ٵ럑R =U ,[xX^\'G_~tE{8⪺عGgc ǖss/#2Kykb;xY\S/ Zq0R뻟P!مΞ '[߿m6+A:[_˞D#jT2XJ~O|psvHD2luc}Dt4,[D4u9r|UlZrqvd2 *)wLl$/{NaBM/OUKS4i8ZU3ZLDПSjFü'"v軚MÝKDϮ5o/@ZӮ^2${Y$s3c$=eiq^Ei;BZDD4l4xFl:dKo{ e.XY΍uׅƛ0~xnȩMQ4!vC7Wtqv +td :_dkqdl =n2 ,M[pS|y9q!k[m_[FL.E~$I;8ߟo'@֪>+Ui_S8Y2x&v)Ξ?? XOӲ Ӻ t6m՘:Oz _ *]Ґd}p@E)8;?NO-? 4><;c*3D%=q1NYWn1J+#y>G~2FGv@?A.oSPX㫰LdȈ<];I:?u06IGg_qP4M'$S3I}. Y`:y-%wfd5:_S7KCښ.r}$ +fQPwOlQ[4QqHWkǴLp<d,8~UB-A?,ssq~^ 6D"lճGyh֎$O\b=\4=Cb{Ș]J2;/w,m9aw¹BRv$*lrZU8W~c4s~6 MwtKsM@KCN>BgYkK¯9"R;wrAH>@g_f)НH8;>:߼:<W.n# LE$C[֜0ؐu8[NPZBÙO z½_)a"\@?QsnY`G fo;AE$ S9Y AŤI:kV˝MEZutn}8uQ}n1CgmQKCljI<:Ii %WЧäfC(85B ]ǟqg, ε'Zf&k`=ǎg}=8 -Ddrl}+0ma莞s:~|:V'ҊΞ/|> d2ᓇ_/=o0OLby&qPu\!_9rIO7y}`IZr)sq׿=!-p`Qɩn")d0W͇YvPP,EdVJ ؿ`jb/ᢳV\FаqSkd3.͡;Bڧu;;,7Bz@:'o2jnNP5K1W1Õ_۲]BTn3Nר]dȁ=Tj3wdXnSo1OV:~-oBL ojW"J苃jkQUw9:K[|u!o%byzDL(ݥB6ܵtsg2>Rp'n2l!X']jg<ӓtȗ1?>̛8 GJ|l^=PHvg]H0SHD2+oN#__zXɴKl}SFymG]kzs5-}F7;._RkƧ`c^}$!7FAw,@?Mю`(>8'C!˯Ȣr%m@3hEg$Z?;1bE/D+d61>fǭc*TOJ0K2 ڼ gۙ(̨. 8')賣ϥy ' d~֘ sqM%.@`c+߮:p>;DiK*uf/]D: {XjRIB:\}C[(8jآ'g>dYs`=Ԏ[tڒ}z+ڃ4F %}޵Be=d+ _O ƚrY{7mUį~ɽ=;ى=[=sqX6/?w@w]v+]$ /^sO]'VK!%d\=9[w?I}bm*ihVnYf=_WiR%GsHL#_Rp}3&jL7ug?7MiJY]j[l \ƌ=n5R~8[?T޹HD}"=EBǂu%Ķ  pi]'z$H7:4U3:'9os43NDnx^]i\M"= R*){)tgJeVѤ"CDEPD(SR !G Eu^ΰ9kϽdͺw,!"ӾRRfF0ή\PNJ"нv^_o(MVeCpeX' 0"uc.PZ3}bYG=Գl(\_/#R_EY!#^*js˶;͋aNוa?z_ĉs C!.sjG)9zYᏑ1m? m YwܠFcیOm$}<=}|]Gz|Y?Fu071+ X|R$awqw:: N# y!/@M'/wt=paE\3.-:Iz!z=E),aO$&n?1}pas[br ]]KX{c݈Vru-fuЯu?4?6EcA4iZ;Ġ;,^jGP _ѿ/w)cB\\"seF8[5(_3 iC :h:$w.-_uk?19J}.VuEx~m:gx|\p]7kn=juX+&5(+\z΁ ibn xd  pwu!@g,.D<.%4{;L\X}W6/ͩ4N~q UĤ }{/k 6h}~AN8޵YoL@_ohC6\]oEZ} ]y3Gyu6~2O/i[ȁ':/l0-m.r=}Cuq>NU7ѦѤ5Sy+ by-J7y<8p`L"].ϯCx5QT χ~{>({ET nɿ YZ@Du/ibC`==z,D}vSՋ6 8ل mkVP*K}r=e-.Qco^%%ߓߔk·'%%ed?YCnY_nt򶐬@_X^nɅVɆWD$O,P6|L= Oylx;g^f5]H>$be[[G@p%2U5m'COEy!ܵBud68b#;[nL2 FV$-L1?'Y=#ћ8nu3 oo7r_^6rb'Y7:?Vj,Gt:tS%3@e׬t)4zɁ+3oP?ؐUQkJytFCӎ$oz\V1fԙLc.H3~"$љB #NzI|0ڭSBS'x}fe&34K%X8:S_;2'g΃ԚW=e,r7T0abǂ:Sn:W^֧'lOtf[>, ˟!_Йmc\8[R߆^w yӘQ99ϤC\X Oѷ_>w0٫YLOta\zek sd%%*:*t+<ؼ06HSDљYؑ3х-Ϛ:<Kcspu>$yxSsV`ƌOLdz_1g8`;xLnV^'te9ij1eKŸE\QJ&Sgiyw ITE|~>"B'ԺŁM?N&Q>zf<^)qCBc&.$1tf¹1t4.mi#ף+'7^s=AGIkȈϺmU]@]*0vukU+#K'{W>qGK_ tpn2hOe3wbyy9XiV,}nq Lw' z3?Q,g~M1)!ԙqvفgI\H\B:J^iTA2Ѝ}|Wٽ*yt\tiG,~ ћEY?p13ځ㟌6mt}՚90޴SapDlgWU9GgO]a#X\WN2q|FUWA*эBrőz[y!x _5᱅ лW@׫}z;)e\z"9D Rgk!݉IwWX-+oV/}P͇Zud':/3 KIJ+S;fV.J}:AR/鷑LzS>8}' Fn_o?@zor;qC7./Č y;_8b=0x.!ЙQLJ:ӋJ߂%%2k?˶s{S?FJ^GW/dž( k/ޅ_ \+i2 9n)lP{\XH љֹ^x(k PgAOϫ k'KRbϥrwi6JOyx+&G%c;b0;,l^.!9ȣ[5!:~wdv|Tp^ QS~o+[p˾|h)'q:<Ym:SdzQ]98=[z*yns/5JtLiR…c3ə*?;漽 {tˁCO:S? ZVa,gj,z AgǣE[q`s]"Roy UWo#C鄇 } rj/'ornkbMSꧬBƫd*:s~k5:|$zodƁ[>8<;-$љ;CIf릖pAw Fg'.[oAvb3tM" v<)$Й)$Æ7f9UφHuԙJb-k#NINF.L4\-E[HRcqޯ)t ԙ /`(Un2˽&(?՗>G6Rxޛ[]AWoFrЙ:~;ȟBHno_ N]+"]iMtE >rc1SGou Qg=^e?`BX[ LɿVF`|}Xv@D6go>U6M?Vt}zaΑ^|n7ulqGG{5tf}0=gbX*]|3ǟQEӢP{z?귝D:y0x[j)tZ7nJ>wTqg[k=QH "oK%&^;`gViЗ6|\sT̚%"_…G̋vbE2&B2׼c40rcowZ *AB=e.He[Lyӫ:"!iAgT)\賢nLBW{TMP~%wgg'ُϚA\ξ2gLאcO߉  /Ȗ$m'љ3;ELjvrFc`ί%dj4X?<f={'45<`%M$$Qg֟_VAEV+%ЏPx;iwX8jV҃ǜe%G>\YLP?H}$y&^z->:|yp|Ggo^WVIઅqά)]T]"2><~C}~ ^Ȃx3*5h wTIBnv(DȦ7#!_ntFYZu8D|/k/D}dr͊=oZJ\tnI >nr6 aV R׏>^eD>>YUo(#ԙdo<]Z+2Ua-:ky4 vG >v.}6(}Yae,T3?Z.,ϿoEa& s)!{ЙyiC? ynso\sR:Ih2uf}m">Eʗ*9B ԙHM)S)~`k/ >A"IgƆS.~$=:Zy > 'aʘ</ I/:~W=CC J ;Yѧ\P3>\xNgl̒[3pjb;Lm7tW 9ɍ2~qī1- eB1)Cg漻_'TSiԙhq<3"# 5xNz%`Z2|'OSڛu\3T'+!_溹h.|0_^23߯r5&;I#z_ FD+ʬڟ;dݢ0G FziFNQIyM^?8  ÃA;A҃&io/$,a~sd\ƉCL\EF6???[B߀G'g%x:sYMЋTttswѥ*P~:}{ɫITZ{깈7tf+$t]@{rpv2uf~ڠ Sز[)BDg:鐶ŝ.rɏ;`uVV6uf~ga2X /jܑ33Du >@HI%V-Q\>Eճz=\77?}7*&sЙwg6lLzWJ^%-s&7ϧ29zHӂ"gz+oЙO  CZ5L}P>e/&Utԙצ0ŇRr 5kp͍\ K}#X0x-)Qt ̑\l;H Ց%\|޵&NHܠά^}ۤ}DF=> :t}Qd::Be_;;p剃$?|]To<XO=xl k +⽘F{6ܹʅVsoTBc=2* _6j'>o1D6= m{B3 ׇX7{Dg|v9 };mL_1}~)Ag?ƃk׆n#љGm0B JzQw3WI\;"љx^]y\L86T*)=D ;(DҢ Ee)e%KRY "Eˬm~{>>t=zF3'61./'#L_OГM'A珚Z3&׍Gt/tZ;'o.8Ni+ >݂})xpw@bѽMq',9D%Kh9#'i]r!\z ]!]dJ%zƟU=\{~`.#Ǫ@pbV`ڙ35}zmlHjԈOLԪig槲޻P.\4 IBlЙî?osKl;0t/us-Gmsw @?nnfw8z=<]=Fȗo?xi莃GП l e}^u׫#sv{F 8,Qp`})Yƀqr퓷v't t/!@ 3f['م~}M5Bb)OLƾ}( !ySw/VվdDzhA3'JKQ7q+_KIwn|2}zo>ŝ+ 37:l˅{Lf =wKQ+/w@*Ӊ3 &tf}v_-ç H ACV8BnDSUYH=Х.5~,̃CYJH:O|-?ݖ KBE=26l:jyJDv|}.2sðwKsг╨qxnw%!LD|?n^uVJc H&:~Yqgpa݋?nza/w*Jڙ1N{Kt.3Ih܈322\!!C7suu)V*ZE?/=XBo ^ߌ~ ]WP,Ii!")oC}3>בÅD B{(<:lnPm]8SsV̅/_YetR.镮/+$+m^\*Pv㦐|Ag揮ÜAFxJ6N-_5$ D0}E)FъRL(t3lu]2E"iIYcʁIwɁw]ЅO٩BoCe:9js(%wi]:ۦ=L~Ѽ-8Ѝ4Onr })JvAP0zɏȟbAih'.oAw ,l^7:k H):&E"\p0BR"O~Ss0HIs6k 8+l?d9K$ }Y.Oљ'K;.ޢ‡ao1gU4Dn##Jїu HEq/ُάjm7N_ !:ispK8 S}8cZ!a]=b񃜞,`ۥ64JMϷy9 }VU9UDԖd]""=Ro>#V"mp|80rg0)\OlHr$όt1/Կ+<)dkK d+]Ki]yq5^B*NSP^Xx3nzX)lXS)]з-~a1!t~ǙWS9DZ@΢3S[Ŏ2OH\iBO՛M=F@jALIM}vcY*ۤWٽ:_-*Q6? 53^x Ȅ^ڙt/"i橚6|ouQ9󛍢tfy [@?o5u)lN7ws~/cR.#la>1Ky&wMbkBR~}1{qQY['to1=LI_/9fOƅAG2tC95;~Y,OW2^yOEp,ߐg9S>Ra+Mvmt ^y{߭|2`i/ݢ %2|k'D2Yv˺H!d_PX%VBi_ח7AE ;IL}6^ֶ5\eڙK`jcliOo?‚wχ93[;[p#i#5vIUgu2SذWHbė!'Y^C8p0"|3[albҗ tgtR粌%>"ﺴ>9v&{|\`*knjlg N;S?]LA2k@߻ `]~7i!"' zX=q|]/D[VZm'}ڴ3[xP*6hS{򒷫KIE"%[-b$Zmm<:^^E|ػ\B8 ղf"f}1?Fb U`k';wtf}3`m5yOw\7N4ד<tkLCgcMeAl'$_MA4?k7̓=zM/I 5:/M[M F&v57S;ǁJ.-a芪{cAIY}yάOǭSrgIU@)V, .iYP(|}JƻsIa|ץ}n8+S|. +hxiPMA8|E'9m}Z(X;'{Fֲy0]fA7qӧٟXO:C{I:ӿy{`WB043{* 2ߝI hGwHjp:t&~~*Rx9!;猐h͠Ϗp3 ^vvAjP(i|o{XD\[D_:"M`eNzpO_gf{ytfL8+@~>]y2&} :=UeHI5?A_(i +8`y<]paСmA;|ny>SW,ړcS#97K^j|AgJj #G:l/&v~sb*;_ڑ|)mr~Oi@go|mݏtڅ݄gI;SxNR8U5#bRY* cr!W5O?A4٣toS[l&!UK#bK;9\G4b,TXvteҒtiG-rUN0`81BggKkROuOͣ?w٫S,x7Aufo'81MK^aM;+xZ^%WHm]ދrqM]"ׅǞG~uQ->ɺ3239DZ P^R@; '_Й18v{uW {(+59+"q'Ntﯥbx9LrwȎ(63:xj'ˁ3YzL}|";7Ҳo!)BgϗsT`$y\%Lt]]Ťe`:SUthCf*%MLxyfo ,%Zlά_, $:^=~\L}~,f.-j3ױO? xP&+&ڙ{-<>}2G?>@"r7ťٟ=x#Կ8Ht&4zxFH.:3?*+ <asO6k1Rin\4* ;t_ ?yPIfuEgB;GXU;AM~R%5L~Gq wm'N_7T/h3RK]L66.-P?7S{mC۟F ˿㫯k;n~0ҟOЙi|(p><)A3*9Dž?ա3וvyܛ -l6?X@я).jAGԊ.kǿ.qr@ע挊GF7:=ɬ%3yp\GB=N(|;X=Q\J;SO8Ʌ-:$o)iRoN`K^2ʋv]lAVP$"sї7\Qno_vCHRЙGO#I)aP5Й+ ٿ:: {|CgG}'V6KYixv=J=/ūFU.-Zڙ,99Z$Rz u\ǹK:S7QGH0^Ș pY__9.Ҏ>}B,qe9JM_uۚy7T؉c/pۃTj=L/-h*9wI7m+YY9&D\xg;~כׅߩ+ C#(aw+_­y;ivn҄Om?z'tȟdm] p|c\X|})Dߊj0E>V ?ڙ5G×vI i~t~S$Zox $kmPjɇI5z :Z{[3lOjEQI~zYi|G>#{h5G>%Ohg8 e7t|`[ibDtf>Hh38֏P}mLmA3sm\87L=/Oљb/u4~iWi%"w5w`_^9||r\Eїtz,(8ܸdڙ/rh4gthؐx>qS,l]}m[i& t}KǧF"\-za#l0 D3O˺:l4?+']μgV†^v3~3feWNuft>,UfÞVb_n »I֣_8B]F`pXU혟&&##};Θp!ul|2ؠ3_!fi 7O9{~YY]4 .HڙM}riI{gkc_ ɻ]p멚]iHvڙ_FH?6g8≚_R'և15Cb҇Ό_湔=G6yhZX"ͯM4a{٠lGrOFNe:/΂a_B}aήٰv&?X{40y:vfx{ÂE32޾1a޽-VBҮϷu_2.Eݴ3S1[]oַ=$Jy)s\~\%zco7>Buj½HuL~6Bx^]i\Li_TVt_I4gJDd YE)KETD" =OPZff{x~9}>*2veYUw[(&.96ϒމKpD٩>=͸0bK6\d/AwMn,G}qÏ}1Z<9BK؝6(o%''Hd|x~PKOt7}s--x]FE9SwmJVm'ֱOxjY9}tgzB2goB6w8_&/Jf,8#_xd9Èu.Lm$+ߡs+2`s_Lw/y Ii/u>t5o8g22#}ɂm L(t6~\ȱL^U1F߄\> <7LJk# ;^gP%> |=ї'~".|8`“G Iy?uݤ ?-uzM^ 穟DTo/]W&н Cr={JhGgU+{w5 OnxOytF*BG);"e)0{Ч8| 1qQ-Yx_1WO%n.I=)stN]`΃3/M%%W7'\Qx"ʝdpKN9Fe GxГy[Hס MqV }kt۝h\Sw1bVȋȼx`ԢGoW34OzWQuw˶|qs]9_:lOwmb屚"n뮼ϯ ɳLvU'anm$= .|57kEdC'%w;Ȧ,8~uЂW\ 13&$w8Z3_ҷg| !3p|f{=>((/LH$[r;Gv1韍mo]Ǚe):?=yxv!ٍ^߶?='0!r隷FZWn(#"x;\˃u_;l:IQ]|; j;92pnٞH :ک> 7˨Ǭ7Y10&X+>iS׾[yb'w*<n е]/&w=p ᇄ<ȭ|aQDϢZ]~!pTJD' @O@|w$)Q?+pmeUR2} _!nPp?~yCdϿN^23u6??پ͈M]$==k(:6sT=i"`)!jԍq|y֝|8ltLF޿S ypXٲze:|<NH%r`yrrѧH=:<=.s֏r;u#tu~+/w Lo'5tc`|z!m#Swޑ[) +%$*"'O<ʊ̔N*:۟,<vgwhA:[X{|sU+j/tv~~x,4UZrW;\b@l#ql~y~pu ;:6g ?Mhy[7!$j=u_{ ]9?\t6̲~[ Q+- 3pk߷OGOL>SвVlI,[g?UfS<EqmwkG[ăm߱< 3&3rP ~|t*|{B/Cxl<28=FqTQ/Oeq*$= SlE 憏G(Ce͋V)QR>-0FݲvWnܻK>s`+:F 7T' R!|0k_S z670}*O'Եzdn_}z¸ONe,ހflKSduv}wÎH/Ģ7Z`כWMd&uï6g`P^1 EgߊMGEגTbRE= *N(|(%}ueć3elּШՒKʋKKȢw?yf\Y}4:>ψ‰cxlL D܁1oy`tƚ"֟vȄM{e7%WvO5Iе";NKm+fhNv0Rb1&-\X63O&èh R ':sY|=7L=u_s/ݽ,$r8BV8=ƈé/Cv<[a: ѧξq w+>jt+t?dgbϊP 1A_hӠvS1 I}5{} Jz+U{`}U9PEnlf&9AgѢ siY("誸 /k_^!6ݤڐ+-_R)˿.x$Q㯯?#cǹRc4u c2BOLc&Ұ;GCxѸ[`cٯx GgOxGP&-y#$Їovu) ~B[Zw)|?8I?xɅ1ߣ?0d /'"4%ъ:]m ]WxG_:IֿZ6$wjO(럟JLFt~x>;$? ILgYGeyd{>%|PLNr4uĉŤ U/Jiv[J4&ׇ.v၄Nڮ$_ 7Kkc:ޑ}$mu>R{hn,>3x4VJSg뒳Y3ox)zcXqaQJliA}?̹@Tca\2N2njvqQ+}$ = X,qi0tKLߘf ZMgM~Y ,Vvϣp>,uQ92z7ewU[3>OITA.h;WvA:>+{aN}?^#X3{8E9=ѳ\`icbYPg '1r1zFw!QB^h{2a! 'jK}6y0;~Z}`;!R}~s3j<"۹h:g[Cc؞4}v[__5Qkz*%lfEE]O k@orIH쩳33gJ:Pg$[PB U5C;H:~t Aǁ?ߗYσ ne,oDg/|Ӿ=C~l[']"+S &btE5e{ǿ)(C3ULN`;Nj"4TP.uZ½?ZV?)եKH6:{G/նF>ZHI :߼slAgNLrήsZ컁)B :H-:FD>JzIK|H g{bu{ɪ_S\@yyF]h1[[ϗ|iLVߥĹ!G9LU("3ͯeʹ3N< Y2{P6SrTȮUC{b>3ftvglG@늻Mc<'ubͨIM L0}w@L"nvFw3{%Ѓ,vew@&)u,̃IuT;RlDŠf L6rVCg/}\[޽7:{|nzZ >1!4@Ve,AW:s/;_sCsަpw%lyρ^kп]y^5G zs@g9u=4P_2n}&!f&)uG0&m79^mOɑ_,$Urp՗*{]ocp.lf\A2 N=Tz$J!Χ-Yw %HGg/Kh2Pq:|/^ &:I/:~I5u4 r5.p-R0s uv})dPu7CHBw<+ j*O~_"C3=lI!{W<^:Ł2tv;Y+-4S}$h-uv}H޼ӤEh~~MiٗQ|8hc6'Rta~p\= \|sdz3W u3|;=k|oG_|Fta#E7Z+0 ti ~YPD~b2=:۟m!<{,Fg_̯\#H4g "r=[[]Wσwf5mԆކx^]yXM8n4LD(^h"BJ(H!BR %*sF 24h@Ý9qy=Z>=}IJ?WK!,Sv7fâfU1`v3t)#8p(s A̢Džki"|i{3_]]RP^7ɣYc Rw}-<ӕ kx[q\M_gÆJ:3&a :>y ]?|SJ.g 7+}MXO%Am=<2Mltr(Y{ aR5uϬ~h>ro׏ہ :sL}*$oPB%N:7m υ" ~ĵZ@VCw^YL䊧Sxdl8~]iѦv*]IdiwFnpΔBJDG>Y2&{N]U]>DhN4aJ_ٳ _'Yγ(=}sPKл4w?W{H~JESk?#~ΝQn})ꛈ+O;{- 5}rOI7HkN#ۯ)Æ}rm^/1DcƻLʆOZnzn <&Q/@;w=ax5TM㦫V.r<1m8g_8գH(g*"r>誇 ِa{YC9tWyJ?j*2$BtsY~ʋ8`uB2-OQLJ][L<$M3)(i~CuAſ6!zteqa|5^8a4 S&?)%v {>}м]BkJ;{1'>cmd}H%k 1gjU Kb!n ':|MA$URwQ;RROO> }g9hV(&w;nRp7GCHHBѽ_hz5Cn6TU 臯; q3c.0|F0" tXm&i7E^Q-((KPB3vj} QO* gѹ:^iD|?ܷPp|dQ;M{:zY(!#.~Dڗ|#$Q,2d!+% #:nѬa6|ҋ\C촩Vـ[E 7o ~E/%ngig&`cgB^gu 3mI5pwa9DCf#/l`i^Oɴ/F6Ho%="I+4~sw;E !zε gP0f1B"wv&ҝ|]\hZw܆n?n\q#&9q⢄)OD Z<!u\߲{݉a+ O\ Rv 8&`JZo1"%G:byB ==c=!\GЮò O}(̦.OSq}EK͆Y-|Lr;d J>W\'hg:kٳxlްjx?yN cO(fè9iB22L}tdfa Y})z˚2VXȂLt;fk5 ֟EWhgCUo[ $鴻?|=$oA/¿oe2 MVf V&8kZ=kxw!+_le kh'љ!fl7\nA/FD>ÎiOӟ gf 9ZotKdUڙzgm8;m,3ӟk2W4F]T"^L|Tnj?dSLL9-W%=% L~!xxō@;(*vNjKxz"r!L~vįa58/<# 3n{}sε9i;\ k=tEqaڞ@)=u\EwKtMڙ2v_FsS vw3H"П}߫vL.D8|J! ۴kk\XޚDfDg?mmlxbMm%8ĿgՕRB-Ⱦ%VxIM/ћfYH햃-:r\Kn> KMʃ{ :3W.g?q*7&^<@KZWt\?T|$\1۳wC@w5WTȁ\p~gkfvU^Rv]Q:?6=sGKyG{ z,65wiggfi]pjAR$?>_9l˧ֻV^ $ }^_D=XvU;J>j}(X?l{$h<]HDF+,GnT!0v; tsk@G7Nydקpj Nf>O9. igs>jaY F6Nj >.z}qfӜ2v`]\x{BR Яܭ|˅yC~t&g| Z[FEq,.9?_jTzNq`KdݽdY%8>C xoJ8C2љ[be+Wz$<Զ߳ -st?RI#OJHz50oP>z]/ OҾwi $W+Kh R+y$9$h%b3ڙҔ-{L|~nL5sC#nFSd/B߁bȎ+̉ohg+[tU`̪S_Iz?SےUs"(h0}C9dW LmF& i52.^ƭ$/W1-N[E!xݸxd[ڙO۪s>vu2]):Ε&2T)p6T@kpk+ϸǁMvI;ڙ'')>;d6 wV{sᤧ"q󨥝977h\-^.ο$eƹ'Ʉzڙṕv?vФ3F߽9`Me_ Dg)Or4G=# *hE'Ru#- * Ӊ[*I\b3^%;g+P瓥Lo1,dӶʻX"$oѷ]lT1Rm~ОaPٿn8ZsxDn^K tv('~ZKLGlT ^xqEۢ/{L~Q`f {=' H<:}ju QP.~r=ۉKޭ f0ޏ~xB?>ϛ҅Y7gt|(\gRzȸ&[}|O5n}t3V21!6P8z㚎<r68^w' Mg֐#FH [ϕ1.)Б{P'gi3J K^"zKfq}vQqS$vcW8^n8 ˘ݚO9ly?WHݟmţn8zߴ3 ΆOp>4!?ْL}DVe vBWBqZȁ9 t^Zy6v$Yn')8?W&P%,(MK$;hh,[UwJ:~lKOJh]׮Vs@q)G.3_oȷ=@μmO&(u%3?|VEvڢY__s7[|Fg̲IJﷷѧҞ\>L0oS9ppqAd3o9A73ع4COڟgYY@ !1n>ղO2^- x,~n͉Q~UeR }!O5ϛ.GTD3ǦMA:eԞjN/L`UnD3Uf_*G>EDO fUA'Ϝ B>I록9_>;lR̓OG_RO?W g_ c/pլ7rFR~/}~ ߩ![UoF/""r b g Y%EB%=Zx13KwDxx+;+HK-p +MPj{X3 ڂhH'u&8gYͿ]$Y3/TڀIkV H6:S?:,nJ$[66FB_^5^{L5.iYOZљ_ m`lxXcԋl8Ҿ-=׏UPœ ˆ'it_faQKO'U@1eIPgyaw= }''љpxtetY-q}7m :7wth:o9Yڙ/nulkб6?)CL0lMJ4h;>>Mޢ3YCq'6%C~]pLU^eΜ_:a[*X Y/_r=6s!ѭ*3,e0ȅnjYY;=c-q+qu92p Vq^xaw;voxek 3﷊aD^\vu c7L~2|J Ɂ0ڙcz买&bKHDbЙgJGmSis [h3IY1\3*pA&O<'BO{za.&T@Й?5> tRu<>gl_CsA5xơsz@N 8𥗔͆ H:6vpD"}ϒy{O|sWmXμ?sSZLAcy7_Y_ o/|]U]yr:Y]0OS2?xoQRmjO/I7{<.W$ &3F^?m^#igfxB4:xp?;DN#{Йu(#@,U{31t.]6 wϸxgz=6W) -C>=sq2?y q!ѡ=75]u 6%0vFgpaM3Y\آ$y#LGљ VZw^Ic3 aqa[ߝ}Du*L|1j6PŨ~b(mPYsTD*okQ&Yd.'͢5}d㲆V+93hgO9c ܧw:wLPp2e++ftA I?I56G2$35Z'l)I <>?7Osɓ_"Y]{L}xx^]y $Siߕ)8p6T[m1ʢS&^I=?Eˤ` vf䳆<ﻺ,FsZ}c]Z;LF:Юn*qu3tl?V*$3h?ll 4fSJ-@?,u]ͼ\xmvԡOKd#kD>4wt[0^߳Dmu)QM{ƏL:mʇnEe$};3ْ=IS\'c| >XεSJOuzȇ$ I !#ؙ1ou`c⶿zف+::Su;A@2,*FA36o|8$}4ss"Jn'roXc54K3bwtwUsԆߊۜBnrՕvSOwR6Ļ]WB^g33wmuyrͦ}m\ِwdEov>`ݸNFzƼ|X׵DJyvOOx '~Cph'/`>J5>,S̖ﱧ+tk]Y5WG^Χ}7Oj=j-Nenr z Z5߂Bmо}uPˤv҄T\vJYGȔ;ۙٸ8g^ iw5 7 - w$ ƇkKs,e"d1<0>fbv>ݍy'?5j7nE褣n_ OtK~7iˉNֲùv;IzlakcPA(:3|n~T8o -'-,W8ȃoZN|g 詮nk8PDNr zgywh豷xI\x1Wo< W^(/m a]RR/dW.7s޴/D?wiL3xZk!"[ vI>!"+h獲:=[78v'v*V5}{ ك[ o<)y}̨Br}1ɳ*.S5jW'gNk"n^mL/ |;Gе_~?q\YCq;7zXЇn1/;nDXnOL3~t5LAw5~5q& oFz}C<\©~oCyN1 ^ U?z5cD%=⇘:`YY}7X3fex-rBgXq,LP!ƕ*'籭`9؈^:fo3%+`?g2/: j^3ډt ?Dai-%v[iGoO|%d#vtӘb`zFCVB~3k(:'?!33 ђoaxf }"gtჱI]uLuj;ݤ?l}v̬;=PM}Ƀa; Qtf~NXu{l$>O//= u=.;n,|.esj>{ȇkekD(8ڔ *1vd3c^is<@!!iFgKsYc(}܌vb!M?> `kpYδն|4ax6vr}:)L-#$}*J}S<=VezS0נFH=8p,ΖngG-M\`A3q\K gniґ=跖Ԟ$np;UzCgi1*.Dk]DmЍb{֞:A׳erd21?߀?,[v}7Om6rg;M %~6/cтn}j6[t%[_eEI:&}!*"|)E8DUVc;>}1ޫX#uRG=EE|Ѐ^tA3<J 3UCN)m'q=L& Poʚ):IH` Z?vOCi">4Klto՘%b*=캏U*¥V~o4a՗4kq!E~vfs3w`x6( L]}M'_oYf:)Pb_t;KHZFpB'vf=J ƞ`!ڃǺ֜^kR5W#%0zr Uzbi qKRP!l6cs> {|[4ԸWk>Rn.eCw3?ul3KqZv4lv"+Y{KwY{Z]slģ{6~͇foԕib҆^^tRj< \ܼ܊YӍS˃)u!~=D { "^3_QÅe1u}OdwRQG~ţ}+ s[ EM{ꪙv&fMգʆ -\ql̲s?)^4 {DgEY8Prz7[9 ~ %†l*tCc e&$+Ǡ]kL-'vA:3˂<3VV!ouMݠvĿ+r_LACѿǣs .jqO@7DLAAo7uVtf~P/4l@icڙ|])0Ӆe<,G7Dr! >gCIH:S_'zذ)F;]`ï%i>B2$?lVu`>WѧhgꗮjMrtf~%D]T#/EKH: ]0ȳqYw[]+pC,7*]:MdΪ.2?v6yyyRkHBԷ?w9ڽ͖T%`A@a?$}zqP߇r.ʍ_G:>?)!qh?m.s6qbn2.v|9S;8ef!Fį3vn?*љ]}u91EJ^3rm_Iɴ3/eN4gH.==!`4TE 1"B,֬*ARʐJ;3:|<+lD>nO oG\96ӽ~ %nD6!k9Ma" }uIv4ڙ`>E:S_5~UC6mEziI(X+լkɺoOţu&tŢZ[rxyEэh^|PP;8>9*۟KcQiͲ]ɲi,0N;~zW*¢}} }m4]Zw= }+egYVl?hE[O߈L$ ͑@k) FgGxoFYJh<\Gg+@m7YBeZvRm .|RKu')A߄`֯!^26W1Ga6!rM.‡*g@L,pW|c'RP=,E ѵJpY'Uz83屶Y8~0.I|iŠ6<8Jp#T f>93oΓ<C]r/BgʴߩGZevj$}<ÆcϿ.@q6r  ͡=E-NH}!gV Bgߡ7MO`^U̥G;S0MEOϓ^̅R|@;3~FwP7@AgWGM~f|5OAw;̾`O5 #7x XO}~w[k ʧ]<syk0;JD>0,f)PxvP73qۏa҅]""v|j`|Iڇ.Z|OL3}ʛO*Ur)iFg·ڣMF%aSC(iȑhGopv`u Cg/_'k@qd^Ek> `x@Q*}:H̜[>wD@ߡ0ԈVl Eo%A D$Y_*-"ڻH3:r=oRDlē1Ohg5t,7T y~'`ˢ u{WY}(>oJhg=\{^><-xMJљ- ?FW*@':+i'?y$.3fsa7Zk z: ;Hȁg id0B*M%zö qngYp9 pmN;,ykGbK?%ԿULa^Q}p´!bD3;-_Nae!1,v--e5H"^gyuPMo{3W@1P> *}.[λSryd[#_xEj :>DɧL@Ti/9.tLAV_y|Y[K^O(j2{%^^F~*$M3r?bUoM*igÔmw5- c=I0:-vٶQҝA2ЙuWkʇ L1O5t̃G)C'vkڙ&inH-lIr5ohgƓտ?:Ymcҹˢף(XLrљ-\,ƯҀ䗠@J. W / -L}Y1FzsE$VU+!ΰ9?d9G,"+VZtTZ_=]yD$ 2|w 9y.ת({#ŠtgHZ47Ct>Ю *oMM͖ *gi^hdCs b)9Μ2tC] ts .`W?$ i/Ncwdgڙ; SZ z/'Q`DZtI):~S5\?LW%BWdIL}}?R誥|>UNo6;~zRЈGpR˃'$_igszzp!ݶe(Y_Z(qabA}r80ΤGdS}2N;3W\Msze+l'IC߀bR3N6vV~vvAH2?5ހ~5o|ݥ9|'pA@JX-3$;g5 ^LBll|}@DZbHACJ|n Y%vp@mٞf1 E;?[-Tm",#|a!!93l.iK {[igIMyub"AB:#Jaau=m3ύ: Gw?*}M;?b nHﻵ@*"љiMMMLR1^w_q2x{uUo<ཙЙFK)pKn%rEjۯ ,'aV?!"igo}LV"!WW?9 z;Лb^7%\XhG녴3  4tf>e}}ͦ<4km) #_!:ȳaU]P6΂*{Q/›߰i}AppN/x^]yl37};?3s=9ϙq.;Is`|Wb?Y)&"\ϷҮl16/OY;I/tm{)S񷀌 =깈8.^l鄟zZ`yD@6Q("I,qg emӗڈ諴&s =ڌG[첇᪨Rr*oK<6 z悀8KbˈiF%5>"@.֕m@4YRGo4? V+IYhtfyhh֍'h76 ?2SѴcyWBpEzK? G?,?~:]*-"civCmw6Wl>ҌEgXd4I${f4\V 2"ў%ޕ_=\8/ 75ПǸ<ԞKAyg_<{V]S4xc|Uߔ]M3tQ/{1_&^Ro%9|Tmte{ڍ$ \xEHCmIg-k^@3W>8 eklDcoR(0!nѧ|PmDJIJ ϙ=],.?ZmM,h7Gc )"Ҫ8Ht uW[j/>[$ ՏVٰ`t]}g`bR҂~)R:ς{24<}ی̢ IMl{7QB*;qyUٰ{c)߽$]}H4谍X-ӫ!_‚ַuSiBy>nM.;$ߙÆKlv!讃 z(Xr(;DO}6]cm9N;AL{<.OJg r O.̠=Lh/ ,g'*ʴܖޘd8톈*[1~Q@AXQӣD[ ?'8??-"U 7Wcn!suxB9 /jI>҆^UlҋLoLڙ;;Nt?sTd,]y7z">53NԈ:";{n7ZC_{lcV$ݲ?Ľh _t_GΥ}"Ѻ KЧ«iav16(FB)o>w_- Ck0~n S'ahg+5/}gm;e.@/עUʂY";vql%rl\nI;~X_6o [%Eљvn,鏐Vofλ$|d52?-گaa9-+Ӵi߂3[8>k${o=xB2yz&+A>X8thg'; ! L;X(\Z-GCأƆi܏CYiƺS9Wzn]5T.OwT[RMZLʹ>^Dy[5m_nBCO_|n+ V^,6@;?/ub=[.Oӿ; W| ]Tj e>m@;_s\g ;U~o!iF/2)UbfԴ,#n~Q9Dg_fceџyTЇ2ʐrtZ;NݢBtԢ{q-Xp2|0?mD8'V_aS?V" LhsJkG;cDa)K tmP1GЙ;ݥ-Wzl#7џ_ި!̊ 7|:d?Hz8b (T%#"}!g Y~ď̯)".qpY ?@R`$GD^~з^g H :3-\vMxj䫃} ݂k$ v6L%Wo?ruCQe/cK7[Dd]̆3 zJ0~ӚJ. ,P(EF/Y1r&-~-˯\qxtOEw<vr̮2oV Sô{wptyt;7'A9?'9k}`&Dʚvfo/g8VvU 89~ܗVlp!Ч+Jw`CrT>ى/瑷E bc|!_,H4L|%vo@{q4k\KљG-ÄeO/o\8_ZXoG'Ṡ qy\C0y'4J /W捁631>pџ=Xe\QZ43 (ltt!)ڙȘ#S@BK3x$}5z7lkpBWEw~Tr9acOљ^:S{5Kcˡ/=c 97tlA.Kk2 8lx}L-J3W ځٚ?&t^ܵ4Ft).P.b/ /hxg,8P3x| ;c*g5 t|vԤ[XC;0x-_ oy^Ҧ'Lip@pwܮ!>Yv&WWwCj$^Ѥr3(x[G.weUj'\#z,䜿5<"#&jS<SO=igGkK@E,o^Ҋ?_TG}F%cxɋ ##7]s!5jG6XPxe~#>js2pf#XUKHDfDxvf۞???E ~E/瞞j 漁; VJ#d+ py I(F_\'&}\o2J&(S==4tЏqӹPq'O<o$ufڙKHWs =/z@0/h{`H;-߲,j3D3+`N[_Gt}9Q׷(=}2 `ɥ}άouْذ9QЉ>eA5;8dpHΌ쑈}&AO2(3ˡ+{2zQuhR =h>7f@H1bźFk8wSrT{T@qX&X}>%o'ȅHN$L~][0zA .[#Sv~݌ɡ`)0\}7:2%_˜O4s[)U/:eMm JwO|D7׭ ?$h 1`[vގnʁXeѷ77f?lA:dj5j{igV `D dLE!=#90)Sa߈δ/a4K~G:t#XPgaa-Fg pؗh' +=naCծ'2v>/[fyU z>ڙS+[T)\M.}X7WMKљyE}% ؆v+ Ⱦ3QCƨs38 5>Fl ,IOt`ѤMlaÏ]37 X~v>A&xLu^lv@d2}V["B]FV: lGg%TyBF緮U F[o9#h߅u?D ZUםE3; fsn'} :s>!߼8? W vwMK$ڙ(9R.oJ H%z}qQP;L;3><.Ad5H :~&RI' )0rM,0'Μ_))h,'ПcQ׌kgq 뼲@Q 69_rיueN Μjv,bCW xv|u*tNWY5ɴkpe;d:3>L+v]BI@F=I3 Y(GdShgކΥf~I>YΜ=<лQ;&NZЙ4PҊNΌog7VolG?B|.Ӑ_/hwG?~3 p|#/љtCoz6II TڙXW@I '9U'$u;V'#Df~g^_{m0b)t'ӒӉk& zt 'VnZoaK]S.8BRkXiXN;^?~)Å.e /OZ{ܑ_=ZV7'z_!S{a( q 6|y[EVԢ\oW:<@umSj[B8Ӫ .^\́Qy#y3l{hzp}[_+3@.^/z$.Jͦ&dUڙną|#x@L[_ND^P2cMZ⸐Ϧ#z ^j'Mwz; nӱSVퟸu#8sC0Bi 'L{Ѓ~ }1dž)ctNG$}_V[#uw\7hA׫^UKAYRx3NPp}\~r =dUVPa*gbqUto_/-)́⁾=b0 /8GJЙoD%20(=}"Xd9~O._@wY;NT).t@|Z8_>^SYœ9ct3R1a~6v~#^{ƞJδplK{I.:S^r]md L.Z(pj r^y4OVޢ}2=Bͭ1m/;0#)ofs̺M{"HѼ'Ki#{{ȵ;oEnU6_*ܿޣ?>|x6ޝvlEggN-S0=''E 2Йaџ?ʥp4BUsUh@.$HU,SNͿIL *nAϧppRڙ᧢wGI:-߸O#7oUogH:s.X́N FgO *;E,:\ڜy*Ȍ at5G9,XZ97*hg] 1f-t>cP7{b5Q29ЊU`#i>@3$nvm' L]pmnL!L$W/э [GO&}]]C`K99'(Wu%usǨu/\O5Cs t~Ok7L"v@{c _$g׋/^X {X}:sgǺx/O:}sl-ٟGxs[h# uOT-2[OBr'9M'8o\tΊ[a~YR$GS Fdԡ3vhRMbjʽ!TA2Bw+UD~K#c_5E n H#:S[;꨹ KFv&_`}]+P@rљ!۽fEr6)d_97žZqӞG~|rv&?~'`$~kewkz(^] or a[<¯]}eYZh̪f|{v} ]'Y)Sb^2vm!ozYc.'zs1KaF qAg_IwWdut-Q v:0n@g/+Ou}In?|J;S zĆTOB$ Kk2ɥ`DE WQ.5%$dcف>]/Pxol'Q=uCnҏ>|>Ty/|{KL@;ϟrUJ NP|*"I12ҡڗkSO!:h~M;L;v &WgYҐ23zYHEu us 5GM{Ih%b<Ձ|xc#$\Dr-+Jn)SpKpx]IQHRM[%lv3SϮ2 ެHA_@C }:{;=[y0La>)sfv*c\k_xöѻX2 (aS'l8\DCT6IStO5/Mv(&?i?b?WQo39ݥ= }MY\.8ߺrл^nnSlOk;I!쟿rl+Je7?l=,޿B=vӲ8CE;S3Ҙ~sj/ V/ e=q-# k zЍ[Ɓ*t~ʊ_t4=Z}-}!"ݴ6g<1Z؞Ǻn&jw$l?n`Z7ikGeQp,X뻈{?ؾ?prrIоi#}KzS_U;;{Ȃg<o> }UF|&`{JLn>ݚfR5h,d ?ka޼`E ,9}ٍBڰ==$ݭkk8[xh񑡝?w]]۳̼TE^3e>ʀ1I= (ڢW9FӋ|yh#"҄>* )7.'Chg")`[M"y&K&v.o(h=-f/"SїUU@5kA!Ag/VqHOCL3C+l Ҿ{rrl$$}2zO  mJY.~- 39\p仧Tؾ < lE>!'ПwfJv4GhB[6i.sml?y>]#xG|xikryF;?w wf`(>'"ci߻tL {2 Ha3Ucqʑ 905P';hUMU2((~EyUw>:G?򑂠s߆<&gЙ!# =`!{;1B;(*((|$s{e A }&H[Na/9.ua5 ƽ.!SL?$lU~֥.aw$c u}if-_{}W8לGSs*_(HGiОȋގEfC= , G= eo$V˟q >C3:?z/!9'Pά  IkNpE:'G!`'O|-oSCg{;OrLf6lt+ y5"}!j2Zbhڙe_~ ^dMlљA}o=aG I :3|6; aMxt|n6zLi }td[=ZJcpٌnp$- tsj>4~4@ѭѭ8\w3C<|ZXY\7QK;>%? Wsu?{Z C){?;1vf}.+ %= =Mi}Ki5rOx3Ue)uO-ڙTo+ԮmЪj#;љ/e2%t>C˂_QeC9:qdRb ֦_f*S{9\nBF Dg'1# R/ft&}v;ߊ Luus<nx>]qO;;=x|DFA4~t}\ҡowyi@m8&Y1N/:s>-J]ς,]ϢW|K҄-:s>v\pgX%t=ڙX"ld%$cѯ'5Gi1c93Oo?yY6DG_‚q|N.MwZ.˔_'? 3]z]tstg`ѩ9@)t߮`>r K>Gm~)V Df[-)Ofa O0'%XkVu&\9*L%kp*yʕ%Aրvf}Ԕ9 I(s_Й[iKC^ݮ^3\HOBH^R?e&fA=7CCv2ϕ 3 :•9|t=C30` 2VMϜ^;d4{E̺L ŏSL81t}ߑ,n'χU^S~"1"![ZЙĹ/9ӡ`4aYidB߁޾&6 1ғN%׏JX0z&L0wm;̰O0%L}ywIq8Ȉ#{Ώ \^fq'GlE.l [KMfRP~25럡yg{7Cr'ٴ3Ս{< dƇP5U  ƴ3怜j3yu^~}eN +"r$dڙo|_-=?qљK_Z_(_*t&vJ_S.Ù("Igx9=@љ?yz TE!jK(Ϧm/X_trljؖ[|Qp$9Wc4Ov_PtLPvfF(}i>$9 W~h{4X`C :?.ejPav+Gu qQl_t=Q׭ޯbbܿ9I퓽]+hiUV3ṿ[;0.!S:TF}Wᮑ/H٠@;? e5 gWjx*p}aez!Dg363eݡ8)$&_љaY\Pt9~1QOtjN3/܁^r5&| wF 9/Vj OW]-'GZ0ѫ}ybǛ3@^t~5%]$Й,xo2,.tY|CHЙ0<,=B;SSWYF򧗔3ƞr|DwW(PpWڿIڙ{>|G\4ֿ&RTt~*]/+#+,4{f~7F?~~v9\>9dž'ygQr?Μod|9qm}OsQvXfie~BS4GнMU,0\iS@?Q<.Z%)=ijwNy%ؿpMmڣ,"|ڙ~Ӓw Iz3} 6KWVuPC/ߘ,P֨6A3 & X]Ed7:3.\9UTfP?ڜFh(M =hgky=|\a5T,$ЙrboTh*e' xit̾Qqeb\̯ZS>muMLѹ8>*`nRbӌ+{1tfѓZd@Aݺyq*rB_k47CAַ6d"0WsU&QMN,M+23g1L~&=ߴ}V ٍh0.r=]*Moo=Ws%Khg򫣱i}j)V.`:TgƬxu\BgG3/y͝aqlv&m0>\.Y,"tf|ǷA܇i$_MMF  [{3__=jφztc.-.s;3a/dhV*}AGRþ[}[܄$ďvfpsgS[FyIWzk$,xveV]NL/t{nqaWKtff%vdt4%#"е}- Z; 3QU#PpbP оzf&A cRJzI" 3_G~.񿴦 +hg Q0K[I;~?:<';I$:s_㠡5G?V4޹\Cg7ΗSo˃O'M:Ƃ 37/3HM ?6ed 2p z,D \YaUK^wp9`vύ.p~VԘdڙ6噑v\0^vz%D;PhgYBɅ>rMqPøcgc =}tl yp".䆈į<Ϝ{)7܇G[L~6G>=>q+ѫ/k[CgnqeUun]&(ഋ bP3*1D6 /WYdL% _i3TH'8zlά[K9lDg~FvI|(rq;#$LcO_` F\4VE2*޵RTzek4U5bⵅ pIw:e ]Jz<J[iExi Cd:s|2F>(& j:L}ȲX͋|Pʓ""SΜ_z0K=& Й>,OÏ O}dzzr if9KBgS”'L~ܟ>L>\M~3 ;oWEDq;L~c %#St-M.lY͎n~ }+9q^mDn/[WbM0Gm_(B>oYGFaY5m"Ez?'fZSvD2]CG8X!fi>_2@o?s{CɄJ!F7@ϯ%wŠ^:_LZ2KOљӨ/^Ժ>Anƭv~O>`/,P;]NDi_^>}kI Y賱21zNj8,bhg⃛ASbqPU&yc$%t/j".}D(;ϟ6pl@s ղix 2vPS6UHOgs_3, \X4A@/ycjeZt_<ӣ(;m["bx叧J80Cm!yv^h0[>^P G7C7Qәxs<8a\S% JҰ}.‚Whp *m*v9M8ǠOI 9 K9&@OØWGԿd [pѧtmݝYGA'3D !FlC_duc|d%({&6pnkXIDwAa.;&nU4 OhM5ꤡQԻu0>q6~X=W6_<)'!KkG=ƷyOC޸YP4Xu#sm{Nsϱ {|_f~PD>Us/x^SgcG#vys=>"DOE4,<=]~7 '1n^(_j#n-ztRNXÉǣJW}' Ɍ4Т- zuIHr:IvSG|-g<6Ir]1&kO:HsS7T? /ǯ}Nv]=ή=42&S?\͑l|̓0qU-O*}3z@xo*7+PIc|$ߜelAў2-H,ѱ}xFt>tg|WXON; WfJ9j#*H:eS&^]e|?ǣ)X5Id0~ĕOAVЙdB& sV~ft tv}]dy"v~zt9@7-S]ԣJ |pN(`^j]@s 38;>IH.˾w2bz9D/SpqZȥWNd_G Ozo nz8X@UKR?M& Tr4 Z?*{lECM]*= z zJt .%~'3^e߅ iXvK/Y~mMQ{J\?x5v^&&$]V\#G iǡ{Jb2wS>+t+t{XkQmr{9u4ҿ<;@f,O{/Ӹ/GG-j^NL7َ~d|kPkfn@_yo"[7MBJ?qzƸ߯/Fg[GK2}>I>@'QS{B)>g3 tVp`5:{s촃H?ڃ/^ὗVvz/),b| Fyܟ, y/&'s)a"?@>1sh&[x[jueAgoӯ!cI':=tLJ6-A2qv}v)7T.>C,7ύviMw3ȧ\C_zMJ4Bn.~O:g߲v $@jyggIᑑKBrKw)dR בvt{X)&jtόOQyqslw/n߿-Mq___ƾ~%+.!A}D{Kv5K;VV}Z |$x}&M"!awƇc'DZ؃1aڬMڏ!r~Sdqim{֓\Pu2"^hN˪&?ku eQfɁ6Fts7Kl2j4tv}'G@{qBYqv"ah G78~=QA~X-- ;gч[ѐBYΎ;ֆ9ߝ&[Чç_=* ע̰ޏotvjuS 1d|nE'/zv]}8[eTt&ٺ19EL#"u(x]d86t1~=0苬k.6\$v3^nsf%Gy!"#pLa eׇٽ[#^_G5>CeZ>l iX}CM_` Zo/XR5 Tgdk_ߌe! >=?⽄4*|kaJ?!qDnѤr[ cUb+Ajֳ,ssO:.?##-U]o:K 7&l~0$&SgVpYXD^BKCɀu<8*x>^D'EX>Ⱥ8>L^ gkuUR??X;nE߀nGvD;XM|GgwTUk&)KiIvQΎs9{}{%QEI.9?c\*-B="p# `Gw gÜҦԒu|9o?u7|Ƨ;~nWSeD?6G<t3K!\@?&3}C.z~9$ sF1.ط뜧M.&BdnMlO[_qHV8;0氎s ״+F&n:)J_LL̸v`u^Go. _˵6ݒ|Tu%_&ˍh7*ZhIQA5;otv}[q3A 1Dg?%>AR$q)tj945u")s8MmdSqvFn4[S ξ}zB!n"CgW72-{H$:;~RTgɴqC]z]_ȳw) 7eʜ9q6=W,zFu!qGgƾzUN/',lScO^.  v#Q;_>i`̸2Bq!qx}$}٘wR7 B;\VFn[J_zyVu) gco3~Ri[P "t6~ذ%EY% M_&[J;]tv 7880Z4@<&0~i>L?>"rCFeks&EB~XKZBmt5:/ٵ8?<+fߓm6}& ?ڦPp`n"IDEwmz>b-?̓F?wFx',?͒esL{ƕ.pϫx0ĸv 0AB4Lz xvklw8n Қk_1:SǶNj W[ZOEħsn0|e< њk hCGhw:[]>Ty}7HLe׺;mhp *DHП\EýgICʴwH7CѓtƗWMo0B-ךBF~ZCѽ[f ٵZ&K5tvF߹ pc_>ҋރJ^E"N9fi8䤸 ].Ed?y4|ٻJD@.3(q!lv+<$a/+PYWϻIA:?<PXxGVr:öSB2ޘ?]|+ɱvB;I&MUpb?m[mCpsiGg"@ힼ[b}sB7Z; ZVm}PQB:y NVUӿx v/t u(."l~u(椙R~2ej.U|آ-PX3q#Rpp}],S1$_7ԭkƮtxgͯ~+¥ Km?VL:G➽4I g6]xO5YBr SSkӷ!V\/y,~VV!yTmd)YQ|Fgz $IC}ըɯv-ާ}s C/IKx6Rr}u=MKe} 8f&;!d*-@{ȼd'!tuu|h[ovЕ??o/##g'qf w]6@R7ⓚuݤ}aSn8E:'G Cn<>Sg׈ۆ|>]1"g &,ŇK&O$tZq^[!$;*6N`>7/]tNc(H޷Ѩ=PHqgo46y}#~e(6OV<' z(zFxIg?\On8%Ol(GOۀw Y"/:~mw= }PЇchэ,#m(}܈;%S~?gWe"cI-rkC?}j<0,*;޺K t$,>*<>Ϗݤq7M&82/}[rR 'f%:?^>ds8pyS|Gctv4v4~G;Er/&Ai@8TDgOcr |'jN*[a' ;|zE =7`x}9-$+ݣLvfkKM!Fg6{PqՏ-zJW3?RP͍]6*FvMg==5F?Φ=rfhZ=&&jI5lY "=M/|+Ti2ٓv@_--x˅yd3zz9Qt19EDkiC_zS0,C{K1 GA͏-_EJ}FZO'>"Cd}I |tY}J1$[θ6@O;R2b*Xy0Jth?wɃ I '7[9;6Y]v#-3sGBv&5Ki2s.x qTU%+-5rfP0+E_Ϲrʗ^QVڍ''k9B𛃆Csz9˷38At]AK d{?Ci'XfGlf9 3gWOM[ć?JHvڧU+DA9Dg;lrsNV^9ϵ.phZxd(@ Dm$>*&Йmow3q1iOL_c\ sVܸҫI;Gqjwt==@љI= n]Cr-D;_hgE8C5<%:} egelB߁;%>+5'~S[[+[ȅSDD6aOFWŹe,Tt͝V紺JӀa}<`{y - S<8ͅKYedd7+я{7 -W'!z{hgߙT9{&yu@AoP\#Qa=D=XtBc/db"Lou.^KjAedKH?>='rȡ`>}=J?bvH@v_B_fOm<'m^ZCt~WW9·q-ͽ:6Uފί_M@#:~?Z}]>L.8AHc,YKWfBvz1|(:\`˒hgSŚ+Xtf~'/Ň"Q |},>O]K %<F 8嘫I6D5Q&HNͤr% vSU^OY^ YΌSu3[֪"[+n|rYbdR_7,cAڙaV|.hkrQC:蛿KL'e9Bڎ:Jpi_UA=޸q#m͏v',]~Xl:J;tof_ٰNdBSaeS@ OΙsV=$$sn=;] n;/ɭSsifz(4! xf4rx4eL=M;3^)N~3@li,xWE3A?%LZ?ySL tRWBW>r%ILi{\˩<\D>h߰phe1:S${D_gD|`tQ\9K*&?Й1x_j.D:_ʆh_pl/pQMY*Йbybw(@':h|n_ŃI)0<;;F;Ծy ?OwI+$6;^{TfUMT/>#at%Kǡ S!Iv>_[e lkwd'G/ҾwFJuo:IxC.tlK. (:UBFYފLO !GKk63v;~b, \Rhgφ Oyv##d:s>Pwe۾-0eN'9>ıb[Q+hm0eUcj7 R~7"OD/~E1w*8CKڙoVsT!Fh(`tfYd<[/LqچE,oif< ԷP T)eoݾGAUlBriAB1Gܽ+0M{Y@6'7JtPgNř=$?FNE^S?qEgϷ>w(w ?~<-3$]xC<^t]sQeW 8A\lfbi;i~=yF Xc)4RK'^^ rmIaL}4K7x ' H:9frO#7Ȳs mCt7B(^bf>M ޽XK16U+|(G/V?2K:?O1߸=">񔐠/3tu]vA r,Pʥ?!y'Ǣ\aSGg+e{vҏc/d9:3VM  I:s~e WN>Æyѕ .D"$L}!-l~Y8 $Йz~b{OFwF3> ztg5:&nGwR/FaRO:FaC-Kн4]N* nEvڙZ^}NwH%ףXN/;9l@J.vCNy+]~S*?Us@?*lK3WhS {H7:3?uޜ ʍ_ i~TXO2d~a=W(-wQ>o#A(?9d^B9:X@yE|ahGF?L2g9N%O&tjCgEYo>SpFžSDv>Q/?>6uI8/cٴPP\Ӣ~NjэҮ#?9;oI72mLxG7| GGhqT#i1ysv%%/aIRgY~ˆ%3c#xU}ȆL~Rxsi|R+jqazV~~~X ֌*^KigOW;;JWo}"efW׎8H%zD-Ɵ>eI;r1L}魺e>EܤV&͏m=Qh 'Oi?Kr/Sų%uYGgQ\2}+|u3-1Zlplnp7;.=Q7EO̓yYޥ^[A;3?>ċc_|>.$Zq#P^)>XsAK%ECB9|Xv!099^3cB_kvt> qs9 _Y[k!wݎ+ڃi{W߈F{ؕCu4Fj:kDfl[j8W[p |2rzin.p39qKљZK^ ѳt3"TE;g@͂=Oȗ' Y+jq,MT'o5C}L7j澙/! hgοY< 5qiI}37<-l{)Ag~^<5wIe3uEjh1Hz5zyĽ f+״z&_\Pe#͟L36}8ڙS׼73!@#h>_mn M7ҝ>&vfsDݩ f#ЙRRv'P3 *"?[Ώ8Œ]Dfrd[ s!D>}rl?j:[ͷx}G{p7Ihe53$ ym ȪuA1Q"Ҁ^TC_ڐ08_X9kp&[ʆ@ttEk/0,3qCg [SZ&"j|e`Q$Ӻ>r7o .8]y'H쟚淍~PУ#z$~9ʃVGwMlRdwnJFګ6}k:G_1hHiL#gr5XE!B;s^3$6;o[Cv0X;Y=|pO- [!aum[D-AkUNV#Й'5yt.$FJA&:sHWu#,.!;K8n$$U)D=8 H%U%vf6Gk =0+ -kMSd YJ;=6y""Rj"GЙzVPݤ iq',G3WT+=(=r^! l)p࣪/咵ȼ3{QTYk<əT?DgO}U\#+XIdigh Jpv*]9>q`ͺ"]/ hujz Pnjvq)yUl.ZÆ S0B_oߴ33߭1,t䫿{+:vˍSvJa2`A9vm,g7Q/YΜFsNBUhGgֿTy{CU Gol?Gru_R+8v|Bg pGyL}>Ϋy&\ =d_ڙ:u/?.,/=\Lo^vW}>i+7u itXkO)O=Sl.$oG*/?(/?tt^o'۽** % 9ڙ{:?<[\g$ љQ2roNV/=mn`Yd+ 6T.6`(Y?*=t}o\-.]kuGޠ3zUgr?un!IޥKWbm$L;>u&~#>Ԅ9m ,HDG~y4 ܹu/ƃ+m:[Ͼbw ?J7w3X#kg-ym97dJ㳦>$L}cq x/FY0@v3v!䇧[w⸁$Ji99n2\v9u)q:^)<,3kN/IUpt{efX/~Ш2Zע]|/ag8l#0gCVr= !F<]ڙZ3@C'v#4fbB>3~v[SHљ>=U=mѧ+\`!.qU]9:Ӿw>$Qu0īR3/p,<ȗ,R3ϨbU، wef- ,؎7"Q\hѱ0̂Jte_1:b}aYμ ܱw:$#aN.(7 !ǢȶZ2,tf|ޖ! ZMݤ}V薉ΐuD!?vкAra59z9hڙݨ@T7prcGbЙ3旗vky1I1:s~688XbR.l;qbЙc# 슚B8v>y{r>Gk1IE6u~aQ{kHoU}{ ί3wƁgGs/jO7.F5T`Bчx^]ybbWL<ۼP8M5W{ɉԧg=5}ϴ˪tGl}PYƀCƚ.=ѯjn0#-cO$W%wY;ѣ,;mȅy2sȚ $NhQ8ąW$shΡ S}3υ/ ZIۋx?tRvYlD=䄲KmA0^ݘal?w5+xU8lwWu4ǽx._UUƁXWo]0ouv}/pNAY@c+;87лn@ƍG$x>/֧͔pl`1rd#4*``n zͭP"f,AOo}Pҋ Va7͙% W.ͼu?71_H=N\2eKzAp|o3*aRpόz<[]q n(>'vU ZCQBy4F^-mfu6> j~r^[$}~uPd>q78YPEwXI* 3! 2{1{^n/QG?~aAǛp4.8@kyz_>r}-_F߸0*4LO&3̛AR}~H4qx0 `horGt wRI(Ag${>>=#|khօ1N0UʃTy1؏}^O@[:vUN=#]7upacFXMGckSS젶PgK 6זaVJF\I./OH3tGtiײӜw#l=l)PNCh̜CquA\|>LAww } ڟoמ(3Pj*/-nH%fr1:;?*TGaŵ3dwm۱nKѡF`U˯n2ŋM^-B1Hj͵isvF}@-)M1K02SJ at9A\&,6QCD.ЀM n#x`sjoʆ&4rc5}!:[ߩ  B8vk{'>A"j_tCROAo55]*Ј yAFS*ڟҶʄ؂yN(I&+]\ākƛ,RtSt)eའ#2d㯜<*XVooޡAnQwFs%VvԍY/@aS -$Q>GT?p>ۗKvsh]!]M)$A QG:Az[NJ}#k<8ڬ9Y>ۣjmM+A?:[Ͻ?͝&We|זf,/t WO49āEŊ }Lu&R06:)<V_t38نɢC:_ @gqQ>q`F Amd"Mh.NÄv₞UL̷#Ek / Hz~K|>|6N^ETb{;Dgv+ *.( Z! Q*#T@GQ_Rbg{̻⿝:6\]e#% Kfi.F+W&=&5ֽd] 9qcLIXɻxиb"M f0h>4/YEwQk, ƃ5+vϕg-3xa 1xΞ_/> 3y,MAS{ yqr u *e_4 E/jpy id!K}>hKw1hOEnem"6XC;;Պ%7e7-Y]3:I.bViPK8ٲ=9kH-\' J /Hۢ=@*QgG U+Sy0Kyo~"q:Xyš|>D6=x* ({ v0; T)+ ԋfΖƣ>CS"u6HO)Ì κkԳwyjheۂ@~=?BKo ܂$c`!Ҟ}7$C[RuCl}Sˣ{?pUYʱ;2yCjrݳ82 C91wR ^rTDܥ'$N2A MspCwnr;:,7j k-$`Ql~/˹&\M&:{wٽ@*CD':{xXc,,p21薍bL Ҧ Bҏ>;ZVw}:g_{ٱ uY= :jo=TLxKNPg+L<>z>r=c`5%WMB9!8Ex-> (#^b>7MA \pq/)Gg疲R 4O M}=\չc uS Ξyȷ6'y[6$btA'C]q9G}[$[qGH7?_]s=7=t+]d~ceI:OojOr{)suկuɃl~r<ȪgX|]Pt7ΈE~dRX%Iz-79㮥!ʿBbg'7lhYQgs?9ή=_n ,}yΞ?L0ľ3Io.=aUD2իy3b !a'cY(f :;Ip S/7I2@Ky&5 %$:{`qvPmR)rs\6YYIu_Pf ; #dUۃՎY' s:[-O8}0^4ԚDHkV!/bۯo8KkfosUis%:uvRe@?fE1`ρfd.WvW<q4&uv~ vZot|uYލy|,JH\nQgϗ;J˨sHόEr*dnw7BG }cGsBFIo 1 /bƔߤI/t[fCQ~g,G^ݦ?N8Bn]0dG?1:{(mjc o2]p=?\#ac7~-W~>O 'ĀO|aA5H|hyVQARѝߋևsW&kpXm϶M!5?~ |Z?( ;{0|]Gnnso_Ɓ/ON Cv Mo')'Va`aȷwP*. o@݁i:U]h =e6:{~u6R |rga@5B"?3h|K dn \t6?o2raz / XkSDwt֭RU{T|.:{>ڢi|K % Vʌ8x /Fks)< 2 =?-7 p@StS^cFX.z-'uO8LSq@rڟMIq|zyyiZ3ȝQVPg翛Õ}A90snj!DOC;tT(mY^/$Cпеa+-#w/8wުGћO6F2h~#уc6k˝&aO|}.c\Ш["?Sg~1$KB<:S`TuBR^>OC&Sw&_ե Ҿfb/Yz) h ?+lnJ=w Y'hO SW~UEn7S oV%dy 26pXW:xP tQgz<.iH4e88hʵZu%:{>2Es{hgpdA,ͻ< @Q㖪KAg@JPjV_{h䐵3S [޸^@Џؔ!&57l6aC}.rlHXήߺ!Q ֖'7p|>.Uc OML$?Xݶ =+\%'G}QͪjuqhAgWL_yY8aed.2ΞD7V֔saӥu6l}ܼ\hZͅo{zɶ?9mp}Q~(aکҶ)kyݫDr\|=ɉCt6Q)yC ;_ֈS "zI=]{# \@<$tRge_ou?zz϶LNLGiO'$?DO;l'!o F u~>JTh`@)k7ΞL <<)qG-3!uE vnbs$v ۻUn8sAM'E%:}ѣwF:қP;" zе3_3%!=oF(XCt-':Twm޶F,h) jkyA3,^-ŤBD:~쾀oK$ Q]dj-/~~Dg+d`I^ҋ柷'$;%C :[hɚN peD} cmyxeV[2N =@K d3z47MxAQk vn o:9ռh Sξ?y}ycnbWcz^rcĹ[ q+a'mVKN-E($c%c_;B*Iu"t2ҝ. ^AFKQg㣥W*7Ec.MOYt10--ʆoG^2x^Uy<8TM֪%K))-DMd'%KDiIHH%%婨IT3>u^rΙs[\o7[V}W!XKį=Y5'+dr]*ͬﵹ'-$'JЮ3>M]qq_~B7R}ͬ,1$}:ّѿ EvKF(|Y=`dz*dhbmkg}"VO ߁^≞w3t# NK}_C.mÃi_ sEq [Uup-E +_$% ,?.Z'+ XΤuEz>SuU[YuSB”}2& z(KS}qWa7Qt]ƵvOsဲeCg2OXk^t,Nk"H?%za{{x4!Dgg5^e7wtYF78E:/J |EIBryNԴ_#xPaEa!5+NHB'i_ǝ XiCF]F[u`L}6?􌹠[poi_<xe3Ϫk`krae99@Nkne;ʁ43_0(\GM}7z2#u(\G 3㓟*٣ǃj s%3z$h% _[l᣿Vфu) t/l6-~9h/=vUt ]^Q}On@7[ణZ5^=N˜u4'Mڙ;}۰Hس!r}z׋: ,2' dt%ָǂ#ZoϯYu e*RR2 ;=nHf0סcncu{M[^9?T|ԡ/FR\R^m*gDBv=YyI1'q̦?4 sK]G8^Qoo(G~3sOtj< GIυMGuct1D}Mhq/v@~ۢ9fRiI0K;_ fDq 3f@4eq!tn,G;_jQ6>r}cV8i6nF̧kM5#`r^q|x4,5?p[O{c@i$ėi.9.t}u=WuDo.//O._Oz/^ZΏ$ Yl]NkiBWW /kMK.iOflF+N' h7C?f6(oktЛO*ѯk}t.3B}ýϐvf[}~!@aad%ٴ|fA{@n)훱}r¯]x% S>z^>ܓ8ϳ }\('TDљ L @jviC߁H.^j/'#u+M"н}bOPzwFq:?\+s.:zd X,}>zFzq~;wF]K7ك+NW&ƴ*ońBhuux~: -%gYq˾'I!zz/ mSGC\2=gU-+ y[S{͞BḰy"Dhչۯ#/")W* ޼̆I.fd<CAAf- 4;+ mfJ~1Wrڙ_S@ Aܽk<ڞ3yMx&ctw_k5Xd0[]1lZ?>F%Q .C3Ÿ 0ȿf/fWsڍ·Z̓IE/IJY\1ҿx UkY8tGGdZ 7 :dtI^'s,i?:kƅS[wd:+ڙ7LI07[ͮ{56\A6;n|G_naŃcx6d fjάN}H ,t;Dmig߭ G$H"U@7GɆ΍:S4Dd/8ԘXā/!OKNM'5(J?ٰRDig꣬G LeĝHm!^t4[xeAC;Sp_qN?p&: ,\قFvX͈҅ԗ7'g촃+~8;@&sigדp@ASHЙm H,zz 0P[OQ~({bŹ}'kܑd77)cݯ[&@:2>iBgciY8f>ǧcZ S6 IJ1NW@E86G{8@Ѯ+Y 5 7H}L CdL}MT.M[Kg,t'VIw֝)mOI:i eSP2/e*qigץmg)B7 b^L"igOާDA[kRg3{U , kig k8D`#:ϼ_35ؽvFgmDO{*2{*?ۊ9H@_Kc)ЌO$\t&aHd>z:߁G2<g($nw+^e2*k1-k/ʥ$}M) xo'egѷEjl]u.u0YN;-|L=5 EڙcɨKS6>}Ͳ,uM?,h]o1u+/SCvmO{_'"U-]ă1kޝ/"7䧾IRWՎOXH:Ao3Y\twUtlZiM!gvNdJtf+:?S+lǚ;H&mvX )զ' ѷ9=쪔V"9s_mOôFgg_^ҽ\d8Y =iOߓe\+ ]О=Ligɲ~nmYc ճ`npAAI^⍾ ]tU. gq}[BtCr!^8T\C;SO\Zveɲ3;?f5#fvO^Ÿc!bv&W_@bi$ G{[pM.3yפΊ"2#&?\Y̕ ϽOrE$nW)8aF#=rPpI[kC7|FgGq]Ùf=_qj l gC{$3_㉒Tuf L=H{>Z9`&wҦC>7#V"v]*Wb/-v~.=Ua6MH~~Eg[S7_^hso&ʀ[(Lj6^m=ւOљw}񫩄 #,f %"ZgJD\hg+Jy썏0 l[GA|ܟ5RN;_S h$HrM6_z pka[߆o) ~3.=G=#luFD/Uw2>(5Dd"ig_@ڢ<ȿ<~F[ aD!v&?Eq2zRqFg`x~fo9rs3slH{>L+i!Q>q`6sCma[6Vaj/ kXڙچU Vml{(ASo%a]4|!q33ktm$8I:~d FR#5zô3[iӍdaOǻIڙkβbaQ^ru~ƥG,9 tBv ZPzώ#xڙr2È'^{OKRtd$Xd>IBgmTg>4KS'SUVQH󃋦OjqWYY BgwgQ`3+W۞GUɢ"b?cv^X;X2ݽK^>%ΜOnr|-+mҹ'}1v>*~[l i~<ɴ3TH|N'DKC-:S?fhuE7kr K:T9.k*oz^H|eC:Й1$a%  ڙ#RpP4,3Kv9`^}@ZbkR-Wqc!HѣޙAHz zppp[~2I_Μoi ?Qh#ΏhgKϘzRxH3~ά{l@sl{P9Agyxd9<>H ρ6\lW/f)S`v/lxh?O5G[H0upv|AeN.hQPѵwO=C7Qu t롯kU63O!Qϡ=ݨYOOU:3'$$< >GNteo|M=bGљh4u lrĝϼ]KV8db' sigSd%']P15&^H\ЙQM[k ?P^ Й8~XuTGgO;#RݺrO?Y-}DI6:S?(zVX⮧;@^oo]ק/ʲc9ڣї輗#E/Omj$љ2\I$ί~i?M6]KHQ0չ OKےղP>=p8NUI'=Y&X n7hgGE 8Y("epnnk}^RwvfYkY|B+ڙnO(Ro3D)B`TYqv~@ Pe,$OĴ}}kJ =Y]t~*֕ڙ}K+8aU}$s)1[';B3s}Zeptv>iEGW,->.xb~6q})}'',ԣCWonWl_5HљhP-Chgo؈ˋlI^Ee[+h7q~|n&n\`=6wc3߸rJ9$$wo$Tp}JCޠ9uǿl@jC/q(9?qavcGHBg'T3vS{jgt.ҲsOMB(/wX }Q} VҕOX?k8`!R]vJ;0]fK6TN4&F#|L'se^k^Ό4"3X*SꞣS/hpx^]y{rl| l_$&"[¿)Zch5E@Oj>Ҟg,AWiLS2i[fxПW1u*}&Mn6.J.%;jǢ&\qqKD`Utuӽ/:BҼe=Gq+نG>&E@)4w{pI‹ Nʽ$(z44UI1>}W]Feo.iЯ]-:G7 tãs|E K8={#^곇շ{Ԇɖ'nLKs(2.ݤ`ڈc }J'r?8[:iB_a}\Y'*#;5L|%(v,Ւok H:Lycxea aގKVW4Ȣkp]†H z=-ͤ4\{*B0$'8w] FEza'>2DkƋE]6ChԼ~ҍ~=<]*}' ]Aп3?+I%{nTt}yCDJƝ?2ތd;$S/ sfZcC.,Zn-=OгkZO o[/˯4\HixV!uSsrXzG|З{hf͡FO|r }>z.͸_rb z4[i$0۟imR-DǟO)po7@nݡ hH?OB{gCTz16>u~t_T2pYU=]w ʂ<ƍz\zw}BWGZkA#ްI Gj*c>wUVwy'T_>hyلgxx|q~p׵vܠ2#(3.$ޯzZ${ L>6p]ѹWӐm LR(@~Eg;pF > Ǐq\Uz lf_0-1@Z tNS6Ui3k Q]OqT?yc=Jm b>b&|7??*54\83]F@C{fqc(l~DZ $&?&n]W. /QcA04Eg맰YW$h@1(EgouGtr@RjRqg OMZJ)@>m]`E G6J0>9p3'7T&u`6 J{ dIݮ}C\pi?>_ Gvi{ه^ZٮӀ}AO.&Kg!/ѼFgN*S"oc?sa1/hin!O*d:g*\.,i7#eg :馱d,h\+]l-gBAK:ͯݠi`F-ѕc\?up!w'mLgoƎ 5c${/C%.zso* JK~m #|b ޿Dz #gGQ4dܚ;@ V 1C#dۺѠ^f8u_ipɏa< ?V]-(c7o*qm e10h6YQY_@>}}Q ̾& k~~z^,Zq^ w&gB~QbP89|oU = Di< ae/_-Å'jjl 1gԭ4xv),Ag珤V ._!!aEY 6Gdzz| 0~*OOW5%5H o;>gO fI Nt|eӥ][vƙ׏_U<GqORFOd|33ߎ|^q؋GM>TŽI٢*S1m7 gF ht.ڧ3[zIl|U#뱽W#t.DQEn,8!V-Z? ;DN"hؐMLcoO˝@建&H :_]I!/~6ÙO0+>pC1+GnK :[(6&ܯPG]+ OW~ 9zƓK>qA)-&($u7r)Hw8 Sf2~O~U(d#~5Khjqfr _)B)__%\P۱\:#[G?>ap`5LH@/:qv[XKkpo1}vE8`kySoB1wе*=^&G%g> )>~j]ۿ)tG6)l|"wRX?*rR'6wBƅN x$}qRΧ w g̢]_Р<9A_.qO|c!1B[^j1Sά_2^/0c\ SFԕrs`%u2!\pϊ1Tt[[s1Y qUV, miC۷]ZK\G."mɸ 1SsOO⽷8t{M~͜Gv3jXo/G:tv9R&ăkCn[1 ޜsL77Bg닕/QPY~@Yy|| Gjуlhh@E3-5EFca:/me+1CoCtwfl_pmg_v:]1?aҎ6_f<[HT["(9+9/)ys)o]knmGKMT&SȝEw˝ޡ Dd F7v? \H]Aq ~VX̸>c А>USӘGеЅד..|}lBg? )OܖG\p/Rs*Olg_/.*/_O5d OK)5(o%>Uu#㣰tuJNXIo4^Uxz"xW_E|ExT8 z^pGf1pau2oע_L?G޻V|2#Q0Gy]ھkX g0董Tܚ6%'.l#p. +:( t>K=_4i2KD:?c_ة,$kT/?n]\C6AL1ήϫ|^! "z>bYS4 W787ndq+tv}OJgXNw⫳|RƯ?#僔zNp>1`?&r'v_szr鿟5Qt"K'm t-=ug~#07%eb4{XXVD7:ebkp~U=o%zތ ^i(?m[bG|>Q+) tv04ѬLs٘KWyA RwdR <W@A^=k] 8}z( M详_ӂ! 1nn:,=_Щ&\LE >l|z=2cUo {?-*&|cq5%pa7~SvkYE+z t9UۦIc 5BooWނ8We(?+0oB)hJ ~?nτ bG+m4;.5i/'~b/厦 S[.䡳O))yڽ6R>mB$k-aU6B*jj&VL9-+Fjxf+%|:&$[? },U `QgHsjfYЏa?&+3?$!gSҫݡkIXIDg^nk>:vhP4PEyX'Fj8nl}tzU$xt̨ Jø4}LV'+gCu&S ZsꁵЖJC@W-M?]NP|rcJ1Eg_?͠@6WG(8f]?ntȣ]&*s1b\̆nj苲Z3h$ bZN 1Q)"Zdk%aD|ү?%x.)l;0|qv|r^HuvX GnhH|#VO4O_nq0FO@8X OJ=ߗm%v1OBoc ׹mtųMU_sAN+>}!Fi}r)qq3uBb 8Kv1#_\ z  xƵ*9 oӏȌz~v#w87R ä]_߹i)gƷ.x? -7Yw*r[$^Q09Qx./k}+\22@jo$ nRq\]-zȀІQȸ^ƞ|J++˅ 6702EG vxN#df~P*l9V9׮ &t6~}l}[ oo6Iˁf8~QD,Cg?ŧs!]%u#/+tv9ע\1Uܖ3L0~ }t\!ʦsWDg]d6)=>H2Ξ?3Z~i'W)& /G|ubrg*8aTW;Zs܅O&3 "K-Ny~4o'at܏=JbĦ80{7̵d{S ɴHg^5•Պx2+ ,WK;9播giͽ0~Yo% {,Ǭ VW%ѫqk΅@ o`_lraYؑ ȼ]ϭUe HISi7E^4\ۼ9AAvoiÃ":{~\D1d b{:<;Sq /q6Zi#˅m E:{>0&(ai#4<>4iCiP8?*=NC=7i&: 6#Y vCj'Sc{I, ŋi mZ&fMd2ή'gx^]y??ssscq{3ƈɦx/yw6yՑ pa<@ߕ,REAߣ-m;ɴakup<7rV9HDݙGq>w? 7 ~wmհ."FC/>Dmz=dI"y^/x}ݴgD݀Oi46M֔y;5S@UwRg(X  WD-y'8K]d1ϡyo>v=8Z|+kʅFL#)YDf {|ZIE/G#EWA Pzϲjv5O@Rh?ɻ/i!OD"2_`' tEX^na.G_Cșn6.t6;IDBFmvVxٷS ߭+sX E1b%۪}灂bh,;E?RYHI'hl +|ۚ7qԠ,Md pJ &te>}п\pJK*%з4WL*Wt=;jnG)E?njp f/pkGow%IN;4uމ1 1JHJwee .!o~w{9OA@ nq͠5Y&x&i$?F>ũu $_{votEwxxě7iM(.8\r'룻-t(Lڙi*`>Sy+J*t  \xj(+n#&pxnfNWB3S%~oË6fP{5uS >j!9nՍCl4؃d&J%"r }(I|hLKG<==y8C.xS@^~}ܥ݇B}`\T){H:$g0L|Lģ3Od.swrL7)5/ۄG# fS`>؏|7HzzzQʼH wNʡ~sZ.\}$9˂ܿO6P07~~n_jPң{YG\#ȅHI_"bw Fi򃧫sL@iwBw,z`;1ڗk33OCD%j'x&Ɯ誱quXP~qjlT=W b^n6tt090n|F/Dg=kEXņu[&"^<=rJY~#`NM7ހ`l_R%"%3#+@%t}&WZ%]HA퓶bWJz^pW?a^O[o X)-,!wg/\?;ߖ?&=Qj{(??(qwQ;e»7 YtmI3_۶ [9wa8@gʧqk.OϣOKu- Ptv2L@}8֯g)OxNSz:>3[^LS9k Mf|} ueWސÆ:?؞%-\Ddѝs?6˜wH4:?_m oi3md |XjŊ7Ztst=_!,z"!IAy+ ?YYIKnW?%&]yew7c|>(KEǛu%Dg?}sF? baqkM}fLFCwt0+Oﴻh 8θn!3[~zÖfRuˆuzH:ӿvi, {Wi՟3爮/\a]L0,ӛ/SQ}ES2cr5?:L~ۘ2G;RV#;ѓ ^ iZ1ى>dNY~_uQd nu6l:7jVhgƿg{M_23SgO#k21:1ǨDL_ng`3C<1sUK] NX~~ʸzxNH*eAT+>_} =H:WfS?MHFщ%j\/UU@љ`< ^4[4]@s3fp ss˶N{ ztܔ>8~#&zi/*ojͻdG~)rv{Ϭ],~>GgDN? NIÂJCH*03R.ڇgUwWC2_Lqk$b96v&_ av\?`ąqK#L\av38̝#$_.Y3n(v)7taro_17ƒ#>#"ڑg}4I z2S+Z[Ki7٫{z|X9fõvoCQ-+(]\S21O0'NHW9#ˍJ"-]Ʌ% xб-q=NB{$[OLyxh~<ˣF)gtWmMen^4azISS`φE$YI/EAӋWZ}Rrk;,$S 5W) $LVL<]ev&Z٬K|iorXKpW0ӿ+PLRhwA7h} ( $iW]t2>hue/%M13AM*}$TvQ\(!~ѵf0r-~h֩" =BQb$&mSN1BB~ѩyyDXAw@Ov_1(u~v)^ s Зhbȁf+YI,X2g 2}ˇu5-RNWzVo`k%Rkx#a@MA1+JCBПlOvFZ{ob>vUƃԨ`ΌAxjq񚞫+e&QtAzC-p]'<&L!{ظwd3KVj~LkM|h?t۪|-rc=B r(?Dv!~s _F[/zȱ3e/6ٝ@mT̐&yMP^B~ wZ""άn-GzI 8(: +%{Л-*9U?WjjF1ԧK_di.}{I5Ϩ\X[wQQ9a@{/[dߤ̯+N$aLzaؗGƺvZOx ,x`,,G^1a|W~Ј }/9'yi Zwn$4ƟJQ#[u;%?@ C>\B/w%7{Ѵ@Vg;"5\'chg'WM։a>zo#saruVd+z>οSݹ~xNq2iuI)>p,*YY'^Fխթ,AgוAƴ3S>s ՖSB2J˞πoD%⹰TSM_@љkU;p!\6Fc.7qaBDd-b+54 .86b3n7 ):ѧ[w,~hށ%R?Åg %Dekܬ"[?{Ó.ϕf3MypFe1)Dg8`m[)3?ٴ$ I :?7'qI<:볷s,I:_ иo7xB"7TuB-SyQ'ol\ t/y7&2D?ݨe= ڙuqځo\#_U*"S-igM]Qb,Cʫ|`@G{AgwE#mMY0ygE;_u45˻ʰ`"L]TI_GIt}HoX%C9ϕ#t.[tQa|`tef?'cmigοEgTOAJ'݄p\^ꊎ_vk#7zA+t|2>`/@t&eّ?z{ڙוwQ!Zn87\(%2+'SDd#gڛNCu{t/un`؟>nP:pX^2׉RlWh }tff]Ekn"O~g> /|_#PY@bz3˼[J=ڲy:i=9HQ&=dz41 /v^tf۫SӖEۜ.p DQOe'YLЙn_?=q*d;̉Ck3:{M(EL \i>1q`/kg )yތS~陃Z͢i߅Νz7ٴ3i{ k9A>x^xB9=Xro0hgg|)xʅYb~ԂL~y&zf2ۆ)mtf}wIpOUui~su sigy:gg'K+FvhiqAybÃv zPƓ2Dru/iz㫯:I:s>kMTXЎ?"ܿņşTW ߇>'+D$ =}(jl>YڞK ^3G|ZÃ۾&޴3{Cˇ,U҃$~a\E4.GlP7YЙ o8&ʁl]q]ĚM;cԾ؜ n )_wEY6xRDׇv|Hl ^.1t1%ڬNsPC )9̡ߊý:6sͯVFtf̗\P(;SEJ\ڙ)&H.5SI2E;>2++:$hgv#\tp_љ[e ՝\0ȟm+!J|נ, |yՏҙd=:2Egc4H&:wAszgK}ig͔Tvt2 UW賌Fem]{]d):3~8p!]isHc^ĻAAZ]B=v KO "ٽ':ӿJW6R/qXѮb V: sigo*BPvByBߋ~< ޹Ie:i>u (Ľ5UH|igY0s[XLٔ7!ߩ9}]i[Bgml~tݕ{(^Lvͣ9_<%-ibbԢ3DEʚw <$QJ7**&.?CV{{7k;$Q% ǨB :/sH.>L돗o)%: @iFЀ`/Mз_M­ 9,HGwF- ;To VP|BgF`W>~~]$%hZ yCgyHNNЍ#w͸K.EO UZFfKRp W էNd)[Ɩ3xw^_E?j3φA >z\5!-|x?y"By~tȼ/m3ktC=\kx>g)ǂF3'wK9ntw)rsGGL<i߉^{'lR|!/۰W[{eI HMz<ۏ1\ғ ߏm?OACNcgM|\G>6E7^tl%dN)^CzU"bJ{3s"NnUZP>]\8G >}u)?y+pkzQf#Zv\tiZiɇu>Se$NAJTGcE8EV2~?֔/DcM#poe->íב՟yǦnN2Y[lc)lh:Wm;qu?A=v@r Ϭ*[.kKqbsH'v#ԔkqIH25 lʵsUy~+CaL{DDF]^Ņic-3VCs{D&hB+ O8?- ޢAfyߘHɓ(ڙ5(6( +Ҿ=}<(PM{b=r2W ^Go΃[#+evOX Ն% I4Sϕvk`Ɉc{otf}^T}0ۚ]gj4=6.k|gR!Bސ~x!}znwq~0I%zRå|Gv z/:3?5 }\]_~r}6z$հ<8zYy.Skp`Eڙqu E9zhcx3Bbvf֗R*klDE?06Bמ}\̇}y `mB }f y<}߉B!M\r{;XFv!'oloU*/y OI  06殬e\p6xpv9 ߸Pny33q)L )R i'*ߤ]Kc\Uwy!&hF< Ævqmp. OT?E&o'S G`<ԴwC8wwе. (@¼&$=`.W3z^11KBϩm~zEM]$}+:i _kƇu["#>ï+w罴F?ihc_r! )G_^OC&rPn^jJ)=٠v&> 6sA_/"NEi6P0] v3g͉a6m1U]KUȚG=$y?|tM^`| Y=:3fz*6mҞW:N4 ϣ ӢSAygeЏ5_fplk_!8D{*{q搜,o6BLEE&e:$v&>aͅfB[odݚ}tmMb.2s>!S:.8%"nGhNz?-j %3K{g.<2g,Cg+V,Xkrʃ'.kdXJ08h1GdRKJ|޹+BC0 v#Z#fQPk]_K Z#|‚igAct0Cљj/n ]Iy{U&Aq ߆sĤY_ZYK`8I}z$/K JRbE;?v ȃ7$BS%޲evB7kt\EOG|7j$ s+j/h8_'(S3i߹ߤ}ཽfΰu,- ٴ3qaQRA7Np@x==P4SaűDde?zgΐL3Z:Y3Fe80ty3:SOb ,27{{m; X}GBriAG66R.kZL!'Й7S>xNU D4ԓS:NsaBCѭo[hI\X}p9n.O۳VtvQIhg[ SnT|ڙZ232YљU}Wv]1hS`GXC~륍4~Ԝ%ςzt$+ ytTw 1'+vS L~:TLv]b 4DBVάʟ񃗽 ]tGfgo; hz!ϰ,=*A :2ո *h_y,[tm7)AgA Vg8D)ߪP˴3<9飹R7A4_Fx;o /K~]E3Ak79LYUL+2_zrf\ȊYz-""vjv-{y\Hކb L!JHKi_Ξ2f.&!ГRȅł;eoD`{ٓv=#Wh@O|5v{3R= }1vanP6J'Rm4,\xZD]P\7UCѯ]ֶ{ղ4{+ !M(,WZ'ȕΌOL(Hc2DJ֢3k;.Ƨ7Z/ Ut&?-:74ȃIS,7z> knGѾЪk|oR:љH%}кtVqN;3F0!r]#Nz ]m䫓i«7o1!lB;Exs e]c/ 0νg_d ws63uR90kR9#;ekGZݰ}x%L~qEnrB _WERM qY^T't)0.8 >/$-ڵozJۗ>{@k5%I@[0;T=43;?F_7Km~k3M&߅;|_'WL=gDXvf?XWk+B,3 ;4 tgw!Q[u=%WH./ydz McjDL}.*f.ÀD>]|麍nn`MZڙB!n+޲韠J]OWL?O-Rx d^cL,e$j֯+muw|YNwLyP+V=ڙV}J>?:cRREj љ+QŮͨMZљ੩.JS>@KU{נUK S΃V6l,sԊ'\avf,_-!3ˋgw\ !Ck϶(˟NM/E6'f {F/xDS[y16^p.FgP`zkEtEsЛFv>{P;)tK7GJL|,/̕wt&~̦@{͎G )I|L^Ά].`]|gA/zB{9z >3Y+osk Fc?n(s>mF zF;3> fj *xW t~ϋ ~ٰ=~F)NJ[" 3 }P`8IX>?E|υJ]$3*pmA=Īvf|מac#:j֩s 7{MSt1ڒ6lI)lϽEgqx5?tc9{#4e<$3I4%YDzR)RD=0#"ЙGc,xPR`*&ʹ3 ln]+$Я7nr(Ah>EX2-&c&]ş[-gkC.e;+MԀigÌJ8`qs\X 6dry$90xC>Yɹ)wv09$L\aS[Q u> lu3徳"ЮN=t:SwT}#\}#]D3?o<|`'dFٲ`*& 2[#g*Y6$Epw^'-e'oN'L%̙3vڙ%^aRK,it7WOЭ )qan(DBv{?*|N4TĠ32vA<?Gv]Y{,!?igV$Ltu AwUvO 6 ("Йq*gKltkj=Bt>Щx|; G$7)|g An3ͼZ6ݗJ.|$- GHb+;֫Jhg4dYNՐ2~b^|V.,Cȏ~"DsN4'*k}VO3q&ڮ;xμT]d[G1>#hf) /sv>~UŃ3+O TtG puS֪tIt!nI<ŏu]H[}0p_4||)!VC?cGXJ]O?>`3ᶟ"v(u8~6.xOB6dǨu<~|m,6GoůږLJa7'gheˁTvfpgGkyXvTg~;zzSnȼ55n"rNv&>h&cJz]t#W^Q#`"п&t%=]$yGmeE<k{3GI ]7}/MhOAWNZUt_peڏs7*:''hgat&̅LvAOv'cGwu=tA7@޲d*, ЙEC/D7.sE 0i L|fhh[`*ҫcX`R?jBЙ!`{T{x iAg+>L~^AheyPD;-ĕ͖u宯{L@^I3 )1fC*[ř9jYd`ڙ5d@b\t9j:\^:\[-߶ ʁ/̩gA6:?S >Sdkt>2m.pgqbnB9_OjpA2/JDbigv9-hk\a|95,G:R> LKMy)k0g/1Gg S9|T|nG7!Z3\g)_*Iљ.)>`ɇI 5 tK-Iy(Q?\N;VO48ăFm2AIvf?WB;n,';}eţ8.μ_xv>3r:O ЙfK3򛃝uKv|عz|Z\$% љm'毲g۔vkB: z/};nƯ 8ʃkL#ig[69ZW3z~Jp}mP^ }zJg 2}{xO,qYNAïmS; ᆥUo)5i6g I;:J||0_l0Lg|24._JG|644[3P06`|!Π\Hj؋~=,fq^B'=?CnEâ,쐒:-?5縂O֕}ۄqKtt7u])uoЧ8{8[._~{f=Č[˝T1N. pJi]D4q.75=ʖVugڟm  pTHۡkRNanP:M04c\;WscMU{KLэTuͣݭsXD.߱Anҥp9HFAOZ 7Loi'Z3#\ oCЇSƃ!r}(٧_hpxU%l_0kA~ঘT{_0W83x1b__<%c߅n7ܽQw'sVm[Ef1ή}kPs^91@bBÒn.³eB2E /\Hlxh'_;7Vz4WL3wi8ucG<'?FCVt(8?eqwUL9 ?p4ԅ-Re3>۫C3nB4{OLe$zȤw đ3b2`躥_|PYEn$ ] /> %שQN_õXo*&Q%]+<,\ 8=R5+g|O`?SOypeES8gXvw)_mn]2BZ 4@L\gחI/A'd,$uc13߈0.cT,5td/:x9A5w4\A?ƴ}:kt7=NAﰬ#$54< Vs \&&M-8Q%4^VԯK*xG߬GfyS`2d7;[qde0n%V6ɋ }S@0_A>k֬2X>Ye$29 |irRNp KKآzͽoǒ 0W~Px{1߷DfvEi/DgGzE>P``K iFE?0Hq)R/EW}s6_*[6\z]a(vm=o۽(<&i7U i7 ΏScbNϝO)x`aǕI":[?_S8=s]"އV9j5-d/;My4҂nޔl^5$]Zk1~]ɳPo7"7>|0Hꢭt؅k.,9z]7y_=Js O<5!=Ve[fu$y0Bg=Iz].lwWecLJfȚRy(EgGWhE_^>TBYMn>p,JJ\KZqHAx:Xù;z9 w(8v"}auV} җD{V""-n[s2Z[S\g2=b.!0'UCПܟ_ERgq^%|xya|D>>N ␪E/B6b Y{K>d\Fg7˦LoŊb҆ގ&S,=)Cs0l|8:t8jsqO~8cF7HkY8S`/Y;oF/JC7i1"R8>8~-X_tǹ͝EAU'hA=$0qt,MIMl}FU~ִd*Ƌ#'F~f0'Эy~͏`~\x_}l ,O>Wl>nqyz57S)uXMn-:B[=`_KCv+"t F!ﯡ`CZtM]9.+-=j/_?n>%pR%uYEuF3$4i%8T OFOڹ|Gli)"ћn\!-Gy33y4Ԫ\@ߍ.j]1P[Hތ0 ,̫r fq*Y{z OT]?{)߿Zt}GCcB6r7_BA%'t]t."3K&Mk)N%}ݾUzh<1bub>퇊ى>w!l}\$hb O4FZz82 !ܻoP/^/)e8cg3c:4c|˙C\agr'D9sf„Ϝ9 ୌoٮ}Fg L#?ZI1CĀ>\_E%)8nsIq}]pmӗ^9FJbߎ}]yvӠHURUӠ>uɪy^i:k}$!--,,7Z %lXp􏄆>S-dgy1#[Lk_lK?‡v;gϡsB(޳p_W}on?^p11Ξ7T+ndm"/s_uǒr {¯^pQ\^]NB݌jYȕ|H*r(U}s8$3TP`:5q?>z>ƝJEd^5!Z{@t#>z-^_%\YUK$8nmH BLr)zyvY~ aOloUQ1mԶQt|dK<_j(|BwDcOc.ӼE&f=_h7?. )ADVqX`@l[ֵ @'l&?G8V[t>ONN^3AV?O R=>/ @['Y#t S$Ys`rJ=Ԫ~af8{>|An{'S+ Թt|'h\{O=aoƩ*0 ث 7h.25qYWGCO̎%dzNڬ8(w-GJ:g|wY|Dg,)XQt ʑ◬j%0awTM[P-RK~SŇH$*?s'J=g$q*?$ľq\qgvUH'S=N :!H[;.Xm yg|Dgܨ oo 2q~{oUF|S;Vx>A^ҁ>f`ܥQe“k/F *7t4b:I}anʥ]fPPhH ѵѧ_ӷ4lfno=> xl/"b )ؓZCgibF2zON[|MD'[,*"X4NT ɲ5} sQ6nrξ?~0(3o"//.~ʇKLz-~EA4m,FBYZnRΞiٕw6b#r7߄>ʝy|g"0t(tMx}o=( 4jS.}"$g{^]b{t'yήRl_e"Mg;Mk-~C^fM:#m>䌟=B2oeژ gD̼^2 XwpUYX=d<<^l_Zw䡯B/L3n T.:"!1_tޭ2ǃ4s. N_?qLV?)J$ Xd7 <84Uш!spmJb21*>j,BgX^SGGX_^,?f匳3GYgM>:"^cCkX5Mכ]t|_A3.ΧU0I*uî5)Al%gpն I=D)7x#W8r't'mNA0Ԉ*q+{ /FPCZ.H 78$ٓW;AW1>}ĜT3V[$%6ly`s{QGߌ>Ddo dt􀄴/J tUx0/Cm>縉d}٠&'xX 1FgW7k8NJl~VxYY~3O 9#7n߳[^'q6>?ݼl`>ɺd'oifCz׌Nٖ Vp =4;<)ogSԙQP ~s |I8@4ʇWC( t6J mVX&[MtI=J# Cs^n'+>S` o,c]%UivӠV&#tH$o՚ɃRwvkKt6Cç()OMm'}8y4&0׮M 0q>Mؽ}Ç#֠\=# F+–{69ܰ}LBgI3!s>ug͸uuR2}f-YROptΓ;Wߖi_H@Gϣ3R)RS~u%a24SfCgr(XЁ::[?ҔiD> }?(ԛ&vFt@}n2P> NždO'r׶tmU4U_0-$gAM:5KEh|B^26nP= ~e9%uџ{dݐ/._(χ&kp|U|? 5QJ>3߷,~2hެ)&˿0ήǥn|PzY1ja]?](x;:mS;ID/A/޿s~nl'"_2&wx^]y3sgli!E%KRJQ)MT{iUZ22~{~_~s9眻d[ st &MnߣǸ++NŒ3+Vk6ƾX TSRj%ߨOGR/qLb'W~wXL,9G-e/hxn]4_>.+titb]dF3Y13L#8҉}d-5nDm.r =0ƫ{mbB}ًc^A|hea#(ة.;AK 7H}I\2Fi@F9[ 2 _lhN2%pu+1@w@v~ aogY^ψ}LWI \Iyu~QC1َ #%{rq1 yY1]7u7/aл7gƵ|0R=PN'Q}kV)!,5vY/ġ϶Lo<#_ޏWFOlpo:;i8mugN"+o?&)vnM%ǽȿ~ zH~h*Q߉|\yt\>Nޠ~YMN9kv9UaY**5ؼby,S#SUE?*;BF _Gtnts!dH&q u}l?e'p#Q/Y=K] HE6 N_n`7VF}L~?~fZ:;2?ヌq.t@w]1drZ0K7yn>ePaW-Ao<-CqwXK9e h0Ycy*cd?:;\$ !*oAipy??*[ݙNy^2P:(vI7IQCo^JTt-#/Jpm{줯] }1W0 ~C TĎ}Ʌ= 籨V0({֑0J]zMBriN cO1UE44GnAش ,(s%CgǏFzt7Fu" ]'!Ӗ."Z?4¢37s{ E`k.kj"uvoOc`z[)C^7ـoWc `^"Ҁ)0P1፤~ iڴlK1E]"7)N(F3 }n+Kݻ:zT-i|Z֠' 2J z~r}<擱NW׸[fHz&Oj1 _dď\ ]?Fyl' ͻ+k,Nwm]ѥoOd%G7vz~?GkD::A"Oߤpa!xFqHxl=`O>73VeJt|vn]])r0:[_%˃ѿsTɜԇ펹pOst?t[*M3f :H.:GT2pB&#,ENUY!ԝC[ 'jĐU|xc\:SDS7BO3]H2Bt%oa22YeA}d PM*3r~IA?Qڏ`E2A}F MgՁl6+̶D/j'7CӾ"6ԍC-\Uj>1^ѳ>sdwrqͤ׌g3ΞC'ѬC0aȭdu[lWQ|H}2Z71 Ag?΃۹ ;tvxfD|0ew8Rg{Q؂ <nl}s\0'u==všy< wp^1~ v/3E矾y\>4#g;g=s ^.[_䭎RcXYppƧV0P AgјW 2oq`a)@/hk!LJ旊$&K}BfAU]&ʜ+ο3?I/:;ʿk2l^+ѹrIsf "+ۇ2v 2x֊>)>fiv-Y et˱ gZ:tv}qXfoM>W#"s@WyN]D&K_2S9N7^qmNr}$>i%יf|E.ΣƧ5?wBW8}oVx<_!"|KHoLTL!i|wtZl{02iۏ#֝Ki1ty-Etv};Ϻ27NTY ۶Og~@1:[ߤ KvqB=6c*Qg?F TM@W^d;#}J Ηfxzbb[di~<s%݅F5N/;#:>rn+Q6-%\Eg{QgI_q C[]KC?d@)uv}҈K."kى/a__x* LD*jЇξc5WD xBP :iUYTeeԍq|YΚZ&jIr곰I>IIZʧ^r=$dk<ا)QAW[ԚrmDͿ,T|'8-E=1@gѴۣy`̜':;~M~ȇn tiONwO.OVv|Dg1\A=_<z~ʓE} ]!&Ρժэzp%b]mrkgKH:[_~ &ݗk#dJ|?Q`^Χ>BZA3$W䱈Ξ _6n\~% *;NuᘢthSgϿ~cнunD;& lpqt~?]e|uʞD羑O=g`e1z uv}&YT lϹs'YK}ڋM`D~J= \Fݙ#"Q߀ni0\flNVZ&!6멳I'UHx{NƵ Dݭ}C ї>ig.DRgK3zZ*Sb0ZNSB֣kOӛ[4J'A1_Lyf_jp`RVw>i N~w\Oَ?NxUvM]0ŵ-lәBXݹڅ㨯B?ݼ L[b@l/iDΝw@FW2ΦyJyO=WybjuVW8I37Uar`DN] $`tvQce*qˍ1չB1p/F?L4L?)LG @;UA4Z6(x3HSGOVvcvj #Pgg^r, LCbBb(DYd@ʄh]':_9g-7@`Ç2SƇ]$}zkЇPυ߆֜I$zϋ[ 2nH _8t7lW7YPgVBƳɏm$j;u~bq9 ^(D|tv`I#*ܦ}EgGͭ/4B_ׯ8Lݟɍ<@"g"Ї |'o& e;wUNdmۨ _o5k+lzNJihO gwQgg `LA[1M}:=:?ݳOI_%8|)2fRg&Y \;H\WrԷ|gfl@BSxb*iN=wT,'#R|O t* AgrpXb9ɠ }d2#dGbr  \nѐ%ʙ<;XZoS6dY~~0@Y+mDa?u62L<*2zΞϏ}~)Y1iCgHu(t2q}7 7w$oIO6 י;AdNtAYbΎ=36]B7Y==dMA$8Vj?,x r?sktÇ?gf?\.Ҿ}EÞwK޿$&%D7!?%!Y &WBkf鉷 |P:Bي|Zl0myYCzqN_|^Nsj{jgoASg@gY}ag"6tԳiM94n|O.)2]g[9/~]NÖ7Aąb^CJR?l8_*^;Gt稳뿴7\U:!"+=OR^ 8uPs'Ѩ~w-ah'G[l6m-J=)¤ԛ/ukx^]y\L86eEɒDR)KyOsYZX J.[J(Bm*$m351<{_:uiЌ;41wy2g}I??G=j!pcr}zEl۷'KH.z,h8R][|Ɲb pb[19noM!*O+zJ.J^CVp>*>Gd<\&ZQ-3Dqo?gn'}Г_'ԧ8Zs1~ =p >ˬk:GB3bs Κݮ 9!>G^u|(rv =|QB>`|:=anU^sS >'&U䙶 wDZB)µFS]Hz&یw%k`zo~r!<7L5(WLǖWiPtzwE?bV 슱Ƹ.= QyWsv@,HnjFORj n *> zzЂu>|zA'BĻ.]χ btt wj%vB9S.7H';fpg.2q{//r(m}̎&|:;nr_ZcJԞ?-uq*7ڼI B|SlZ1r |?.d ܕrlK̏qYOC79<ݠāt[NosL^W9+CϋZM8C5\BtU.\#ȅ7%pޖ_S*j|Ÿzja;k;0XzO\ T_3|e(ۗ篒eYJA~nB⊮&V|ySMvs%e+_PZ$!I{՘(ޢC=:{}^/CAөA"b]x,~` (7* rcp$SNP-a[ MOṬ`Md`?:{}| /jtƟͤa۪KLۢ4^t~F{AvLDgǾska\RoF@F7:wkm}dƟ߼s L <oL޽ĹR]'Qbz܉azT~‡D=f\Ha\}+z~AX\}r{Ok oA3fqA k.NwA؀gCq]rߡi aA?yNe.o Qm͙nx 8uVbRl.ִz`A~0~>yT$p9A\ QBd|*zRGh&/d/.TV6!yx}v05{/{4௬lk)F?h 4X/&/~3*j*"͌Dx~M* 942'Mѕsf/Or"$/"Uֈ$=Eql>d4g vU<̇ޕ_4;ɒƍx>~->׺>}m{Ͽ)tx9*34 }*#@ :+G}jQ)gn.Ҁ1N,j&&{^ȝ6F1O$*rEo̙CLax + )<4^BL/D]qoC)w& d7!4{~GK/^| <uQ(E۫xo@or]25[IN}$"ߡlM YEwb)2l1> =rґh}">UC- BnI TϵIeӿ% I`ߏSd_}XH2ή?;]δAŁrp= ]U0~jZ|JZ#:oߗ[P*\IP:4[+ vmoѸЄw$}C+aI9ݤ/?hxYIj(PxUFHLF2Ӳ7h\VCtsE֐`dydA5h=_D>Wq<%!ьw;\Z?DKUƍ[!A-~ $ =Y E+ea?WV`p,lqR? tÁl^/ %4 zt"],FJg|J0Y(]jp=XNQV^%&歲Dz5c$7:[;E'\ClTc<;slaF~EyθԼkjhIFq]^Lq3*$ уJt47P}_{Yu7Agt>>d|hi;~s0c\W7_RY&ڗ wp Rq>sH86p* ?-=dzzH/ץ6лcZbd8{.?&ewCg,$8m%=%N^&1{ܒ[ʫ6mV8[).z-$5}Ds7f-O3~[* ^~sle/`8>kΆ5NCa|J-ix?]};wQp<z.X:ӨB9qM?n|M]L58x@g%Nw`#YFKNú7¿u%lfN\xV/::[L^qh# Bbf8|~a P0;*W D-UugsG,;D;U,=Z#rCggSr`d\uOWp i% &@_$sXgYLPBgP+a?y]F;@؎&}d9]R[04oo 93UkB1]:[_ )grkձNK2ޝ{*&Oen l?71@p= ن>%Agdl+&28 zbWO"oIUUYAgת~+b8 ƶ؍"`}-4IO4=X΁ftW.κLJyi緀:`k4JOe'h;tCra5KO%[ 6k=u2if0t4D_/CzF[ytU]ukH.䣳Vlˠ>Ah[a8?9ŅQ+7N~17,fAhV1Ɨ)ño/vlt?}mʊx531S1^}^t"zH:|NGvϠD\:LC80}X67;<+ttdo~gNt /SUCkPw3w|ӽe fF/Pz*rA8:&;ߩ O"Ը E}d iFߥ3y)\N3IJ.nVn`0&Ȓ+I^RS;vO+KZ%6+B:{դy=8*kv?E>2$PCSYŅNv'V~flu7ء'aʕq0yWDDks538p =7ř4Do~9h:3]rᮒ +o'V0Wo|i~)Lt)}_|azyno[ӣ`~ndI4di)߯? ~;>/*ky9N""X8uXHxo>;:ͭ>!\.0>˝4.Nrh'Dg_>y,=*#/!oŊ{hhu1&]Gڕô&p:|A1,63%gta|>39W<sħ-x=O?)"-OzӍY/:e}uw@uf{Z 4?zwY %{u!69(3ɷ֗!7>WOLBmӓqvclɱ[ƛBj}.5k6|V$9Ÿ+߾A9>Z:H7*U$srj cNAec∷]lzO>D/@g_sݶ@dS $C70}mxyO+uvNڤ;Ǡ? rGN4A":[^]CAޘlisGP[zca]?j]![j/nbnbz\{mzc)&]5!L]K+cR횴~K{F/{FwN m i8Qk m:piG&6y*A^2?BfnkUGMOG I)xS1QVYqG*" f'~F.չO?Ӱ|}\VIm5Gd{1MI+aP?RxJ @ICOXcҌe:{;vDJGodrl8zy>:OH|;;ɀ({e}̇VW!:sN^4T-l$ǩQGSvhc IM v .b |~T|:[OKg)GA[b7qvY[ȴ'||BŤ }QnЫiHmr j ȗx^]y88AYMYD"ȹdB}%i%"Z!-D*-<(m'*6f1;}g^13s9g^p M0Y ,E/ gB56*`L/T{+  d)iޙ,(YZEH?E/n';i)Kdi" v./Έ@t9c<^a~DlSl00=e(KB\RҼ;\4;|Le/yh~K N)>OdsгIqɵf= =}}oYSZd5X(? sw}kcH;z.> ؠprDIRR(߁[]lRClGT}D=r?5]Z3hN,Frd.Nsy}љe'2aR2 e ?a/H<.+Z0zI j}{Ul(!ttڶBY;5XS~ =F:;esNVt@Cc'7.cRn>L5A\ؚ1ƕ5>Kq~ts;cvBV<ǏWt Sު}8*")^ۭ1? l} &]g gp`m_b yn' s#4>;dbúuN: 0FeOX0_'.~/ZEtjdRN4C2jˢdt/4< &[Rn}p8)bvΗ+!\9@4ts9}92yy?air?D>^Ӄ♦t"!SDg:KWIrt-l0uUO==LE-6\UˈO{g7YDֳ `AC_ub[tEEBU> NIdX/Bw5o qX|"OL0>!*SJt.:HmG;R3Tɐlcy]0g;Mr([]5v+}خ ]8zWFCYʝ4W,xAOs)FGb=ؚ彥$$^ώtWqAz |%k xQx}qyC/M._ȆȰhډm:WjRHQc|LyF"D?x^-xpzs ^@9'HXf]Ϭf)q>Oy8ŢWN`<);W5 }΂H'kэ?[Jyз?ymÃZT1YNǔN s § ^Cg$4;#zKcNiF!4}^Y>|E~&{," )y`?nn׾|,|dH ;Og(A=*aM=ij.¯%.S!9l`kjZK;V^O{6FSn,Ж UzNjI<:?s}Ȇ+lFHt;eKvAmGnRVUva)A N C;[|}f_}7yPsIluQ|ߣ'MZf ׃&^X̀)Dip&/(P8 a 6>0qwInC=Y?^?1u!aVQ'1)xY ~W=wvuvy6 h:9/ OQ%0_Tv_#;mʼ < FGxm7.{n'l0p#W:im-oǿ 'y)_[n4΅sGPނZQ)e= Ggg /(#PNk?5ƄOOR"t>]AVY$YF~8-4TⓏQTz6o.!f(dznz١ J1^F(_n?+D)ei)ƪ6MfOI8tN)1,&t} sn`ZbUO9Xx;;hp`vә/d:R[Sw͜)q? ddcCЅNYifJNE &*tz%,\e?{cnR0D8ÿl4PNPlXۢi=#fQ_H5G66*W[1N?{))*rtÄ=a $:ݟH߯΂cm_ HKw309 /RRS/1Ç߹?PtUYd1\~~7)F{ g_ (@X[Tg37Jj6Fq lK@L|V |F_߻m/2_8  ށ=5t+ssqlwE_+x033Aڔ0uAF&ؽKzcz:F/e?͕w?2e`i├b2=Q^,y݆ݚy c2v]4ů a~{S+]}pȔ[хu<%;8P|<\L>RNOkco-W.:nׇc\(J]5:av/Lz|c8pJatV[-[~Y D~U2'>5WŒ8ގ FWim,8l0"cCwrY>Ztr,GDT[(WTce?fC<:]߰͏{JNzp/}hg8юB2rtsH*Ț l)D/AU0+cB L Ly2zG~a&DO'I%;u<@MN)eLB9Ɨ_eLmwCB_~tI^TD~HI7z%B& (BinmG~dq'|d?Z0b!N(78d9j N4Fb0͎>XD)7y9 7pse蠜atp?oN? {vD$;tz>TkǓ Ltd\.aXuRN_7Iw OteW.3p3:뻲䡛+~the82}67{c9|ѻcJRr:Ct"li N7㹐{Uj$$RN}gs7-p$!68?;´wxCdJo?y8!`^4.X<]킴L0lKNEϼ +叓n H  Fsč9\?Ɛ/]áUFgî4`em׬.~'&'kг]O䚱縎/y Xʧ>ȩ8.l@Dk2+o<)$;z^KgZOLy;MY@w} 3pr+r~`HZy}"H皘xD\z6^@JgK .5kQsTFt}<3"6]cm/Q|zq,Lxٙ}*;EPx[4Mq0 <[`6 {)͒Ǻ9sN=6.ZKU :]lX!fV'Dc]b \P.N?WbA *ײ+ZuEDAB9}*BKrߦ3l`Cm d-/Kp+ }Oe&U@y^2OJ'"ۙ`- v}8p;BNoV8/ByQd:9kMI?(^߬)FiЇOΠͺ5<Zc(tOt}ٺ6|>E D?*N\Э 6Q'{seW=#B?0a@-[$@rtdє3o``8s{{VlVst1Tvחlh\f|~(?L8~d%Nԓ^sYbRvEsVLBR2뭋">p!=j=DSr:m̨'aJ~t:ԝ7?H):]-yaǂαiぅD#2B9}Œ|8VQNOmwp'#\+pe켕{%LBg'Y_T*stq$~]70K(4t-%xó6}drSeh{}@G;{0!~r=ך'1le~҅Rb4r|QRHl=?;IeMiM9 =`?,zH:}Mr6x QV:S-C(#7ԡ1zƎe\rA~2 B9bJxP6LepOH:[:* |}ȿ2r}cxoi'ӿ?鷵G~q"R]Aʕlxyj{@9-r&qgjub ==pð7hYp>ٯyEhM_m*%G!lXydnFOW71r? I|5 LOXHF/EwmP}T!#aߴ}ѫL8R$!AEތ`Ճ$Z jyGO tUO;Vw`"<N9ߨJ9mΆʐ9職 cb=VBVTG;z6؝ʅ>8"(IyTW/#y/"6[',+vxܽ;A$q :6۠L3bzGe)Y^>¶ hu71M<"C7Tym/*,[ ?,(ܰ`] t2ƺj$p虂}[Vs!rx9p-)j>Ein+T'=3;-[(n˂S6/_8CjЙG 2t2=I~;.?()Hӿ0y&"m([yq"mK9}$r~~n@DwnI:mm= lSG98J`X;rg#V>AkZbjkct5zͽ`Va~={MpG?-fzCD?.J]ȼŁKm+<>hyfN9]?huBČ'+:}?k]^j~s~1` ~ngѹĽd:ݟ }3 O=tX3)7B/P:kyZ[42TٰA$jX(?~km?p܏ z=IR':(F:/yz5NL䂴fDwY\-.xFDwԖkkM9}>ը# Aog_U=s')FOFt /|-tEG HM#m #oe~.csƙI#K:qEѨ4^K]=K9?M ԕijvBzٛ!'H+t}\~y2qg@ :=?ӽpu~2zt;׆yؤP^땥[&Hz1zI.u_6T/ \Mzbt E tW7vOEM.pX8Eww?RAtts"rxyR=+Mך~t|C% u{I :?x^]y`a {tRHݾ\wJA(l6 L(ɵL bGC2hzM'/|G.%Gsc\{ lSrKg\} oǣU -[ߣE}zc .2QHc]oL8z =$ؚUr/4ok;Hړ}؎TؾJK,mhg ! d9Mwy7OHocY|+ $Umgl,:K v`M^~J{?K/z]~:о Fv5u^ާZו箲A(^!Gg䴹hLb1 Bi,E{ ~o6Lde`aCmV6C˸A;0MZH@@1spiQu!@jI$ {c5KM'ͱ8<8zj{I }X: c_. I+4VZȃCvGi>ݤ}68*Ӡ 4qI0d)`l\e#n3aؓÆk[3=:S,O]*>w[}ޭ^N -ev\cKv\z `M97Gb{Xy7Q ^w' /6NkF@qL)O^k OTa_KTlӱdY & go#kЭUw>L9Zh6bѧ[^4 2i 7 J{/˩x l[C_8o36TLDE'.۟PP^gV[WT.~3}j7T5"ZG(.ҁaVG@FExOڶv}!ȽcG0qjؐ,>R`}\eVԝ+"~+*}rTz~r}!iκnA@s/3wM)tXD63[P);V:Kކў=sa^R;Y=w%sy ;ݺpA`ge$ᴟF4p.mj[9Lr&6t'OvOCp-hՏnbI%;7r与 _t]t0G9`t[:F?ш==s]c.;b/C*љo8m =Iv_]4[Q'lrzK,(DBW:dէA>=o֤BA|qG`7U*eK6)9Xڙ=蹺/e{NӮ Uֵ̠~]ۯĉ <ZQdv">y`d'ǛXʁ/zlh;9 h^1uc0T4+~'еϽ} O$ %z!NxvB̨!;{yڙHhc:nȳ~ ‚s40P|{a2!v&{^e1Dx{!Ago"ywPd3]n(Z Tt3Iktf vtfL3+6GyVv 3k1<ȮOAЙU^RSPrI 3ci#8Y2cFF@wwaaz/Y͂yig٤;)H3:Xљ+$bESĂ t&!U"\~;JDoE^]>S0%ɽD;3OO>2>}vԍC o=/5KkյY"vf,.v1էX!L|ݙ&o~j#n!;s?F5/OFCT.S7/R@ Ts)BC!r@cW\Nq͇$x^'2*jts^{u$Gg3"'Yq~>uv6S٠輫D}\˔m e[&l28 3GA]?ʤYZz.Ol* `LUywi>9E{71L읳{IU/fBPG[{5ڙAǚߟs![RrF?DÜO錪ߟޭrC$:1>qiNl͛]?MU.tf}M8cf˅F%Йyyήwx֟"BgGyR{ix4kK6ޠ;$vSpqRݡno68 5gGrhOf-h>a3'){AjN7XO}df.jjW#Gb}+£˼[3A+OL)TEl"Py3s,hM8 &ZSX3/A7[>d:_zK2ыХ|t@8y|L Dq__(y$v|iW3G!tv⸤G(xQ3[^ODN6~g H3)Ϗ?g'r!7ÁAY@;|#ry5"⇾{>EPj_Kn ]2􄶯lFYR_HFtμ8JޱyY'TH =v+/H~:3kL}hdO@\@<Ż;[%jd}}=>Ow(Zغ}0,]?|NE^Uh_+pΧZ%d:|y<>ru4LSxNc>]o{/}IkGЙ2f}/8ZKJљ^)/O=1`wuig֫֔nƃ 42zW[egn 7C<&ލ;;)cd=:_w9J瀱G2r#% c~k1N)&k>҃Μ6xS),|wa6_ &`άcɖT$.U }$:Rݏ9=)l#tf|_]:C 3l9]"XJ"_*'}!Qe3fj=%Wbӆu6Am@Rv?vf^X)hX4$pEA4Kє@ ]ϡ%ʗM]c3O_@׸ZH 6>GN=9Z3; ޵Gu'pA~IA9ʉG }9 W! C*Й/fs 3xO BgDYg4/D0aUΜogW ~Yء3cWWϧuxGgIתOޣ3q9<(0D\HzaG=dt4Ʒ뇂^P%3^άOjȐEpkScFg&ͯ1AzI :NQc MWG KϺ-ae z#. )QL9kg@juVFnbΌwb< 8Dў'ROi"Йg6OO~3_(hX>F2i S<^ +gMoWu&E-3} V iEgof6_&ʭ3OCکK/{pЙ#<>H ,~KI\lw~$nlk )~~}d"peC^J`AfpÉBljIF;s~!{u+} z^C,~Μo}nw=G^;6x/Uˊp w9P.KN@}MfB. sۑd/z/KL3?CDL|>xc4q|b>G􈥁%GUك:S|:*8z4xgV~3sg%].7Z:~~=<{Lڬ)Dg z N/">ceYmY¥2PDR>J cq,,KRRaM;Si$,Q۸c!?oq}Y}quS1ΜO |BT/$˕SncçNItެy'K~OjЙ'MГrC_zIj/W,_.e'ޟvnmO\_@Q\ྴdDxȖulܝ>b9O;c?WPҩCTh/I]unμߥ1^^)|~(iL~@/g)v~ y~ۑG<пaӬŽd3,x}-[`T3矹Ϭ3|vgv&*) /c'7ڌB Cd3QǍ+85>oT/bCmV~_vGlDGn޾r+ƅfdh_.S#/h~}wd"K;s~{#z.53oB`g߼M,V~Ԏ }hHڙBd6 F?wxG^E-x(ͅ]_O t&;3Px|uT<jТ}:arXv&~XPoɃ0.e!Oj /R$%" pп]U53f;t|T _ <<1@y뉜 6K?[˂t'k(qqg!~.e`,D]M%ho@W:Z" Vz O)G ~ƗϷ-{FgCrLC`435' x^idLBJPTBEA 4ьJ<~pq]~q_7ϳ^y>&P]rN cdJ㇆ )CBn'RT[{;T( =ES/;k̟`j$Bcju\=4Y^ WL7ĊIS#lݹĀΑ?>=wmT};QC}-_?a}Ok'[ǟ8,0`?ƣ7y>}BL%^~I~FXh;G +jG4m'[O5-޺C}$nH>ؼkiU=+◀.tIB{|_#V30jԽ a]~}Ei^L?ף>=Xm+w Ŝ"[Чt?/=n]׻xհJeɪPn3U)r[}ls[{@RdMm am&}3zNOae>%C/v6{#"ʂXgo;2ޣIC\V_պN$ym"0#5b(_IM5C&KУ]0? ˻YtZȖFZs >Ҳ2Ѐp xoҴib~}sy|/ 9ND>_BkW=$ې-th54 :e\#wU=8z3?As uoawha  =t]@ :u y.nqʁd1yl|ѐ+. }3_[@֠F7>hj,>zz{yM> Ĺ v n!Q2^:ͽ_ a+ jc?~;qB_^7zhS(=OG'\GB*{n> }[J8gy(&GHl:[wy5ㆣT%3^AS40Su>pJeV=fj#UӸEJnzhkiFwA:wa[SGħ r)|J!Sd ܿd׫rN]>I}X `\B)k'lD՚~;7fsNlK}IhNnpÂ($wSYTSDD> }%2; r?3r==` z%d:AT&A(BG}䋐硧&Z2`>.[8̤緧3c7>u}B]U\p\PZ?)fEgp}q:#'UƁ'/*9K^0м_U̓U ,OEpE\(QJ?M葆r;]\[N"ΦޅLJr[. 4=o@ ĺAd؁E$}{=SFz] }y\=և%wϟ4/ܢΉ*'߯H5J2ڝd3u]=d4ڝepPwD6z#.VHЇaK''J9BHRA;hܢ|+n(?3kn/ ɾp`L3&^+9A V;^ްCOBWLH~wIT 4 M:ICfE6yzLPoOyƷw=\_20Ox\tƵ~tg)W`qBI'O^.W[\CV<yR^ڏ7[;X3Yn BdI+;J__Ko'֎reH;CD>3 f.DՖ}* f>= i%υ:;>eяͷ cVZK+w"<_У=$AHgqU"/}lޣ7N{lSvw1>hՅŹ ~^E4nӌp}އ#\yO~v^|/^VFb~.? 䝫uSMQo# ۡY-eʪ bt#5[b;e#wdZ ׿E7vl^CPg/Uޓ*|t~Gg +K'g5ͩrPxѢ <ؔ0w1Q . v 8JDq!uv}`E(ߛ1xNw?H>:~2Y GE"lV;HASџYJ.B!dbl1xXwigS[/7O'qFi&&t7nT--Ճ%ԛUOYR;gȄw!K[άpl z+Op+X4lbAƫ4"q?[$ ~]KoSr|?@&¾ PΎk?;,pe ɂ~u~=jr bjz%&WKKx˃س^@#OT2 .&{'4BZ墳7Ld>8m=S$ F+w%\: FQgr.3\D79pk>_U"VRO=,Fz;:]M|~GZ& CtVQg?[U?_D*  !/ߣKIwxmC.PgYjUXw̳D@ޣO^<fmvse,u.o5L f4k4UobBAP|SG=}tzgXolhA֣+`nXrT9.wT5$~= rVnR>}8?]OQ72l?ЋNE wxĬfYO[n -u/ⲁ zˁoV=xzv/ɲwN M1H[g^9UD]:}Wowԥ; Vlzx{ @gO~H9`=PAe0@EW>f;Ɵ%vw Ϳ)@rq]H3"*1Чɗ- Vm66d0Il)B_*U~Iu"Khod:[_;>dVQdKjk_vo24g49Nwqïfdl~m{vw8yrȧވ=(x;MoܧyWB߼4`O܎@m.エ߾5OsW:oCwN-%$ =_spE=)HHԵ1Ig_i)#÷ROD3d~;X碯SJʀIʿm VD}M! 4hK}~9$wu>=9CDЅ23*Hqu>9Ju l۵nw>tZ)r=!n_|u ;J=sZwx]~YDg1K yF|Ȯ)wt#Ǩr9|hy5QAOFgJZ( K>j#ǩC;^1|I !otJ:z6cJ>D_sq+^>YS}ăSMX,tC]N ̒8=/Cz sW >Fս$ &;K$O-]8εk $:~w{agxjoߣIDjOO)IhY]D}"'e>ʱυ`30gݳ#;Iig՝<7nm"P9wu'<$L^;K}%z=`Kyz>҈>aj8;H :L81 z9ZO~ȁi͖6KFi\ÕVJ0PD1++w3kݚn_%=|냆%!wOU u6[:Ķ嚈} ;";I:;>d>5ˇo.Rl~4)d,"| }Ѥxi6̳dy xlGg?}\2Ȁ~ɻ@[FfA]BrlB߅vڏ9p{CQ8ݠݴo%3<$ּ]zMD&uv}}(]N/ VmÙھs~JU%uv)RJ B"Fg/osζ01jk!KnQgvh3|ɁGOyɂm3&Tήw<ۇ:H3:>R+ %D~U|7@/j^q:3mo%n`6}^ciG!ପ v-~# [Q߁?x|1և6Z6_Eݧé \fy=`.}+zӪ b[eWi"-;8Y;ϑ%[%SmgЫy_ ñq$W4CwjxrK:X~%Dg=U[Wjm}V>Q tv߮wڡZi;I:}*' ˃~iɪn?s׬-\ 4+QJt6e9dvH9E}H >[lK/b@T TL~Rg/Qw7 D]vk=ήo{u0w.~Խx+&El~pCRZLVxArSgs2Pꕰ^HjзGgHrHHN}F~Tl'_fqTl@_4m yEOX;.҅ζZ9|{׽C9SB}c'>X "{SiC.r?OO@З7P6,JEfߣ sɾG.񄒃ߝִ 'cV3YؿN:/0z.y)$^P?]r™[H_#uv|̡ٜ ?i9:}Z>2|HH\@^OO/hnsB_}|趐XSsWqΡhlW'YA.h).YIqoFw?{+$$?c{{?t˅\$=u@y_:Ʒ_ 4J>O'=+Tiv6ntM _vӵiLH>G7zwdtc//7ぞD'/{EJ:[H">g6>dzc)"_.cMlqg|xFKL_.J2 CfldI[tcN 9=f&3ϊ]*t]Wl~u#s}&K>РZ=qe9x>so"~/Y}^O|o_7]Fc:PwSIFo?Š1 #4A2ףis-F@;*RCen*vc>z'_u,_E3~Si9r帲P>=NY5<(?S:%^.4V3qw8k#Yx4gX9k Ec8' uMkZO6FJ$or3Ѕ\}_*hP\ut4!y[&?mNwC0Okw`[GxlBA]XiX;:љlBлw!|ca#hP Y j-q+F`01Dg?cf6N78槂Ɠ<Ͽ'J.enu%PK |zֽ[Y z}Ύ x 8%Kt,9DO>ȇU80,x,zց^[(^ltyoP~x`LkS<㽸N\YX!zqţу)d*|ϓ/@Lx(/:&o2>vMD7g$ɓ+Uj!PQ  E 1ypOY=ctfdVl\jFgϱ%ZE_Cw_Ud~*Ag+\v퐀{Cmw,^+ w+I}&+nJivL3`^ df!}od!`qf;7(4g%z]I؇~ z /ι'sfL$ܟf.)zq߰ k] lWI -%H>O3簄ObM󳶆=Dn%=wF NR왍p ɫdjTR9ę#ߊSD/#Fؗ= Jlr;wV795>$Xg_9@i[O nS[Tw3!3i֗.'yLMO"M;0̏8Tat!L^8cK% u] &A)ݣ љ뛍j'78Az_V>0b^kH3^= yq\L8!,2:H&itۚb.Ъu9?/}ӟIM]ԨW(|gs/~*H}r=\ 2 эs6}?p1lTDeo׹,OlUeGx4^Hf!տOm9J5查Tv iAjQ%{8N!ӠHn*@;rⰶ_(D;%o9q8sәBt~ɍTL)x|f}qB#wW)WN_>sm pUPt5t-{ `D C\Pσ{j;Pz'|O K+fqa-:s})vY *KB:|8Hms}N? 0;E3ݏWлrV*}:xßB̖Id}7g=y8dq,#]j\pDi-!Tٺbh}(>ʬQCNh!&LZ;q&sIÚ$?GhFmit緮޻pnG 3IhXu~ήrp=<),5WHɸ~~FC% C@,oR7ɐ烫fBGEBügj%kf|nj:3ONas:LF9r\ٕoW9>s}S,&z>^/z?%Dg޿oe0$y 0*T|OTht\^ѕ/w- 9R˅*? }h83UW~$D'\w5Es~ s~4oT^US5hWTm. IQ_T<,zx<3(گ-Qk;b!ỵ^;tC;;P(m5yOU/w]x>_MMZ@233ߕ΢!aSPj_|Z4W4X>q͉vYB(+=wDl[t]yXza>?>s{yQ!`ytO+߆Ox! |AWFH5ZonCפ ͆/=g4^#;ruv8Ǩm +pf;eߒQKAy|nj ;qW':y J Ruęg+緆C*%`)z;&J;xsSBgǵ } 7|lfi [8%c##~c`-.X6Pr-f)_j\odD$|*~qfFNtychSiyB_w蝽#q䊋Im2/eA҆14$w[JB":9qs]!յ )Ztf9/">sF!;gzDG}K}o uYSrUŝ{]oho$3) uyoT)ȼGS0Zyi^87McN['G5H$h4̏FLGpvʎ.`Ru84=?3O;/o[yOrB4,) 衘Zdx96nPK%W2U0%3S>&>&xU\N[q͌JR|`L3?KglK'$80B_UP-ew?s~|Ҝâoο)O'|Q? 1#Rj{1n%y|WW`et`_e(K2(Qb/mP! gd>}0W6jMw!= =3^23 yvR ,Ga?}~ !tbϜ_,xECfp18Ј _vgfJ0_F/,7'^5XC9usCiW*fF+h_<Q1fV!Hu]5OR$|~<9;Lg}6 t_X5F&Ipy].z:r"ͅ~tk\_3+䞑=Sސϗ9QC8DgOgl17$sSޒl|},pe_:A9(S^t|×-27 ku+M,` @nameMGCOLMinKNOW-Event-Detection0.46.1.9 b201408121556multittest_continuoushighland51637 343964306142.8MN02178 sequencing_run 1410197150 35.375 (ce0394cf725da948ae99402872de14495606b21d0.46.1.9 b2014081215568x @versionM,.TREE-2HEAPX/event_detection@ u3TREE-2HEAPX1PSNODm//1/1 @modeM Hpeak_detectorM @ threshold ?@4 4 @ @ window_size ?@4 40@ @smallest_event ?@4 4 @ @long_threshold ?@4 4@ @ long_window_size@( @ long_smallest_event@ 8limiter ?@4 4GX 8 start_time@7 8 duration@ 0 8 start_mux@ @median_before ?@4 4P$)i@ 8 scaling_used@ 8 abasic_found @ abasic_event_index  Habasic_peak_height ?@4 4Y[@ 8 hairpin_found @ hairpin_event_index E Hhairpin_peak_height ?@4 4RyWXT@ @ file_version ?@4 4?9;TREE?HEAPX(;tracking_idchannel_id0 M@0TREE?HEAPX>PSNOD}CCEE<m<>m<> @asic_idM H asic_id_32 M H asic_tempM H device_idM Pexp_script_purposeM Hexp_start_time M H flow_cell_idM Hheatsink_tempM @run_id(M H version_nameM=FxTREE?HEAPXEPCE Hchannel_numberM 8offset ?@4 4 @ digitisation ?@4 4@ 8range ?@4 4p= A@ @sampling_rate ?@4 4@ 8 read_number@JhTREE^`HEAP`Configuration@5[ H time_stamp5KGCOL2014-Nov-25 23:06:561.6.3chimaera5HUJ @version5K @name5K\%^TREEbHEAPpջgeneralsplit_hairpinpost_processingbasecall_1dSNOD"bh[(1`chTREEbHEAPXMbPSNOD`u0uP_@ MyUt H basename4UdGCOL4LomanLabz_PC_Ecoli_K12_R7.3_2549_1_ch8_file30_strand24/tmp/analysis/28Basecall_2D_0000False230000/opt/chimaera/model /opt/chimaera/model auto r7.3 K/tmp/analysis/28/LomanLabz_PC_Ecoli_K12_R7.3_2549_1_ch8_file30_strand.fast5 200channel_8_read_24$/opt/chimaera/config/basecall_2d.cfgauto8  `-b @read_idUd H local_folderUd Hworkflow_nameUd @counterUd H use_localUd H max_eventsUd Pdefault_model_pathUd H model_pathUd Pcomplement_modelUd H model_typeUd @inputKUd H min_eventsUd @tagUd @config$Ud Htemplate_modelUd @channelUd |hTREEbHEAPX{Pu  H trim_endu|GCOL100.50.1550104.50.0 abasic 1.5 30 200 1500uy{ H pt_windowu| H min_pt_lenu| H trim_frontu| Pmax_pt_search_lenu| H min_peak_lenu| Hmad_thresholdu| Hpeak_thresholdu| @modeu| @pt_dropu| H trim_hairpinu| H min_eventsu| @first_nu| Pabasic_range_backupu| UhTREEbHEAPXP Htstat_thresholdGCOL5.04.00.810.80.6`ݒ Hstutter_divisor Hstutter_factor Puse_post_processing Pstutter_threshold H tstat_factor5pTREEbHEAPXݧPp Pscale_iterationsGCOL102 Premove_iterations pTREEbHEAPX}Pgeneralsplit_hairpinpost_processingbasecall_1dhairpin_alignbasecall_2daggregator@ Pboundary_value_2dGCOL002.05002300000.5200H=] Pskip_2d_for_bad_runs H max_ratio H gap_penalty H max_events H min_ratio H min_eventshTREEbHEAPX]PX Htrans_max_diffGCOL8.00.80.2656062141291000151.02.0101 9.0 simple 1 0.787450951983 0.2644331761552.50.058778335592h= H trans_fmin @c03 H chunk_size H band_size Htrans_min_diff Ptrans_unity_diff H window_size Hmin_mean_qscore H trans_mod @use_sd @c01 @c02 H trans_fmax @c045hTREEbHEAPXP Hcount_qscoresGCOL02Ssplit_hairpin,basecall_1d_template,basecall_1d_complement,hairpin_align,basecall_2dX @threads H sectionsSConfigurationInputEventsAnalyses/EventDetection_000/Reads/Read_24/EventsSummaryBaseCalled_templateBaseCalled_complement%ETREE}HEAPl` 8 num_raw_events@ TREE}HEAPX%PSNOD0]H@p|X 8 num_events@&0 8 end_index_comp@0 8 split_index@E @ abasic_len ?@4 4,C? @duration_temp ?@4 4`kw>c@ 8 abasic_index@ 8 num_temp@ @ abasic_peak ?@4 4Y[@ 8 end_index_temp@' @duration_comp ?@4 4S)g@ @ start_index_comp@c 8 num_comp@ @median_sd_comp ?@4 4Q}D? @median_sd_temp ?@4 4wZ? @ hairpin_peak ?@4 41`@ @ start_index_temp@2 Hmedian_level_comp ?@4 4WQ@ @ pt_level ?@4 4{XHJ@ @ range_comp ?@4 4Њ@ Hmedian_level_temp ?@4 4GᩃP@ @ hairpin_len ?@4 4H.!? @ range_temp ?@4 4Pe@ TREE}HEAPXM P 8 num_skips@ 8var_sd ?@4 4゠? @ strand_score ?@4 4*X @ 8drift ?@4 4A1;^? 8 num_events@ 8 called_events@ 8 sequence_length@A @ mean_qscore ?@4 4 M@ 8scale ?@4 4pD ? 8shift ?@4 46$Ҥ @ H model_file2 GCOL2/opt/chimaera/model/r7.3/template_median68pA.model -  @ scale_sd ?@4 4U ip? 8 num_stays@z 8var ?@4 4,%C{P?,}&, uT!TREEM"HEAPX !FastqEventsModel8SNODS}b@channel_8_read_24 TTGCTCCGTAAGCTACTATCAGCATACTTGCCGACATCCTGCTTACAGTTATTACCATCCTTGTCGGTATGCATAATTGTGCTATCGTTCTAGCTCATCTACTCAGGTCAAACTAAGAAGATTTTTAATTTCGGTGACCCGTACTTTAATTATCGTTAGTATTTCCTGAATTTAGGCGTGGTCATTTGACATGCTCTGTCCCTCCCAGGCAATGATTAGAGCCATATCTAGCGAAAATAATGAAACTAATTATTTAGCATCTGTAGTCGAAGTCGAAATGCATACATGAATTAACTTATTGAAATTATTTTTGCTGTTGAATTTATTATTAGCCAGTAATCGGCGGCTTATTTGCTCAAGACTTCCAGCCAGCAGCGGAACCCGCAGGCTCCGCCTTGCGAGGCAGGCTAGCACCATAGGCGACAAAAGGGGCGCTGAGGAAAGTACAAGCATCCAACCGAACCTACACATAATATCATTGCCATGCAAACTAAGTCCTGCAGCATAAGCGATCCCCTATAATCCCAGAGATGAGTTAATCATACCTGAATTGAACTCCTTTCTCTTGTGATAATGAAAGGCTCATCCCACAACTTGCTCCCGTAGCGGATAGTAATTCCGGTAAAGTCGCCGCGTGCTGGTGTATTCGTTACTTGCAGCCGGGCAACAACGCACCAATACAGCAACAGGAATAATGGTAATGGTACTGTGATACTTTCATCGACTTAACCCGTACCCCTAACAAGGCACCCACGCACAAAACATAATCCGAACATACTCCGTTATTTCTCCTGCTCCGATGGCGAAAAGGGAATTGTCAACAGCCATAGTTCCATACAATTAATCGCTCTGATGGTACCCGCAACGGGAAGCACAGGCGTCAACTGCGTAGTGAACAATACTGGGTTTCAACAATTTTGGATCTAGCGTGCTGTGGCTTGCACTGTCTGACTAATATAATTATGCTTATGACCAATTAACTATCATCACTAGTACTCTATTACCCTTGATTATGACTATCGTTATCCTCACTTGACTTAACTGACTATCTGCGTTCTTCTTCTGGGTTTCTCTGCTTTCATCCTGGTGCCGTTGGGGTTTTATCGTTTCGTATTACGTTTCTCAACTTGATAATGCTTTTGCAGGCTTGGTTTTGAGTAAAATTCTTTCTGGTTCCTCCAGCGTCCACGTTTTGGTTGGTTTCTGGCTTATGTACCTGCACTACGGAAGCAATACTACTTGTCATGCGACAATTTTTAAATCTGCGCGGGCATTATGAACCGGCTGAGGCATTACCATTTACGCAGGCGCCTGGCTCAGGCGCAGACAAGTATGCACACACCAGAGGAGAAATCAGTACCTGCACGACTACTGTCCGTAATTGCTGAATTATTATAAATACTCTGGCACGACTCTAGAAGAGTTATCACGGGCGACGTATTTGATTACGTAGCCGTCTGCGCTGTGCCAGCACATTTAGGCTTGGTTAACGGTGGCGGACCGTCTGCTAACTAAGAATATCGTGCCCCATGTCGTAAGTGGCAGCGCATTAGCTGGAGAAGCATTCTCAATCTTGCGAGCTGGCAGCTCGTATTACAACTTTATGCAAAGAGCAGCGACGATATACTCGTAAACCGTTGGCTTTCTACGTATCATGTGTGATACAGTTACGCCGACGCAGGCTTAAGGGATGCTCCGAGTGCTAAACCTCACATGCTGGCTCACCTCCAGGAGGGTCTAGACTGAGCCTTAACAAGTCTTGGCTCTTTATTACCAGTGCATCTCAACCTATATAACCTATCAAAGCACTATTCTTATGGTGATGGGATAACGGTGGGCAGCGCGGGCCTTCGGCTTTTTCCCTGGCATTGGAAGCAGAGCGCCTCACCCCAACCTTATTCGGTTGCCGTTTACCGTACCCTTCTTACAAATTTGCGCCTGTCGTCCACACTTGACACTTACACGTTCTGTCTGAGTTTGAGACTATCGCATAGCCGTAGCCGATATCTCGTTAGCATTACACAACGCCATACTGCTGGTTATCGTTGCTTTCGCATAGTCTTTCAGCACCCTCGGCAAGACCGTCAATACGATAATCGTTATGGATATATCTAACAGTGAATAGACGGCGAAACGAATGAAACGCTCTCATCCCGCTGTGAACCTGCGCGCCTAGTTTCCCCTACGACGTCGGTGTTGAAAACAACTTAAGTACGCTACCCCAATTCGACCCAATTACCATGCTGGCTCCACAGCGCAGCGTAGCCAACCACTTTAATCCCATACGGACGCAGCACACTGTGATGCCCAAGGTAGCGTACTGCGATGGTGAGTCCTGCTCATGACTATAACATTACAGCGGGCTCAGAAGTCGATTGGTCACTCCAACATTCGACACCCGTATGACTTAGGCTTAACTCTACAGCCTGCCAGATTATTACCCTGCTTCGGAGGACCAGCTTGACTTTGGAGTCGTATCCGAAGCAGGCCCCGACGCGACATGAGTGCTGAACTATACAGCATACTGGAGGTGTTGTCGTTACTGAAATCTTTCTCTGAAATCCGCGCAAGGAGAACAACGACTCTGGCTGCCGAAATCAAACAAACGCCTTCATCAATACTTTCAACTATCATCCAGGCAAATCTAAGTTATTTCTGCCGAGCGTGGCATTGCGTCCTTCGCACCACTCATCTGAGCTTAGCTCAGCTGAAACGATATCTTATCAGTCCTGGCCCATCTACCTTCTGGCGAACAGTCGATTAACGGGATGTGCTGCACAGGTTATTCGACCCATGGTTGGGAAGTCATACTGCTGTTAACTCAGAAAAACGTCATCGCTAACTCCGTGACAACTTGCAATGGCACTGGAAAATCTAAGGCGCCGGGCACAGTAAATCGGCAGTTCTGGCAATGACATCATCTGCCATAGTACCAGTCCGAAGACCCTCGAATCGAACCATGATGAACAGCTGGAACTAGACAGGAACAGTATGGAAACTCAAAGGAACAGCACCAAGGCAATCTCTCCTAATGGGTGCTTGCCGCAAATCAGTTAACATACCTTTGCGCATCTTAATCTCCTTACATGAGGAATGGTCGTGGTGCGTGGGATCTAGCGGTGATAACAGCGAGGCAACGATGACTAACCGCGATAGCACGACCCGTCCGTCTGGAATCGCTGGATACCAGCCCGGCTCAACCCGTCGCGTAGTGAACGCGTGCTTCGCTAGCAAATGGCTTAAGCGTGGATTAGAAACCCCATGCTGGTGAATCGAAGCAGCAAGTAGCTACCAGACTTCATACTTCGGCTGCGACGATAAACCATCCGTTATCATGCAACGAAGAATACCTAACGCTTTTACATCAACAAATACCGGAAGTCCGTTCCGGAGAACAGCCGAACGATCAGCAACCAATAGCGACAACCCGCTGCATCCCATGATCTGTGCTCGGTTTCGTCTTTATGCCATGCCACTTATAGGAGTTTCCCGTATGTGATAGACTATCGTCTGGCAGCATTCCACACCTCTCGCGCTTGTTAACCTGGAAATGCTCAGCCGGCCGTTGTGGAAGAGGCAACCTGGCGGCAGCAGCATTAATAATGGCAGAGTCGTGGATTTGCCAGCGATAATCTCCTTTATCCGCTGCTTAACCCGTCGTTATCGCATCCTCACCCTGAATGTAATGGTCAGCAGGTCGTGAATGATCTATTCGCGCGTTATGCGGCCGGATTGGCGTGAATCGTATCTTATCGGGGGATTGGTGGGCTGGGGGAGGAGGCTTTATCTGCGGGGGAGAGGAGGCGGAGGAGGAGGAGGAGGAGGGCGGAGGAGAAGCGGATGCGGGGCGGGGAGTGAGAGTCAGGATGCGGGTGGGGTGGTGGGGTGGCCCGTTGAGGTGCGTCTGCGTCAGGTAAGGGGCGTGGGCGTGGAGGGGAGTGGGAGGAGTCGGAGTTGCATGCATGAGGGGAATGGCTTCGTGGGTGGGGGCGTCGCGTCGTCGGGGGCGGGGGTCGTCGTAAAGAGGGGGAATGGATTGAATCATGCGTGGGAGGAGGGCGGCGGGGGAGGAGGCGGGGAATTCAGTGGGGGCTGCTTTCGTCGATAGGCGGCGTCAGTCGGGTCCGTTAACTTCCCACCCCTCCAAGAGACTCAACTCATGCAAGGTGCGTCATTACAGTCAGCGTCGGCAAAGGATCGGCTTGTGAAGCAAACCTGTTAATAGGCTATCCTTCGGCTAAGGAAAACCTGGGCTACTCCAGTACGCGTGGCACCCGACGCGATCTTACGAACACCTGCTGGCGTCACAACCGAAGCGTACTTATCGCACGTCTTACGTGCTGCAACCAGTGCTCGAAAACTATCCCCTTCCCCCAATCCGTAAGACGCTGCCTCCGTGGAAGACAGAGTTGAAGGCTGGCACAACATTTATTAATTTGTTTCAATCTTTCCTACATCATCTTACCGAGTAGGAACCGCTCCAAAGGAGGAATCACGACATCATGAACGTACGAGATGATTGTGCGCACCATTTATTGGTACGACGTGATAACTCGTGATTAGTCTTCTATCATTTAGCATTCGTTTATCTTCTTCCGACGGGCAATGAACGCAAACCTTCAGCCGCAGTAAAGGCTTTGCACCGTCGTTCTTCGGCACTTGCATTTCGTCACATGATGTTATTTGCGTTTGTGCGAGAACCAACATCTGCCAGCGCTCGCAGGACTTCGTACGTTGAACCTTGTGTCGAAACTTGAAGGCGATGAGGCACATGGCGCTTGCTTAATCAGCCCGGGCGAAAGATGATGTTCTTCGTACTGAGCATACTTTGCTGCTGGCCGGATAATTATCTGGCGTCCGTATTTGCGTATGTCGATGCAAGTGTTCGCTACGCTGTAGTGCCGCAGCTGCATATCATCCTGGTGATCCACATCCTGCAAATGTATATGGATTTTAACCGGGGTGTGATGAGTTAGACGAAACTGCGGGGAAGACAGATCGTCTAACAGAAGCCCCGGCAAATATCGTGAAGTATCCGAGAGGCGAAGCAAGAGTATGAGAAGAAATATAATCTCTTTGAACTTCCGGCGACTCCAATCAGCACATTTGGGAATTGTACACCTCGTAGGCGTGTTCATTAAATCAGTGAACGCGTGGTACGGCATGAAACCTTCAAATCCAATAATGCAATGAGTTGACACTCATCGCATCGAAGTTGCGTTGTCATCAGTTTCAAACAAATCGCCAGTCGTGTCCGTGTAGCTCTTAGGCTTTGTTATGCCGCTTAGCGTGAACACATGCTTACGGGGCGAACTCCATTAAGCTTACAAACATTGCAATCGATATTCCTCATACTAAACCCGGCTGAAGTTGAGTTCATCAGTTCTAAATAAGTCACTGCCATTCTGCGTAACCAACGATATCCCATAATCATCTTTTCTGCTATGCTCCGGCGTTTTGCAGATTCACCACATTTGCGGCGAACCCGGGCCACGAGAAAGTTTAATCGAGGTCTGCGTCAGCTTACGTTCCTGTCAGCATTAGGCTTGCCGCGTTGAGGAGCAATTTCAGTTGGCTCTGGCAAAACTAGAACAAACGTGTAAGTTCGTCCTGCTTTAGCTCATGTCCGGGCGCATGATTACCGCTTCGGTGGTCTTTATACGATAGCGTCCTTCGTGGGAGCTATCATACGTCGTT + ###%$#"#""#"#$""$($$$&$#!')-+**""$#%$!!!#'!#&&'-))-+'&%'!%'''&"&"#!%"$#%"$%+-*+(%"!$$!.2'"###$%(&$!!""##!$)&$&"$!#!##$"#.!27'&(-21("!""!"%#&."%$*##$'&'*&&*%"#!#,35##$##'(2%%#$$$&!(!&#+0.'%&$$"#$#$"!$!"#$&"$"!"#!%#%+##"%"&""#%'##!$$""'%%$&()&$+&%"&(,'()."#!#*&#'%$"!)&#$&!#!%%($#!#)""$%$#"&"&&""%!#**&$%#($$.8/0+$"""*!*!%(!'%)#$+''"$##$$%&(#""$$!"$$$)./###(#$"##&+&#"$'''%'%%%##"!"&$&$&#""$&%"%#%-()"#"""$#"$!""$#$%$!#&((#"""##!##!#####"%)$(*+#&#%#%$&(($#$"&&#(##%"#"$'%#$%(#$#"'-)*)(-+)')$#"%#'+'#'%&&#'%##&$($"*&%$#!##$&+#'#$#%%(&$#"-%&&(%%$##$"""$+%#$%$&(%+!.#"##)$%""#"'&#"(%$#$&$(#&&&##%"($*'%&'(&!!!%$""######$%%%&""#!$#"$%"'"'#&-#"$#""!$$*,!&*,%"%/-)&$%$!!$$&"$$#(#$%%''(%"##"#"!&#&#""$#&)"!!##("""#$%$,%'("!.01"!&$"!$$$&#$&")!$%*#%!$##"$$"$$"#&""#%#&$$%"#"#$&,%'"$$##"#"&!!&-/%.24$""&&$##$$"#$"#'%&'$$#%''(,$'#!""""#%$%"#%)%)%'$#%##"$"&)%!#$#$"!$!(!#%%($%(#%"$#!$%(#&$$"$"'$$"%(#$$&&#(!!"&#$$#""!!%!$+'#"$!'246+%!#(#!"$""!!"!"&$#"","%%$%"$$!!#""#)&$##$*#"&!!%!%$"!#"#$)"##$!$'%%$"""#$"&#$%&"")&$####'"!%$$$"""!$&#&&,'+#$#%"$&###"'$$"""!#!!#'##"#$(&()1$%!"#"!!%%&$$!!$!%$'!"!#!$""$##$(,#!#"#"/2%"'$!+!-%!+#&#!$%!%'""$$"!$""!##$(#!#,-,'(#$""#&#-#14&#!"!#&%"&-$)'(#""!"#!#$%%$$%$##!"#%//0.$%#)"%+%0%%%%$(&&#""$#$%$$#"!""#!"&!'&+&$&%%$%!%&&#$$'#$%'+2138+)'&-&-*+#&##!$%%$%#"!"#"!"$%$$(%%''"'#"'#-*&'#&&%&%$&#$$$%$&!!$#$#$#!$#%"!$'!%#%"#"%"%$$)%$#&%$/%$%'%%&$)"%'##"#$"%(/%%%*&'-+*$%##(.)%'()##&#"##%##!%'#&#%"#'!"&%""$#-,--(#%""%'#$#"%#%/&!!%!"$#!$"%"!!!+#&""$%(!"#%&'$'#$/$$"""))#$'#'"%"###%%""""#!!!""&!###!""&($%!&%)!$(#)'(&&/$#"!"$&%($'%'&(((&&$%&&%%##$%%'""""$#$,#).)$"*#$!!#$&##$$%&$&$##$##'!)&'%$%$"$#$"$!&"#%"(%$$#!#$%!&($%)-/0(%"*/1'%$%$!#%$#%&+)&"$#!$%$)%#&"%$########!"!"#$!$#(###&%"'#,"$!$)#%%%&#&#&$$$$%!"#"$""$$#$"#%"),%"#"##$#!"#%##$!""$"#$%(%##$%,2-##+"$"$(-%$*&"!$'$')#$&#$$!"$!"%##%#"%$"""$!"+%()&&'"#("$!&$%"$"%&$$%%'####!""%#$*%#!##.-),)&#&%($',!'$$&$##"&%$#$##$"%###'%%%&$#&)&"#(&$&*.14*'%#!(#$%"%!#*$$((&$,2,''"#""!%$"$&)"%#$+)%%##!%!""$$++(!#$!#%""#,,(#""!$!"##!#&!#"&##&%"$#"##!'"!%',&$$&$&"&$"&&#("(&'#&"($$%##'!#$"*!,#%)05+$%(""%!##/1"!#%"$"$"$"#"!$"$"$"!#$%&"&"&####%$,''&$"$"#%"($"#"%#&"#"$$"!!!"!#!#)#$"%('%$)$%"!%$&'+()'%#%&','##%!%(($&$'""!%/-4'&$"!"#!""!$"""$$+/&#%("#'#$-$%(#)###"###$($#&((!""#'%$%)+#&!%&""""#"$&'#'$$&#$$"$#!"!$#&#&&$%)!""#'#$%&#"!""#"""$$&$#%""!#(""!&""&$$#'$"##,#%#!%#)&%$*$"#""!"!"#%$$$!!!###!&#%#"%&%&!!!!"&%)()'-&"#''$%)$$#%'$&##$'!#"##"""$#!$%%%##"#""#$%&##!%##&'#'%'%(&&%#*$!&&%$$##"!#-*"$$""&"&%$$$'$!"!-.%!%#%"&"#)##"#&$&'#"%&$&##"$#$!%####"!""#"##$"$%""##'($#$!!###$#!)'!&$'!'#%''$)&,&+36"!##""$($'!"&#%$%#%"$'#%$#&"'"###"##%#'&$&'$)##$"&"&$'"$$',#%&$#$#$")10$!$#"$)"$$$&)))((%&%%"#%'0+*126-,%&#""#$'+#$'%%/$"&+#"$%$""##%%#$'('"$"###'$#"""##!##$"*#%#'(&*&'(),%$%'$#$$$#&#,($""#&&1"!##&%(&&$!#%"#-"#!#"$#&+'(%!$"$"#!#$*&$%%%"$#$$($"!%"%!"!!!"#!"$"##!!"-%%#""#%"$&%%"$!/##%%"$"$##!&%$!"###"#%,))'&*$$'"!%%%&(&(&&!"#""&"&$#""!"#$##$$#)"&"%%$//#%$#&%%)""$"%$'(%+$&&'"#"&$&($&,&'$%'%%#(##&$#(,$"#$$%%%%$&#"!"!"$"!##%%""#!%"#!#"#&"#"&#%%*#!"(#""$#$#"##%#'%%"#$"&#)""$%%&!#&("!"($&%'$!$%#'$'$$#%,##"""$#"$+/.(*''((%!%%%)!$#$"(#%%##""(%)&#$-'&+%##!##$!$!#)"!!"&#$%""##"$$%$$#$%#!!"!('"#"!%"*"#&#&$%"""&#'"&"#$"&%2%&""!"$$""#"!$""&'$"%#%#"""$%")!%$-'"$!%&#*###$$!',$$#$##!!##'%'$&$!"####"$%.$#"+"$!$(#&!&%$(#$%%$+$"&"###'#'('*)'#&$"%%&$(#""%&'&$"!$&+$#!#"#!!%&#*$$'#$'$$"')'--,'##$##!'#"#&#&*##$!$"#!#&.2#"%(&$""#$%%&"$&#&#&!$&*.*4''#$"&%##!#&&$'"'###$$&&)#&'$$""%%$!$'&'*$""$$&(*$!##"##*#''.##$'""%,*"!*$$&%%+%!'$#%"##"&$&""$##*0-4(&%$/%+&,%#$"!"$#((),3&$#"%'(&#&!$'#$##!""&$$(##()&*"#!$!"#"""&,####!#&$"!%!*.,#+$)($!$%#!("%#$$$&$''$!&%'!#$%$$####"$&'%%$($$'#!#'',""$#"#$!""$,"#$&&1#)!#&!!'##&"$"$&#)+"(!%$%$##%(#!#$"$"""$"!"!%%#'"#,%##"!##)#!""!%%!'""!#&$#%!##&&##"!""!#"$#!)!&!#&$%$!!!!&"%""#"!!!##%!!!!$"$#$!"!"$#$#&&!"$"$!(#"%!#"##%#%"!%%!"#!&!%&%#!"!!!!!!!!!!"###$"&%"!!"$%!!!"!"%#!!#"#%!&"!$!!#"!#!*!"$"#!!!!""$"!!!#!#%#"!######!!&!!""!""!!!!"#!!!!"#"!""$#$!!!#!!!!!"!$#'$$#%!"!$##"#$!!!!!!!'!'!!!"!$"##&'$!%#"!!!!!!#(!"!(#!!#"#!"!##!!!!!!!!!!!"%%!!"(!!!!#!"""&"%(%""!!#!!!%!!!!$"&!#"!"!"!!!!!"$"!$!#!#!%"!#!#!"!!"!!#!!!!"!%""#$#!"!"!+!!!!!!$""&%$!!!""!!!"!###(&'+.%&#("0)%&#%"%""'%$##"#&""%$$#!$$'$$$""#&%$%-!!%"%#!!"!"#&$'"!#"!%#%"&*""$$$&"%%"#"$$'#"%%&1#$#$#$$&#%)$%###"$%"#%(&$%%!!#"#""""%#%#%$#&#%"$&,%%'%!%%#$$"#$%.#$&"##'#$##$!#!"!#$',)#$&"$!#$%$"#-"#&""$#$'%&&-"%#%%'.&(*(%"!%$#%(##"&"&"%##!"$"#&"#2$'%&#$#+#"!!"""$"!"""""#$"%,"$"%##$$'&%',$#!#!!"#%#$#&"$'"0'&,#"#',$*")('#%)"-25'%##'))&$%"'#!(%"'"%$#!"!"#""$'%"%$%#&'#%&,%$$"##%$#$""#"##'"'!"!&%"$+$+*)+#$&$&%(!(&*$*"&#%!####!###"$"#$("%'""'!$(&(!"%"!$)###&%')+,-3#%!!&$&'!%%$$$###%'&$"""###*""##(!'$"&&%%'"!""##"#(-&%!#&*)'(!+2')&)$%%%$$(!!$*/-!!&!"#&%#%)'/(((-,%''052,1+#""#&$%#%"$&(##$!$$"##"$%%"'##%#)/%$'!#%-+##"%!(+$#"+$""(#$$!%"$&%##+&##%""#$%%##%###+#&(%%"$%$"$$"$$&))*,&%((%).,15%'$'$'"#%#$#*''$%,12!$$###$#(#$""$#%($*.))'&(+/##$,%'+,'"%*%%"/#!#,"$%%%,&02'!#""$"#"#&$"""%$$#$!$#(!'$%'$'*$##$$!""$%"""&"##!"""&&*&&%"$"!!!(.4"#!%!#$"#$!%#"##$#-$#"####(#!&!!"&'%&'#"$""!(#$)$""!"!%#$"%%&$$"#!%"##'#'!%"(##!&(&#""!')')*)&&%"#&#%$%$"$##'$(##"#$$&#"'".1('$#&#&$#$&$&$&&&%$(#!&'#$##!"#!"!,!(,)&&$$$%%#!###%'.$02$'!$"#%###$+%%$%#"("""'$%#&(($%#*"$%!!%!'%+%%%#%$'+''%%,$#".%#&##"$#&'$$#%$!$$'%&.$&)-("&%&%$!'121(#$"$#%#&#$$"%),#(!%*$$"-$%$"##&$'''%$%-)'+"+"&!%#"&#"$#$*$%$&!$#%!$!&"$$!!#!!(!(#$&$%"%$"$#("'&$#!"-/,**$+#"#"#(!(#"%%$#!!$("%$$!"!!"#&$)-#"*.,#!$%$*10%""$!###'($#$%#'$&-0%($#")%##$$#$")($'%%$!!#&)%',&)667$&#!"#(!"$%"#""$3356.)&$%-+#"''$'%)/*"!$!"!%#%!%#""$&#$"")*&'$'/#$#%$"$#!#$"!"%!'%$&%)%'$23$%%")%%'%$'#'"!"$)%("("%-.$&)&'&'$(-22'"$*#%"$'$##!#%%&#&!#%##$#%"#%*""#&#.)$'+%!"!#'!"##!#%$('.$""!%$$$(%!)#%$%'"!#($""##%)%'/-*$#'"##$$&&&%!&,#!!!#&&##"#$%%$"$""!"""% HXjmean ?@4 4start ?@4 4stdv ?@4 4length ?@4 4model_state model_level% ?@4 4move-@p_model_state5 ?@4 4mp_state=p_mp_stateB ?@4 4p_AJ ?@4 4p_CR ?@4 4p_GZ ?@4 4p_Tb ?@4 4] uT @ duration ?@4 4`kw>c@ @ start_time ?@4 4"uq[@4KN@"uq[@F?Q?TTGCT b/)N@WPOï?TATCA!:l?}?*/֞)N?1ʼ?k`9?] #P@僞j@5aA?+eX?TGCTC=P@?TGCTC?Ya9?3 =? ͍?d:?pIOQ@7>W{@PVv?y&1?CTCCGeYP@4l2?CTCCAS{?L<?^-?Bxh~?sQ@fX@M$̣?M O?GTAAGQ/`Q@:o?GTAAG:o?$r?XCTG?_\?/O?^F̪bQ@@@6?q?TAAGCTP@ Д[?TAAGC Д[?h 6:?tjl!ˁ?b8t?9v?09Q Q@RI@XS?&u?AGCTA~5rQ@(]!?AGCTA(]!?kMAAL?PD?%?c~ٖ?wD¸-EP@o_@Nr?/$?GCTAC~ZP@ӫK?GCTACӫK?DžS?K9h?\{?cL? IQ@A@w-g?@Ǹ?CTACTk⎓P@H&?CTACTH&?x/?#^_?8a3?vK ?K:P@ŏ@,r?w-!l?TACTAy[ېP@'?*Ͱ?CCTCT.`b?Y_i~?$1?6?aM!?ãP@?@@W ?)\(?ACTATL=P@VJכz?ACTATVJכz?Um~?/\?rOA9I? $)?qOiهO@Z @O?~jt?CTATCe :FP@=(?CTATC=(?rՃ v? f<#֡?0=d:J?!K?c$3,M@*@4>?r?TATCAB_2 N@ВL?TATCAВL?{k}e?o]? ֺ?A?/E3Q@@d~1ܼ-?tF_?ATCAG -+!Q@Q'Q?ATCAGQ'Q?h'?,ζ?8?yG?l5Q@ZӼ#@l):?:v?TCAGC(OQQ@8{t?TCAGC8{t?;?~0ّ?"u*8?*7?6Ş|P@ꕲ 1@?_vOv?CAGCA'P@)N)z?CAGCA)N)z?)i?yi.?8?wT_?vwZR@Pn2@&*_?mxz,C?AGCATCR@%aW #H>G?/͝X?'M@_x@&???TTGCCQI:*`M@Y?TTGCCY?/ffN?w㗽?DWfg ?MS8?rMzQ@y&1@J?ZӼ?TGCCG:{]Q@[,}?TGCCAÊޘ]D?E_g!ϱ?k|y ?ٌS0?EϨ?21@R@aӋ@O# ?5;Nё?GCCGA`cBR@Y ?GCCATQϨK?E+?&%)4? ?UCb\?kvQ@H@ ڄ5?`Qڋ?CCGACؒ\MQ@_?CCATAz?|ԍ???&B.?QP@AaÓ@2y4? 0*?CGACAk&P@E ڎ?CGACAE ڎ?żҪ?jn٥'?H?O?OWqQ@X9Ȗ@`(?i|?5?GACATUQ@l9bH?GACATl9bH?B?dL?7?$6-?θQ@S@'K?J4?ACATCsŴP@j8Cȿ?ACATCj8Cȿ?.x$E?7 ?y @?Z;)?S۟[M@b2U0@U?H}?CATCC]ܩM@LUgҷ?CATCCLUgҷ?0"?oԃx?c?)i?388Q@r @?/$?TCCTGZ*Q@&{%?TGCTT]?>/? hu6I??㞺K?v@KM@-@?Hu?ŏ1w-!o?CTGCTrzpN@ݙ~mt[?GCTTA (? }st?06nYQ^?Nz ^t?dC?F} &Q@@ #?~jtx?TGCTTrĢ Q@M0y?TGCTTM0y??m9J@G@B?ZӼ?AGTTA@L7K@Jצ:?AGTTAJצ:?a>0͖>1љ?xo!?(wrWN@6@U/?F%u{?GTTATem M@Ws?GTTATWs?Z]-C>??`i?¸-j?݇2?I %O O@@~aX?(?TTATTVG/GP@"Ċ?TTATT"Ċ?￝?7Ѓ?֍-lX?VT T?KΡyDL@58E@L]?DJ?TATTAe:aL@?TATTA?Zխ"?voW>jWޖ?J L?JW6\M@g@Sq?*Dذ?ATTACFΎFM@YFo?ATTACYFo?h7B?`x#$y?׶c.?o x?4=}/P@7@au:?HP?TTACC}O@6?TTACC6?ڤ?|%}X%?qc?8^u?}"Q@@@?S ?J4q?TACCA&P@V+?TACCAV+?Dz{/?X#vܭ?Ѽ[?e;? NR@]@ʘvp?y):?ACCAT>SR@&M[!?ACCAT&M[!? ')?bGi?;:l?8oc?ŤULM@s@"?ׁsF?CATCCV0M@Yd?CATCCYd?'U?Ԕ&Q?$8a?cCSʀ?&wP@St$@2LE?0*?ATCCTm?O@s$_?ATCCTs$_?^/?P'z?"H?1FK)?ӷXP@~j@Xֱ?1w-!?TCCTT8)P@fP;?TCCTTfP;?C;?wOa?A$?Բrdž?'}M@S'0@#!*@/n?CCTTGO.M@nb?CCTTGnb?oGYY?ό}-?G_? >?jOg"dL@W2@"0QF?S㥛?CTTGTmZGL@]x?CTTGT]x?ɒ>[h$?wGe?3u!?LHJ@|г9@d>}?F%u{?TGTCG+yJ@^?TGTCA!;?`{ DWnv>vm6>C;p? 8Wz?I$ P@Zd;@2[?Ǻ?GTCGG{TT P@iD?GTCGGiD?>7?(?\E?c 5?߳:JQ@c]F@? `Pw?{Pk?TCGGTOEMQ@fW^?TCGGTfW^?uZ?y{?k?gAT?] dN@ŏ1wM@r@&S?CGGTAM@}`g?CGGTA}`g?60ϋ?|g?Dž(D??RV?P@R@eǝ\?gs?GGTATKO@%A|?CAATTJƢ?A ?b?X~?D$?Q4`oK@aT@ck?tF_?TATGC * M@E0}?CGTGG:9b9?V@l>ȵ ?_۱YP?:ж"?R~P@cZ@}?b2U0*?ATGCA'!O@>?GTGAA5䣮?#?At? XQ?W:v?y(!,' S@5@@ށl@J4?TGCATu׫R@G?GGCATd ɴ?cC"sU?!R{:?*L? bu?'hԒQ@~8g@ܴ䂰?y&1?GCATAH@欄Q@\ S@=u?GCATA\ S@=u?F`s?:LȻ?>>UI ?aCK?ӈwK@d]K@p4u?oŏ1?ATTGT/[CdL@om?ATTGTom?S,Ldi>ۂ.?gk?Q?EL@i|@ 5!?L=U?TTGTGDXL@i?TTGTGi?h>Cy~B?yf?a{?/_ 8K@/'@UD?Zd;O?TGTGCLȏJ@4&P >S @?aUX?\c{M@c@-nDl?&S?GTGCTh#M@%N~?GTGCT%N~?cÏ<7?p}F?O#?1 ?6.[BQ@Tt$@l%|I?Zd;O?TGCTA}Q@п5Y?TGCTAп5Y?~?o"#s?d|0};?Av7?RP@#lxz@vp(L?(?GCTAT@P@5 ·?GCTAT5 ·?{8??@A)Z?ko5?;?N@hDio@;!@JY8?CTATC၌7P@/@?CCTTAɨLM?Mxa?c>lY?u\?I(?HzbM@ q@X߫&?gs?TATCG&^N@g`J2?CTTAGEyp?!!Oc? 16Cɨ?.(/?+r?2(N@dZB@.~p@a+e?TCGTT7zM@}X5?TAGTTrۤ?4?0?IJR,?Wh?T8tH@ho@)UB?"u?CGTTCU۽G@,6G?AGTTC/?tNX =v\=QWX?7t?+.J@Z8@ѼI4?Mb?GTTCT*_'J@w?GTTCTw?f|.вP>x>K5N? jk?zN_0P@@@O[?Bi?TTCTAGsO@T$u5?TTCTAT$u5?H:Nk?`&(%??->ρн?<"Q@X@E? ?V_?TCTAG‡2Q@f¨?TCTAGf¨?u4imz?2v?J??}?7Q@ŏ1w-@&.X@HP?CTAGCO!)Q@ zS?CTAGC zS?H?~c?-y?xoM?U؀P@Ș0@z?0*?TAGCTN QP@}lsx?TAGCT}lsx?&?9.r?d'?PwZ?ѧK$Q@?5@ ? rh?AGCTCKP@=??AGCTC=??ʿ9?'uSҔ?*h?t?1c0P@VX@k??&S?GCTCAڙsgO@ ?GCTCA ?|긠?*~ò?j?/Ц??ƷP@(\b@~c_?5;Nё?TCATCZiP@h]4Q ?TCATCh]4Q ?FE0wr?C?jM?`N>?20?/nb?CAGGTvȂc8Q@j)?CAGGTj)?VB;?*?_?iŕ?tG[O@O@a@# @2%䃮?AGGTC[YM@cs+M?AGGTT `Š ?\?Bhg%?p+ ?W& ?Zgz J@&S@+?"u?GGTCAȽyJK@n3Di?GGTCAn3Di?\YM>t$>q?#f3#?U`P@p= @9?`Qڋ?GTCAAI?msP@__?GTCAA__?'mM?ؼF?79t?fϏČ?Q@ޓ@sC,?F%u{?TCAAAF Q@J( ?TCAAAJ( ?pGD?c$?-Q ?5.t`?W6P@46@ ?Q?CAAACt_P@ %DZ?CAAAC %DZ?n{?<^qȹ?=~Fړ?җ?KA7 O@vq @75? ?AAACTgbM ?i7?}=b?CT?0BQ@|a@EYM??ACTAALQ@56;?ACGCG.AQ?#_?3?!y?]^ǒ?颋nXR@AǸ@14@/n?CTAAGm3R@E!Ƴ?CGCGC:{K?}??;'?rLyi?qݧo?|jŽQ@QI@EZ?_vO?TAAGAPlQ@N?CAGGAbaU?8:? ?F1+m?A+G?ZS@B`@4;K@_Lu?AAGAA8zfR@A] ?AGGAGM?bwV?I4?w?\*ޣ0P|>ayS@2%@{0?J4?AGAAG7oS@)d?GGAGAOc?^V&?!w?KzVO?M͉>,R@|/L@Ќ4?_vO?GAAGACQ@8ز?GCAGAݠ?p5?cgް?UTڡ?}>b}P@r @-?:pΈ?AAGATCQ@O˨[??*i?wPUr?$NM?ӢJP@h@4Ʊ?&S?AGATT:xNP@%+߸?GACTT/c?-qy?l?NA?QÝhy? qxm&I@v@v͊? o_Ω?ATTTT7joI@"o ?ATTTT"o ?,g>}KO -=vm ]?>[?mUI@.@b0??ܵ|?TTTTT0EbI@%%-?TTTTT%%-?n1=? b67=tOn1?zzx?"8'J@6@#k?Y5;N?TTTTA[ڻGJ@vm?TTTTAvm?ш=pMb.1il>6wc5?|S?kM:N@@|G2?M O?TTTAA-ON@rMGx?TTTAArMGx?b?tz||?qf ?uQ@ @@v?46\یB>֖ T?AP?).:I@z6>@Z{?(?ATTTCBH@p?ATTTCp?m0C=쨏_=u@"?G^s?jtrK@#@뭖?Mb?TTTCGKzw{K@]}?TTTCA^/i%?S]c=D>(?lU?KX?J\;I?0cP@\m@oYX@J4?TTCGG?6-P@L?TTCACf쾭?tr?L@kt? Iw?Hv*?y|P@D @0!?e?+V(^KT?-eBP@St$@-O?q?GGTGA4[N@o%n?CCTCT?uS Q?0^{?N_?Ê?#MO@ׁs&@GN:?sF?TGACC jO@r4Fd?CTCTC.,?(yk=?^?4v?GHg?˕MO@"5@u`?3?GACCCaL_O@A'4?GACCCA'4?&䗄o?8m?^" ?؝@?ѾK Q@UM@s"? ^)ˀ?ACCCGNVuQ@PP3?ACCCGPP3?xiT*?N#?w>a?Z `?U qR@oO@T+@S㥛?CCCGT> tR@l ?CCCGTl ?0P? Ky?zb}G?svt0? z3N@mV}V@0C?Aǘ?CCGTA=XcO@6c.Ή?CCGTA6c.Ή?fl?=:?' ?(?^K@fc]\@ܫ1x.?_Lu?CGTAC}HL@)F^!?CGTAC)F^!?Qfr@> l??8i?;n~{O@V-]@Ƚk*?`Qk?GTACT!>GO@"%?GTACT"%?M?$R?i ?wse8A?sP@%^@#c@_?y):?TACTTTWP@͝ y2?TCCTTn3? <(D|?nhE?P0K?Zr~?ITK@ c@r?a+ey?ACTTT]#HxK@o?CTGTT/|?K]Qld>>~`?{ǝsM?FI@?ܵd@rdP?:v?CTTTAGJ@=d^+?TGTTAx>?vG>Uvq>ÖyE?b8?mON@ h@*R!m?Zd;O?TTTAAZ4}ON@; `?TTTAA; `?s;|[k?>?Hvu?=?+vQ@(m@/+?&?TTAATbQ@^y?TTAAT^y?`2˚?n<?"P:?%m૲?SP@m4w@4?Mb?TAATT2SK2P@(T?CTATT5?p `8?2ذf?0)?rQ19ƶ?msL@?W[@i\$?5;Nё?AATTAd4K@ZEt?TATTA탭sk?BD?%>Y ?c?%O@2%@#4C?b2U0*?TTATC'‡O@"?TTATC"?Гe?OTH?8 (}?8S&1?x&N@=,Ԛ@e?/$?TATCGN@T|L?TATCGT|L? "z?FN?Wz?VxP?PP@t@rj@Q?J4?ATCGTV:^P@xm?ATCGTxm?|X8?? ?\ck?ٔ?K~"M@R!@&H?~jtx?TCGTT&HaM@v?TCGTTv?3cEs?X8d?7? S?uN'I@ͪ@ 8?a+ey?CGTTAM]I@@ÑW?CGTTA@ÑW?.5>O>$Kd?~F? qxoM@[ A@cW?J4?GTTAG 5oM@0~?GTTAG0~?+?|%hx??.‚?W鿷-?vgj>Q@ g@ '3+@ ?TTAGTw9BQ@G?TTAGTG?%q?^d?@k?KF?Fڱ)O@fX@^#@ŏ1w-!?TAGTA hO@7$5C?TAGTA7$5C?e=?{>6"?=򄲵?z?,xP@J@j 8@|a2U?AGTATZsN@w&5?TCATCfI?ݫ(ln.?ł?-? 3|?"9YM@UR'@y2~WB?mxz,C?AGTATnN@ D?CATCT6]m?,.͠?l~?>(t$=? 1ɖ?jyO@(@ 4¬?I +?GTATTs&O@xY?ATCTTWOG?q@?jB?W?Ɔ.?ϵdK@Wʲ@8Y?&u?TATTT* }K@lM?TATTTlM?e6&z>{[>Ď? )4?kI@Q@=:I#.?/n?ATTTC8H@S#?ATTTCS#?bR=E5{=H6%'?v?ףpJ@G8>!<,?7??1asO@|?5@>$?:pΈ?TTCCT@gO@{?TTCCT{?Ow?I?su?%|?P@) @_1&n?a+e?TCCTG<*Q@‹{KB?TCCTG‹{KB?& ?S}b?2m I?L[z?q= /hP@Hr@SZ?-C6?GAATT o=P@x0?GAATTx0?.eFF?6wk?f?AATTTY_ԨJ@I#?AATTTI#?i2b >Mo)8g>\.Ȋ? ܨ?[` CJ@@P8>ρsg?LȑWUu?K 7NN@僞 @Fw?_L?TTTAG8N@i04?TTTAGi04?0WEyb?삱?4F?U "&?GCGTGX>"&?֎Z?Xv4?:'ٲ?;>t5>_?J?%@EO@S'0@Io@gs?GTGGT ?O@ ۋz?GTGGT ۋz?"!}mϱ?j}?0!*N?ꩺ?le߬J@N@3@D?jM?GGTCA^x1K@ 70ݧ?TGTCA~qEJ?vp>P ]?'Td?NPLP@^K=@}Ԁ?j+ݓ?GTCAT1yfP@:?GTCAT:?t5?-{{?)?Fǜ?XP@H.A@k @gs?TCATTbYḂQ@b ?TCATTb ?h؉?&?S[Gn?eG΃?<7BL@?ܵD@w]?Q?CATTT:%exK@t?CATTTt?3d>pھ>90nE?p?Fk\J@UM@kt?_L?ATTTG 0/LJ@?5??ATTTG?5??+ W>HNP>66W?3?ΖlUL@QX@ft?/nb?TTTGA"&L@Qo?TTTGAQo?%>rh.?=PA?=n?tuM@,eX@W4Ǹg?Mbp?TTGAC:QN@ZwY@rӰ?~:?TGACANaP@?TGACA?myx?opj?(B?k?fx\uQ@9#j@.4?F%u?GACATK$eUQ@ϡ`?GACATϡ`?sj?%:?yDx?_>;©?127Q@;Mm@ {a??ܵ|?ACATGgVQ@s=<Y?ACATCY,?)ۣx?Lt$?I!̚?{:i?(N@)\u@WO?0*?CATGCWL@PXq?CATCTX[޾?Ш?eE1`?2w?yp'?GO@vq @WSE,?-C6z?ATGCT.>}VN@?YD?ATCTAÔjô?hzS3P? 6C?̢l?F"j?e}SYQ@(@ofM?ݓZ?TGCTC{GP@dk·?TGCTCdk·?hZܟ?b3?,]Z<{E?Gm3\?Ґs O@c]@gư咐?J4?GCTCT9yO@}?GCTCT}??8R?ӕ\?HH?K)P@ͪ@:?ׁsF?CTCTGZtP@tOoʥ?CTCTGtOoʥ?̕5?-F?>mY?16?3O@~j@i?ǘ?TCTGT*ͽ;N@{ct?TCTGT{ct?ptC?ֳ?݁=`?kdqX ?SjuI@^K@2yT?'†Wʲ?TGTCC`I@]p$?TGTCC]p$?;0H>58f>Q~?h}?Jj+Q@ү@4+wY? ?TCCCT]HQ@KwO?TCCCTKwO?4Z?ƻ?%1$?iܵѵ?a:Q@kt@ %b?S!uq?CCCTCI [2Q@5 o?CTAACr7?rH?/?p*2?1Z?)\O@/n@P? rh?CCTCCfO@aذz'?CCTCCaذz'?\SA?`%6?^۽7? @MJ?贡O P@7[@G?b2U0*?CTCCC_p4zP@gyn?CTCCCgyn?m?9$^?Lde?5[?k@fQ@M F@)fA?y&1?TCCCA[oQ@4pR?CTCGA2Ȧ?Vg ?ݐz?H}`?P?4 }R@q@Ay?mxz,C?CCCAGLD#R@rO?TCGAAj;?T7?8C}?[8 M?|]?*AR@V@ro :!?q?CCAGGfUxR@,]?CGAATM?]bG?gzV?j__?3`$>(\+P@s@'?a+e?CAGGC?'dP@h,c t?GAATG|4fm^\?05?B#?ǀ}??%YѪS@dZB@ͣFWz@`Qk?GGCAA&VS@hXLѢ?GGCATJۢ?f?PKk?Qh? ʟ4> ~{,P@2w-!@Wﴵ{:?ׁsF?CAATGEYP@5?ATGGTh?#?ǸZ1?|? 0=?P'N@W2@[ ?`Q{?AATGAb."8N@#?TGGTGMN.?/:T?Bd_A5S?=/ ?@C?}diO@Eio@\7@ŏ1w-!?ATGATlW;\P@.Q?GGTGA_@?t!s?3o+=~a?fB?Fm^C7?a& N@@@ _,?F%u?ATGATjM;\P@=ZSz?GTGATkF?Ψ ?D?^ҥm?BdO?ZO}P@Af@J9?ŏ1w-!?TGATTΖ_ZP@1 ?TGATT1 ?+P`?$? c?S*i?p3VL@J@,?v?GATTA"L@AB_?GATTAAB_?^ `0?FV!Qk?}>?@׶k?MM@&u@b?HPsע?ATTAGf:N@a|˶?ATTAC )?Y.I?d.8=b?,O N?UM'˯?K~q!{Q@@2V?_vO?TTAGA擏lQ@z>,ܱ?TTAAA:zE?[h$???T?]Q@|г@UI&h?ŏ1w-!?AGAGC..?Q@!ͯ ɦ?CTAACd2پ?E;˵?Zi$`? ;e^?X V[ ?/O@k+@{*^?Pkw?GAGCCk zP@.?AAGCCQw ?Y~?@?cP?½? &;Q@:@8zx?n?AGCCA:r^Q@>ғ?AGCCA>ғ? P&x?gZ -Q?Q?9R?T*ξz(R@?@?~jt?GCCATY + KR@^tȶ?GCCAT^tȶ?T#?'0?pH?QGl?ؚzP@48E@ H?(?CATAT driP@Apz?CATATApz?%JQs?(!WMw?Fq?&i?x=9P@gJ@ٙ,?Mb?ATATC>WSO@[u7?ATATC[u7?B?N0?dfsx? v`?rM@N@ֿ?V-?TATCTxM@>ݰ*?TATCT>ݰ*?X)?H?8ê?zDK?HW@P@KY8V@J(?q?ATCTA P@oqÒ?ATCTAoqÒ?w$?ݼ$k}]-R@av@b?{Pk?GAAAA8%R@}UoU3?GAAAA}UoU3? xo?g G?z?k> -?byQ@46<}@ θM?r?AAAAT2h@Q@ i*?AAAAT i*?Ā*?|$A?R~O?Phk>?K7O@|/L@F?Mb?AAATA/_eP@I}@?AAATAI}@?A9?K_?2gB+W?a+e?TGAAApBq- S@c2?TGAAAc2?\ ?Az*? ? w>QnQ@Q@s$ "?-C6j?GAAAC\o 5Q@AX 6?GAAACAX 6?2uE?L >~? /?z[ EO?ĸ_N@9#@4wO?HPsׂ?AAACTҦҳ?yakJ?,"һ:?]y@MO@ܵ@S?_vO?TAATTL{92P@ ?CAATTFLPc?OI ??Ğ^? 1M?iݞ@L@H@d/?H}?AATTAEJXeK@4P?AATTA4P?c⏻O>k">/h2u?TÌJ"?N@7@{́>?b2U0*s?ATTATWN@8?ATTAT8? ?'=՟T?sζ?;by?PPP@W2@BO3?`Q{?TTATT; P@ :O?TTATT :O?@V?Fy?u%?5XUHrq?X~K@Eio@ө? ^)ː?TATTTܾ|K@UP:q?TATTTUP:q?@Y>y> ?Ϟ2?s8n?ayPJ@9#@5? ^)ˀ?ATTTAuJ@»*4?ATTTA»*4?~rff>gM.>jg ?>n?ˡUN@<@@u?`Qڋ?TTTAGYdN@Vr?TTTAGVr?m0h?m?$ ףpQ@Q@#ۉV??GAAGT\Q@ju8abf:?0z^M@!@T _@_vO?AAGTCw*L@0C ?AAGTC0C ?n?ݼV&\?EFj+}? n\0޵?9tP@q$@/?n?GTCGA}.DP@ t4?GTCGA t4?1M?#a!3M?'?eNԾ?Č9R@镲L@Zj W'?S!uq?TCGAA(dR@U^fv?TCGAAU^fv?%?ūg,{?㣁?2-JI?`} {S@jMS@"6)鋈? ^)ˀ?CGAAAJZ%S@cR+G"?CGAAAcR+G"?w?G. +?,/Ӳ?sE>O4+Q@>yXU@_?~jtx?GAAATKQ@o?GAAATo??2?J]zW?08L.q?0}cå6?E)O@ŏ1W@ǵy?<,Ԛ?AAATG0otO@|)R ?AAATG|)R ?7?hp7?;K+ע?{RԻB?@P2N@-Ԛ]@C?"u?ATGCAo% O@~O!?AATGAAW?9Rygt? &?e{?Py}?Hz$#S@6`@N'Q@oe@j@y):?GCATAP ~Q@90Ľ?GAAACe}v?30$uT?J\ ?jPbڵ?|].?\`VO@ i@#?q?CATAC=O@}r,?CATAC}r,?_?爒la?c~ғ@?*+[?:m\P@ŏq@! ?L=U?ATACA&pP@e`?ATACAe`?v/?!܍B??t"\?bUQ@:@86_z?a+e?TACATIQ@?CTCATK?hn:B?IY?h<|y?6 ں?"9Q@v@JPnv?mxz,C?ACATG{VQ@e͵?ACATGe͵?@:&.??^7_? D@?4rO@x $(@XIF~?b=y?CATGAiLO@uGFҿ?CATGAuGFҿ?Ef?$J(?|%9?Ad7B?+Q@8d@V1V?a+ey?ATGAA5TP@b|¿?ATGAAb|¿?b u?.ظ ?0?mz?6R@t@FGM9@vq -?TGAATbR@ ?TGAAT ?[`?M?Vq?$送'>= ףDL@@[A@ 0*?AATTA־vXVK@ m!+P?AATTA m!+P?(\|?׾M>>tG? H??k{M@ @7ɣ?ŏ1w-!?ATTAAZ3,N@?ATTATE3?d?'G c?pKn+?S˫(S?ddSP@F@ g?vq -?TTAACR,#P@M?TTAACM?Q_?K?%By?Xd$?5O@k @̀T?n?TAACTdO@>\?TAACT>\?#KM?{)?ji5?;u?s(w;)P@ q@3|?/n?AACTT kO@F$M?AACTGڿ$J>?娪z??P ??0?܀ֽ? ϞN@Bc̽@hO? ^)ˠ?CTTAT2'N@V#?CTTATV#?ebj+cј?Nlq?U8,t@>?_8,?@ P@1@=?@Ǩ?TTATTVO2P@ {r?TTATT {r?B.e?:A?jKᨩ?#U!?=\K@@S*!?@ǘ?TATTGdL@?TATTG?e_:?$3>y ?Њșt?<'L@A@\x&?5;Nѡ?ATTGANL@`Nn?ATTGA`Nn?2LIqn?hձ?2?i/ ?zP@(@|ap?_vO?TTGAA$5|P@؄m&?TTGAA؄m&?_Ѽ?"?&?f']X?>3R@}8@ ?Ǻv?TGAAAW# S@Ryn[?TGAAARyn[?>,1u?n?\7)g?=?Q@@$.@&S?GAAATR"Q@R|I?GAAATR|I?-CH8Ŏ?@inr?u(?\>'N@e;O@|)?46 >mnīD?y5ݡ?:cN@?@sG__? rh?ATTATe[oN@T2?ATTATT2?px?_Dv?6P@L6?TTATTL6?"\?E E?/4?/2DK? \K@]C @ľk?_vOv?TATTTx|K@(b?TATTT(b?>~e>Ríp?{?T|mdI@(\@}?DJ?ATTTTnI@ ?ATTTT ?ӂ=%H=|%QQ>jT?D.,J@/n@{8N?+e?TTTTT& bI@q?TTTTTq?hc?= I>2^$?lI?熊}I@ r(@"?z6>W[?TTTTTpAbI@ : ?TTTTT : ?;!q1@@=N=BA?&w? ףPJJ@p_9@r(>?-C6?TTTTGЦ榜%J@?^:͝?TTTTG?^:͝?%dp$=y|U> {?-?%J@Լ=@H@N6?_vO?TTTGCJ&.K@ʲ?TTTGCʲ?ISJ>aΑ>zsI?CqWi?!%zO@?@8'c?ψ ?TTGCTEp6(N@~o?TTGCT~o?DŽKHӳ?;Yk?#㥡??lh ŀP@ ^I@,x?&S?TGCTG8yKQ@Ez?TGCTCrzi?s}2%->%`*?0X[W?S1J@x $(^@oS?y&1?TGTTGJnI@ٞ?CTTTAf ?ZjB>Y?H>Sq?Y5?|9Q@&Se@Qk /to@n?TTGAA|P@-8{?TTGAA-8{?% 1j?&<(?՛/?h -{?iΓS@Bfg@Wa??TGAAT=q R@^B?TGAAT^B?w'۵?~?M"?Jm7>C;aP@僞j@ע5?j+ݣ?GAATT`d=P@lZ?TTATT "?1?W %?\e4`??bJ@~jt@'mɘ?"u?ATTTA1{uJ@gP?ATTTAgP?S@> Õ>1"x?w$?It$N@x#y@aF?tF_?TTTAT(=M@ǂj?TTTATǂj?0*+?|(=?p7f+r?~Y?1DQ-cO@Zd;@5]ޗ?"u?TTATT nP@zNg?TTATC;v%?Aª8?'+9?OՃy1??t@KM@U@1?b?F%u?TATTA<L@A{?TATCT5q]P?>K!??>}?sFY?u'O@ꕲ @e?_vO?ATTATb1fN@ka?TTGATܳ?(63??Uo?s|1ϻ ?u&P@|Г@,?ea?TTATTрP@&4?TGATTbrS9?? U/?&??#?3eRK@2w-!@"Y? ?TATTA{L@K?TATTAK?>1?*zo:>c/1V?5?*M@@@k,5?cZB>?ATTAG?9N@h(?ATTAA '0?Ο ?)(0?b]J?Ag31?~˪P@aִ@$ m?Mb?TTAGC;UP@??TTAGC??3B?}*|?C+ۜ?vch?C턐 HP@D@?t59?gs?TAGCC˷(5+P@ڢhuu?TAGCCڢhuu? W?]]'3/?oQ,?0}?mP@HP@Y.)݇?^)Ǻ?AGCCAҌ^^Q@wq?AGCCAwq?E?m$jn?py?o ?bLR@X@`V'?_vO?GCCAGfwWR@<$j2?GCCAG<$j2?SJG@E?BEC3??ֳI?DJl?"yR@G@ޠ:9@Mb?CCAGTA1VR@q?CCAGTq?d>&w?~D L?~j!O@sh@Zc1 @4J9?roh? 4D? У ?]PۯQ@z6@{.g8?8gDio?GTAAT{疚;Q@uL?GTAATuL?]>,?K^?g1ٴ?K~D3z?`PP@S@w5k?ψ ?TAATC pO@7u?TAATC7u?{P[?8?ݕ?|=W?tw?jM@h@-c?J4?AATCG0?ç޽R@( &@Aw6e?UN@?GGCGGtR@:.~}?CCCGGQ~)?#H?$?[?rFbG?KX&̈́P@)@i$N|??` ?'K@.@5,:vQ@&S?GCTTAB;gM@{?GCTTTui3lt?Ƌ7>6vU >Dë?5&?#N@jt3@HbY?{Gzt?CTTATEMs'N@i$J?TTTAT㜀?Sx?/?e ٳ?}J=t?Ud=P@~j4@Y6-?HPsג?TTATT( P@ ?TTATT ?qmF?(d1Z?r*x?&㘱?\K@9EGr9@K`!? 0*?TATTT[^з|K@Pn>_:??˘[|I@Qkw<@':?y):?ATTTG}tLJ@$01d?l$g?Cv,K@/$A@!V?48EG?TTTGC:}prK@#"6?TTTGC#"6?8U>:z ?uG%?w5??FdP@jMS@Py?ׁsF?TTGCT% (N@\rI?TTGCT\rI?ڌ;B?BxWL?\}?K?/Ô?9.P@ ףp]@;?y&1|?TGCTCO%P@"1?TGCTC"1?~`D?k)U?H?Ά?6h:tO@Zd;_@\ޘ?ǘ?GCTCA4Z*XO@].!?GCTCA].!?$?d?JI?{$?eQ@O@ac@PJ? ^)ˠ?CTCAAp*2Q@A?CTCAAA?׬ 2?>MS?Qs?a&Te+?(vb'R@k@/ i?_L?TCAAGp9^Q@;Mh0ֹ?TCAAG;Mh0ֹ?ۼ?dpo}e?Nzyb? ?Q@:pn@.`V?^K=?CAAGAQ@%ɵ?CCGACBq?[?Z*?byC?z)?e9KP@c=y@DJb?&S?AAGAC] P@ W>9?CGACTZNi?/C-?7x?a4?oP?njO@(\@-s?ݓ?GACTT:GO@sj8v?GACTTsj8v?}1?fh?O?MƷ?݊-'K@ҏ@:Q@? ^)ˠ?ACTTC] ʷJ@7G.?ACTTC7G.?n~LT>, /><אC&?W`ǐ?8vJ@47@q?{Gz?CTTCC4+,J@-`Ƽ?TGTCGp~4?u^rY>:V4>pu ? l,?~ %P@*ǚ@+R<@~jtx?TTCCAm*P@5Y?TTCCA5Y?l?G7?A†J??,fsVQ@HP@%k6 ?;?|sd?r녷?:u}R@@7\L?V-?CCAGC4jћQ@] ?CGCACs0+?e 2W?e?C ?ƖA?d4MP@0L @jI?F%u{?CAGCC̰tfP@??gC?CAGCC??gC?q5N?`p*-?,t^?1T%?fGwQ@W/@[?M O?AGCCA!AW^Q@G?AGCCAG? F?:xgi?wq)?sq??6 9dR@@?ea?GCCAGcŻpWR@ΡU4?GCCAGΡU4?T?@u?bg?4v"C6}Q?/?%Q@47@Sj]*?H}}?CCAGCЛQ@^?CCAGC^? Ɩ4? NM? *?Wxs?mhrmP@@Ӎ48-?&?CAGCA}|¥P@=?CAGCA=?I.G?AH?5[d?~bE$/?l7R@w@Ju?S㥛?AGCAGJۼ#R@ j|3X?AGCAG j|3X?LCĮ?t 0?&?áw?brQ@L@:g?m[?)s CK(>/ɢO@)~ @""? rh?AACCC-O@\>?GAACA{g?3P??0b?C?"+(?eQ@1*@`3?eX?ACCCG7)uQ@KD,?AACAG[pB]?5!Z?B`U?M \?@*r?y94R@4@.ċD?H}?CCCGC:~R@pr?CCCGCpr?kK?40H>R@l)@Gͥ? rh?GCAGG&_R@ ukv?GCAGG ukv?SHtV?'Pu?[}F?Ï' ?3N$P@ 2@ٗm?&?CAGGC0/dP@t\?CAGGCt\?isH?qS?gt?yˬb?Q@{,C<@ -?mxz,C?AGGCTFZeQ@,<2%?AACATX82?}%6q?s?K t??(RQ@*:?@ k?/nr?GGCTC󴬼eQ@=u1H?ACATCDu 9?vl? ME?L4Z{?=VƧ?GkN@D@@n?a+e?GCTCC@EN@˘?GCTCC˘?+e?3 .h??7 D?DDD{^Q@58EG@+f'?J4?CTCCGUp P@Ìķ?CTCCGÌķ?.&?`z?Wf:?]1y?ͷ:Q@[d;O@_9?vq -?TCCGCKQ@E\밇?TCCGCE\밇?y?C)!? S]?O?_ÿQ@j+W@E?z6>?CCGCCcjNQ@ONZ)?CCGCCONZ)?A?5:R?l|?=ָ?Q[OQ@%c@M]?<,Ԛ?CGCCTa1Q@}_?CGCCT}_?!_F?S9?0+?C4 ?NV; aQ@`TRg@9 ?Ǻ?GCCTT#ZQ@~&?GCCTT~&?^D?֡?pUY"? ?~DׄM@Vm@ga]/?g@L>*lR?űikD?R-՟M@69?R@@?"?<,Ժ?CGAGGY{+$eR@5.YXβ?CAGAA{?3`_?P2w?ruUB?V%?M O@\ A@l]@( 0?GAGGCGP@g|?CAGGC*9?8@g?آc?x?s8qڀ?Ib|ߑS@ףp=@[,p?5;Nё?GGCAG^IS@("?GGCAG("?!BM?Q@r?\5?]1YtA>ۣxR@2ı@lΥ?r -?GCAGGo\!_R@='y?GCAGG='y?xb?މñ? (?$qK?|j P@@{{?ׁsF?CAGGCJdP@~yJ@׷?GAACACe ?}"?g|ǡ?4\?)?۷!P@[Ӽ@̿ eh?Aǘ?AGGCTG UeQ@9ɘЉ?AACACD?zUj?񚇾? ?\f?S_? quQ@L7A@B/2k?H}}?GGCTA Q'R@=A?GCCCTqu`?C?J?K@?VB$)?lɖf)Q@+e@z"?&S?GCTAGm9 #Q@{?GCCCT5ݸ?8?`:O?V?TnQ?ĦҐsQ@gj@HF?Ǻ?CTAGCҹc)Q@ҫ?CCCTCZ ?m?Bφe?ȳݪ?3Fnv6?}A{?~uRe6P@x&@EUhX0?+eX?TAGCAP@ ]h?CCTCATW3?HmPx?*i%Ř?27~O?='1? R@/!@d@S?{Gz?AGCACEK"R@c4Xg?AGCACc4Xg?, ?ٷc?/KS?`ewu?tP@Q@L Ư?ZӼ?GCACC*~eZP@tdͧ?GCACCtdͧ?Y)͝?֠#d?<5?1V5%? rQ@/L @5;F?y):?CACCA8HT7Q@7k?CACCA7k?V ?ӆM|?l;?2z`p?z S@Aa@ɂ/Emt?~jt?ACCATƝSR@&)Ҟ?CGCAAHN?0~/?h?tQ#? 9 *?]<Q@[B>@UJ׬?ŏ1w-!?CCATA r\Q@%e?GCATAg,\w?8CZ?f?;j?az?ݰٞaP@x)@Br<@ǘ?CATAGDTgP@3cKɇl?CGGGGc~R?*Oh?[s?cA9?=Ȭ?Q>A#fQ@X21@K[?y&1?ATAGG26mqQ@4ӹ?ATAGG4ӹ?p[?+ H?_q?LVG?^vP@}гY5@4Irv[??W[?TAGGCafLvxP@F+&V?AGGGCβ̓?ĸ?6X}?0} &@?OS|?}bKQ@Լ=@md!?{Gz?AGGCG kQ@G ry ?AGGCGG ry ? ?? ɲ}I5?}Q?Dq[?=X8S@??@LH?UN@?GGCGA8@h9S@0]Jt:?GGCGA0]Jt:?.O?` ?$R?d։>\H/Q@StD@)'?~jt?GCGAC AQ@/ ;?GCGAC/ ;?aխv?Y ?|ڛ?1*!Q?P@&†G@הݢ?ŏ1w-!?CGACAGI_P@V'[?CGACAV'[?Ax?34]c?21h?e>?-uQ@xI@@ F%u?GACAAYQgQ@pꂵ?GACAApꂵ?cf '?=F?>T?l 34?Q@FGrO@<>@?J4?ACAAA*>Q@i$c?ACAAAi$c?H8P2K?|Ct ?gU?JHXk?5uGQ@R@n%U&?Pkw?CAAAAwQ@ٙ|љ?AAAAGS0>F?٥DH??WY5?:vҶ?}ZQ@c=Y@{Ϥm?HPsr?AAAAG,k}Q@{SZLl?AAAGG%|L?gnc?Mv ?n?yJߨ?]*R@PkZ@?`Qk?AAAGGK,QQ@zY?CTAGG6?B%?7)r?i?+=P@9#J[@$?=U?AAGGGX"Q@ˬY?AAGGGˬY?H?Pc>? ԇ?2/M?]]]R@l g@x?`Q{?AGGGGWQ@%yݠ?AGGGADU?c?ѓ?co?TOi?(\ uN@ ^i@DS@J4?GGGCGP@\z?CGGGCq?|^n^?(\걦K?ql5?nuȚ?BBR@.q@ ڹ?Oec?GGCGC52dR@!K/L?GGCACYO%?% ?}G&?|oa F?$A1?P@d@N?DJ?GCGCTKmQ@W~?GCGCC"?td2,R?HzQ@e;O@Q? ?q?CGCTGU^>Q@1}m?GGCTG4?yu? &?6owq? ;4ǁ?++:O@6;N@6[?kt?GCTGAdOO@.];?GCTGA.];?'ō?)Ԑ~?@5'P?F&Hx ?^l8_P@HP@dm7`?n?CTGAG@ nP@?CTGAG?hD?H>?st?׍U?J'R@qΈҞ@0qظ?gj+?TGAGGtLR@a *?TGAGGa *??:? dᰱ?)?oltQ@+Ф@o\?<,Ԛ?GAGGAupQ@.0j?CAGGAwa?G-Th?iz?]N!G?YV ^?u,N,T@6^I@Ǫ>/g@ ^)ˀ?AGGAA4aaS@7c_?AGGAA7c_?Z?<co4?z.@-?! $=nK;S@ c@ t `?{Pk?AGGAAsCKaaS@'Ds?AGGAA'Ds?j:m?ԓq#?}I?BV a\> BT@F@>|m?Pkw?GGAAAʞT@3?GGAAA3??n?fǯ+?yTq? 3ƕ=NwR@!u@bl?Y5;N?GAAAG}G9R@h,L?GAAAA?ܹ?\']3?ϚS\M?b?~3!V Q@2@M@ v?y&1?AAAGTTfM'"Q@OKG?AAAGTOKG?I?{5Su{?&Ʊ?xՏX?m TN@V-@0h0.[?Pkw?AAGTAXO@2 ?AAGTA2 ?8*v?Ý,&2?8Mt_?6*?fffvVN@+@#Y?-C6?AGTAC5 M@a5#?AGTACa5#?9S"j?gKa?9 ?j?'ZP@c]@S5?HP?GTACAwP@e#%9?GTACAe#%9?\WSeʣ?I7?_rʔ?6?ThnQ@u@]p?]K=?TACAAJ"8,Q@Ջ!!?TACAAՋ!!?^L?sKE??-0ޘ?VjR@ h"l@}w?_L?ACAAGJFςR@(ҚI?CGCACJ_U?|Aby?x?n(M?$;@?R[P@s@,3W8p?_vO?CAAGCdP@7B?GCACC?T'?oo?Qь? Vy?^N?j*)f>Q@b@?'K[?2%䃮?AAGCAٮP@ŏ?AAGCAŏ?#o?L?Gr$(?H,\{R?,R@uq @| l?b2U0*?AGCATwjR@{#~?AGCAT{#~?pi?&Ы?ڹ ?^e!?>P@@IFXo@ׁsF?GCATCOP@+0>?GCATC+0>?w?qX~?Gj?gur?a `M@X@|]?L=U?CATCC' a M@,?CATCC,?2ô?"`?n߯?8[1?8?sQ@\@?mxz,C?ATCCA"04\(P@?TCCTAx?oo'?a*^~?6?(E?VeQ@ڊ%@QɎ+?/n?CCAACP@/t?CTAACU ?[Z?q?WzjM?H?5kr&N@ZB>(@f?䃞ͪϥ?CAACCU[O@鸵:!?GCTCCsIF?/?;?x'H ?qae[!?2قP@&3@|@?_vO?AACCG9\ 5P@Gġ?AACCGGġ?=?w.y?D??`~$R@5@QD19AF?St$?ACCGA0}yAR@;J?ACCGA;J?ʤɭJ?ݹt?W@y?djwJ?:8R@y):@Ĭ,q?ZӼ?CCGAAWhR@?CCGAA?}?;'b?'H ?W0Y>V,R@Bc=@I?<,Ԛ?CGAACeDQ@fWP?CGAACfWP?w^?S]I?mI'?x~><k2N@ioD@헫7?St$?GAACC[N@ة:?GAACCة:?ui!?<#ye?tHIGS?e7?aO@:M@IaJ?ψ ?AACCTe'P@e`ٞ?AACCTe`ٞ?g|Q*?jv?%? ۜ?$-Q@X2Q@D>A?+eX?ACCTAnElQ@7B]v?ACCTA7B]v?Y?V?eB?a6?JҨP@ OT@ dC?1*D?CCTACu`P@9M?CCTAC9M?M*?;l?U>Y?_̼g$?Q@.!l@w?j?Y5;N?CTACA`@Q@+?CTACA+?h?Yq?r6 #hfQ@=u@tsk?b2U0*?ACACA,[kQ@ )?ACACA )?562?dv?c?ȇO ? Ͽ6R@o@`?H?CACAT7D/R@jI;n?CACATjI;n?z ?f?J,X?~[r?uvhЩQ@ݓ@q?Pkw?ACATA`yQ@O?ACATAO?6K?U8B?<{e?HgsU?K~jP@2ı@^Qo?b2U0*?CATAA%ۡUP@6úG?CATAA6úG?E 7?aɒ-?#?zu2??1ǭ.Q@x&@X ?J4?ATAATd%xQ@:?ATAAT:?]3??lK9? ]c??أpAP@jM@D3U?_Lu?TAATA1xP@54>?TAATGbW?30?q9&l ?N?g ?Gh&N@3@XJ?ŏ1w-!?AATAT9,O@ F?CATCTWm#?>?/Eq?؋?_V`?]/P@JY@gZJ|?ZӼ?ATATC%nSO@ě*?ATGGT|-`?p?0߈9?I?Fy?XsaN@H@xR?j+?TATCA:zN@j?TATCAj?2ۊ?ηBm?)c3?KF? qP@C@d+?Q?ATCAT&Q@Ŗ"?CTCCTA z?n?N?`"M?Nn{߼?=%%*&Q@Mb@&C ?HP?TCATTNfuGQ@V!X˄d?TCCTTM?8v?ꝕ0?}Z:?7?}\kL@镲@@?ψ ?CATTGr uL@3?ACTTG$vyd?@F{.?.)>w%'`x?&^?>2K@!u@v99? ?ATTGC&1-IK@ۢ?CTTGCCvj?DŃ>,)Y6>?LvL?($ZN@Af@&?ψ ?TTGCC _\u_M@~ B?TTGCC~ B?fGH^?k?h*C?E(լX?I4Q@y)@t0~?ǘ?TGCCAFhvQ@X&?TGCCAX&?,2qϦ?r?Wpz?͗X??;/.cR@_vO@/8?n?GCCAT8[JR@5㚊?GCCAT5㚊?+:5?p?Xz/?k8?_{gQ@S@/4s#?{Pk?CCATGAmQ@Ō~?CCATGŌ~?+#3qN?g؍?U4螹?0b_?L@@dӍ -?<,Ԛ?CATGCG")L@id?CATGCid?C"?A?AS2>s-c$T?C?C O@U@mg2?/$?ATGCAp[ O@~Hy?ATGCA~Hy?.0N{?m|?uI/]?ô}C?&1R@ @W]3R@Mb?TGCAAVR@u?TGCAAu?72-?L9?C'?W5X> >Q@1*@E??GCAAAT̀)R@/A?GCAAA/A?CU?[` ?0&Al?>S V0?6P@v@l?HP?CAAAC,8P@"ޘ?CAAAC"ޘ?u?G 6?: , ?h+ar?j7?O@x $(@P?`Qڋ?AAACTAr??Y ?#+?333@R@W@%N?b2U0*?CTAAG3R@$?CTAAG$?U|ǹ?Ho?98 ?Efou?_9Q@|?@& ?5;Nё?TAAGT 8χQ@V?TAAGTV?Wն?[G? [R?ŭ{Kp?= ׃M@|г@"h=v@-C6j?AAGTCL@@p?AGGTCgyv:?qG? J00?g ?6-_?QJ@ޓ@G<"i?-C6z?AGTCC=pJ@Mx?GGTCG&V?ki>)x}i>4N?`TFS!?zP@(@*sz??GTCCTѾN@(>?GTCGCbNGϳ?y?Pt?2,/?ủ `?axQ@+e"@09?(?TCCTG:H*Q@=Pv?TCCATb ?;/?;t ?3)?yV?so$&QM@ݓ'@,z8/?"u?CCTGC bM@Z{л?CATGCs ?jz>?Mu8J?D\/?Ԕ 5"?C_&O@t+@=&??D /R@jM3@y^,?o_?GCAGCh:Q@p?GCAGCp?N{Z?ݢ7?4zD\?|5;?x}P@Q;@ɮ?~jt?CAGCAF孂P@~5OCo?CAGCA~5OCo?dD?]?H!? ̢?8~sR@\>@|?+eX?AGCAT·jR@#'?AGCAT#'?ҺM??w?o]?GQ@7D@r齳?_Lu?GCATA&TG1OQ@Ek^?GCATAEk^?\i](?z5*2? ?qE'Yjk?Fj)P@F@Hu?\ Ac̽?CATAAH% OP@qH?CATAAqH?"b?;uLl?P[{?u]|?RMQ@%c@9?&S?ATAAGp3Q@1)?ATAAG1)?-_?)?wAyIJ?ed'T?JIqP@h@.R?q?TAAGCXna)P@^ ?TAAGC^ ?c|`?Ji?Y5~^? W?WyTgoP@Lj@Q1.?NSt$?AAGCG<ǞP@c]?AAGCGc]?~@ܷ? NZG? Oh?E͵o?$R@`vOv@4WN?:v?AGCGAjER@@u?AGCGA@u?oM?@1?Bѿ?* Q?7sEoR@?|@5F3D?ׁsF?GCGAT;@yR@I8[?GCGATI8[?i ,?KZh?t$?X&?MP@ׁ@]R @`Q{?CGATC8'wuO@X`?CGATCX`?VӖP?8;(>m;P?Q"}>n4L@%@9eo??H?{Q@=@;?`Qڛ?TCCCCcF Q@6P?TCCCC6P?b ?%@zf?gs?TAATCmG0#O@n+ ?TAATCn+ ?}&rV?‚Fz?)"?d-H?Y(BL@+e@'#2c?HPsr?AATCC{@mqOL@ 5X9W?AATCC 5X9W?QL-,?բE?nZ.f?{p?*#O@d]F@bjd?a+ey?ATCCC3Դ%jO@=4VdF?ATCCC=4VdF?)u?J=?+wη?^#0R?T3F_Q@/@)?EԸ?TCCCAg0oQ@r:?TCCCGhe??C/p?E?3?H6[u?OR@V-@D?b2U0*?CCCAG1YR@ӎh?CCCGA=?nf)a?c?'$?\ 0>-A*S@aTR' @a?ŏ1w-!?CCAGA'=ܜR@IҲ?CCAGAIҲ??_?zs)?9oп>Q@- @9 E?vq -?CAGAG10-Q@ڶ5g?CAGAGڶ5g?t?rcZ?}ɪ ?˿ S;?XKR@t @q<"?H}?AGAGAmSR@Kl?AGAGAKl?M?*?{{?}{y>\)Q@ͪ @P?0*?GAGAT>> R@$A ?GAGAT$A ?shn??ľY]?H2$?rP@D @i_X?I +?AGATG >P@?AGATG?bpQ?ֱkO#?W2D?|'wr?1v2ĭN@T @{ՌX?|a2U?GATGA ANsN@qм?GATGAqм?"?:-k?:?^C'?=|CguP@f* @&yL?St$?ATGAG.;P@Lg?ATGAGLg?mU?޹j?$?lCcؒy?ƄcR@/'/ @/P8?y):?TGAGTR@puܮ,?TGAATj w!??$?nY"|??P 9? P@ˡE3 @1NͭN@"u?GAGTTz;ru)O@-:F?CGATTq0e?N?fy? HMD?G.?DJ@I}8 @:-#D? Zd;?AGTTAr#6K@>Kȑ?ATTTA?6~>ɰ(>)ˋ?%ll9?rWإN@W/G @1@ o_Ή?GTTAARM@Qh?TTTAAܧE?O i?ӈ\?Ӟ??|lQ@EJ @`?H}?TTAAT(bQ@yhUx?TTAATyhUx?Xb'0?jS8?JjUYЦ?V"?UBnP@nc @Bmw? ^)ˀ?TAATC< zO@Ү?TAATCҮ?2v~?o)eL??3$^Է?WxEM@a+e @OW?a+e?AATCAgYɝOM@ ~?AATCA ~?ΝƚW?8=]?;w9?^}m?QP@=yXh @(9?_vO?ATCATVX5Q@ @?ATCAT @?YG?F Z?nYo?DK?qjQ@r m @ .?J4?TCATA_ѐGQ@| ;?TCATG;SIPo?`m?f?g+??lYO@zv @=R?MbX?CATAC+)O@Q&0?CATACQ&0?ZA?GJ?98?1M4Z?bJMfP@ҏ @ʯ?y&1?ATACCD%P@oj?ATACCoj?<7?"?U!?dG?o)&P@/! @z!#/?"u?TACCT鳫ѸP@$??TACCT$??(=ˬ ?;1?4}M?G?7n3NQ@*:˟ @w?/n?ACCTGG9Q@fȵ?ACCTGfȵ?KX;?!?bu?Դp9r?eN@_I @ um?q?CCTGAO@st@??CTGCG% ̪?2,~I̩?S(m?pw(?Ɖg5oc?=R@0L @?i?ǘ?TGAAT,,H۴R@e?TGAGT}<ױ?Ȼ۸?/No?.>c?~@.G?,6P@V @䦹?F%u{?GAATT)e=P@oD;?CGATT3M*&?oc=?C@?WShm?^1?7SK@ @Czfx?_Lu?AATTGћK@vZ?GATTGC1y?wCj?%p>x%?#!?9 +M@>W[ @1?Q?ATTGA;gPL@z 1?ATTGAz 1?p"#^9?$P T?1,?=N?9yR Q@|a2 @Ֆg?_vO?TTGAA@bl|P@7T?TTGAA7T?+? jJ?I_?؎^#g?eK R@?Ƽ @ Cip@?TGAAC\kaQ@x?TGAACx?zMj?d?(J?=p{?k6O@yz, @G61r?ZӼ?GAACT>biO@:.M?GAACT:.M?#Ҋ@o?j_ɳ?QJO?]?}|O@Oe @od?HPsׂ?AACTC?DAE?-c/ZԢ?ߚ]g?NLP@ޓ @&f?_L?TCCTTs)P@ΗO?TCCTTΗO?{e0}?-QU?V\/C =0{?EB.?jzJ@D @.?hs?TTTCT3XJ@ ?TTTCT ?Inh m>) C9>ȗeB?ֆ'P?9O@Z!@l?*?2%䃞?TTCTCy5O@OL ?TCTGGv+?hEe>?DJ?S~C%?NIL>?Q}P@~!@J?-C6?CTCTT0 YP@ʩ?h?CTGGTq?G7g?n O??5@$/?! }M@dZB!@0L\??TCTTG|}gL@bEĩ?TCTTGbEĩ?UI?\G?)f`??GE|A5K@:!!@[?ǘ?CTTGT+FL@I?CTTGTI? 8>` >0 ʢ?'w?X9#L@8A`%!@%`_?Mb?TTGTGl 6L@: I?TTGTA ʮi?/yx>\ïј?%D*?,wЄ*? N@x)!@b7_?#?TGTGAݽL@7JZ?TGTAT?/ !W?osf?H_RX?v0n?yJO@Qs7!@NV?/n?GTGATUpO@&?GTATAQ?o?CTCAT !|?ݛX??d??D*wu?^f P@9C!@HF ?oŏ?TAATGK\P@uy?TCATC4$g?dл?x'?\k?9?,M@pT!@gCݱ(? ?AATGAN齑 8N@?CATCCk=?1?۞Ɩ?aUF?m5?`raQ@'1\!@!0 ?gs?ATGAAAeP@)bM?ATGAA)bM?1SU?c8?޺?B8-v?yJgS@+eb!@K4`+? ?TGAAAc!˰S@{0P*9X?TGAAA{0P*9X?>;?7?7u>8?ۗD>d:!RR@0L f!@$Ua?+eX?GAAAG,йR@>*@^i?GAAAA1?T %?t.GĠ?;)lzD?LJڨ?z5,E7Q@,ex!@{6P?H}m?GGCTC.pteQ@>~?GGCTC>~?[K?0yM??@D?̥O@p_y!@Rb=^\?ec]?GCTCA:O@\?GCTCA\?x?Hu?L*?J20W?A. !Q@#!@),2??CTCATPԟQ@f xe?CTCATf xe?v+dS?EM]%?Uϗ?yX!@ ?Mb?CCCAC%L*R@ [ :?CCCAC [ :?H۠? !?%ѿ? $Zm?LqQ@bٝ!@(Xp?NSt$?CCACAK{Q@o K/?CCACAo K/?\9?rjxi~?JO?x\8 ?۴oR@k!@Ӹ`?䃞ͪϥ?CACAA.טgGR@jlts?CACAAjlts?{o?ąc?\|.k?ӷ Z?qP@NS!@;cS?_L?ACAACсP@/p~?ACAAC/p~?K>?,Q1?dz{?bhV<6?kO@/!!@v8_?UN@?CAACT鉌O@x Ȼ?GACTTfrU?fFA???d?l8?4܉>Ff*I?}C1$"?:*ˬP@H!@ŀO~?z6>W?CTCCC.zP@y}?CTCCCy}?q:Zg}?Oy?G=3?>u?O^Q@E!@ :Q7?HP?TCCCGxgQ@)~(?TCCCAO0?\?G?聼^?29*J?J M>|?98x>WP@+!@Z?y):?GTAGCi@FP@NJ0On?CAGCA;p?ԝu? X,?s?CSC?]`gcR@߾!@Rva!e?l?AGCGG.k\R@;v?AGCACƻH?}7?5,?LH-?\,J?jBz?ɋwN@/!V"@L!Bd@{Pk?CGGTA>M@"G?CGGGC5;k?\x?O}^]? `?Wf·?־aQ@k+]"@?-? ?GTAAA$ENQ@: ?CAAAA`J?YP??wP=ʷ?]*X?1Q@K7a"@6|? rh?TAAAG5ŸQ@ep?AAAAGȀ?=ݽ?""?V?z?`veQ@Se"@uwS?( 0?AAAGT "Q@sy0qa?AAAGTsy0qa?ɫ?z? .?}n!?\ܛ|L@{r"@h? ?AAGTC'h6L@=uc?AAGTC=uc?]>?jGI v?5C}z?r֑?}I J@2Z)R?CGTGC2Z)R?xC,t>T'r>la{?,mc?pM@ɥ"@V{9I?UN@?GTGCTOGM@=V2?GTGCT=V2?N7?4K?/?!*? %i?)\2RgQ@0"@5;K@-C6j?TGCTGKQ@m?TGCTGm?2^O?G˿?}, ڵs?rq?K~"O@gj"@BΡ?b2U0*s?GCTGG O@WzS?GCTGGWzS?f-_?$l?w+AR?3O?CO@mxz"@@c?vq -?CTGGTP@x4~u??CTGGTx4~u???t?ʅH?دK?w?;YM@{"@Us?Ǻ?TGGTG*jN@;mM?TATCT[q7?v%Nr?5ȟ1:j?Ny???ڙ5?F:N@("@﷗'@/n?GGTGTl8M@qiwzֺ?ATCTTO?׶S?zfo?!-?,H_?,K@Bi"@hZ??ܵ|?GTGTAYEq)M@Ob#(ߒ?AGTTAԊ6[̪?H5>QY$>"T}?X3Q?'8p}>)i~z?B?9.XK@;"@☢b?y&1?ATTCGK@!V?ATTCG!V?Ab>QU0? 8X? ?oAN@_L"@=9 @ ^)ˀ?TTCGTfBlP@3~?TCGTTqST?8wU7?J~?486?i 2i?I-]BWM@3ı."@B .?fj+?TCGTTxM@?TCGTT?MU!d]? ^(?N߲Z?| ?\I@ Z#@哖|?_Lu?CGTTAᖂI@~?"?CGTTA~?"?c>A>oOm/>JU?ɧ&?bX9ViL@1#@,'::?Mb?GTTAChµ[OL@k̚?GTTATqTP?Bm>y=X_?WS(~?Q,?lDP@W/#@k+Si?p_Q?TTACTxK~SQP@ ^?TGACTԸ?/ Z?`D:?AayNR?`?^*-sO@[Ӽ#@jo ?ZӼ?TACTT P@k,i?GACTTdk?N_޵?7:7?#wJk?lC?} 2M@2#@T}? ^)ˀ?ACTTGXc9L@Gc?ACTTGGc?"Ok7"?a-(?'9(??42J@46#@˸?HPsג?CTTGC|7ʜ6K@e/O?CTTGCe/O?0\hp>Ex>|{?lxl?l.M@D #@'Sn?( ?TTGCArZEN@w*?TTGCAw*?kra ?kIƽڐ? ?>6?<γR@m1#@ (?S!uq?TGCAGF\YR@gx?TGCAGgx?|kX?w \? U?~rh>)\" 5R@~b?#@O*z?b2U0*?GCAGC5+Q@f ?GCAGCf ?]|H`?B?'?B2͌i? ף P@A#@;[- ?-C6?CAGCCx{)P@N.?CAGCCN.?qQ?wť?rp?S?,Q@QE#@׶Ř?<,Ԛ?AGCCGxWLQ@6?AGCCG6?%U(_T?; B?ѵX?w?YH+R@qH#@?b2U0*?GCCGGthXR@7uA?GCCGTg?z 1?*h?m&կ?u;8k?,M@ R#@γ@ZӼ?CGGGC`VuN@q{Tc?CGGGCq{Tc?_f,+?ɞ(5?ewI?o *?~SǶP@_LU#@K8;T?V-?GGGCAfQ@LC?CAGCA>?DNZ? ?ԓ?Mf'Ɩ?|?R@2%d#@Z($?Mb?GGCAA/D+US@D ݾ^?AGCAAljG?Á?d*?;?יB?3tQ@1f#@Ap?vq -?GCAAC;U7@Q@L9?GCAACL9?%anc?o\qդ??pڊo? cO@_v#@K9N?<,Ԛ?CAACA6:9P@-GOx?CAACA-GOx?$Ѩ} ?9O?r ?Kl?Q8WQ@Լ}#@Njz?HPsג?AACAA%\Q@ ?AGCCT9`?h?ȎEh?0 7??1MP@ʁ#@ƭG?_L?ACAACעqsP@FƀX?TAAAC ^?8#?m?xiݨ?w;?bnHO@St#@z" ?&S?CAACGîDP@ {?CCTCC>@i?eN9?L&4W?v!-ס?$N?;f"P@#@H?J4?AACGCb P@Cz| ?AACGCCz| ?UB>?f%?=C4?A-M?=4Q@C#@-}|?ŏ1w-!?ACGCA2 Q@pɝ,?ACGCApɝ,??fgqW@?T)9? b9{?$:B6R@<,Ԛ#@t\0?a+e?CGCAC2;Q}iR@Ͷ`N?CGCACͶ`N? <#*?o-h?ώ4P?y?ˡE6bP@1w-#@ R^?Mb?GCACC0h%P@M!8?GCACCM!8?fW]??`Ű?ʟw:Q?.Q@9#@ 2?/n?CACCAk7Q@`nԇ`?CACCA`nԇ`?T?eHK?X!?Mt(?~?_L?CCAAT(PQ@A'^V?CCAATA'^V?nDĈ3(?)E i?_Oå?7pS?Bx^HP@u#@b/g?Q?CAATAkoArP@Bb?CAATABb?ߪ #°?an?3?TO?̗>N@n4#@S3At?=U?AATACтN@1L?AATAC1L??d_?X?h~Z?tZ?R~P@V#@Tio?/n?ATACA6Ð5P@/?ATACA/?/M?^yÄ? ?2Rxq?׭P@|a#@`6?_Lu?CAGCA^P@e:?CAGCAe:?[ui{?_P{-? WB}?KAQN?qR@ˡE#@zUOL0?_L?AGCAAR@-`?AGCAA-`?LKk?D?M9y?jd x)_?7,O@_#@wM~?"u?CAACA<6P@6dH?CAACA6dH?{&H'm?Rʅο?1ι(??ޤ4W?=`UT@x $@»(@/n?GGAATzS@[h?GGAAT[h?A.?of?=zR?7-;_=˫7P@)~ $@4q^?0*?GAATA3'4tP@Í]@¿?GAATAÍ]@¿?tEb+1-?a;?s~W?\08?l'Q@ʡE$@S#u>L?I +?GAATA 3tP@sa` ?AGCTC ԅ?Z?)&kBI?q$Z?~]?mYP@+$@dI3?~jt?AATAA`P@NfpQ?GCTCAZh#?"="?PqX?sG?3o?WQ@Zd;$@Z?z6>?ATAAT5ؚxQ@ҿs?ATAATҿs?%nrt?epO?׳?Tl3?K~1hP@Z*$@(B?b2U0*s?TAATG`C\P@Ğrt?TAATGĞrt?4h-s?? )Rq?`Su?\b40*M@_L,$@ L?&u?AATGG!1N@ }S?AATGG }S?Q1?#9zy?*L9*?cV?`fPP@3$@r-aJ2?Zd;O?ATGGTr=TP@m?ATGGGU[?k?Em>?ݤuC?I?5t"wO@b9$@ K?:pΈ?TGGTAP5?K,2ƪ?9?^jO@y)$@Q@/n?GTGAT0pO@6P?GTGAT6P?AXy?eH?|$?2%l?_5YP@z6$@r}b?R!u?TGATApݥP@a?TGATG:1?FD?+ 3?)(?ݡtA1?+#N@ $@ 8u? ?GATAC¦N@8xI?GATAC8xI?_7惖?vAɛ]?W4GQ?'3? 0 P@,e$@S?{Gz?TACTTv[၏P@냌?TACTT냌?pe?9 J?cw?*+Xߌ?)J@$@ 4?Q?ACTTTRwK@M諆?ACTTTM諆?G/B>HB,6>?5Y?R5I@ڬ\$@Q?-C6?CTTTCH8H@#9 P7C?ATTTCo?5z=iF=- N?V[??*%ʙ֒K@> ף$@Ut"_?_vO?TTTCAGC3.K@62?TTTCA62?|vA"qz>MtKD?%O`n??[?BzP@j+$@F~ŕ?<,?TCATC!P@:q?TCATC:q?b?zN?^Q)}?mȳ ? mN@L7A$@MƸh,Z?Zd;O?CATCGlN@J&&a]?CATCAj"i?;?B\K! ?H1D;?Ԧ??m=1Q@/$$@Z!>?8d`?ATCGAA%;P@Oa@^?ATCAA4A?cs_}:?5%e:olQ@?CTAAC`S_U?_/ ?T`?|x?Uա?zP@|г%@G)є.>?-C6j?GACTT#OO@HZx?TAACTڸ&?Gcz?N04@?|T@?c[gl?3V_M@ޓ%@B?@Ǩ?ACTTA)ͮ/M@>$Yh?ACTTA>$Yh?xqn?& #]?ݶ4:?*?QߦO@x&%@^nI^h?_vO?CTTAAKʫ_N@?CTTAA?v/? `NF[?߳ `?O?a˹P@.1%@)}pA"?+eX?TTAAC^ǭP@pV@w?TTAACpV@w??Yڹ?ijI?Uʏ{I9?IGqN@[Ӽ4%@i u2?Af?TAACCqGuM+O@=vBM?TAACC=vBM?i3?Bp1?D#?ؑ0?1[ĥO@Tt$?%@ut?ZӼ?AACCCDӁO@ Rx?AACCC Rx?s#?1C ?6Fayz3?nsJ?uQ@9C%@??{Pk?ACCCGE7tQ@EZ?ACCCGEZ?SU?m` ? U?Ƽ<{֒?r ^R@+I%@On@n?CCCGTL1FtR@|,?CCCGT|,?ƒI2??{ƚ4O?QHĬ>ߦ5IK@VL%@oRN?S㥫?CGTAC!bL@ !?CGTAC !? 8?K:+z>"UYh?Z ?FXnZO@y)Z%@4B??GTACCRO@H?GTACCH?Z{?P ?b?i?ŠG`P@6`%@vxA?<,?TACCCX2mP@(찉.?TACCC(찉.??P ? qI?V r?uQ@b2U0j%@> ?gs?ACCCCQ4Q@ %$?ACCGC!8?\e$?F.Me?#8?Y?ZoQ@l%@a9\C?_vO?CCCCT,ADIR@b l?CCGCCd[B?i?VHjM?]?Fþ?q.ϾQ@ͪo%@9oj?"u?CCCTAnW{Q@ϳ'C?CGCCTQb?l:h?Z?fy?%8Y¦?C:Q@=yx%@2|d=?Oec?CCTAA6c}Q@?*?CCTAA?*?$?@jR6?n}Ȗ?>S?EPK?Q@J +%@fck?a+e?CTAAC9V)S#Q@*갛?CTAAC*갛?)?ZK##l?+?^t:?&^5P@;M%@x?ψ ?TAACA]бQP@ډCY$?TAACAډCY$?[?aY7?υ@>?i- y?ؒɶP@8EG%@m?j+ݓ?AACAA+`H[Q@Nj?CTACAXOa?~`Q?%q?^!ۍw? ꃾ?cR@z6>%@d?tF_?ACAAG8 FR@ˋN?ACAAGˋN?ޓ?k`p?(?oSϊ?-GTSUQ@ű.n%@:&es?o_?CAAGGZ'Q@<#?CAAGG<#?b}?5"?cUu?f?^2NP@$%@K[@_vO~?AAGGCȆlP@~ j.?AAGGC~ j.?6gמu?U?4d("?*O?)Q@"l%@q:?mxz,C?AGGCAQ@Ƣi'ؑ?GGCCA&"S?qA_ ?R?%ڗ??ycR@H}%@kլ?Ǻv?GGCACI4R@ ?CGCACjl?~ ?bK$?Ŷ?|;?@yg Q@\%@?IX?NSt$?GCACC)=P@#2G?GCACC#2G?Mgt}g?p!j?`5?ιs?Aw`P@#~%@T?:v?CACCCzfo*Q@:Gx?ACTAC3O.o? ;?f*FI?=UH?OX?'5P@x&%@Ұ?Ǻ?ACCCA.(6Q@׿^?CTACAlTC&?o?B27?F`P?^lܱ?ÖYXR@%@x 5k?&†?CCCAC)rR@-W44?CGCCA`a#H?i*#s-?omI`?&]X1?>(r?ݚLQ@؁sF%@~W?V_?CCACGo8kQ@a]Y|,?CCGACQVd?G2bn?uŵ?JaaT?*<{?#dP@/L &@Mu9?V-?CACGC2jQ@+T?CGACG@I??d?˶?E,v?o\;?oR@s&@zI?"u?ACGCA⛼ Q@ ?ACGCA ?qH?3j1?Mh6.?\3vp?}R@z&@l?Cl?CGCAC`X jiR@ 4oĥ?CGCAC 4oĥ?;є?}dalO?鏄?C?{U3cQ@|a2&@@t5#?w-!l?GCACA NSQ@(?GCACA(?x? ?xH ?"?MHH??q-KR@:pH&@*CP׆?M O?CACAAf="GR@ɸ?CACAAɸ?5xaL?Ò? z?v|E_?.iQ@&S&@z#N?J4?ACAAA_Q@?:?GCACAzXhK?[":? :?9@?Lj|?mQ@QsW&@J=?q?CAAAAC/Q@~?ACGACxͽ?ћS? A_n?{…J?&?Yo[P@"uq[&@yԡr?/n?AAAACfzP@2{?CGACC:7W??Y?$,Dѵ?Mg?tm$+P@V-]&@ٔ?HP?AAACAl&tO@kQu'x?AAACAkQu'x?/2YO?n|NE??n?]w?%PQ@\ Ac&@s?a+e?ACATA _"yQ@˄;?ACATA˄;? ?' b?r©?I!?MwP@MJj&@Zk?Mb?CATAAW5P@z뵌?CATAAz뵌?>?vp+?m<뉰?5M? ЋQ@{r&@g>b?_Lu?ATAAT~MxQ@{?ATAAT{? 0"?T=?n:Z?Q"9*?OxP@|s&@V!؄?Mb?TAATC%>滹O@:K]3?TAATC:K]3?J"jI?=K?o ?cw?aU UL@sw&@'AE|?(?AATCCedOL@:m?AATCC:m?7 ?(?4;.??v!P@ec}&@P:?ZӼ?ATCCG!PP@?t?ATCCG?t?a ?1?5?n|_?ezR@/$&@#?M O?TCCGA`-R@X0T?TCCGAX0T?$w|!?/=?Ș w?j-9?R@c]&@F? ?gs?CCGAAcX WQ@^)ː&@ o?Mbp?CGAAC"ZQ@lG?CGAAClG?)j$?/l_̐?1l?wU"U?zTTP@;Nё&@eG@v??GAACAGO@$+#p?AAATAD%??.s+?"!G?s?a"?, RP@pɔ&@vPn?vq -?AACATu}RQ@nlt?GACCAfڳ?)???Rdu?ٻ?;o6Q@Ԙ&@ dQ?\ Ac̭?ACATAc^ yQ@S@?TGAACUE8uI?%0=??~Y?{Z??ܑbO@W/&@g~?S㥛?CATACPsMDO@|| 4?CATAC|| 4??^m"?WbF?Wr ?-j!#Q@U&@g›3f?~jt?ATACT LdP@FX?ATACTFX?}7?G0h^?aI.j?Ҝo.?4䒁P@_&@Ά#?J4?TACTCgFguLP@:|Cs?TACTGv-?Iz5; ?Y?\?['!L? N@ޓ&@q1L?_L?ACTCCB O@)값?ACTGT' c?=ei?@jĥ? 6/?Qc?Gr+R@/&@R ت @{Gzt?TCCGTeιQ@pݚ1?GGCTTz#[? btU?{{Ϳ.i?t߬(,:?||O>te4M@:v&@F)|t?"u?CCGTTh팷M@%s{?CTGTT_N?ys1X?N,?Z?*?}? O<~?}K8J@1&@) ?"u?CGTTA{ZI@fɪ?TGTTAzй2?:xt>FEP>rK?'O? t)pL@lV}&@{?H}m?GTTAT,"? M@]L?GTTAT]L?AI>~(T?m?萒?5u3\D%> g Ut?Vr?:47H@X&@?j9\?Y5;N?ATTTC{ 7H@X?ATTTCX? pE=kd=?g?d><J@v&@W ?<,?TTTCTJ@\?TTTCT\?r |=t2>{^C?a =o?`!xO@g&@:_1?<,Ԫ?TTCTC9O@3?TTCTC3?H@9ti?3K?uCt?-W?I:>}3O@T'@A/f?q?TCTCCKZ!DO@#O[~?CTGGCps?5E?* ?BC?˖!?UgO@S'@?_vO?CTCCTG@5P@?n{?TCCTG4H*Q@Y: ?ACCTG֥T?6J?f?LQD3?9q]-r?s|g M@Q'@`?NSt$?CCTGCsjz0*bM@PYC?CCTGCPYC?v?@#Rl[?l?x?0N@.n!'@\Q|H?_vO?CTGCT'DoN@u8v?CTGCTu8v?#[T?cT?1=?4?Q@~8g$'@U?b2U0*?TGCTCS*P@<(ذ?TGCTC<(ذ?1'5? !Q@ hB'@8p?-C6j?CTCCG4P@Iuʱ?CTCCAm,٘U?V뛰?2]>?C?nv?.`R@9C'@㝔?S㥛?TCCGAi4׎-R@&tB?CCCGAl@?{I[?^e?;:?I?'.gR@9#J'@9#?_vO?CCGATpˍR@h^?CCAGTW?u? @N?Kf?4k>>{i^:N@ͪO'@q<?ψ ?GATGG]˫a N@E>vһ?CAGTAiہY?b 餓?0uh?/?{?KGN@ 0Y'@(MH?q?ATGGC|N@+?ATGGC+?ܹ 8?3~]?IU?$a?VmP@/]'@-f 9?y&1?TGGCGzZP@3O]?TGGCG3O]?n7? L?9?es?…\S@ Zd'@\xy'?NSt$?GGCGA۔[9S@LJB?GGCGALJB?{s?T ?l)?]?X:I'R@9#j'@ rͱۖ S@jqn'@h`?ׁsF?CGAAAܠ$S@ bL?CGAAA bL?[?>3?ۀ+?h,V>^=R@s'@č?gs?GAAAAyč$R@' J?GAAAA' J?y@L?qP7?ƅ?B㎺~?=nsQ@k y'@71K? ^)ˀ?AAAAGN}Q@,KlZ ?AAAAA ?Q?uӼ?SvB?h&x?&R@a"{'@K?R!u?AAAGGFuPQ@P(34?AAAAAӉFa?#+a?,?# /? KN?\:]Q@_'@9?0*?AAGGGo"Q@~Nc"?AAGGG~Nc"??[?$n׷?-2?;t7`? R@St$'@jxU? ^)ː?AGGGAQ&R@rV>/?AGGGArV>/?tv ?rJZ?- ^?6'?a&S@7>W'@.WD?<,Ԛ?GGGAAHWS@mqp?GGGAAmqp?/~?? jj?m/A>QIS@B`Т'@D߭ ?Zd;O?GGAATBmS@q?GGAATq?N8uv?>nk~?UJb?;5/X+>ͥmP@X9'@ɦ*O?UN@?GAATT -=P@?GAATT?vj(?|&y?<ծjUJ?}tM?2CvK@;M'@J2*?ZӼ?AATTG&%K@$?AATTG$?5eM>M>؟b?А?=L@x&'@DXrp?`Qڛ?ATTGTwjcL@sYA?ATTGTsYA?! >z/ g?; ?*5?KJ@I}'@ IAL??Ƭ?TGTCAp_IWVJ@L?TGTTAp1k?W#<;rs>n>JY?v@M?\qQ@RI'@q# @a+ey?GTCAAy7rP@XQ*HG?GTCAGtm(^i?Xut?f?|P]“3^??ګVBoP@'@r?6?TCAACz%P@clz?GTCAC%"?[^?y(?cMx?-I?KEP@"'@na?b2U0*?AACAGnW`5TQ@ ݆?TCACA]S?T#Q?( ?< ?/w?grR@G'@ s ?_vO?ACAGCT{Q@?ǭL Q?rQ@'@WY? o_Ή?CCATAD!ZQ@u])?pk_?b7?lnw8j1?x1+P@N@'@j]?q?CATAG9P@-Z?GATAG ·?#M?y$/A?8 ? ?s4YQ@z6>'@0XB?3U0*?ATAGT&sIQ@l?ATAGTl?=v?Ț7?vڟ/'?Eo4y?AaN@`TR(@o4% ?N@aã?TAGTTO|N@ Zi?TAGTT Zi?a7β?ͮk?١!?( >v?NWzgI@K4(@cHq?ŏ1w-!?AGTTC!9MI@^nm?AGTTC^nm?_r9T>y*Q[t>xf?ZK?p=P@1*(@)Br0?-C6?TTCCA,P@Aҧ?TTCCAAҧ?M?Z L?!Iӻ?M< ?vMR@_(@$yV?Mb?TCCAT0(R@1]}?TCCAT1]}?|5?{U?Ʊ?{g?U?j6ywQ@Pk(@e?x?F%u?CCATAñQ@ޭ?CCATAޭ?$ N?7?odl?Kow?k1O@Bc(@jx?<,?CATAC>y,O@!'+z?CATAC!'+z? /?˝DX~ձ??.ڴ S?;|UP@@'(@ΐ 2?W}b?ATACA-zP@̥kV?ATACḀkV?7? f.H?sKDN?LB?Q@faA(@戣%C?_vO?TACAAW Q@!:?TACGG)=]\?j2}?AFF?AK?)Ò?s7"wQ@]H(@? ^)ː?ACAATT'Q@Ύ-&?ACATA{[|?'V)?C_?}e?P8?؞P@(M(@T1D?ǘ?CAATTqP@7p\?CATAASqW?%#Tt?o^?~&?&BGD?nUa>K@H](@?I +?AATTA 9lK@ф?CTTCAR@p?2>PI>lquu?]?cr}Q@O@ac(@CC? ?MLHO@zX5(@^ZWT?a+ey?TCTGA-]qO@j?TCTGAj?}Tyٯ?ry!H?>=?{[?v/B;P@ˮ(@Mtŏ?=U?TGATGyfP@VETO?TGATGVETO?&;? `v;?Tg?p?bM@a"(@ɲ?J4q?GATGG ] N@/tc?TCTTALɍU?T Dž?*_x?hg?ByP?"ٰP@46(@Ϣ?(?ATGGTE?0P@v&?TACTT9Wh?`ӛt?Cޫ9?Wlfr^?ޑ@;˾? M@J +(@5?-C6?GGTAC%N@@m*?CTTACQ?"o?M{?֧˷?Z+ս ?mE0+O@iq(@7_g?MbX9?GTACCQO@CNg?TTACCeg: ?x?U?5{N?"i?r#oFP@z6(@A] U?Bi?TACCCmP@q$?TACCCq$?I?E|mS?&bMtZ?#˯t? P@r (@=.?z6>W?ACCCG2utQ@GW?ACCCCעp5?&O?ӳG? 푲)??zrQ@ q(@?ʡE?CCCGCx!R@,7;?ACCGCçA?^3[? F.?NjJ?$_ŃX?)bR@;N)@kԃ^?X9v?CCGCA,Q@x O?CCGCAx O?%z?HaHM?>???}h:`p?,h#S@)@?&†?CGCAAA S@|}B?CGCAA|}B??:n?Ր?$ >j{H3Q@O%)@? ?GCAAC̀ @Q@ٕ0?GCAACٕ0?riz[?IzW?hOl?*}s?*HO@jo))@rc&?ZӼ?CAACGM@fP@-?CAACG-?IV?DL:g?횑? r ?M*5#Q@ h",)@Te?ׁsF?AACGGZTP@JC~'?AGCCAx07?[B&?=wR|?P ?9 X?!JQ@K41)@T6$?rh|?ACGGG\:vږQ@+\?GCCACsY/?Q /?\ ?hk?m|? 54Q@{P)@ DZP?46?F'c?L[R@ $(~l)@ޔ?`Qڋ?AGCAC&!R@aw9 ?AGCACaw9 ?џ!?p2%?0y|g?hh>?^EXQ@FGro)@eE?_L?GCACA`RpSQ@CVm?GCACACVm?4v*?t > ?b^!9?_D=?S>R@_Lu)@HJ?jq?CACAGJ -OR@qU2?J?CACAGqU2?J?5TY?Fqk?M?W,Җ?*}R@y&1)@  L?HPsע?ACAGG+QF@R@4␶)W?ACAGG4␶)W?Ž:??<?N%?4uPP@u)@tSđ?A`"?CAGGC9cP@D?CAGGCD?tNy?GL*/?[u?w ɤ?䥛DOQ@H.)@?Mb?AGGCG7%VkQ@ko?AGGCGko?hop0?nL?4B?,P.(?~N"܂cR@:)@0z+r?<,?GGCGTdS:R@6G?GGCGT6G?K?אQ7?ɭK?$y?Ϋ^K@|P)@~ ?_vO?GCGTC`+!fM@h?GATTT56 a!?+ɷl?gN >*󁫽?sCP?NSI@_)@%VՄ?NSt$?CGTCA J@`;ጠt?ATTTCBˮU3?%e)>vqa>MY?5!@f?NrQ@s)@wD?5;Nё?GTCAAD:<rP@2Ȱ?TTCAA/b_?t?4ԡ?~n.?]?~UNP@gfff)@~+-x? o_Ή?TCAAC?tP@Aֽ?TCAACAֽ?<\J?uÔF?Py?_?O@UR')@R2?o?CAACT"!O@y94?ACTCTeUy?Di?4TXD?>?`QУ?:͢?AerFM@~8?TCTGCtMw?ՊȪ? ldk?Rm?l?NtMO@٬)@?j+ݣ?CTGCGd=N@`D?CTGCT|G\"?h$G縩?e3ӿ?S'0?ɣp?;Q@x*@lj!?:v?TGCGT7R@^; ?TGCTG ?☤o?W2?0g ?6tg?0a7N@rh *@:n#?Oec?GCGTA=r~6@P@?GCGTA?okҼ?ל%0%{?%$v?>D?_,ŁM@{,C*@ wPa 4?b2U0*?CGTAGQ@Q*@x)S@I.?~jt?GTAGT"O=` Q@0Gz?GTAGT0Gz?# 2?'*?B٧?w[?Uj ^9O@/$*@o!7#??W[?TAGTG/%O@&{?TAATC JZ?4(6?A8ai?2@t? S?X.IM@_,*@b@? ?AGTGA=M@ l?AGTAC;3?P'i[?GE+u?Ikh|?Ob ?&ܲQ@S'0*@%@gj+?TGAACQ@Z?TGAACZ?u[?:VĢ?wQVqP?c8'?mG(O@ܵ<*@^UR5?Eioɤ?GAACAL&In{O@fď?GTACA[*H?',j??p%?] ?P1@#?#0(R@xF*@a>f?ZӼ?AACAAu[Q@`?TACAA2Hbf?x*̑?Mt??bwɫ?tjC1?dSvQ@>W[Q*@Žv?~jt?ACAAT.^Q@3@?ACAAAc1Ó?+vH?9,? ?p.ߎOo?0 iQ@m4W*@RHx?jM?CAATA- rP@֒k?CAAAT%GGFt?)=WIX?MK8]?{G@NS*@?0*?GTTTCOˣH@?GTTTC?0ez=wX^z=3]#)?n?J@?ߞ*@ui?~jtx?TTTCA-L-K@*u?TTTCT r ?ZCΠ(z>{!Ҕ>"ກSp?H0?P@h*@M1?/n?TTCAA\ P@aa񳉺?TTCTAm*?QI}Ѡ?-?v^3?ʗt4?/MP@ *@+m?2%䃞?TCAACG#/cmP@J_-gp?TCAACJ_-gp?ُ?;}QX?Dž\5?"Wf?MU*-P@MJ*@1?mxz,C?CAACAZ P@YC֕?CAACAYC֕?)?H0?8?(A_j?=0R@ҭ*@i5 ?@Ǩ?ACAAT|Q@+?xЍ?ACAAT+?xЍ?m⏏?֫`v'?_?8WXMt?Ԡm:y.P@6*@M^ &? rh?CAATTwP@MMu?CAATTMMu?17?Adӟ?pEy>?ۿxv?I8'J@%*@ք-?L=U?AATTT|nJ@c&[?AATTTc&[?2mEy7>ހʣA="!o)e?m!Lm?*%DnI@gfff*@Sg6Y?_vO?ATTTT``mI@G͛5?ATTTTG͛5?=ڟ%=,%?`uHF?sJ@3U0**@bS?HP?TTTTG_$J@A}?TTTTGA}?FA v>ZZ|h{>!?Vy?@YL@9gDi*@G$?46jƑl?LH?ʏC?yżQ@T*@yK@<,Ԛ?TGGATpٯ5Q@V?TTGAA?Ċy?qɶ?+ȵ?-gP?r)^Q@_vO*@S<$@J4?GGATCSɄ~P@=m?TGAGTRӼ?Q?7\?oA̾?ʸE&?!ML@"u*@kw9'?_L?GATCTL@b?GATCGB?\Gp?HN3?-܋?gga?NP@,C*@Ʋ?Q|a?ATCTA}9> P@>#6P?ATCTA>#6P? UVt?[?)?cZ9?P{?ORQ@[d;+@{Ri?hP0?~P@QI +@|?d`T?GCGTGe j9O@W7>?GCGTGW7>?6영?sPan?/w6?P8ଗ?GK@2+@v;~?Mb?GTGCT}gړM@~R?CGTGArq?GrJk?mWO$?ot?otK?Z`Q@a";+@6M@?W[?TGCTGOX\KQ@HvqV?6yexǖ?;א&F?X?1DM@8M+@Ǚ%j?<,Ԛ?CTGTGs/LL@HzNt?AGTGT.5,~?~x?|w?>Hv?)d&?aQ 1#L@#\+@Jgx ?ŏ1w-!?TGTGGiä ML@%Dǫ?CTTGT3d?D#?4>L??^7 e?-vM@z6^+@4?a+e?GTGGCHsN@JSz?TTGTA4zt}?ŋ0a?Wʆ?R*?L?h N@a+@m7e@?TGGCTdlFesP@(* ?TGTAG{ ?ƈ?i$]?:dY?"P*?/7|Q@y+@q?Aǘ?GGCTTRFQ@Τ?GTAGT{]?NI?(`&?L,cc@?ɸ_?a.ǚM@H+@϶ʙC{?`Q{?GCTTGN8M@ ?TAGTCV g?I+?9_^Z?/%?MŸ?uLJK@/$+@qFa\?~jt?CTTGCW6K@t-?CTTGCt-?Zk>ca>Tq ?KZ?l8-P@t+@p' ?F%u?TTGCA iDN@7S?TTGCA7S? J?yg?1 ȳ?K`?_R@ y+@9{H(x?Ǻv?TGCACͷ=2R@+P?TGCAC+P?<`ז?rCg?@)&&??lWH???P@+@?`s,?gs?GCACTq2?Q@Ŷ?GCACTŶ?Ah? ݺ>?拁?n!?6^IP@+@?Mb?CACTGE P@Γ]?CACTGΓ]?5w?jxĉ2?a=?Z-ȶ?ÍSN@d+@۵"?Q >6;?H?5xN@e+@ ??ʡE?CTGACn1_UtN@6,[?TCTCCp?n X? ?lT? ? ?gxO P@QI+@]:?HPsׂ?TGACTN@{P@|򩨼?CTCTAB ?$*tv? Dn[?X?1[?I܎pCP@?+@µQ? ^)ˀ?GACTA} *@P@"?GACTA"?O?Nn?0?gW`N?EP@+@V??ACTAAmb2KQ@xS0?ACTAAxS0?XC?΃ؕ?t_{t?g>,r?DPN@(+@Ìgf?X9v?AATATyO@:% Nj?AATAT:% Nj?{4?6?j켰>_{!/]?XT?T{M@Q+@`V?ǘ?ATTAT~LPN@[QI7?TTGCT \?Q+?+Zjd?V?tVF?NdUP@,@A t_?_vO?TTATG1_MP@5}?TGCTTka?+?7>!מ?*z ?)]hŋ?rM@/',@ƮZ?ZӼ?TATGCUAյM@EOMv?GCTTAs'?5#z?((PI?NZ?LNy?iwQ@X2,@g @St$?TGCTTMiQ@RVX?GCATCmP aX?3 >w?!x?Mwb?\Θ>QN@u,@n7V?b2U0*s?CTTAT>f&N@S4?CTTAA$?>xk?4o?gq??:JQ?7FaP@z6>,@JYY`?J4?TTATG>O;MP@wG/?TTAACX?2-r?j??H ?oQj?#Bo~N@,@vL?( 0?TATGAՙO@?_j?TAACCSOٶ?)ML?_gL?y>`?p/wڸ?_zO@/$&,@rʊ? c?TGACC O@^h?TGACC^h? U%??ez?C :?5P@3,@Wd? rh?GACCAeP@=֏?GACCGQk?Q?? -Ӛ,?ꣻ0?0R@j+7,@:eg?b2U0*?CCAAT{: Q@QA?ACCGTo?˘F>D? ?WLc%_?Rc?*CO@u<,@Љ> ? 0*?CAATTǘ{P@挏[?CAATT挏[?"d'te?l,~e?rM?$*Ģ?K@]H,@eb3@/$?AATTA\۷-K@nXt?AATTAnXt?ğwg ?'=}>BDMF6?bFf?2>O@ˡES,@Rq6x?_vO?ATTAA7N@⾛!?ATTAA⾛!?}c ?,j-G?H-?J-t?Z%Q@zV,@s8?+eX?TTAAC4NP@J'?TTAACJ'?ZAָ?d?ɍ-O?OZ?Hz`1P@J&b,@8N6?Mb?TAACTzB;O@"!}?TAACAu +??!="#?pܸ?XݎZ?>?\±vP@W2d,@B,x?b2U0*?AACTA8zE8:P@g(YB2_?CTCTA5:2?ėk$h?S/[}1?2x$}P?q?NQ@w,@?St$?ACTAThןP@m;S?ACTATm;S?8?Tg?P)l#B?EOk?^gP@Q|,@o?gj+?CTATC+ S{ P@^?CTATC^?ss?yxMp?/}以?E`?_L?TCATC rP@tu?TCATGjr^?ٰ?H3֧?Uʈ*d?w?♳;?~jt?AGTAC8M@!H?AGTAC!H?Vn?lwԲ?e> <'(?eL`V?#еO@lw,@F(?Aǘ?GTACT]O@Ñs?GTACTÑs?Wj܎?jw?J{[?XH ?L7>P@]C,@L{WIJ?\x,?x;??Eu/Q@,@jB? ^)ː?CTCTAobP@a?CTCTAa?W?vX7W?JZű?j0R?/k*YP@2%,@ޱͽI? -?TCTAT(G˳P@Y%L?TCTATY%L?P~?f 3?rg̱?.V?6IT>P@`vO,@z(?Y5;N?CTATT@gmP@uGƲ?CTATTuGƲ?Iɚ?<^5?)b'$?΃<\%?NVM5M@\m,@;D?J4?TATTA lџL@F7?ACTTA]?V`D??TTATC̛J??G(0?OPD?9J*f?znLP@z6 -@?`Qڋ?TACCCsWmP@ "]?TACCC "]?$5?9XBR?sɼ?3=?Mͅ Q@2ı-@'#?M O?ACCCTzpdQ@(Eإ?ACCCT(Eإ?e?A%D?D?+I Rd?N%MQ@O@a#-@Z!Oެ?A`"?CCCTTm, nQ@ $ ?CCCTT $ ?sLu?4?v)/?Vxum'?JL@{0-@n=?+eX?CCTTG l-M@1?CCTTG1?{a7i? #U?ccT?{y?zgqK@,3-@_]TZ? ^)ˀ?CTTGA7L@׶輫?AGTCAEI@?Ӌ /D>.'b? C5?&TJBE?bWP@"5-@UbI?ZӼ?TGATTV|YP@1覷?TGATT1覷?o?rkY?k ?%c>?v K@ioD-@Fq>?V-?GATTAPuL@Z?GATTAZ?Fiq>jl> ?BV?Sk2O@CK-@*y7-?_vO?ATTAT';N@0^?GATATBvȖ`?oA2?VVc?u ?h;@M?Nc'WP@ׁS-@T|?Q?TTATGA.!aMP@}3U?TTATG}3U?=Uf\?OяV?WT? ] ?3)O@V/[-@PS^?5;Nѡ?TATGAXO@ր̈́?TATGAր̈́?[z0W?ZU[?{J?t_S? hlO@td-@aǧO?{Gz?ATGAC,#O@>Jݺ?TGACCYU;s?c?Ku?-??JP@f-@?ˡE?GACTAi7T@P@9Vj?GACCT$Kg?0zK?9(?Y?E?kFkQQ@x&q-@GH?J4q?ACTAT7 P@?ACCTGCf?F7?2ue?;w#?y2|?i^XO@z):r-@zlw?_vOv?CTATC@s P@aL?CTATCaL?f?Ӕ\7?rWϺp?,썴?CM@s-@Þ_< ?q?TATCGpN@B?TATCGB? , l?$K?N?,,6?5{tmG=s(=?ҟ?βgL@؁sF-@BQD֓?:v?GTTAT M@!h?J?GTTAT!h?J?B[%>yYl?*Ǭ?SN?{O@Pk-@0?HzG?TTATCVRO@l|ϼ?TTATCl|ϼ?F_S?3c?Dާ?o?N L@#-@((? F%u?TATCCz,M@L _?TATCCL _?xLF?=W??X?!G?kO@9-@3?_vO?ATCCT ELO@V&%?ATCCTV&%?QsF?e ]dsw?V?N1pA~?%Q@H-@YF'?b2U0*?TCCTCi MP@Ϛ?TCCTCϚ??ħ?pS+n?{jZ? DvP@) -@fI?gs?CCTCAS%jP@bw(?CCTCAbw(?#P?@ǘ?CTTAA[wN@Q?ATGTAl\1?#g?Y?h?k ?.eQ@oe.@4Q?M O?TTAACKq+~P@-#mS?GTAGTYڤ ?ʨ3?}Al?9%OD?=?<#O@fj.@I5?{Pk?TAACT'O@ES ?TAACTES ?6?n2?>F85,?=?k)r?lJ#P@ q.@I|xO5?a+e?AACTG#%:P@?CTGGT2@ɥ?sO.?DBpz?}Z?:?.|0O@ Ot.@Qb?<,?CTGAC0gGN@0 (gͬ?TCTCT ގ?/w?ATCTGe[SO@ƣܽ?ATCTGƣܽ?l}Z?Kx?Kw?aTK?7q K@k .@#rӀ@I +?TCTGCY/}$M@FZN?CTTGCVP?:h$>\>:<?rC?sPM@Qڻ.@e;:?<,Ԛ?CTGCGN@d}!?TTGCG2+j)?:g?>?f#'?-?zQ@(\.@WR@-C6j?TGCGT/xzR@>?TGCGT>?#*??۠?|jz!qN?r4O@O@a.@,Qcp;?_vO~?GCGTTnW;N@>RC?GCGTT>RC?X??Z?E? =$?XAgH@M F.@ KT?3U0*?CGTTC"G@^L?AGTTCTY?.=IW=vP6X?D?l'K@e;O.@LW> ?Mb?GTTCT11&J@YR]?GTTCTYR]?x >;A%>@Zj??HtI@!rh.@e3FXZ? 0*?GTTCT0&J@ҁ?GTTCTҁ?v# >ݝle>sy\?[džZ?/O@Qs.@E}?46?ì>Z?q?wQGJ@ .@9k$?S㥛?CTTCT*$J@M;?CTTCTM;?L=>Ix>HL]?zS?gP@ h"l.@ wna4? ?TTCTTH=O@۠3;hP?TTCTT۠3;hP?a;(?BQ5?OMn?)j\?P5QK@fc].@Z#W?/n?CTTCTA wJ@gm?CTTCTgm?/Ęځ>&ҕ?RcY?߁?nlO@.@6O?mxz,C?TTCTG)Z4O@J/V?TTCTGJ/V?hcq4?iv?2s?fBdC?ǀ6~N@J&/@4S? 0*?TCTGGuO@1)&?CTGAC&'?LP!? ^3ְ?Ae?kH%V?ŋ0P@a+/@ñ? ?CTGGGGdP@-^oXc?TGACGl wz?r^N?'?$;H?Ha?\xP@ /@SY?:v?TGGGT4P@hs?TGGGThs?Sv?\j'?5d߲?Uoӆ!?GqlP@ q /@V2f!?-C6?GGGTT\P@+ ²?CTATT #ͷ?944?m>a?^>?]!?3J@/@J@HP?GGTTTgĪ>J@&>?ACTTT>)̤?pd>bݑ>ݶx?`?ܴH@s/@J?3U0*?GTTTCH@` W?CTTTC]?]E#=Yd=$,?Dfؑ?`K@-C"/@jr? o_Ή?TTTCT/>vJ@;@?TTTCT;@?XtDi>j~D>$bp?eg?_,I@/$&/@jhh?b2U0*?TTTCTxr vJ@BH?TTTCTBH?m=<\b>&ٗa?x42}?M@FGr//@7j?St$?TTCTCՎTO@]? L?TTCTC]? L? C ?xBOS.?=㩓J?9a) L?!~ gP@|?5>/@LM? rh?TGCTTEQ@f??TCCTT'?u5?Ew?AP?X4A|"?;Fx8?H aK@(\B/@)FJ,(?_vO?GCTTTD)L@%Z}?CCTTTˮ@?t(?CܒO>gFL2?ξ?/H@JYF/@m(?J4q?CTTTC>H@V3`?CTTTCV3`?1ii $>0ٛ>mvmF?I?8diL@ClG/@R?UN@?TTTCAM,-K@(HԼ?TTTCG fķ?g4 ?F1%?m*5?0c?jP@+I/@{V@H?TTCAT?#{P@7Jw2?TTCGTS8?D>ְ*H? +U#?>0>H@M@8dj/@7?Bi?CATCC(= M@n(?TTGGCbI:Ʊ?]kCz?|p?^eus%?L?|ھQ@y/@%jU?/' ?TCCTG]8*Q@Vн?TGCTGOL??,x?8dh?9қ?yzFE?-k#O@U/@?>v2? rh?CCTGG™'O@⽧3?GCTCTb`Ў?Z7Emf?G5i?P ? ?bz&/P@]m/@[? ^)ˠ?CTGGTnP@;ظ[?CTCTG~\?1?!<@?b~*?+b#԰?QN@Zd/@:P7?HPsr?TGGTG=%4iN@9JOS?TCTGTN ?,!2k? ?H U?,! ?(M@|f4Q>ʵ>d?UIy?TlUM@o_/@A;z7?ŏ1w-!?GTTGGLuK@?GTCTCrqg?dzB?/e?I?MYT?9Ǟ{O@/@?3W?z):˿?TTGGGWjlO@σ^UJ?TTACCHz#?#?̩˰?Jj_(?dK?E'+SP@X/@EK?&S?TGGGG5]P@t?TGGGGt?,?5K,'?sy?d(:?ICR@v/@(B&?{Pk?GGGGT9őQ@M*Zd?GGGGTM*Zd?3 HR?: |?%ȏ?Tw*j?ZH@IP@.n0@aBwv?H}m?GGGTTEsP@!?GGGTT!??Dz7ы?c+?~?RH@(\0@b|@HPsׂ?GGTTT[J@t9?GGTTTt9?ҋtyby>rs=Ҁr?Z=l?s1WH@J0@DcXyq?F%u?GTTTTa[0I@Um&?GTTTTUm&?O=cc=-=:.^?Bf&?I@Pn0@u?n?TTTTAFJ@=0Q?TTTTA=0Q?~7Ԧ= u>Ah;iz6.?g?`\hTN@D0@A|?UN@?TTTAT'YM@o?TTTATo? G+(T?ݜ9b?|=Z ?f$C[?N@fX0@'nr9?<,Ԛ?TTATCc**O@ d?TTATC d?#?r(##? qa?8,?p= _O@( 0@He?ݵ|г?TTATC)O@!ܚb?TTATC!ܚb?u;?*ZS?ET?N>? M@f*0@H?q?TATCGnDN@H*?TATCT=z?.HRK? .?f${?8n?ѱO@G:0@G[q? o_Ι?ATCGT윋ҿP@5¨?ATCTTڛ^?ut?VaL?7ɑ(?q{,?0)ƕP@TA0@gC_G@&S?TCGTTwsM@X0f?TGATTwb@G? F?武?a7?|f@?X,ӱH@ڊE0@u$8E?0*?GTTTC*pH@y?CTTTCeL?4ZS>`P>y=_oΛZA?mH?ӓL@S'P0@d ;??TTTCG>K@=?TTTCG=?Ff>"|w?8&]k?%,M ?w%N6Q@zV0@Y9u ?JY8?TTCGT-oP@S?TTCGTS?!.?mI]q?=%D?:?(xPO@=Ra0@JF?H}}?TCGTAbIbO@cqWN5^?TCGTAcqWN5^?-4bM?#F3aӝ? KcC?IK? RbQ@ű.nc0@ s@8c@vq -?TCGTAIbO@fhC?GGCTTԓ$x?j+A%?F?Bw?'&?pL@ yg0@wdb?_vO?CGTATa%M@0@g?CGTAT0@g?E?8$P?.hZ?'l}?V[wO@M o0@oc\:d@Mb?ATTAC*EM@#Ջ?GGTCG /r? _"?ކdc)?R??YhRO@a֔0@zoD"?J4q?TTACGc`P@+ Ŕ⺬?ATCCG ?oT&t?)"?p ?&a3h?bIQ@0@/ @J4?TACGT3aQ@nR?TCCGT.$?,q3 ?$n?)?gKͧP?H@Mb0@0!6?q?CGTTT'>zH@o~?CGTTTo~?U텕>o>ꍥ=3RH?şH?`_'H@߾0@\ +?I +?GTTTCcZkH@=M?GTTTC=M?72">u(A;)=nx'?D?rL@?ߞ0@I/Y@<,Ԛ?TTTCTF-^J@:qB?TTTACSٳ?^5c;?fVw?>J{?R}* ?O@O0@բq? ^)ː?TTCTC+G=O@az&ɋ?TTCTCaz&ɋ? NU]?1k`+?nڲS?K[?O=P@yǩ0@W9?ׁsF?TCTCA.{O@ -?TCTCA -?4 ?;?v8iϼ?kHܻ?DQ@+ٮ0@''6?ǘ?CTCAA:,Q@H?CTCATee-?^? o,?D?D;?%Q@]m0@t8g?I +?TCAACt`=P@(5?CTAACok ?a{8{?Է?ӫcK?)yx?C*O@ͪϵ0@1LhΠ?S㥫?CAACT)rO@9;Ma?CAACT9;Ma?쭫?1K? X?&iDߋ?m \N@w0@Wh ?C>٬?AACTTO@FoD?AACTTFoD?Խk?$S?'?ԏ6I?˽pK@0@[jZ1?M O?CTTGA[nCL@u:H+?CGTGAAqNR ?wl?C]?0חپ?ﵰj3?@;,P@K0@sCnU?V-?TGATA0|P@|DF-?TGATA|DF-?lW?we}?f:?F0?/$>tO@Q0@gA3?Mb?GATAAO@5n?GATAA5n?A-˖?ʄ*?d?8-4?fXZHQ@w0@ W?vq -?ATAAT 4xQ@?~m'?GTAATU=e޹?%?V`?ܪ??%YLcOP@&0@DP(&#?`Qڛ?TAATGo[P@9R?TAATC+Xib#?OL"?i50?] ?sdY^mV?L@20@@B?:pΈ?AATGC0#WL@?TATTADޮ?WZY?4yQ+1E?Cw? ?^d,P@O@a1@ϭh&?"u?TGCTTQ@oiȽ\?TGCTToiȽ\?? V?u/?Q!%?)rqSZ?IN@0 1@Eum?/nr?GCTTT7eL@{?TAGTTs6?(@S?槩?Xkp?Ë?p.I@)~ 1@$A}t?-C6?CTTTTETJI@2׽?CTTTT2׽?>=>%muA>~Y$?F. ?K?i*_J@h1@i d?/$?TTTTGU`x0$J@GܮE?TTTTGGܮE?R08@D>o>D?fY?rJ@1@ D(9?eX?TTTGCk7K@ɣ ?TTTGCɣ ?}"F>9B+>\??SJ?WwO@lw"1@i?I +?TTGCA/ {DN@jN?TTGCAjN?K7q?OV?!հX?03s?6`k-R@r -1@Yw?&S?TGCAG*яR@J?TGCAGJ?kn ? ٲ!?3?i,کfM?œjR@ŏ171@co:I?ǘ?GCAGG :~^R@r*5?GCAGGr*5?s_y?zHd ?qo%?H6>3vDЙP@7>W;1@#?/$?CAGGCkYq]cP@q?CAGGCq?HjV?g=Р?.?ncw: ®?Q@n4@1@\@Mb?AGGCTѩdQ@wY-?AGGCTwY-?'?pI??Ąe?'TQ@B1@i=?0*?GGCTTQ@;V?GGCTT;V?-CElv?.D?MA ?=l?SM@ H1@bRm&Y?aTR'?GCTTGL8M@{ ?AAATCˁo?l6Մʾ? }!?3{??dGJv M@ktX1@Z(*J?ZӼ?CTTGG+L@QuL?AATCTp߸?lU?z?rPr? b V?.;N@46\1@/i?#~j?TTGGT4v5O@m?TAGTT+ Ɨ?۝ >?|3{?;<;?} ?&QP>Hם%l?r\Y?H@'†w1@ό?HP?GTTTTt%0I@f^?GTTTTf^?J6-="k= ݄?{p[}A?8*J@2%1@>?HPsע?TTTTGJ+)$J@`?TTTTG`?GcE,> \O>}&lp%?/??S@SL@rh1@ƩY|?X9v?TTTGA!L@6_E?TTTGA6_E?p0>DPEb?yoWj?Aףؑ?R@$1@c#/?HPsג?TGAGTR@ ?TGAAT@w?Bm?8'?IAϲ?"+>7xSXO@61@?F%u?AGTAA3BO@#Y:L.?GAACA d?]m7?n?ɏʄ?9݉,?TqQ@k 1@dݨ1u?<,?GTAAA= PNQ@P9w}?GTAAAP9w}?e85?Obn?G!צ?-qq?gUQ@0'1@iFZFX?UN@?TAAAAߙQ@dL?TAAAAdL?|?i!ys?T4?+\?%]-[Q@ŏ1w1@ S? F%u?AAAATsR?Q@T2A?AAAATT2A?t"Q?D%?*̃H?%rDi?qG;N@1@ bQ?j+ݓ?AAATTWnzHO@1?AAATT1?6z?ܔy؜P?u;?Oz?A[I@41@1I3,?`Qڋ?AATTC]J@@;c\?AATTC@;c\?RE}gu->]/"=><~W3y?ҿO?MxJ@~j1@%%U?S㥛?ATTCTS3JK@Cif?ATTCTCif?H~Q>]]1f>jO?.?meGN@S1@Y]Iļ?ŏ1w-!o?TTCTTO=O@o"'?TTCTTo"'?oS?ꍄ>??Af/?]sI@:M1@]?0*?TCTTTr4]K@(s?TCTTT(s?7<>Bn w>r@ʓ?H.u?/ᠺH@+1@${G?d%>N+3?fy ?ȹ.pL@jt1@FC.J@J4q?TTTCTqXKJ@ԓ5?TTTCTԓ5? ?a!VJ?f;<"?O| ?mEP@$1@s3?ZӼ?TTCTG]U|O@noFr?TTCTGnoFr?9?tIy?r'?3>ŚN?+iT[JO@k1@F?Aǘ?TCTGGޖluO@ N?TCTGG N?p3?P'o?97:?Z-?J9 O@w1@E?vq -?CTGGTbE[P@ǞmK?CTGGCD?GB߮tiS=t?c?_|nP@ψ2@k??TTCCTnsO@~m?CTCCTFwa?z??$iX=?W#f߻?_ LP@X[ 2@u?&S?TCCTCFtP@Է?TCCTCԷ?zh? L?̒8? gi?uztO@!rh2@{^?I +?CCTCCKO@fM9?CCTCCfM9?&-O? H"%a?]kTF?;?*2P@cX92@ڑPq?+eX?CTCCA9h1=!>^L`hJ?(A?0hsQ@ۊeW2@aa ?gj+?TCCACQ@iHDՍ?TCCACiHDՍ?y%?ؖv?s(}?*#?xRQ@O@ac2@)<@n?CCACG>kQ@P^?CCACGP^?Ek?L1T?qS)?g'd?t%R@Oeh2@ُѻ@&S?CACGTf"Q@ [:?AGCGT:~?E<w??T?VKxk'?4rOBM@Vm2@嶧?w?ACGTTLM@3@?GCGTT=·C?4'ɄO?s 0?GrB?uoÙe?JH@jqn2@%.??CGTTT8 zH@t^ ?CGTTTt^ ?|Dչ=%?fffVI@*z2@k%c;?-C6?TTTTG+$J@('N?TTTTG('N?ǹIi=>Gi>zc>>k+?ij L@( ~2@֑?H}?TTTGGdiH}L@gc?TTTGGgc?Ir?*h>8ض8?=ȱr?98?]ljO@2@n' k(?S!uq?TTGGT -#O@u:?TTGGTu:?~? u ޱ?ym?gPrː?enaM@&u2@ywO ? c?TGGTTcaM@Rr?TGGTTRr?HeT?l? IQ?E #W? w*?\I@42@GDz,@<,Ԛ?GGTTGK@ioG?GGTTA}b zλ?}Ia>zh1 >GTl68?|̼ z?ƒtL@p_Ι2@d/HYA?jq?GTTGGN(K@u ?GTTAT|> ?y4^?y:?{AB-г?oh?ALP@镲2@n+:?Mb?TTGGT O@}֨?TTGGT}֨?HG?Q"M?ZcXQ??L@^)˰2@l?_vO~?TGGTTӃaM@I|E?TGGTTI|E?{m+0 ?} ?ȥ'w??;I@ 2@ƖU? ?GGTTT=J@=鯴?TGTTTSZ>?iT =H=;1A?)thY/?G@T2@󩪲9? ^)ˀ?GTTTCIH@C!y?GTTTCC!y?X=ʅ]Q{=?Yk?4!.%D?^xiI@'12@ߊ7?Eioɤ?TTTCT|=|!?eBs#?贁,N@_)2@n@b2U0*?TTCTGmO@֕?TTCTG֕?5%P?|[( ~?ꅏBA?J7(?_) O@jo2@"2x?0*?TCTGGȆ+vuO@b?TCTGGb?۔5??+$"b?u(W?΍N@2@빓?F%u?CTGGCeA*%N@9ۿ?CTGGC9ۿ?!?6j?]E?꜋O[?sP@V-2@AJ?6[ ?TGGCTm)sP@p?TGGCTp?FBuD?OԈZ? PΎ??in#? T ZQ@9m2@4?5;Nё?GGCTTc[׳Q@(?GCTTA>?.\?J-v2?dY?.aM??_N@7[3@~ <Z?_L?CTTATFgL%N@\OwF?CTTAT\OwF?_(ʠ?}?8Rt?g4??`oP@&S3@LZI?b2U0*?TTATG9t LP@fLb?TTATGfLb?{0\4?8bQ?_G>??I!O@-3@m?UN@?TATGT2.*?N@;;ھ?TATGT;;ھ?ED?[L?Uؚ#?yxIp?ףpMiM@ÆW 3@c6g?-C6?ATGTA^t@ZYLM@wC?CTGTA.bC?)7;?wb?'Ɇ?N ?O N@&䃞 3@kN+ݖ?6;Nё?GTACCeKnCQO@7?GTACC7?-D?,8?5||?aIXg?A`开P@Dl3@Lq[?~jth?TACCTA =P@ L?TACCT L?,jg ?a 2b?/}R?v? QRQ@'13@w!?Q?ACCTG**m8Q@=2띳J?ACCTG=2띳J?LJN-?M?N~+?'b?^I 4?E>?4?ۆQ@XQ3@?+?ACGGAW^<ܿQ@^R^?AGCGCA2?}q/?Жx?C?~,?o^T@ܵ|3@g@_vO?GGAAGo T@~?GGAAG~?`Wb?[y?-OQY{?J X=TQ DP@_I 3@ A?mxz,C?AAGCA#cP@d @ߧ?CAGCA1[︵?ڡ`~?e\?`u<3?W{+?iPS@O3@ʺ ?k g?AGCAAnR@AJCUH?AGCAAAJCUH?͘;B?r,>?Л Ǫ?wf>7R@HP3@ ?ǘ?GCAATkƬ R@1_ӁO?GCAAT1_ӁO?03 _?.D4? ?5A "?Ψ̚oP@{G3@H?F%u?CAATA qP@X> 5,c? 7Z?rP@p_3@{Ϛ ? o_Ή?GTCAT9 XeP@fPz:?GTCAATyMf@?j6?j/_#N?N]?kx?0cQ@^K3@&!'?L=U?TCATGuE2Q@rtb[?TCATGrtb[?=E? B[?7E#dy? &ew?K@/3@Ψj?(?CATGC}L@=:q?CATGC=:q?UE:?n7>ֱ?0?pZkR@"3@T0ɢ?~jtx?GCGAC9GQ@cNg?GCGACcNg?1WQ?m7k?o7?:Z#?ʱ'P@m43@f3&?Mb?CGACARxتP@Y?CGACAY?*?{?atS?X?#/Q@?W[3@hܿn=?Ǻ?GACAA0 gQ@ ,NjD?GACAA ,NjD?er?5k`.?Xq ]?D'+?J?Q@\m4@?_L?ACAATQ@v=g?ACAATv=g?Kt*?g\N67?;{4?%y?]L Y%P@4@ʢ@/?8d`?CAATT`P@n?CAATTn?Ekc?Qh?Rc?hL:?HCf2J@8EG4@dL8?ŏ1w-!?AATTTnJ@ݬw?AATTTݬw?ΟU>Xő9>|m,v?*>L`?)S2I@4@J\?F%u?ATTTTgqy-mI@s2?ATTTTs2?ZpU= 9=ؔz2?95?qaZ~I@ ףp4@!ǖ?~jt?TTTTTd c`I@P'G2?TTTTTP'G2?Anci-=R)=k"]&?N3"?p?9:J@J +'4@Y?vq -?TTTTAsEJ@i;m?TTTTAi;m?9xZ=a2ƌR>"-?7?&XۏM@z6+4@C?ǘ?TTTAA8MN@SMN?TTTAASMN?K?+? {߇G?M'?ƲpQ@(\/4@.j?46cщ?gs?TCTGC|B$M@k&?TCTGCk&?kYX>?#tv=?^Yԙ?ÞE?1zN@*:4@wS?Aǘ?CTGCGAnSN@ȢR?CTGCGȢR?-:{?͓ba?qF?jpȪ?)AQ@^)4@lU܃ ?@ǘ?TGCGCvQ@)ӳ?TGCGC)ӳ?rK?);??ھ?5"`:?oW(MQ@>W[4@_ J?_L?GCGCG:xQ@7e>?GCGCG7e>?0O?hp?ɄU:??6R@/n4@6?`Qڋ?CGCGGٙ;ճR@Z|zQv?CGCGGZ|zQv?˨ԭ?hc+?b=!?LU?O &R@i|4@nVH?{Gz?GCGGGQ@{l?GCGGG{l?>D?/^'J?=|6?-iI?O_[2N@T㥛4@_7r@_Lu?CGGGC_mtN@j?CGGGCj?t?.*f AS?15?;Xk ?"۹S@Eio4@A+TH?Mbp?GGGCAŚUDQ@d9>\?AGAAGEvo>?1?*#\?\]G?c4k>+P@tF4@І@ݓZ?GGGCA+DQ@rc?GGGCArc?jC?E?Vhy?x1ng? R@> ף4@_3?X9v?GGCATâ @2S@$Ϲ?GGCAT$Ϲ?l!%`?wC ?e 3qM?b>JCP@kt4@b*d?J4q?GCATTLdeSQ@[V>?GCATT[V>?-)^? ;x?f!9?TCtq?fϣM@ 4@y]%?46b\?~KrN@`4@PU|.? c?TATGAVWpO@" ?TATGA" ?v*ٵ?b0 ?ξZ?f'?c/Q@%4@+>`8?/$?TGAACWQ@oaE?TGAACoaE?n(e-?&0n_?ts?N ?0KcO@\ A4@l?:pΈ?GAACCI?jUTr?I6{?ErfR?}zO@jM5@ 6K?ŏ1w-!?GCTGA1X4O@Ů(?GCTGAŮ(?@!?zZM?2S?H"'?nP@Qs5@>t9 G?Eioɤ?CTGAGNmP@E]D?CTGAGE]D?@OŹ?NG?\H:H?!q?v0R@!5@&=?-C6z?TGAGG'^KR@H|?TGAGGH|?Ӿ?xD?Nx?6n?$P@:#J{#5@"?H}}?GAGGCO/P@e0?GAGGCe0? 6@w׺??^?FJTZd;;Q@@߾.5@K\"?/$?GCATTssaSQ@40p?GCATT40p?b?8"yr?h_7v? <2lP? zL@x-!45@T??ܵ|?CATTA˲y&L@j2y?CATTAj2y?|UJ?f^_3?? ?(?꒹CP@fc]<5@h?n?TTACCkO@bHͱ?ATCTA$k?fT?`xA| ?V{?1?8Q@iod5@"ajmw?F%u?TACCAgwP@F?TCTAAS?'P?u6K,??DB&Ef? BJ?/@R@@g5@{ (? ^)ˀ?ACCATgRR@ ?CTAATjzv?B WT?gSM?L O5?KK?i5MJ@li5@+|Ӥ?ZӼ?CATTT2SvK@#l?AATTTf(o?d5H>[1[;>rP?WQ ?={* K@b4o5@\2?C>٬?ATTTAq-sJ@t?ATTTAt?'L1% >j{>RDe~?K?9OW.gL@V-}5@s? ?TTTACȓoL@uA@?TTTACuA@?C>96t?SoS?q𭜎?&*[-P@ׁs5@"rH?{Pk?ACGCAf#}Q@ K?ACGCA K?2?$3?8g?vc?s(7`S@X95@R{?F%u?CGCAG[=:X4S@ #V?CGCAG #V?Nyay?Qv_)?0N`?S&>2c|^R@_v5@.V?Zd;O?GCAGG?oZ^R@B'?GCAGGB'?+S?,c?hhvc?d˼U->9:P@}гY5@[j6?i|?5?CAGGC9cP@?CAGGC?kT|?I]|?ks"1W?]?>?2+P@St5@p?5;Nё?AGGCG]@IjQ@j?AGGCGj?gt?R*>߿2?JlJ?t)M?#p?R@5@۩4e%? ^)ˀ?GGCGCpcR@"ae?GGCGC"ae?<#Ҷ?Bå?|<~?NR3?󍶏P@I 5@;2_??GCGCC/FQ@M3?GCGCCM3?v^ f?Rݸ?E.9+vT?6 ?bcLXR@]C5@C'B?<,?CGCCTgQ@V?CGCCTV?OJ?6L?_X?jʜ!b?q= AQ@J&5@,y?(?GCCTG)3MQ@; ?GCCTG; ?o[?5u?z?|Ɩ?+xP@l 5@抐J?y):?CCTGG{.O@gHJM?CCTGGgHJM?!G?ѥƹ?=d6Y?Ru&?n>N@K{/5@Ͱk?L7A`?CTGGCvYN@\U?CTGGC\U?l&VVȭ?(ɮ?ʯ7??fZP@35@in) ??W[?TGGCT sP@߼B?TGGCT߼B?I?07?h}?gs5?$YQ@fc]5@eO?ZӼ?GGCTC }dQ@?GGCTC?k)?Aۯs?13?[J6?Yi$nO@"5@e2'? 0*?GCTCA1y^O@b?GCTCAb?WL2ljJ?%G?(0?D]?OQ@o6@74?䃞ͪϥ?CTCAGҳcQxQ@lu0?CTCAGlu0?S +? /+?~Mp?mt?\` Q@V6@ꮊm @q?CAGGC:6cP@>B[b?GAGGCZA?߮˵yx?MA9? |-?b,Q>m&Q@6@͔Xͯ?b2U0*?AGGCG6wjQ@HF`K?AGGCGHF`K?O?6?qoK?kly?6R@Ϊ6@_6?_vO?GGCGCʊJncR@Fh _?GGCGCFh _?;?`|1K?̓.NY? Gd<>{GW?GCGCA>W?{m?yͽ?*n!?҉C8'P?MR@a"6@h͝+?gj+?CGCAGȢ U4S@f].:?CGCGAshAz??8tz?Dm?]ޭe$?TJH?/)?&S?-~?QP@q(6@M{2?~jt?CAGACADP@]56?CAGAC]56?rn?8EC] l?{ha8{?EGv?׈[N@ F%56@qgN}@ QI?AGACAP@8ZP?GGGCC9-?&?q? Rt?2:?(µ.ˊ?"Q@Qkw<6@z+;m]?{Gz?GACAAXfQ@Xȕ?GACAAXȕ?#0?=X?UTRZ{?gj)? 4R@G?6@>Q8?a+e?ACAAG5R@cH?ACAAGcH?-? +?Wl?uh?鄺~Q@8A`E6@^g?2%䃮?CAAGTx:qmQ@g?CAAGTg?GZ?U~ܠ?yS?-:i}?!LkhO@3T6@+?mxz,C?AAGTASMO@̱?AAGTA̱?/?o ?TId?{@?l]^N@0*X6@D@Mb?AGTAT9N@Y5e ?AGTATY5e ??-W?2 L`?.L? P@6Z6@ ?y):?GTATG#~P@ɞ?TGATGoǙO?t6?7͸?<@g?nY $?L@Sc6@=?-C6?TATGCqM@ܲ?TATGCܲ??: L?{>i?3;,?+MQ@4x6@z*ף?&S?GCACA*v+SQ@sR(۝?GCACAsR(۝?$9@="?=U?Ic?na؋? ڟQ@5@6@SC?8d`?CACAC.!+Q@>?CACAC>?۱ s?Nj*?*Y"?>g#!?Q@ q6@/mle=?|гY?ACACAT;?kQ@` ?CACACnǶ?IϤ?%d?Ri?~d2+?JzQ@gfff6@z?-C6?CACACXY*Q@y?CACACy?*:ϯx?YAn?s@#?Џ+x?wP@.!6@&D7? o_Ή?ACACC؂|P@!t\?ACACC!t\?{;t?2uӟ? K #?>old?xQ@ -6@ai )? o_Ή?CACCA4c6Q@fҶӪ?GCCCAźr?Ѹ?[r?wu_?(ې?|S@ g6@䥗ֶ?_vO?CCAGAR@ܻ|D?CCCAGpu?OIM.?vKKe?P2D?ْ(?ZܑQ@j+6@?[?`Qk?CAGAGOxQ@L?CAGAGL?Dܲ"5?C?sTQ?y]m?ReS@p= 6@Ÿb*?-C6j?AGAGG+HR@[uZ?AGAGG[uZ?3n?JE3?= ?:6?QhQ@۷6@7׈ x?b2U0*?GAGGAc Q@F B?GAGGAF B?2L'?Lu?o G?s%%-?Ni@S@Q6@n@S!uq?AGGAGSi*S@Qx?AGGAGQx?ѣs ?X5Cd?̝!?!9o>m2_}uS@H6@+? c?GGAGA/nS@j8 %?GGAGAj8 %?^5#??a?"?["?oOU>:cYWsS@z66@0LJ?HPs?GAGAAM!|R@ V?GGAGA?CU,t@ yS@6@Z? rh?AGAAAV@TS@ջ?GGAGAtm5?y<$yt?=mߔ?Y?h&gs>433CVR@?6@V?-C6j?GAAATZW#Q@Vt?GAAATVt?&3?19Pb?)OE?S>9!O@"u6@7Μ@_L?AAATC̿N@2W ?GAGTC.?+c?Rw=?q?}`^?c 0EL@6@h\?&S?AATCA+6NM@d]?AATCC* uȂ?ǥZ1?M ?v3?>7?V(nO@iq6@A=`@?F%u{?ATCAGGX Q@Y8qf?GTCAG@C?˓(?j[>?N'?"ARH3?*I@Ax7@.?<,Ԛ?TGTCCZ!L?ve?;VN@mV}7@bJ#c^@`Q{?GTCCG%߈N@Bp?GTCCGBp?G(xH?SS?a6E?`LJh?"Җ,?3TA$?J~kMM@&17@*8eH?b2U0*?CGTAAh^M@D0]?CGTAAD0]? kN>?W*f? ?ӱctj?ƫ?VQ@lV}7@K7c?Aǘ?GTAAT5:Q@V^g?GTAATV^g?"+?']dP?U)?xkl?ĦRO@<,7@DHc?Ǻ?TAATTQB1P@?TAATT?4 Lb0?[?L1?!`}t?* L@[B>7@Կ?ZӼ?AATTG,.%K@{"?AATTG{"?0>b>M೺?0?YvhK@ڊ7@?HP?ATTGCCQGK@4?ATTGC4?m>ޔX>Ơ b˴?TTGCT>˴?zBqO=? cl?uSJ$?l?LZLQ@ݓ7@&@/n?TGCTG+DJQ@ D?TGCTG D?{}\?d/?8iM?>*?B?7"9N@+7@#?? rh?GCTGA  O@:?GCTGA:?Od?6?6v&ȭ?*U#aO?pQ@3ı.7@zZ3[?a+ey?CTGAAeDP@&%?T?CTGAA&%?T?_F]?!6TB?__A\?ym]?Y4R@o7@'J?b2U0*?TGAATc"R@?vBO?TGAAT?vBO?䕮5?Tlf?WBe?TRP?.bP@7@U7>?Mb?GAATTLZ6d܏,6P?7?iBM@J&7@-ZW?3U0*?ATTATMN@(p?ATTAT(p?B[EV?C*n?]DT}?;-?dP@b2U07@>Iz?b2U0*?TTATT['P@%a-F?TTATT%a-F?_2i1?n]?Վ?*UaAz?vi?3333P@Qs7@GJa?ݵ|г?TATAAS~P@9~?TATAA9~?JW0?뻶b}?T?[?ZQ@:M8@~}ON??Ƭ?ATAAAi;2Q@b5e?ATAAAb5e?0h)?Ui^?뼣* ?766-%?taCQ@ 8@T,b?V-?TAAATҕuQ@@ ?TAAAT@ ?ěFi?T?OYW$?7QT;?^}O@28@ ~n1?I +?AAATAiP@+O?AAATA+O?4/9?I.dz??ڊ+ )? ,P@v8@]q$?F%u?ATACTEcP@l<p?ATACTl<p?ˠ? qR#v-?,3?o9?9S_~P@RI&8@z,V?I +?TACTC KP@P0C#(?TACTCP0C#(? ? ~?sԸ?UH?9@O@Q)8@-ɯe??W[?ACTCT! O@Nhr?ACTCTNhr?5rr i0?[s=?o:e?MB+?T$P@ꕲ 18@Y0? q?CTCTG/pP@ #?CTCTG #?Ta??Q?YgvH?@ǘ?CACGA5R@Z?CACGAZ?v)ល?6?7S?o ˞Id?"Q@[d;o8@G{?pr?C>٬?ACGACܿةQ@uj?ACGACuj?cε?qǸ?  &?z -?yR:P@C>ٌ8@so?HPsע?CGACTH P@\?CGACT\?/?#02?J$#?dٶ?{F fO@ʡE8@oS@xM? ?GACTCvO@rC 'p?GACTCrC 'p?^?v?2Zp?=ܳ?gcO@68@L?<,Ԛ?ACTCT~7O@(?ACTCT(?I?y?nqtJF??|;?-P@(8@6Ub,?ZӼ?CTCTA,P@W8?CTCTAW8?yz0~5?K?:ys?I?;r&Q@:M8@)¡?ec]?TCTAGAت;1Q@ZY?CCCCCdy(?,p?'?@Q?Y?t 82y?q"R@{8@=}?y):?CTAGAԺ/R@ͧ@?CTAGAͧ@?.r?>C? v]d9?Р?ћ \R@ǘ8@m+v?W2ı?CTAGAn//R@뚖?CTAGA뚖?oU.?0k+P?ȟґ?B?PdR@ڬ\8@wr?Aǘ?TAGAA1rR@ ?CAGAAs(?S?o(?C. %Q@ܵ8@0-.Z?Ǻ?GAAGA*5rQ@?GAAGA? Io?1$Y?G{-Q?I20B?>R@jt8@^__^7?y):?AGAGT,魆R@vNf:?AGAGTvNf:?dZ ?KM?#¦?ɦ?z>]O@kΈ{;i> :Aygg?g3>5 ?d"N@u9@M㥋a?gs?GTTAT(& M@l?TTTAT1?sծOa??MpX?;f?N辻O@Tt$9@L ?b2U0*s?TTATCؖO@׉M ?TTATC׉M ?P*(4 ?Շ~?L2=?9\G^?2eM@Y 9@z?`Q{?TATCAUߒ7N@cȆ|9?TATCAcȆ|9?9@e?@ 0*?CGGGC+vtN@%)?CGGGC%)?Re?Ov=?b8?UOפ2?H$ʻP@H.A9@L?n?GGGCGoP@S(㈴?GGGCGS(㈴?-p'Z?V?6?FS; ?X@?|?fR@ioD9@ϱ1?Mb?GGCGÄ8S@L2Z=?AGCGA4.7?ؙ-? 3?Xԧ?M0zB)?jQ@ǺF9@~z9=?vq -?GCGAChQ@3R}?GCGAC3R}?M)?aEr3?l(;u?gsK?A0P@0J9@ai?:v?CGACGP@:Ϸx?CGACT'l?0YE?\?E^!?)B?G`P@[ AQ9@(?kt?GACGT tysP@?GACTGL?Q]t?'?IL?1'޻?k˾;O@{,C\9@>)?>$5?g΢?j8ߗI@9@%jl?M O?ATTTG@JJ@ao?CTTTGP+? sc@->SvWg>nX >?磻B?oF.cM@B9@![zo ?_L?TTTGAEI`L@&2?TTTAT|i59^?5!??7j?"5?P@镲9@b@ ^)ː?TGATTЈRYP@0=CCGTT_;QB>1ҖyX(>ctW"=`>v |)jϥ? mT? + ( ?+M.P@Q9@]6?S!uq?TTACGN`P@̐?TTACG̐?G2*?bC}?>?gD<`?`gdQ@69@#!Qfu?HPs?TACGTl laQ@7?TACGT7?x:&?5º?TD2R?|X?%b)M@ y9@eF?Q|a2?CGTAGuM@E?CGTAAsB!? M?gnZ? AZ?t xg?f' HQ@s9@,~?{Gz?GTAGCPP@>kI{?TGCTC÷?D/?{5a?mXEf?8pu?2j[P@HP9@wG?_vO?TAGCC`ZS2P@w.?TAACAw?C r?2'?w?qt?sgٙQ@9@#l+%?q?AGCCG&K$LQ@Hm1Ff?AACAA.ɳL?%gh}?N??]h4?6ϛ(i?Aȗ|p?*t g?A\O@mxz9@gQv? ^)ː?GTCTGrN@#2V?CAATC{4Dr?v #?ߤup?nuR? )?1yo|L@D9@aiv8?vq -?TCTGCT#M@?AATCC(VY??cT?x2D?'#>?ajeN@[Ӽ9@!5?Pkw?CTGCGRN@sG?ATCCA:@?HPsע?CTGTGݓ$r L@[?ݵ?CTGTG[?ݵ?ȭM\V?ҁb^?1k?Xsfi?nJFJ@d :@p;?Q?TGTGC?|\-Ϳ$>>j+?cq?lP]hpL@UR'):@9M?|гY?GTGCC C80L@Ř?GTGCCŘ?ch^>Wμs?8?ݹ?(nt?7b?w}?e"R@NbXY:@7@tF_?GCCAGW|VR@`"#?TGAAGA?ˮmHH?'|1?7~?$~UC'?HɂQ@ݓe:@}et?{Gz?CCAGC>RܚQ@;"h2 ?GCAGClK3?Qt?M(?O ?"3[x?dXoP@h:@x;턯?5;Nѡ?CAGCA=P@4٣%m?CAGCA4٣%m?m?.}?G>?[0?ei`r^kR@u$p:@,ME? ?AGCACh2`!R@CW?AGCACCW?6:B?.i+C?^q?/S?at"1Q@y:@C ?NSt$?GCACADRQ@S ?GCACAS ?:'|?g?rzSK?.45̟?lQ@ :@GA?z6>W?CACAT5.R@]?CACAT]?I} ? Vs?G[~ʷ?`Qso?[bQ@zX5:@)'" ? 0*?ACATTϪQ@1F?ACGGT y?%?1ڪt?NkE@ޫ?*q [G?{?dK@N@:@ ?Ǻv?CATTTqb2vK@rĴ?CCTTT]o[?cy؂>"\&>kYQ*=?nD?PI@ O:@93m?vq -?ATTTAksJ@EǴ?CTTTAxi|?8y<>Ӵ8ܓYl?? +NN@/ݤ:@O3?y&1|?TTTAG N@.TS?TTTAA%{? 2[?V60?~~Bx?Ces?ӕ^2Q@罹:@n?ŏ1w-!?TTAGGugQ@/`)U?TTAAT}# ?* ?%?7^?Cn?"14P@&u:@'`gV?_vO~?TAGGCKP@UEǯ?TAATTJٖ?xX?lpK}I?$t?O?Q@#~:@~?&u?GGCTT]sܙQ@@Kٹ?GGCTT@Kٹ?2rw y?Kw?U?LEyK?^ J.L@$(~:@8s?䥛 ?GCTTGg8M@ (?AATTG94{?Cnq]?F|>aG? |,H?ƋL@<:@.?~jt?CTTGGA7"L@<?ATTGG̓S?Nyhi/?; u?Pv?!K?G]պ0P@|a:@?I +?TTGGT%oO@fUoƴ?TTGGTfUoƴ?7qE?P?M?%m?k/'M@^F:@9%j?y&1|?TGGTT"lxaM@#»?TGGTT#»?Q.v? j8?zz?ڻG?sbXJ@p_:@"!y(?St$?GGTTAvK@Vy?GGTTAVy?@gV>?ވWr),??C~NP@( :@? ?TTAACd?ʸP@6@?TTATAjkᏹ?}b"?e}?#s?{?̽O@N@;@f?"u?TAACGQ'\ P@]r?TATAC? $k?ZxWx?t~Y?<%#?m-zA?K&=Q@#lxz;@DMWJp?-C6?AACGGPP@Ybn-?CTCCG{h?K#2?)#N?!,2?ک_Mh?My1R@&1 ;@8w_!?_L?ACGGTU{Q@W?ACAGT S??a?栐?yBP?jycM@2ı;@79tq?Ǻ?CGGTG#IM@ [F]?CGGTG [F]?K-(?L9?iBCk?-$?΀dN@ŏ;@aaǍ@ŏ1w-!?GTGGCRirN@uѷ5?ATGGC7?(߹?7+!nٱ?q}5?%\s/?f<=P@hs;@SN=Z}?y&1?TGGCG`P@⠊5?TGGCG⠊5??6涽?z?[-,?&j?./S@k ;@roTb?&S?GGCGGtR@Lh̲?GGCAA d?e??."5?4\S"?oR@V-;@lo47??GCGGA$»Q@x ?GCAATH76?݂K?xZܞ?B)?Pt "?0`P@d ;@Z6?I@5;Nѡ?CGGACBcP@WV)?CAAACٻ?}i?ӡRq? P?,:w? " 0O@ );@tȴr?_vO~?GGACC_EDP@$yvp?GGACC$yvp?_l>u?ƛ¼?Hwo?4WkXN@u<;@I;%`?HPsr?GTCTG̛N@5{?CATCT^]w?9ߺm?ëh%??Ï z?zGN@( >;@a 뒸?z6>?TCTGCt1#M@8Aeٻ?ATCTG?oYAKHH?8?1!5d?F+ /?voM@BI;@? 0*?CTGCT(\nN@YWE#?TCTGCS_=?IѳGq?7`:Ϛ?NM? m?{aQ@O;@F q?Y5;N?TGCTARQ@jy!\?TGCTAjy!\?0u?T̜5?ȲԾϟ?^ } q?{tb>Q@/$a;@la?/' ?GCTAA* &Q@Zj.?GCTAAZj.?vt?s+?iWlJ5?]ɦ?ĦfQ@4v;@3¨?Ǻ?CTAACRϰ>"Q@UPJ?CTAACUPJ?W?"?vw ?`lo?X%P@4x;@"Q9?F%u?TAACT{JO@v4?GCTACJxD?8mY?g]3?<?;ʅ?WhP@HP|;@u9?L=U?AACTAܵ[9P@otU?AACAC`@ְ?@k? M?_?ޒ8?ܑ͈R@L7A;@Iu?<,Ԫ?CTAAGk=2R@v=|?CCCGGFtn?sl?97+?[!?>d?.GR@U;@ ?"u?TAAGA?wnQ@mz.?CCGGAUn ?9?˽?X?=0?caxR@s;@瞳@Y5;N?AAGAA]nbeR@ t?CGGAAN?dόYoS@Y;@bVK?HPs?AGAAT S@Y /?AGAATY /?9sNK?Kf?d?cח>oP@V-;@PH1?<,?GAATAҾ~vsP@Θ?GAATAΘ?dc?qg ?pJ?T[9?t6P@JY;@!?/n?GAATA*usP@K?GAATAK?Ns(?#>5t*?L{?o? O@(\;@!>?ec]?AATAT(*O@%H_&?AATAT%H_&?pQ@? )֋w?\Ŝ?䪼?yeN@ڊ;@|1@ׁsF?ATATCmMQO@ͬDt?AGTATl|=qT? 4?/WW?kVߵ?% 2ſ?@Nh>O@lw<@jA)?ǘ?ATATCuQO@><@_W?ATATC><@_W?Wҹ]?ޙDK?/0b?#y+A?pHN@&<@ɠ? ^)ˀ?TATCGfN@rp?TATCGrp?: *?Y:?m%Te?xKa`?SDP@q<@FF?{Gz?ATCGTBogtP@l4?ATCGTl4??\/?#Ą?& s?GJZJ@HP<@kd?-C6z?CGTGCIiwJ@1S?CGTGC1S?_A> /]e>}¨?2K?TN@~j<@1|#xh>5"c?ޑ ?%ՁI@QI@<@]6R?Mb?TGTCG`|RywJ@NJ?TGTCC?:R=%~~>fzdj?ʇ,.?2kN@ B<@w@ c?GTCGT7a\P@GqP,m?GTCCGl6h?TJ2?t?~$4?PA ?AfO@ P<@}j"@_vO?TCGTA٬ZaO@9}?CCGTAŸ#?4m:?-?xA?1d?0lS;cN@gS<@_S@HPsג?CGTAA9dM@w]?GTAAG>]?jg?o%?>?un^? %Q@Sc<@)7@*Dذ?TAAGT_]BQ@ih=v?TAAGTih=v?\3?=>?JB?XX$?#q{N@<,t<@-BZ@0*?AAGTGhz0N@'u?AAGTG'u?s@?"c?%M?T~?+`M@9EGry<@d+`?Mb?AGTGGBd ӇM@ 2?AGTGG 2?Be#nd?ٲܺ,?LH)?ee:? k߰O@~{<@-0@/n?GTGGC vrN@+?TGGGC%kT?VY?~^O?L?8蕲?׭Q@H}<@ǡ ?]K=?TGGCAU}P@k{~8P?GGGCAx ?n{r}??}p ?4Q?6MxCi?mVxS@q<@P۰?/n?GGCAGHS@eb{?GGCAGeb{? ?Pg.?sĻ?MIr >8& R@Hr<@ْH?_vOv?GCAGCRLHQ@'_?GCAGC'_?vnC?Dt:?Ё?v;?BW.P@iq<@-Mu?UN@?CAGCG9P@U^&L?CAGCGU^&L?NL?ӷ?V/cs?]6!8?䡄MQ@A<@՚?J4q?AGCGCvY(rQ@ 9W?AGCGC 9W?| v?³~?J?Y 4a?i- Q@}a2U<@?<,Ԛ?GCGCA\jIQ@;?GCGCA;?S?fW??KTMk]?־aES@p= <@W6?/nr?CGCATerS@ܴ5?CGCATܴ5?9!#?P0?@yJ?:߼)>WhQ@0*<@?S$?n?GCATT3H&SQ@ɚy,m?GCATTɚy,m?*sH?W ?Xf4۽?9W%Ze?{׍4#yR@|a2<@麮?@ǘ?GAGAAK|R@Pb?GAGAAPb? )?v"գ?R9?ǡ$0A?B S@Zd<@q}O?H}m?AGAAGFinS@ׁǧqv?AGAAGׁǧqv?~Z?ԡ gZQ?G2?ԣt>"P@HP<@uS?ZӼ?GAAGCS)FN~FQ@}?GAAGC}?i4?A\ ??]Q9{?ðĚ8Q@\<@O?2%䃞?AAGCAClP@igwz?AAGCAigwz?qS?5@?SzT~_?ܶu5_?NOS@Ǻ<@ fY?b2U0*?AGCATƪR@Ƅ?AGCATƄ?t&?C->h?lE?;U>.P@<@C!ޮ?_Le?GCATT.c[$SQ@.kú?GCATC8x-? B?KItß?OJ?͖?GJ@B<@=e}@b2U0*s?CATTCNJ@ޱHVkN?CATTCޱHVkN?!wx-'>Ot(n>:?z??LO@f<@K%*'?b2U0*?TTCTCyO@h5?TTCTCh5?W?f>B|?T{?Q|H?<jP@ڬ\<@{S9?5;Nѡ?TCTCAO@bq'[?TGACAPQۘ?1l?IO?Y8{?]ʻ@?X/Q@ʡE<@;F?ACAATm3?_$6?^'?s?jQ0?`P@( =@O"?ZӼ?CAATC}O@W1?CAATCW1?vNN?eR?eG?wJi?raM@|?=@s?{n?S!uq?AATCTi݁L@EC67e?CGTATw:T]?\Mc?_Y?24?1?/'uO@Q=@oA ?{Gz?ATCTT/'*VO@uÊ?ATCTTuÊ?Z\s0W?]j?!g$?%"5"?ttL@z6=@S{?Mb?TCTTGǷL@[#klr?TATTGre2?حKsB? >1]i?hD-5?s@TK@"=@8X]h?b2U0*?CTTGC4K@rc"L|?ATTGCizj)?삅|j>DLq>أt?֪?"CN@48%=@[=x?eX?TTGCG=^8N@1`A?TTGCG1`A?Yb?BC?ÇfT?,ԕOx?o9rR@Hz.=@ Խ?HPsע?TGCGA.9R@ Sp?TGCGA Sp?^Y?%/?ݹTL?(wº>-5:S@m47=@̅y? Zd;?GCGAG1^GR@'iL%?CGAAGEeEF?.aQ!s?̠Cw?oȋ?Ѱ>k@Q@՚G=@ON{?UN@?CGAGC"HdQ@?GAAGCt`;?VhC?ni?tCt?+q3?ouP@joI=@<}?S!uq?GAGCT,ьP@N e@?AAGCTw?E?tx ˼?5?@B?oNQ@MbP=@ge+w?~jtx?AGCTGl5/?Q@ݛ?AGCTGݛ?VJ?րgS"?CTATCX}ؿ?TI?ܼ?5?(?rrrM@{Ga=@GY,0Q?`Qګ?CTGGC;N@g@f?TATCGY(?/?t:f?K-?I27a?W_P@b4o=@+?~jt?TGGCAP@u Tѱ?TGGCAu Tѱ?C h?7&?^? ?v>wS@8EGr=@d0t?Mb?GGCAGq4HS@6 ?GGCATE0j?Ȁl ?; t[?-+?OS ?7GOQ@NSt=@ 'l?]K=?GCAGCH1Q@1D?GCATA??LZB?8'?h!V~?BL }s?"(P@s=@nN?J +?CAGCTW[?GCTCG3O@ГɅ?GCTCGГɅ?DX$ V?WGV?>i`t?(k?EJQ@/$=@ ?y):?CTCGT0grQ@J$?CTCGTJ$?D?E?(؇.?T+U?&,<#O@9#=@%Oݕ?T㥛 ?TCGTAuaO@7?TCGTA7?_M/?--,Z?dn-?k16?A:ĭM@\C=@Y@Z> P?j!K?Pn.N@2%=@)z?&S?ATTACMWDM@M7 )?ATTACM7 )?q?ʍ?C,R?VnQwr?O\neP@:p=@H'W?Eioɴ?TTACA/qP@N0k?TGACA\?Z~?-ϳ?>#?κ?kjsQ@k+=@6qVFC@_vO?TACAAe{פ-Q@t"?AACAA) ?tvK?*B uo?3 y? s) ?'㚨#Q@fa=@tP?Q?ACAACP@4^?CTAAC?<"?B.0?7kC?lf?#?;dC!P@ÆW=@@Q?F%u?CAACTOO@Q ?TAACT%\}?Y\l?03nH?dQ?7'vs?M DO@Ǻ=@'?{?AACTTl)O@M?AACTTM?ƝD? @V?UDG???mYJ@4=@\`̒?2rFm>y䏣?`Fӵ7?FM@?٬=@<?46@TX"?-C6j?TTATGxLP@e\?TTATGe\?sZl?OD,d?<?հCw?~+կL@;N>@J*S?/$?TATGCrrM@u pR-?TATGCu pR-? V*?cqD?@vy?hMh3?Mt;P@ŏ1>@VR^?q?ATGCA,[gjO@w>m[T?ATGCAw>m[T?2!?|5n?H@l?=BKv?IQIS@H.>@!'?ǘ?TGCAAճ]R@y(t?TGAAA':?nO?=$V?j%Z?FMR< ?" R@ y'>@$e??ܵ|?GCAAA*(R@?k+?GCGACe?2fK?,2?0?יzB?D v'PQ@/>@h?N@a?CAAAGo/Q@W>@ӜR?H}?AAAGA Q@/~?GACAG*ԫ@?UVZj?|']'??`~d ~?2eR@cZ>@;?J4?AAGAG ,,R@ $!?AGGGA|??=O=?, |?]?7U2,?haz[R@ec>@+q1k? ^)ˀ?AGAGCQ@#*(6?AGAGGN܄l?;P@ʡe>@Ƙ[?$ۧ?GAGCA`hڥP@ς "?GAGCAς "?_?J*k~?X'0Q?&{?R@ŏq>@Pf??AGCAG#R@$l(?AGCAG$l(?S!f?F,ue?37oN?CG[S(?wZP@Q>@ ?Mbp?CAGCGk P@qv *?GAGCA v?p&f]?pNp?Zʺ?8J?{2eR@ÆW>@;sκ?{Gz?AGCGAI@MR@ s?AGCAC;u1M/?D.+?s?bI1?Fj?`6_QQ@*>@# ?{Pk?GCGACUQ@2R3^?GCGAC2R3^?B =?\0?> ?]M?ݶP@V/>@ u?Mb?CGACGgNP@F#N?CGACGF#N?NC?w@j?H}m?GACGA:Fy.Q@Mcǯ?GACGAMcǯ?G\6?\J?X@0 ?1Ʀ?v!hϪR@x $(>@͓?ZӼ?ACGAT4

@1_{?`Q{?CGATA>HjP@鈆?CGATA鈆?~?sf?fн?3?L7A>O@e>@[?:v?GATATQO[O@U>g?GATATU>g?UH:? w?`R?͞*?coP@c]ܦ>@%!9?`Qڋ?ATATAC&\fP@R3?ATATGڰ ?uB?j@W?없?hI6?QN@ÆW>@ꝯB?n?TATACQIpO@ 0C?TAACC25>?Pg\C?rn?:J8>U? j5?+kP@d`>@m#?JY8?TACTC0 \KP@R(h{?AACCT@ @V?tF_?ACTCG{ISP@F`P?ACTCGF`P?9?p5?>2?y\3?B?Q@X9>@Ʊt?ZӼ?CTCGTZg]rQ@l[?CTCGTl[?{K? `m?<ŷ?߾ۀy?eMM@&S>@lh}?d`T?CGTAA<ӛ&;M@<)?CGTAA<)?@I"?Mbp?GTAAA'MQ@VZUt?GTAAAVZUt?Zb?AG?~4…?"˃31?pɂP@$J{>@cf@_)Ǻ?TAAAC\P@\e?TAAAC\e?}&At?R?W`G?jР?S.N@ZB>?@׎?<,Ԛ?AAACCYdN@>?AAACC>?5?2,?3%?ˌu.?NI-P@t ?@~d۵?J4q?AACCGn h4P@xi/J?AACCGxi/J?\w/z?-?|.x?hHZ? ӲߔAR@V ?@OR;?ݓ?ACCGTGVQ@4Ax?ACCGT4Ax?Ļ|S?SQk>?!M?9k@?ZAM@Q?@j'An@y):?CCGTTmv3M@dP,K?CCGTTdP,K?8bq?}#z>dLw? Ϊ?4m/I@C,?@9??CGTTGmDI@6jdY?CGTTG6jdY?裉4>os=x+Uq ?*'S?(K8L@{2?@3Q?JY8?GTTGG_tK@.A?GTTGG.A?aN>>GJa?at6N?+42?A EN@k+=?@Jy?M O?TTGGC⹊?TGGCT>⹊?9yҁ?cnXh?Ct??d[j1Q@;pΈR?@Ȝ#c @n?GGCTT˿tQ@Խ?GGCTTԽ?ZE:~?_BT?8NCb?^s4?{lL@' U?@?0*?GCTTT ρL@%@X\?GCTTT%@X\?>u7'>Ͼ?TTTCT>?5N͂> b&?huM)d?ߌYY?zRNi4P@5@b?@@)?_vO?TTCTAuO@1?TTCTA1?Z`8?9<)w?l?b?ut.MP@0L f?@q?q?TCTACR8EP@9`=?TCTAC9`=??x?TP5{?R ?#'nP@o_n?@@ ?F%u?CTACGpp\-P@ \,+?CTACA?V?o4?sS?k?b?}?`#R@!rhq?@K^?F%u?TACGTs>aQ@[$?TACAT^CB?^;v?q?bp?Q"u?~7hM@\~?@{l^?a+e?CGTAThp$M@z>?CGTATz>?ORf?<5? T%?&?F] P@M F?@G5}A?ׁsF?GTATC'# V*O@O ?GTATCO ??dUQ?}z&͸?v.}?:WM@$(~?@ 3?_vO?TATCAkN@GUC?TATCAGUC?C?/d?M=r?G?)\vPQ@HP?@&TO?:v?ATCATP]Q@?56 ?ATCAT?56 ??o?P#c?ڒ? p3Q@7?@~"C}@~jt?TCATG5#1Q@`Vo?TCATG`Vo?Iqq?y S? %C*N?~7]?*0O@0L ?@(w?H}}?CATGTq{aN@`'$?CATGT`'$?dW?hܛv?[B?{nU7? L@@?@,UEb?F%u{?ATGTG:L@؝Yf?CTGTGw6?4V.?`K !?{Ƽ?_u?+^GK@ ?@~xާ?ZӼ?TGTGTK@ ?TGTGT ?|>G"U>+z?IB6?<]靝L@K{/?@ ?ŏ1w-!?GTGTG4L@j?GTGTGj?7(?Ut$2?B$n?<1N?",L@R!?@6eO?( 0?TGTGABwxML@W3?TGTGAW3?OTN?&|$P@QOB?CTCCAb}?VƝ?n)?wٮ??-G&?_ö́ER@<,?@&?{Pk?TACAG]Q@ (^?CTAAG5uS??84??]d?jf?0Q@*?@e#?H}}?ACAGT\y%R@V]d?TAAGT?oiX? ;?uyX@@x'`?-C6?ACGCAI Õ)Q@?h(?ACGCA?h(?I~?wH?, ?ZDM?ER;#dS@46@@K~@m?w?CGCAGc$A4S@d#?CGCAGd#?֢=87?RF@AP?fV-?'0 >N2R@V-@@,?b2U0*?GCAGGpgf^R@hdd?GCAGGhdd? ?>\z?.xf?D?ȹ?^B;-R@aTR' @@aɁ.Y-?_vO?GCAGG̃R^R@Q~X?AGAGG?89?sn?v?н?Q_sZ>ޭu2P@1%@@٪k@&u?CAGGC20~bP@ 0KR?CAGGC 0KR?w?wDᴋ?(?a[W`?0}76gQ@zX5-@@l?jM?AGGCT 2;dQ@Z?AGGCTZ?D?Y~ h? !?S#~u?mQ@/!6@@`Ӈd@HPsr?GGCTTmQ@  }IJ?GGCTGq]< ? ?NF?3Y}$?mf?mR@0*8@@:lSn@w?GGCTT㬒mQ@ocձ^>GGATTIu\?"$?>5 ? I=F5M@ 9@@ &/+B? QI?GCTTAodM@O?CTGCC˰g?ЃBk?J82?g?á?uoZER@d]KH@@7A^?<,Ԛ?TTAAG†Q@c% ?GCCAGg:Χ??l+T?@ٮ?nW?R@hO@@ɯ<~?(~k ?TAAGGZQ@oۖ?CCAGCzR ?U ?#(?]?: N7R?{P@ h@@"'e;?{?AAGGG,U!Q@N?CAGCAc?NGf[?:?FxH@?3Zԅ~?BR@Mbp@@[2g?y&1?AGGGA6 %R@3Z?AGCGGmkx?+,??UK?C7kW?d#Q@s@@c R? 0*?GGGATՠR@Oϖ?CAGAGdGt?iOԱ?f?f ?FE_@?p=tR@/!v@@\&?`Qګ?GGATGLAQ@0m?AGAGT#Z?Ҍ(Y?p}??Q)7>L@J@@$Ń?<,?GATGChҠL@NpVz?GATGCNpVz?l]?w\V>&?s.5?Z?%WM@h@@gԧj?UN@?ATGCTD|N@OA?ATGCTOA?N|? E ?7? 1F?TR'Q@-@@xZ?{Gz?TGCTC?d_P@Mμ u?TGCTCMμ u?J ;?A&+"T? m?m7ą?2WݱN@V/@@t+ch-?~jt?GCTCC{N@?J?GCTCC?J?QZ~0?Ĭ+f)? [n?vjpz?*4%O@vq @@PZH?$ۧ?GCTCC mUN@>?GCTCC>?(?Iik9?Fj?CW0E?(}ҧP@t@@2[?H}m?CTCCGP@Br?CTCCGBr?5g?bNd?ɪW?6?z5\R@@@`*?@ǘ?TCCGAYE,R@ B8?TCCGA B8?N!?f3?;V?EQD=?}i9S@HP@@}&?F%u?CCGAGU R@_a?CCGAG_a?T`o?](v?C?RKgR>VR@z@@7X?Mbp?CGAGT64 !R@} ?CGAGT} ?i?4Ӊ8LA>v.?#ȉ? 3(L@o@@Mu?&S?GTGCT{gM@ x6?ATTCA8+?l9> \41?g[F?bט?֏Q@M @@%ZF?(?TGCTA%-Q@?a+ey?TGCTGuJQ@c=?TGCTGc=?IﶏW?Yݪu?cX~?sߍʏ?}eàO@JY8A@+??GGCTCHS+>?%Y?X!pP?}!?T;?RjO@oEA@M@a+e?GCTCAJZժO@aj??GCTCAaj??A??i`ק??5jQ@PnRA@nW?"u?CTCAC=MQ@>J?CTCAC>J?,3`?iL?nY?tٵ?% >~P@3TA@q6?S!uq?TCACC\JvP@WNkN?TCACCWNkN?G:4~?E ?k?O;?m;Q@~[A@u$>?j+ݓ?CACCT)&Q@R qk?CACCTR qk?P?i?Ḽ?bpP^/?AACGC<?M.5? E?w0B:?!?4d%R@ rA@}iKhX-?&S?TCCAGŲ6HR@+@IS2:?TCCAG+@IS2:?; ?Պ?Rd?ƧvYdF?wR@/n|A@a? F%u?CCAGGu&vR@K>?CCAGGK>? ~?Y;?߃3?SK ?LE҅Z~Q@@A@n H_?<,Ԛ?CAGGA'4Q@kf)?CGAGCbi<"^?#?/j9? ?x9:? oR@lA@wg @F%u{?AGGAGhD1*S@9WjJޢ?AGCAG|>? T?K?d'@l?\Sܕ2?/=DR@ qA@t?@Ǩ?GGAGG+BS@OKש?AGCGCW׾?trZ7?4.!N?Ok0K?;B?`LQ@MbA@&l? rh?GAGGGHߊQ@sѽ?GCGCGzc?|g?"Hg98?L+'?1?1@R@~jA@ '?n?AGGGT83Q@`)gb?CGCGTRs9?If?5P%?/p?´P'?[ O@\A@8#'1@?GGGTC;:TN@>Z?GGGTC>Z?C3?v} ]?Ex7F?rj?+II@/ݤA@Y?I +?GGTCTS8(:gK@IA^*?CGTCT4q?o\>8E`>AM4c?ml,?_"$#N@#~A@bQ?5;Nѱ?GTCTA]ԫN@7/S?GTCTA7/S?D@?Iw?E?#1?ArDP@HPA@ ?Af?TCTAG{ֵ<1Q@gI'?TCTAA9&|HF?JF?7Tn?٩e_?xM?cp;Q@鷯A@z>*?`Qڛ?CTAGATjr/R@對!?CTAAT3?_4 ?3Xf?`sor?2UP'?cq/jP@]CA@-XI4?I +?TAGACr P@zh˹?TAATAjۃK ?Xk#?"?ƉI?_D|?Z.P@A@ّ^?ψ ?AGACT&yP@ ie?AGACT ie?" ?܄? cժ,?h@?P@A@\IgK? 0*?GACTGQϋZP@FǸ?CTCTC뙛?W$Nvq?i-b?I? #2.?3ı.O@BA@)[a??ACTGA5O@h?ACTGAh? 9hrn?LƝPG?{J?ҙL?C9@xOQ@1*A@4a.?0*?TGAGC!eQ@E/?TGAGCE/?vL?KT?w0?pG; ?ƾO@}гYA@?镲 ?GAGCCM0Y,P@# ĸ?CCTCCn:L?&RO?)Q{7? k?:e? Q@QsB@ ? 0*?AGCCT;;VDQ@1!?CTCTG)-?՛ ?E/|?{}Uz\?[= ?,;Mwγ?Lf4P@58E'B@vBd?`Qڋ?TAACAymP@l)ͺ?TAACAl)ͺ?2;??o}?Eb??zWR@o*B@rb`L?:v?ACAAG$bR@Vf#?CTCATN/Dڶ?e>@?2 D&? M?ԀT>?mٚ^Q@Hz.B@~?~jt?CAAGTf wXmQ@aS?TAAGTIZɾ7?Q)C?hKҶ?ѤRW?Buq?Ґ?L@x&1B@??Ǻ?AAGTCUL@P?B?AAGTCP?B?$&ͻp?צ w>r$?"5&?4)O@J4B@7A^)o?eX?GTCTTӷdN@۵X5?GTCTT۵X5?ǣ;|G?"?UhM?yU? ; fL@oEB@X؝Ǘ|?X9v?TCTTG+L@OJT?TCTTGOJT?4f6?ݑ.5?qYrE?QC?߃=LlK@UMB@ ? ^)ˀ?CTTGGƂL@uX%?CTTGCɝ?ۡ>w9?qԭ?V&@?ɻN@oOB@ y[?:v?TTGGCKN@資5?TTGGC資5?|a?Z^? g?m+w?P@HPSB@ka?gj+?TGGCTgOrP@KGqZ?TGGCTKGqZ?KԋS+?y4qP?C/v? xoܳ?Q@&SB@pyxi?1*D?GGCTCBldQ@1qY?GGCTC1qY?Hn?(?E62??]P@/'B@X2b{? o_Ή?GCTCTܭjvO@Q?GCTCTQ?$]f?glH?9/r?g?v?3P@|aB@$#?6?CTCTTt(XP@Kݑp?CTCTTKݑp?N?SV?ͫ;rA?o ?3>Q@#K@L7AB@ng?@ǘ?TCTTTPK@1Q?CCTTTQ?"t9) A>?1 Y\?%J@ׁsB@ M?~jt?CTTTA EJ@]q=9?CTTTG֛/M?{<( >p<9>G0u?}Wy?n—5M@joB@y?"u?TTTAToh({M@ z?TTTGGg$?5>aO@?yGx?5UVC?=(O@(B@Ik?n?TTATTuP@z# .?TTGGTBQx?в"u??s?TΡfF?,ʍ?Γ30?Yo4?((?ǹ.JLO@B@1M ?Ǻ?TTACC牓O@D|?TTACCD|?X~Cc?D.V?!?a6NǶ?q= WP@oB@4?UN@?TACCA1HsHP@.۸gغ?TACCG ?S?rE7֥?+O??mcR@+eB@{[?0*?CCAGTٱj=UR@uҋE?ACCGTO?#֙y?^im?a|??Y?{,C,N@z6B@m6R@Q?CAGTGݠj&O@~bL?CAGTG~bL? Y˰?P3*"?"YU?~?!7 K@@B@SxE?w-!l?AGTGCҌK@4-74?AGTGC4-74?3R_>X~9p,?1ؑ2?ʸT%?X~JN@4B@+; @:v?GTGCA=M@~:0m?GTGCA~:0m?/ԡ_c^?DACx?>_?S|?vbqR@Tt$B@x@\'@J4?TGCATeR@m[q?TGCATm[q?,"?ÝI?哽`?KfDz>_Q@y&1C@NgB@HPsׂ?GCATCLP@&?GCATC&?pR?к)?r/)?6jx'=? ףpifN@L C@Js%?{Gz?CATCTTN@] 0?CATCT] 0?r׎?9הS?m?Y:?[(#P@uq C@=A?sF?TCTCAn1fO@j?ATACAM4?1`) ?-E?+Τ?TSo9F?$8]Q@ h",C@LC^?w?CTCAAQ2kQ@8;?CTCAA8;?4{A+ɭ?+\1Z]?O2?}axK?EP@&䃞-C@KXx?HPsׂ?TCAAC̨P@2$p?TCAAC2$p?)9?ghI԰?ճ?VK?N@FGr/C@x?5;Nѡ?CAACC*iO@+h?CAACC+h?-9?5HΪ?}[?5S?fwP@,e8C@vH8?`Qګ?AACCT@`P@8"L?AACCT8"L?+0?^*?IUC.?&j? c4Q@AFC@ї??ACCTAqۚkQ@BZ8?ACCTABZ8??9^^?$Y6?%^?}XQ@SC@ǭ,0??nRW?0cP@=UC@;_W?jM?ATAAC[bP@-%[گ?ATATG6QE? ?Lyo%?:@?`Ph׼?C,N@C@12f=?Mb?TAACC7)O@`1?TATGGi?kda/?ňY?HW? i"j?jEO@^)C@kb?:pΈ?AACCTn5cP@r4?ATGGGiѯ u?)? 8?/?DB?{o,Q@9mC@N@_vOC@ 5?W2?CTATC P@ATl[?CTATCATl[? %;?2 1b?W-!?s?N@C@?p{?Mb?TATCAi)N@LcH?TATCALcH?x3"l?ە?FT?AK;?Q@%C@Ga{8?<,Ԛ?ATCAACQ@2I1̿?ATCAA2I1̿?N ?x[?%LA K?jw?ԟl5Q@c]C@b?ZӼ?TCAAAv୫Q@<?TAAAA{8;z?o ZI?M?>ѷ?+ҋ>?AwFVQ@ͪC@?<,Ԛ?CAAAGUKQ@'T?CCACT|=އ?GCACTd|>އ?O5b?ɶ:?YhS> ??7Q@7D@~^'q?mxz,C?CACTA?\!Q@ڇ֔?CTAACʷ?JG\3?Z@$?FHjΘ?8)Q-?(\+P@RID@@IN?ŏ1w-!?ACTAT6\YP@'ӁLƖ?TAACG6]|?L ?iU؄?,?$닚?oP@ rD@3ؕ?gs?CTATT8NlP@6ǚ8x?AGCTT.Q}(?;1+8?ˢ?]E ?L2?yJ@^) D@T{-?&?ATTCTȮ2IK@o:}?CTTCTdY?P>?h>RGbd?ה#?|P@~jD@!?vq -?TTCTT7g?TATTAvߴ*?nE> `5?E 3?fB?,N@n#D@)Ձ?F%u?CTTATk$N@^?ATTAT 5J?xHq?>!~Y?4I?ǎ)0)?I +?GTGAT.ӾO@Q?GTGATQ?DH }?_QF*'%?&=I?Ƅ?ڃTP@|?UD@e;^?n{?TGATG/V|P@ḍ"*?TGATGḍ"*?abx"?X?+3?C_d?H$IM@1fD@?qZH?Ǻ?GATGGxnN@E?GATGGE?Z {?{ݡ~w??Wv ?0DO@CkD@$mG^?d`T?ATGGGb*P@Yc6?ATGGGYc6?P0Cu?;iF?G^O@"D@Tp?W}b?GATAA(O@C$9?CATACLS?rT?,oJ?_!?ܢI}?ZdP@W}D@/1?Mb?ATAAC NP@ә|`?ATAACә|`?l۷G?VW?}/^?v?O@7¤D@qe?-C6?TAACG-sn|V P@ǎ0?TAACTQ>'?K?w?{,2?gLX?ݩv! P@|PD@vP?`Qڋ?TAACG$*HV P@.XK?TAACG.XK?`aZZ?BqI?$#F?v/?4eP@ˮD@Et? ?AACGG P@aQD?AACGGaQD?tq?Ν?V9C?ժOT7?m:]Q@mV}D@ukx>?~jt?ACGGTO{Q@S_R?ACGGTS_R?XY`Z?W8;?r=?xwp~k?7&zM@ qD@5 ,ȯ@H}?CGGTGT;M@|.A?CGGTG|.A?V9'0?ԓ{?bMp? M? M@Zd;D@qJ?vq -?GGTGG0bwM@4{tu?GGTGG4{tu? Ck??ҝ?ݔ?A[w? *0N@d]FD@M4?ŏ1w-!?GTGGG{igxO@?GTGGG?(&?Y<#|?7O?/n?odFO@J +D@A C@<,Ԛ?TGGGCɅQO@`?TGGGC`?)5?]I#߱?S7tS?nP?jkQ@fD@[y1?Zd;O?GGGCAR_Q@P֭?GGGCAP֭?IsN:?Q!?\_b??I3Y?OPS@mV}D@1=0?ۊe?GGCAG4*D@THS@f4ƺ?GGCAGf4ƺ?;c?Dn?= ?0l:>j4GPiQ@h"lxD@.͠4@1*D?GCAGCڻQ@?M:?GCAGC?M:?o[?檒? f?71K?XLZP@=,ԚE@<Zp?X9v?CAGCG[QWֱP@V\ES?CAGCGV\ES? ? a-?r)?[]?fxQ@jqE@d;?~jt?AGCGCsW.Q@."?AGCGC."?eO˸?'IZ?Gn?P?!>8S@DE@zv?Ǻv?CGCGG1łRR@ǓJ ?CGCAG0h?![Ǹ? S=?{Q>ͱNN@|гE@ A@/nr?CGGGCrsN@ ?GAATCBR=?DB*H?`bġE? 0?6`?b֧P@<,E@q+F]?F%u{?GGGCC_biP@GE?CAGCCM?HgD?]Yw?OJn)? K?DQ@ܵE@Чʮf?JY?GGCCT9(߬Q@%M?AGCCTBM7?ĩH?1@d?- p?!'ف?5 Q@' 5E@~(c? c?GCCTTbu]Q@B2?GCCTTB2?iUf8C?R[,[?q[H7?/HOW_?l_xH@@BE@A@vq -?CCTTCm#uJ@Q|9?CCTTCQ|9?p~e0> Q;rc=bI?e~r(n(?ͯJ@0JE@3WcR? 0*?CTTCG)K@G?CTTCGG?LmD>F7ÙA> t**?jѱ+?TP@> ףPE@KV.i]?L=U?TTCGGIKִP@Fv/UV?TTCGGFv/UV?1 ?.e0U8??9Ƹ?@hP@¨N`E@l6@ ?CGGCTTO^P@"3f?CGGCT"3f?ε?3Pc?W?9`c–?t@''Q@?dE@̀=@q?GGCTT0'SDQ@q#?GGCTTq#? L?՚?R?-GÑ?BM@7;V?tv=?]|H@SE@U U?~jt?TTTTT2SN_I@l 7a?GTTTT/?L1\7=)'&=\J8?"M ?:I@]E@ga1f?<,?TTTTTz"N_I@vD:?h_Yy?1Q,H@ E@Q z?NSt$?TTTTCF%H@?TTTTC?_= > ?kݯ?#"""@O@ԘE@mՋT@~jtx?TTCCC;F/O@CbJ?TTCCCCbJ?? m?po?ā?V.!yV? Q@}?5^E@q2p|B?ZӼ?TCCCT+.OGQ@=?TCCCT=?$y?:Zz?g [?vvb?<\vQ@Tt$E@첾ޯ?F%u?CCCTGYAϳQ@ID9?CCCTGID9?AHkB? v*?&?.?Gz O@uqE@\f?-C6?CCTGG#O@ `;gM?CCTGG `;gM? JL?4ihU?r?VR?Y>VO@V0*E@j Ǔ??}XΡ?Jn?1?QP@DE@2c?a+ey?TGGCAMF߯P@YE@JnQ|?SiyT@ȘE@'w);@Ǻv?GGAAG\ T@&nCq?GGAAG&nCq?4w$ ?1}oRS?0|?p0x=E^$mQ@E@)]? o_Ω?GAAGC6FQ@*'G ?GAAGC*'G ?*Y^??}Y9?99*D?EB\*l?.]P@\E@8]?c8@/n?AAGCA>˥бP@#<;ƹ?AAGGC6?:?!?汞?c?1ik?CU(R@ű.nE@@u?n?AGCAG$NR@'bP%<,?AGCGAF?kF}g?5((x?PQ?~[?Y|S@EioE@@0+S? ?GCAGA,R@7:?CGAAA ?ВD?p,?uV,2?p>A qR@E@=I?F%u?CAGAGFQ@^?GCAAGשoT?s5?Up!?֐p?$cs4?I Q@K4E@ޠ=?kt?AGAGCpQ@Q?CAAGGCcL?3ԃ?lR?ۘ@5?=F? s?uP@46E@ Y?`Q{?GAGCGȬYMP@){"?AAGGC,eq?~\?),U?|mz_??t?y&SQ@EE@:>?Mb?AGCGCu t'Q@`F@ ? ^)ˀ?TCACC%OP@”O?TCACC”O?0pu?g??j7?yۺQ@ψ@F@,־\/?tF_?CACCCeel)Q@T=ޭ?CACCCT=ޭ?10?P˝? 3~'o? ?Z[_x?ǗQ@VMF@J qP~? 0*?ACCCCf{W.Q@43v=@?GCCCC1TBmB?&?h-1?qI[? lYR]?pe,Q@x#YF@Zr?2%䃞?CCCCA[R@]?ACGCApD? >V?;??73?11!O?*S@䥛`F@ڵE@Mb?CCCAA䳣LR@іڿ?CGCAA*@͊?(5.?<@o?v?+-> P@B`bF@oȴ?b2U0*?CCAACd4 P@Tf[3?GCAACa? /?$P.??BIE?uD_O@M FeF@a?Mb?CAACCv`S6O@(c$?CAACC(c$?ORx?Mۃ_?sO?{({t?4"P@`TRgF@oJ?ZӼ?AACCTAP@Fk?AACCTFk?}vJ۽?ؗDڹ?`0Z?E?G!?_ځ?a$.?__rN@"yF@͟MG?]K=?CTTAT%$N@m/?CTTATm/?N{?9? 8#?^Q?8L@dF@MLpM?"u?CTTAT}KA$N@75 ?CTTAT75 ?OD &?W.7?/?Z?eܩ?Ws"2P@xF@UV$s? g?TTATT<6P@_9?TTATT_9?r5?Q4@1?g!?%zB?H6PI@ecF@F?F?&S?TATTC!0ҩJ@n{?ATTTCG?nB>Yn>+2'fu?.?Y-ZK@j+F@6?y):?TATTC$LЩJ@&l3D_?GTTGTW?ۂYթж>赣MB>V ??$iJ@~jF@:Y?I +?ATTCGP"saA>bAY?צ,?qۨ FP@Zd;F@<퓨#?W}b?TTCGG kP@ 7S$?GTCGG~wFN?Z?2O?O?ME?̨qQ@tF@~iE^?a+ey?TCGGTKQ@Ԕ^3H?TCGGTԔ^3H?H@+[S?8:?/= ?*;??rK@4333F@5Ǽ?q?GGTTGcK@ŵ ?GGTTGŵ ?O5MD>bWx?Mwрa?1|?K@ŏ1F@$/Ŏ?mxz,C?GTTGC JJ@H?GTTGCH?aR8>l{I>}?׺?6n6N@YF@jp.?{Gz?TTGCC \M@cCj?TTGCCcCj?=\u?(?tXa(Ȉ?⺟gG?y/^P@F@ |q?/n?TGCCGR[Q@QP?TGCCGQP?R&Xp?6=?$ŕ?T?f9?1HHR@+eG@w?Y5;N?GCCGTUeQ@5?GCCGT5?0 ?PXdã+?sڷc?`-w%?l>N@o G@wY@ڊe?CCGTT?fM@!~?CCGTT!~?2w`?tf>^?>iv?DS|H@J&"G@)|?"u?CGTTTLxH@J?CGTTTJ?Р =KHuЂ=". ?EҝC?=V.J@E*G@OO@C?I0=D>^,?73R?JCJL@B-G@q;>?Ǻv?TTTACm3YL@L=?TTTACL=?Y>]Nrr?)3u/?Q,?[tNP@2ı.G@3 c?1*D?TTACC_dMO@H?TTACCH? }?&e?c.?5\|?c/AP@<,:G@W?F%u?TACCGdfP@`?TACCT$?f"?"?&,ʪ?b;z?>ΐEQ@|?5>G@@~)? rh?ACCGT!6Q@;ս?ATAATE?gg4?MA?!YZ?We?gffJQ@(\BG@K`R*@~jt?CCGTAZkK`O@eD[,?GGATTϑb?5o?/}(?&NE?QW>LL@ʡEG@%?~jt?CGTACwڀ}L@?CGTAC?|J?1ϼuU?=]?1M?Lzͬ;O@X9HG@Y0U?@ǘ?GTACC6PO@Ly?GTACCLy?9?ƮRO? iC?#f`7H?LwP@1NG@1)=?y&1|?TACCCLClP@zAv`?TACCA P{?@M?SzB?st.?s@?QQ@{PG@ `?l?ACCCT:cQ@zFDܷԤ?CCCCTgi٬?MMƣ?ТaL?l=???LP@y)ZG@)?a+e?CCCTTr9mQ@mGw?CCCTTmGw?ȶƿ?>r-zB?yc?ob9k?C2M4bJ@ lV]G@4V?8m4?CTTCTZJ@╶w?CTTCT╶w?SNu6R,>D j>@Ty?J=;?YF%O@H}G@X 2I?HPs?TTCTT1-1zID>!>N?Z[?7nK@z6G@ ?/$?TTTGCAP\K@~n,?TTTGC~n,?G"pK>yJ]>7 Uq?71 ?6`x?K?~P@}?5^G@o o?ψ ?GTCGTP@k?TTCGT;ه ?`9T?\6?+Ĝ?Ss=u?ILL@2w-!G@#X@Ǻ?TCGTCL@WLq?TCGTCWLq?&NR?;Ϛ+0?<0,?x?o{xaK@H.H@`Y?_vO?TCGTCYL@7=?TCGTC7=?QfO>G>Ͳ 6?K?<2?(RH@H@1|LV}?b2U0*s?CGTCC#]%I@0?CGTCC0?Fy=gD)=g ?Q֯?PFN@鷯H@y@Q?GTCCAn[ѪN@w}!?GTCCAw}!?=ł? $t;?}#t+??2h?nYoQ@Z H@B~?~jt?TCCAC*wMQ@nn?TCCACnn?sR!?}Nԓ?vP?58dp?Q@u$H@o.? g?CCACA[:{zQ@ҽ@?CCACAҽ@?{S#s?V?*w?NPJ*?\[JQ@8H@J;ib ?q?CCACAD)>zQ@!/H/'?CCACA!/H/'?R+ ?J?7<~?uvX ?pCݗQ@<,:H@w?ݓZ?CACACUϑΝQ@ ½?CACAC ½?w'?Z;Y?pMa? x? Q@3ı.NH@?ׁsF?ACACT-OQ@!=lb._?hDP?L@,eXH@D??l?CTTGAVl{iL@I.|?CTTGAI.|?LJkhA>{7a?=I9?7]]?@N@ cZbH@xz?y&1?TTGACp!CN@VE\ ?TTGACVE\ ?g!6?:[?nz%?d. ??#/"z?ʇ-j? &]P@+ФH@3IQJy?n?CACTTțsP@u̍kݳ?CACTTu̍kݳ?qV????/ޯ/?7H?+EL@+ԩH@T+ɽ?Mb?CTTACuPkM@,'ղ9?CGTACsG]?md8"?X"A?8 2?}kjV?Ag}{P@(H@DvSH?Biޱ?TTACA qqP@?TTACA?f57Q?gSΜ??.??GQ@*:˿H@~?-C6?ACACGX՛E`Q@o0a2?ACACGo0a2?C䁜?:6NS?/?w2?c!Q@nH@ g?%~?CACGTpQ@!?CACGT!?ΩsT?p<?80?@ZMM?2b(L@( H@68@~jt?ACGTT@~M@b?ACGTTb?\G/);?.6>KG?%F"?g>ѤG@-CH@HLk?gs?CGTTCz\G@A5`4?CGTTCA5`4?#=4r=MLgX?1"/UA?p= I@=yXH@@gt?/nr?GTTCTUϐ$J@JC ?GTTCTJC ?Y<=3?`>L/?=n?&6P@xH@!@܂@ 0*?TTCTG O@ t>TTCGTՖɶ`?؃}T?Z@#Yd?„Z?JA>ŁxmN@$J{H@ג?T㥛 ?TCTGT(N@k E?TTCTTo*y?eR?U =?=?,)?@w-J@?H@M?ˡE?TGTCTNK.FJ@z%G?TCTTCS.=?cnr>[}>r?u?<O@9# I@TZ_?ͪզ?GTCTG1avN@6 ?TTATC b?s8?p\)?~Pv~?S?$sNPN@S!I@@gb:?(}p'O@ _?CGATTb:O? ?uC'?T+;?-Z?\9I@ZӼ#I@L2?ǘ?AGTTTDJ@'[ݵ=V?~.?yN=JJ@@'I@"*]S4H?Uد?GTTTGIʨI@y?TTTTGd0>?Q> A>P? }C?j^K@7I@:? 0*?TTTGAahL@TgX?TTTGC*U\]??>X !y?,yHM?3Of?(\RP@<,:I@lR\?Ǻ?TTGAGP'P@桡F?TTGCAB?lb #?K?5 (?{?Kq,R@V-=I@(E/_?H?TGAGA;pR@L ?TGCACS-z0`?}|?ȀL?WF?'cueu?"P7kQ@Z8EI@ ;Su?n{?GAGAC 4OGQ@>?GAGAC>?[Q;?>sT?^?$O/?$~-P@X9VI@"0?<,Ԛ?GACTAT>?P@4n?CAGCCn? Q?@c`!?Q90/?f! ?e;߯=Q@dZB^I@&D4?~jt?ACTAT%/P@3y,?ATAGTչ?p4?VB O?.* ?2=a_kp? gC3O@~8gdI@Xs j?vq -?CTATCe(ɔ P@Nl?CTATCNl? y?C~ܙ?/-'??vON@ rhI@)֊?ec]?TATCG옅/N@&\?CGTAG)]J&?о4O?c֧kA?Vqs?ԞB?f R@avI@ Yu?~jt?TCGCA ;3poQ@EW\?TAGAA`,]ya?P0?3`R??\fh?*'4P*?Uâ>S@?|I@Yا?+eX?CGCATɍeS@e?AGAAAqt׭?bF (?iNl?@34?DJ>e:ʖQ@?W[I@(c1`?kt?GCATAnphQ@,?CGAAC}? O?+U0?lyL?rN?>:QP@gI@M%ѐ?46`=?hF?p:?~;?^YP?[' P@{,CI@ƺG?&S?TAGCCب6P@O ?TAGCCO ?? $I\?ssW?twzi?5? ږg1Q@DI@>?mxz,C?AGCCGKQ@&B?AGCCG&B?o&?Ku5L?ƨ]?0WO?%R@#I@^uS?_vO?GCCGTk2PQ@Io?ACAGT⁷?@j![?'~HP?zs $ȿ?/ƒ T?̔fN@I@4?NSt$?CCGTAAY$`O@s+?CCGTAs+?\?Up@?*Y>կ?:h?\KM@BI@Տa,??CGTAGtTz*vM@ .Z?CGTAG .Z?l-~?'r?q?#D8a%?ˊ'MP@1*I@Kޗ.u?:v?GTAGC P@f-?GTAGCf-?0?rg?׺C ?[h\;?:mP@ecI@3p? rh?TAGCCNG/P@>ˮ ?TAGCC>ˮ ?Ñ.]?t6?פOrw?Ƙ3?T 0dQ@I@đɃ?y):?AGCCG̜KQ@IW?ACGCCi?l {8?`E=?vOO?H ?y@R@|/LI@0pq??GCCGA^rAR@]Ko?CGCCGVU+?d&?~6USJ?wɳ? ?*JIR@HPI@ xJ?j+?GCCGA=J AR@z Dj?GCCGAz Dj?W㍱?R]q?=GJ?kY7?/A CR@eJ@} ?V-?CCGATm R@#?CCGAT#?87?uݬ?n ?1>ʏ>HK!P@Q J@fp??CGATAVyHeP@E)?GAGTAt/&?ޕ@?tr??/?FO@J@IϷ?y):?ATATCPO@}P+Y?ATATC}P+Y?;&?#;N#n?28?!3?Gz=M@؁sFJ@>h?-C6j?TATCTe'&5M@]?TATCT]?b`>|?ϤbM?ugFty?DmV?h'u'P@1*J@4?F%u?TCTCGИsrO@o \?TCTCGo \?E'i?@7 ?!+0t?hA͠BA> g1f?w? L@`TR'J@}?/n?GTTAGuPflM@Ҩa?GTTAGҨa?;nEiT ?X?Y|u?g? v|5Q@}a2U0J@1:?Cl?TTAGC P@0o?TTAGC0o?쥝3?}tJ?6_ӱ?'?p=zC}P@?o6wg?ߤSQ@}?5^J@ߦA?HPsr?ACGCC6u;Q@/}*?ACGCC/}*?Q/Vx?膔?3:j?fP8z3?oX?gO__?6(_uUQ@_I J@h/? ^)ˀ?CCATA Q@.F?CCATA.F?( ?ns %?ôr?-n0|?k`O@2%J@*!?NSt$?CATACSO@=?CATAC=?\kR܊ ?lJ$?(Z0?{hJ?1&'Q@J@eƢ?{Gz?TACTG^"KP@Ѹ?CTCTG4?8e0?קYmp?s:1Dė?#_I2?}tXM@M J@a5?46y`M@!)?TGGTG5? S?^@]f?WmҘ?{H%?$zL@,J@]Uh?"u?GGTTATLuK@FR?CTTGA7d?i1_ ?1Dk~=,?qkf?B 00?QN@'1J@5D@ ^)˰?GTTATC M@홇?TGATCLق? JU?=mj?1˄?z9?LL@ŏ1wJ@bT?L=U?GTTAT5M@|?GTTAT|?3g+6?aM?gD?=XL~?akP@I.!J@Y?q?TTATC}&}O@2_m?TTATG>?UǺ? ?/?kޤ?RN@[ K@瘜?^Eߟ&>I?67?7.6>hD4a?.Q? 9L@3ı.K@ }f*@HP?TTGCTێ¦%N@*s;?TTGCT*s;?Dѡ\>N1d?4@4??L8&Q@6;NK@㏢?St$?TGCTT3Q@/J}Ut>Ȭ?s?UUUH@gfffFK@[n?U?b2U0*?CTTTCҰH@?~rU?CTTTC?~rU?an"=׼=Z}ɜ >ȗf?s HJ@qHK@K?+eX?TTTCGxb:K@ 4+?TTTCG 4+?eQHM>>( C?ITFj? P@2ıNK@fϫh?F%u?TTCGCoP@ F?TTCGC F?# H?GI#[? !?G|=>?VUUUcR@sRK@{́>?H}m?TCGCAxcaoQ@ڶYHD?TCGCAڶYHD?+2?b?ahn?zR9uJ-?o۶mR@]mRK@ /_?JY8?CGCATYVS@Eg?CGCATEg?CC?UN?.N8iz?I@>ǂT){Q@^K@Wx9?St$?GCATASQ@GJ?GCATAGJ?7=?*'{?wҴ?.JS l??^TޣP@ cZbK@:?+e?CATAG[Rt4P@ǖ'?CATAGǖ'?an?*a? Sכ?C?Z7H6Q@nK@f7V?S!uq?ATAGT:8\XHQ@  ξ?AGCTTfc=?$WL?v?Ir(?Z މ?ډ K@>yXuK@P, ?ψ ?AGTCT(DRK@UV ?CTTCT0jR~?qRTY>Àʖ>}рl]?_W?4IlN@PkzK@?UN@?GTCTT/MdN@F~)?GTCTTF~)?<Qe?ʇԹ?xbXɱ?8Bm}?WG/L@Gx K@`f ?@ǘ?TCTTTL3ÒK@ƁI)*?TCTTTƁI)*?15/>qvV*?Ⱦ?Ic~Dk?Y" H@ףp=K@{DT?Ǻ?CTTTCwjΰH@xD??TGTTCB6?. *\=v=?;^Ys>A?O<K@\CK@i)^?UN@?TTTCAo<+K@<6?GTTCAT^?WTݎz>'mK?lS cX?wbVK?l7o`Q@'1K@۪pi?ͪն?TCAGC]+PQ@rқ?TTCACM#>?+f?8jf|?igַ? -?lS6P@ׁK@F2; ? ^)ˀ?CAGCA7} P@,s{*?CAGCA,s{*?_%U_?<R J?vnC}??4(dR@=K@ǃ`x!?&S?AGCAC1 | R@) 6?AGCAC) 6?SK?†p[?'Ӆ?nd`?w[P@\CK@N::?&u?GCACCU:EP@< ?GCACC< ?@lQ?_vO?ACCCT,{cQ@ j?GCACCr<;j?rw?i)?ލ~j_?z#m?d/Q@՚K@.!?~jt?CCCTC-0Q@rz?CCCTCrz?[;-M?4?S<=?$J? y4P@b2U0K@?O?q?CCTCGkgP@z^f?CCTCGz^f?ՇP)M?S Z{?ۓRX{?A2&s?嘓柛Q@V-K@缻V??CTCGGR@Q@Hn#T?CTCGGHn#T?8zH?4"?$5k?+i?miOP@ F%K@5sP@K))?CGGCAK))?r%ro? FO? Lg?9 w@?cX9UiR@;NK@T;?Mb?GCAAGdq -R@?GGCGC1??܁ZH?#LI.?ku$?(`f?Q@,K@w'?+eX?CAAGA;P8"LQ@m?CAAGAm?-?.Tr?*K.?xȚ?d_ Q@X9K@$2ե?ŏ1w-!?AAGAClSP@L?AAGACL?)=?"l2?c48?"A?O@ǺK@>xm?w#?AGACCi/ P@X aw;?AGACCX aw;?ם)?!cQ?1|z.?"_*?dO@hsL@+? 0*?GACCG=SO@oT'Ч?AATAGF9F?{u5wA?䔣?q{0_?Q/?H'}Q@=yL@%a?&S?ACCGT%Q@QVV?CTCACw@]ð?K{?D@.P@ L@hu1?r?GTCAA qP@$]jg?GTCAA$]jg?9r!̍?pA?'ݭ?{w[? y]NQ@2L@F [?q?TCAAT}s HQ@Pz~?TCAATPz~?V#\?Q @9?&?ek/`?]2 P@x-!4L@pN6?b2U0*s?CAATA0!pP@(`?CTATCB׈?\?% Bo?15ͷ? 'Rk?ԤKEM@}гY5L@|s?a+ey?AATACn0jN@7a?AATAC7a?ϰTR?שښ?UaŶWӹ?;lӆ?2 ^zP@6L@yE??o?ATACGn`xP@ Mvl?ATACA[\O?F?w-!l?TACGA~LQ@Հ.?TACGAՀ.?>Ct??f{F?/5? ډ?2ϔ R@=RaL@ܹa? ?ACGAT@NR@^j ?CCGAT{ ,G?f a?e5=>?:7?`QSD?QP@ÆWjL@3|R?/$?CGATAURP@Q9Q?CGATAQ9Q?Sj?ǣlE?h8#?;:e?r/O@oL@j@gQ?Q?GATAA1SLPO@z3?GATAAz3?T[?b2?k{>?Q?kI\aQ@jMsL@^n R?{Pk?ATAATk8YwQ@h?ATAATh?Sjοޤ?h?X3Yճ?}?~M@y)zL@|?b2U0*?AATCG?+AD>M@YVW?AATCGYVW?K !}?+ܝ[?2A?Q%?~9P@|L@L$r?p_Q?ATCGTi2P@R\:?TGCTT ?M6?9?DR@Ў3?A%?WŕKN@=yL@ Z?(?GTTATIjM@Xy?TTTAT0;ŴC?b@*xa?*`?O]uM?{J?:H~P@EL@8~v?Ǻ?TTATGLP@q?TTATGq?|?;%p?<ة?SD@?X:ɺN@鷯L@ ?"u?TATGGN@*j T?TATGG*j T?T(?E?uQͫ? :?TP@L@.?p_Q?ATGGAʅy\JP@߀p?ATGGA߀p?lVęn?v#=?8XOX? ?V-rR@|?L@i?`$Sd?$/?"<?ɡnT˱?H u!O@~bM@$ԀO?ܵ|г?AATAG=ѬcO@.;}?ACTCC@a:?6 SkU~Q@%b?CTCCT:/X)x?'e݊?M}S?fz?=? P@PkM@6q?sF?TAGACtaqP@ff6?TCCTCf-?ݏ?qD|?N 2?+:?5-kP@՚M@|Jק?HPsׂ?AGACG*.P@Ý,?CCTCA3-ӹ?S@?lI?޸tl?7b?Y9h\Q@xM@kVh@Mb?GACGG~ddP@0ܶf?TCAGCe6?^? B?Še?eޙP?@,P@RM@s?z6>?ACGGC`|%P@ f!O |?CAGCGu8 ?P6?g?IP?.y?ENĀO@St$M@[N,P@ ^)ˀ?CGGCGaP@ - ?CGGCA%?ԟu<> `͒>~G?8(Ws>T)|R@c=M@ a?q?GCGAAuyR@(9FL?GCGAA(9FL?Hբ@}?-A^?PCD?:/?g-KS@L=M@?p= ף?CGAAAnlo#S@O{?CGAAAO{?l??g Q?b-?@А > mneQ@M@yn?_vO?GAAACvs4Q@z^ i?GAAACz^ i?K)3?/KJܓK?׽|[?xpS?NN@ͪM@y"S?7[ A?AAACG9cO@W?AAACGW?!Iy?avbKм?9l?G:?GQ@DM@5pq ?-C6?AACGAH$Q@;>-?AACGA;>-?[:&?x?ɍpm( uR@vM@7CXR@~jt?CGAAT#CR@jJ2?CGAATjJ2?g4]&j?#C^FP@x $M@e`??W[?GAATGKQP@t !?GAATGt !?vU?5ȷ{?6?ɽw?QM@PkM@}B|lz?"u?AATGA!A5N@]Ghw?AATGA]Ghw?yȩ8?-{x?>na;?SOqE?HzQ@/nM@44+c?_Le?ATGAACNP@eW?ATGAAeW?9?8/l??Xk?ƒy S@'1M@ET.@~jth?TGAAAS@C2V"?TGAAAC2V"?Î*7Q?%vg}?^v>Ӱ?j>sߡBQ@ ףpM@ĿZ?ׁsF?GAAACC`4Q@zvy?GAAACzvy? 5Aƙ?zݯ?,@3?ʎ%p?(\o 5O@@N@@#@?-C6z?AAACG22cO@8[ 8?AAACA2Vx$i?z?E$Z?2?|&V)-?i{P@2%N@ ~w? rh?AACGC8TChP@+A޿?AACGC+A޿?_}?}6n?!H??>OQ@C> N@yC?@ǘ?CGCTCTyxP@/?ACACT^%?+΢?`R?~)?0?|?ɓrNMO@ N@ţ?_vO?GCTCT&] uO@o4L?GCTCTo4L?]?T{?-1;?E->V?b|mP@ΪN@@*|4?Q?CTCTC9 P@wA?CTCTCwA?(ߣW?<2d?FR.{_?j($vY? 5O@?٬N@5!?St$?TCTCAeO@? @?TCTCA? @?KtM?yQͺ?`ݱ?u`q?ǮsQ@\N@9/? 0*?CTCAT,InQ@ V9?CTCAT V9?k3@? 2Q?d5S?'dJS$k?+R4zP@s!N@Y}?o_?TCATC<|ˤP@nZea^?TCATCnZea^?3ä;S? i?'l=??P!aF?+6M@ 3N@ÚL?-C6j?CATCC`Q M@ėg0?CATCCėg0?Z׋?x~?5/?3M{?vِ%0P@,3N@Xu?I +?ATCCCÛmgO@0m[?ATCCC0m[?J&?ۣ /? #zp)?4^le(?n%>Q@mV}6N@Ye?eX?TCCCGRϣeQ@e?TCCGC٢I?u;!?(?c5?̄?=KorR@OeHN@_?䃞ͪϥ?CCCGCM R@jy7?CCCGCjy7?.K??.?ׁ ?d K?V6Q@jMSN@DQ^j?Mb?CCGCTDz!VOQ@z'ɖ?GCGCT (~ʼ?٤:r?+ٜ?G?/4k"? [Q@ۊeWN@f)?tF_?CGCTGȾQ@gÏs?CGCTGgÏs?ѤK`?+ ?:9?$,'r?fq';O@%cN@L?ǘ?GCTGTpKO@Ee !?CCTGT.輠m?ROcֶ?5k?u\b?̆?;IL@W/gN@Mes?V-?CTGTG&{nL@o8*?CTGTGo8*?A΄f?sob`$?Q%?Tp;?TK@sFvN@Q_NO?3U0*?TGTGAƒ L@>|vus?0?S7X?]P@~N@R?X9v?GTGAAR|NUP@+E7?GTGGA53?2 !?;[?ʈj?+t? *{R@ǺN@ ?( 0?TGAACtQ@cMuPf?TGAACcMuPf?H8'?&Q?:v??t=#?} &N@C>ٌN@?_vO?GAACC iN@ڨ14?GAACCڨ14?Ibtw?x?adu%??^sQ@/nN@.:{?~jtx?ACCTGn 7Q@y?ACCTGy? P?k,An?-?Y^0?ʡEFM@ڊN@٣U?Mb?CCTGCf_M@ۇ?CCTGCۇ?ٖ?od?B@d?CGCCT'C>?ab?>.?U7*l%?I9q?2GQ@FN@GZdE?H}?GCCTA)dKkQ@uI?GCCTAuI?.nz?ld@?cv[1?{ 꼳?T-IQ@VN@T#]? ?CTAGTUMoQ@g?m?CACGTPc=3|?Y?ژOI@H.N@n>?I +?TTTCC6GBJ@;UL?TTTCC;UL?/K =R0:I>Tv(?_?nN@iqN@yڨ8-?gj+?TTCCC.O@?TTCCC?魢~?4N'J?"?VSq?g]k EQ@hDioN@U?F%u?TCCCCs Q@-Dd?TCCCC-Dd?{YE:?X]ɾ`?TT윾?x`l䶲?HzrR@ŏ1N@Ij?ݵ|г?CCCCT, AR@vc?CCCCTvc?:YT]?d?zaot?hvr?KQ@Gx O@x?ͪզ?CCCTAھ/Q@UL?CCCTAUL?9`Q?5x? =F?'Iò?OզP@_vO@x`L@UN@?CCTAC#۬P@ъ(?CCTACъ(?:;?B?"0J?~4|s?{Q@CiO@Sa-?Zd;O?CTACG-P@e?AGCTAi@p?R|?)KP]?CB? PTV?߼4Q@O@F?H}?TACGAViQ@1$L#?GCTAAyú? P?T>}?_H?[Ǥo?~vIQ@"uqO@tPg?Ǻ?ACGAC2s9#Q@ ͝?CTAAT\?,Jܳ?;Z?e~?\{ ?xwwViP@1w-!O@82G?b2U0*?CGACG؈RP@8_ؐ?GCTACv?q^Hq??0?'?܏P@a4O@6բQ?( 0?GACGT{0 P@F}?CTCTT( W?.?!՗{?(I?;/?bԀK@a";O@y5fݹ@ rh?ACGTC dL@ip㡧?ACGTCip㡧?4-5>5z>0W?TGTTG8CI@ ?CGTTGc? &>e:=6614N?Ph'?3(rK@-Ԛ]O@3?_vO?GTTGAL@U=V?GTTGAU=V?fv\נ>C;+?W/E|?;?3P@d`O@k @xxS@p&?TGAAAp&?I?Ozv?{ 3?fB>Ll[Q@HznO@}ę<?F%u{?GAAAAY/#R@L]DW?GAAAAL]DW?A?3?y-f?nKK? OFP@ooO@kdTR?_vO?AAAAC[dGY~P@3G?AAAAC3G?-xy?ObF?֥Nr?/r?3w?KP@鷯O@n|gR?F%u?AACTTU;O@] ?AACTT] ?p?x?-K?NW=Ϭ?*L@_)O@zÌ??ACTTA|-$ -M@R?ACTTAR?uaΗŹ"??L5$I?R?B;&=N@ŏ1wO@v ?UN@?CTTAAVbN@hr?CTTAAhr?n ?fiDZ?F<+??.8{6;R@[d;ߏO@7O?:pΈ?TTAAG5jQ@>=÷P?TTAAG>=÷P?:CWq?-?wՕ1? ndH?;ᢘQ@ hO@pW: .e?8m4?TAAGTjLQ@}>(?TAAGT}>(? ;? $i?)ѿ?l>p?B`ЃN@B`O@)gO?~jt?AAGTA=6RJO@S?AAGTAS?_@W?>V]?fT?Gˮm w? `M@CO@{?Eioɤ?AGTAC%hM@S?AGTACS?Җz{V?76P@HO@?Q|a2?TACGC&Q@7~?TACCAD_ڲ?d9':/F>4;{?k_a?9OWzEL@veP@M8a?ŏ1w-!o?ATTCGQ+K@,m?ATTCAR?;)?A0OD?0p?rPͪf?;*P@0L fP@.U@"u?TTCGA*JolP@.N~k?TTCGA.N~k?Gt *?Xss?"+P?T>._#GQ@ZB>hP@kfQ?Mb?TCGACGEkQ@|l!?TCGAC|l!?g)?9Hy?fkp?\3L?(j4AO@VlP@黸?HPsׂ?GACCC \O@pN?GACCCpN?)&?V>?+D=?$>z?צ0Q@2ınP@\?ׁsF?ACCCA l Q@`{"?ACCCA`{"?JĽJ??S>?DElz?G!S@xP@m׽d?Mbp?CCCAAAsR@I J?CCCAAI J?U=C?hvvY??4~&?KjQ@"yP@zS) ?b2U0*s?CCAAThQ@+ڠc?CCAAT+ڠc?m?O,"? .\?oL@gfffP@=Lm?8d`?ATTACJ]o,CM@ ?ATTAC ?o ?˃ݰ[??X1# ?O@*ǚP@A0l?+eX?TTACCD\O@Ģֹ?TTACCĢֹ?QR?.OJ?h;?}? ?}R@V-P@,gF?b2U0*?ACCAT2iQR@QI?ACCATQI?'t?c&Dׁ?X&?,ρJ?lQ@aTR'P@2O?:v?CCATGuQ@i}q?CCATGi}q?:T+t?B%0? 5!?HZ!`N>?ȐxL@:#J{P@}@?W[?CATGCL@$TmA?CATGC$TmA?V pz?κ>~rb?R[v?"unN@P@];(?1*D?ATGCTBN@#_ ?ATGCT#_ ?cرP?jfQ@P@p2?r?TGCTGE(1JQ@iw-8?TGCTGiw-8?F/u?[aD?Rt=?E?ILO@x $P@5 ?/$?GCTGGO@ݗò?TAGTAIfc?d֜?2#q?)D Sl?-? -})O@;MP@lQ?ͪզ?CTGGCBCN@2f(?CTGGC2f(?:BKx?E=?؋?0:?H5Q'`Q@4P@Bf?&?GGCTCDcQ@߉?GGCTC߉?"B?py?XrN6v­?]V?>O@@P@ Z?UN@?GCTCCdIN@V H ?CCTCC 鎣?̖yb?S|W6?"?FXjZ?`,P@JP@XŔ?b2U0*?CTCCAC|SP@n ?CTCCAn ?瀃Q?p?V^_?UՉ?m:Q@@߾P@]f?`Q{?TCCAC%$Q@$wJ?TCCAC$wJ?+ńnPb?rL??W-?h d?)Ȁ}5#Q@ݵ|P@o~?Eioɴ?CCACArɸAzQ@C?CCACAC?Hj?pa?{O=D?u0([w?} G{R@M FQ@[x& 4? ^)ː?CACAGNekMR@TZ?CACAGTZ?vIpz?lDB?܃w?3h t?3 R@x Q@1_ ?r?ACAGCWN|;lzQ@@/۶?ACAGC@/۶?z1|?G?UQ++Z?* S?3&lP@;pΈQ@f3»]?<,Ԛ?CAGCGIEvP@HN?CAGCGHN?c?M"?:C?39N隼?bDGQ@ʡEQ@E&kX?2%䃞?AGCGCߔQ@m?AGCGCm?{ )?){?B{? ,ݽr?uuQ@-ԚQ@}%?gj+?GCGCA\`LQ@yd5?GCGCAyd5?{ŪF?M1?EX?{M^5(?&R@%#Q@S6!j?gs?CGCAG,p}3S@u/?CGCACau?\kf? GH;? V?nUd M?2I.P@=,Ԛ&Q@=?p_Q?CAGCGWuP@k?CAGCGk?_OZ?8Z?4#?e?=ϾIR@Aa3Q@ں?OqA?3Du?Cʃ!?szң?YBO@@? q?CAACC#!؇O@iS'?CAACCiS'?, $?}Ο(ϼ?>}Z?2!ߡ(?!wP@ÆWjQ@:7?-C6j?AACCA{#q@P@B)?AACCAB)?GRT?9~?z?V ?%u\Q@^)kQ@37}~"?Mb?ACCAC$oBGQ@?ACCAC?UX ?壊?&O?3?,*Q@zX5mQ@ _5{?F%u?CCACT3YQ@Lg2'?CCACTLg2'?dH!?YRN(j:?uτbC?8v}[?4P@ȘpQ@taf?y&1?CACTT-P@8W?CACTT8W?IA?!]M ??d^19u?QfVJ@<,tQ@?' ?CTTTAGM&DJ@_勱D?CTTCC+5?92H>|cW\>#Y#? 4.C5?`{O@ҍQ@e;u?/n?TTTAAdKN@E?TTCCTPI+?g9?DXf?*F?t ?}'}sQ@1*Q@1ڿ?_vO?TTAATxY`Q@r@?TCCTGR%?aIK?>q ?BAM?QS6? tN@sגQ@f?tF_?TAATC O@= W?CCTGT?J *?v ;}?Cc?}W?Ӯf L@GQ@??j+?AATCCXLL@X(?TATCCH?CN4?:(~GQ? i?f?q= o O@ҭQ@j#?-C6?ATCCC%gO@^ژ?ATCCC^ژ?\?Li#Ա? CQ?|?΁D+U>Q@`Q@* ׋?ZӼ?TCCCAK mQ@-K>?TCCCA-K>?ʑ?A?[%L9?.Ŕ? RkwR@~jQ@F? ?CCCAT3R@(;?CCCAT(;?e8w?d8?iߤڊ?hX?^ \Q@VQ@?"u?CCATAw!Q@ۚc?CCATAۚc?@ke ?>?̃ ?њ)?FzO@Q|Q@?Ǻ?CATACc ٔO@?U;?CATAC?U;?R,? ?{? ?HW@P@}8Q@dLsK?q?ATACG'xP@bWR=?ATACA*8kw ϶?Tx?c`!?A?/m?u\eyQ@b4Q@=?mxz,C?ACGGA1AQ@`w?ATAAT挲 ?f&?h?%??kWyx?x *P@ʡEQ@&| ?HP?CGGACbP@.?CGGAC.?nCt?N>s?0re?j]?CwP@ܵQ@-4R?&u?GGACGCP@ iX?ATAACbH$?T?Lu?^T?\LT?mIP@Gx Q@4_j?:v?GACGCiuP@~&?CCTCGs?W?ں3xx?eYa?B?,Q@gQ@)?Ǻ?ACGCAB_Q@\o5I?CTCGC摰?ԡ)?h,}2?gN=??*bB4\S@j+Q@ T?w?CGCAG[xv3S@&#p+ѳ?CGCAG&#p+ѳ?5Џ?? XU?<:?w?;6Q@'†Q@͍z?_vOv?GCAGCe]sQ@UT?GCAGCUT?U?c3?!C ?z?8 P@k Q@.5j%@"u?CAGCA P@H?(V~?CAGCAH?(V~?ʲ@=?> 4S?mp ??"KR@ ףpQ@yqݜ?n?AGCACf R@?AGCAC?^g?17tL?\i¨? Sk?qLQ@Q@r~J?HPsׂ?GCACA/s1-RQ@F% ?GCACAF% ?^\?|;?LK/N?ɪE~*?hmQ@MR@JL's?y&1?CACACnOQ@V-%?CACACV-%?#W?H;cF?H?1uK?luLlQ@SR@WN?~jtx?ACACTkEOQ@R1/?ACACTR1/?ʜ6s?h? ?ƥȿ?pOv%Q@ClR@6h)UT?F%u?CACTGP@wwAM?AAAGTP6?JTܛ?z9O?G%l?^Zם?+_N@僞 R@1O=#6?`Qڋ?ACTGTaj|N@NAN.?ACTGTNAN.?ct ?TGCGC˳:?o S?uޭ?X핯?4`Ip?@@ ?HPsג?GCCCA| }Q@\Je?GCCCA\Je?ŦE?eǖ?;AD̶?Id%!~?R%\R@V.R@`W ?ݓ?CCCAAR@V?CGCGAstֿ??ǺG?@?>6)? R@ǘ;R@Tzrbg?H}?CCCAA7ohR@כ&c?GCGAGF?/p8ɓ?u:?[ ! ?۬:7o9?ULR@7BR@? rh?CCAAGX}R@?CGAGG?d?[6?y6F?tYNX?. NCQ@`TRGR@*S(??CAAGGR중Q@A*?CAAGGA*?+u?3Q?Xm1?g B?傦TQ@MJJR@PZ?HPsג?AAGGTnpQ@*|)x?AAGGT*|)x?z?y?yi"?F'?5_P@hOR@(v]{?a+e?AGGTA†1>P@iД`q7?AGGTAiД`q7?/\/u? 7ߵ?>_T?LȘA?Z)-M@}гYUR@ ^?_L?GGTAGO@GU&?GGTAC!j?iGN ?h3K?hG/?d3? w?8 P@^FXR@](?:pΈ?GTAGC>ĐP@8?GTAGC8?BfG?G) ?)z?=U?1'P@LjR@47??TAGCG9P@Bxk?TAGCGBxk?@Fwk "?UBF?b̫G?೏O@R@%i#N?JY8?GTACT O@Bp?GTACTBp? t%?4@?D?"pr?=R!?CTGCG(LUsN@ Tv9?CTGCA_-f?7խ?2k3?ǁ?(5 ?՚S@R@??TGCGA&՝R@Bz?TGCAAeIN?,`N?w[?q}O4~?q}?Wmc4R@jMR@T?a+e?GCGAT,DxR@p0b?GCGATp0b?jӿ *??.*Z(?[S!?P@R@5V?H}m?CGATG=P@"m$?CGATG"m$?$q{ ?0?+.?ekXq?h,N@ R@(HgN?HPsע?GATGG_BW/N@gԱ?GATGGgԱ?kBN#Z?4Շ}F?3c9?ÒZ?EPyO@QkwR@jNIn?M O?ATGGTS2WP@gPmO?ATGGTgPmO?^9ZeC?FV::?Y:gK?Y`b#۲?(\O M@.nR@4G%!^?-C6?TGGTGăgN@jݪ?TGGTGjݪ?{f{Q?)dzZe?043?]9?rB*~K@y&1R@*}??߾?GGTGA(N@0)!ў?GATCCxfK?>ri ?qYLM?g?ŭlO@b4R@d\W4?8d`?GTGAG=ppP@k?GTGAGk?:=).3?QN?K?0`Ƞ?mLR@+eR@,?=U?TGAGT$R@N_7ù?TGAGTN_7ù?9?bnj? Sv?%<9? rM@oR@8ŏh?Mbp?GAGTC-Z#N@$rD?GAGTC$rD? Ԓd?Rv?e?Y7?n?J@&R@ax @HPsׂ?AGTCC^DzJ@ɏx7?AGTCCɏx7?9>ʵz>?PePV?K?>;BQ@R@H@Yh?M O?TCCTG0.\(Q@ﰪG!?TCCTGﰪG!? |?R|?8?c;?0'N@BcR@.`?(\µ?CTGCTv۳JlN@G}k?CTGCTG}k?߉Pw?龶?x*?Shf0? P@jMS@Ұ?w?TGCTCl P@5H$?TGCTC5H$?,3ʢ?4??5?H+F?N' KO@' S@uL?_vOv?GCTCAg*ŎO@'W4 ?GCTCA'W4 ?^U^?o?v^g?ӫW?4mQ@"lS@Ü?46a$??CATGA1`c9IO@g7?GCTCT$2~G^?f0]R?DŽ|?*i]Ř?5?|P@46<=S@Wd?{?TGACT=zP@AO; ʬ?GTAACRP@kyb?TAACAUL?7P:K?8 o0?|Lg?e|?#'nP@x $HS@\!?F%u?ACTAT(NP@wܲ?ACTATwܲ?*F?{?Ч -?uY?L{3Q@RKS@x7Ql?( 0?CTATAg2P@|?CTATA|?!?OOg?*?pT+0ة?.\ 2! ?ATCTC!=?;??|?Bߎ? nRh?ʸcBP@8EGS@?:v?TTACA,1qP@_OA?TCTCA$%??V?~jw?)d ?а+hR@=S@Κ?~jtx?TACAGi Q@Nj)?CTCAGt?=V?;lo_?k<~?#<&q?VVQ@St$S@ON΂?JN?gs?AGCGGCYZR@N9R~?AGCGAOl?ۖO?cR?ǖ\?RDtIj?ܦlp2M@gfffS@3$@~jt?CGGGCWrN@T_q:l?GCGTCK@{H?!:kM?}>\BV?.F)Q}?1 4:Q@ S@/?46^R@׆:D?ACAGA O?8)*n?4M?\\>s?G<"?2Tvxx*R@`S@hn)?H}?CAGAA屯L4R@s&e?CAGAAs&e?L_?#Q t?+a?O>Y-oS@=yS@;x()?J4q?AGAAG&>6mS@u?AGAAGu?x]ޤK?H؃?a[?ͣL>*;̪Q@$(~S@TȾ8@H}m?GAAGT8wQ@l9?GAAGTl9??b@a?Hx?Vˀ>K~kL@h"lxS@`t(,?J4?AAGTC1L@'U;?AAGTC'U;?Yq?;w>9_T#?[?`REeK@S@0# ?8G ?cu?X?Ch0)O@\S@,?/nr?GTCGA\ $YBP@(?GTCGA(?#T~?5>?Q6.?E˟?-5XE3R@vq T@̵*@o? ?TCGATGrz!R@C ?TCGATC ?em^?lj9 ?Rw?RK?Q63O@ŏT@Ӌߋi?b2U0*c?CGATT0vF:P@?CGATT?o@hO?0/b?l?7j?IXR.L@V-T@iBB?^K=?GATTGK@rz?GATTGrz?%Ά ?J`?(gc?sS?/pfK@]K'T@N?6?GATTG&!iK@S^B?TGTGTB9?ܜp>lRqo> i?gR?d`T L@>yX5T@A?{Gz?ATTGGayL@4aOn?ATTGG4aOn?מۤ>&֩N?/ ׬?<%Ȯ?yWO@478T@}\|?a+ey?TTGGThu O@:\?TTGGT:\?fKL?TȩK?Xj0A?+~\?,f[L@p_9T@j+?UN@?TGGTCI6L@?b%?TGGTC?b%?Tc?+31I1?J?ݴN?"u+K@46l? ^)ˀ?GGTCA]cK@uF?GGTCAuF?(DԆu>x,;?hS+\?T@=W,?ׁsF?GTCACW4P@@@?GTCAC@@? ?M_?^P?Í7iu ?C{ eP@O@aCT@T\?ǘ?TCACTW/P@ 3X?TCACT 3X?s?ʨ? @|?6EXM?pf=sP@&†GT@]&?p_Q?CACTCZD}P@k.K?CACTCk.K?D?|"?g+]Һ?vᐫ?u-O@ OTT@9 I?-C6?ACTCC1- O@TóMk?ACTCCTóMk?@w]{?2W?yș?G9k ?Ot.HQ@L=[T@ίق 3?H?CTCCA\KI7P@qᛚ?CTCCAqᛚ?C7J?qx?}턑?fp?TR@O@acT@<? F%u?TCCAA 4R@pt}?TCCAApt}?, ?73d?w{?O x?6uP@iT@o;?cZB>?CCAACA`P@ؘSH?CCAACؘSH?wn?B ]? ^? LC?z1P@ΪvT@s~?w-!l?CAACAӇpP@;?CAACA;?0oJ/?jqC?9)q?CS}hv?ȴ|Q@_I T@$0S.?I +?AACAT%9?QQ@sEH?ATAATUo?ϒg9?c+D?x3˳?_A?΋}oP@zT@5/8?~jt?ACATTBQ@MiM?CACTTqӊ{?qj_??$?$AkX?'oJ@CT@%K |(>'So?V#?UQ@T@磈 )@~jt?TTCGA&KP@HTY?TTCGAHTY?Կ?|M?>Ny?Q@?Nё+PQ@mV}T@t ?{Gz?TCGACȎ,jQ@Nqk?TCGACNqk?DҏK?gW?}:w?]? P@c=T@??ZӼ?CGACAP@L.?CGACAL.?1? !fݿ?9ܾ?iv"?+,1Q@uT@PRhn?HP?GACACO}P@8)xޱ?GACAC8)xޱ?Zu+??C|i?B-j?yz[%P@T@`vC?e`TR'?ACACCNGP@7?ACACC7?zI=??X ?FI?O˩ Q@¨NT@N@W ?n?CACCC(Q@̊[?CTAGC2[Ϋ?ŭ-s?9&h)?ԡ N=?NJcҠ?qںP@&ST@uk?F%u?ACCCG\dsQ@v^2?TAGCG%Qt?鹅4?o(?T?Y@?:;R@X9T@D?a+e?CCCGTrR@ܟ?AGCGTpFX?%wym!?n?P?g遯O?. 6nM@T@b4@J4q?CGTAT캩#M@{d?CGTAT{d?$鞔?ȱ'9?J$??(\P@.!T@O ?-C6?GTATG =VP@lBF?GTATGlBF?@K"? ?/K?oYTtY?l?N@T@:G?a+e?TATGA5O$qO@ID"[!?TATGAID"[!?2?x㼣?t"&_s?`o?!AN@hT@м?y&1?ATGAC3af!O@?ATGAC? QAQP?<=5?iOr?SX??>iP@ґ\T@Y5j?ׁsF?TGACT^XzP@1,] ?TGACT1,] ?1g0x?"7?1~?[XK?6JmO@HrT@ZV?S!uq?GACTTPԾO@e=>g[??GACTTe=>g[??ME^?cϬ?mb륞?'|^L?rL@VT@R @_vO?ACTTAc۳,M@~)""?ACTTA~)""?۞7?SI a?q}?R8 ?-ZQ@ˡET@JP?&S?TTAGG~'fQ@y᣾ۡ?TGCTAii?_I?L?w^~6 ?!@?Al6,C? =̽?e\|P@yIU@'nB?"u?TCTACdDP@Mq?TCTACMq?P?FS~?nڳ?6" S?֬P@Zd[U@Xgu?F%u?CTACADޘQ@DB?CTACADB?R9?x f??hT?3=A? I{R@\m^U@]~O?gj+?TACAGS+Q@!Nx"w?TACAA<[?xZ"$?k "&O?&?c|WV?y` 9Q@7dU@Tt,?ŏ1w-!?ACAGC}IzQ@E׹?ACAACZOT?vH0[?b/p^?5 ?ي׀?{g P@%U@zO*?/n?CAGCCP@B=?CAGCCB=?ze ?6?k =?if:?G"GQ@OeU@l?UN@?AGCCTԇtCQ@sJ*ۚ?AGCTG7ݕ,?ƨY{ ?#bl?m?]g|?/$M@zX5U@2pAT@I +?CCTGCkmE_M@-r$?CCTGC-r$?w`m.?4g"]*?}?Pz$?~uѬEN@U@Lb?^K=?CTGCCMM@v ?CTGCCv ?-?CCAGAf R@<=ҋ|g?CCAGG7?q?c!/?f)3?X?wH`>JkQ@`U@  uP?/nb?CAGATQ0smQ@ҙK2?CAGGTRp?حh$?Lr2 ?T)>d?$GT?%.ڌ|O@mU@?&#?Q?AGATT_߇LP@cYU?AGGTGH(?EW?4?8e?{fb?5kL@$U@Y'?_vO?GATTAk&L@f?GGTGTN&GC?^@73?6/?wµ?|V>?з5M@|U@h?HP?ATTAThpN@r%?ATTATr%?ʁ> T?畳?L-?rWE?';KgN@U@^~z@n?TTATTPD-9P@ykN?TAGTC >?Q{? jT}T?ƐH?̰җ@?[PL@9EGrU@gI'? 0*?TATTAEL@>?TATTA>?PPlQ?Ha "*?Čt??Ux;MM@QkwU@Cz?_L?ATTACE~RBM@ \<~?ATTAC \<~?Xr6?ˌ殺?u?f? V?RO@2w-!U@8:?MbX9?TTACC\ZcO@W?TTACCW?Bi͇?5FV?ydl?`o?%~EP@ZU@o/No?Q|a2?TACCCctblP@~ ?TACCC~ ?h?L?gmOá?Θ;Ѫ?Q@EU@? rh?ACCCT_1.*cQ@+VH?ACCCCi *?]oE?dB.??P[%?r}1ȹ?6ʜcQ@MV@i?46,Wd?[tBhC*?<6?d ?/lzQ@AaV@Jo@b2U0*?TGCTT|{fsQ@)pb8?TGCTT)pb8?BOk? f Z?0roOt?<6b"?~:ՒK@KY8V@"`@<,Ԛ?GCTTC38Q1K@2Rk?GCTTC2Rk?ȣ >9i>/#pR?ě ?}vJ@ѳYV@bZd3?Ǻ?CTTCG1b(K@=tS*q?CTTCC+?l >IP>xA?#;??tP@ZV@m#R8?Af?TTCGGr.P@KN:?GTCGCb$C?ۑ2??F? 8&P0?oQ@&†'V@O^?ŏ1w-!?TCGGAg*Q@1?TCGGA1?؆%? +M?bHq?0˳ϐ?P&NR@gj+V@]`:?Mb?CGGAG-Q@GM?CGGAA?]%?2?d?P?kR@3V@x~?q?GGAGG .BS@.?AGAAAj3)? #3?*F?kj 7?/0?Fe~Q@=5V@ї?( 0?GAGGAQ@kLT?GAAAAP?, ?ˮwz? ϘV?E?eiQ@Dl;V@<??~jt?AGGAC!֔Q@ eu?AAAAGqopF?7x?Ht?Bk#? d_}?/wP@_I BV@LtS?`Qڋ?GGACC4CP@qG{?AAAGC!#R? s?Ǻ?g?0tڡ؛?u]P@ݓEV@峪 !?Mb?GACCAP@$?GACCA$?F< P?~7jo?=^1?:o?+ (NyR@ݓGV@W[V@>Aw2?{Gz?GCTTGsDJ6M@ڣC?GCTTGڣC?!~-_?h+Z?Y#?TZ4?mnL@-Ԛ]V@&= ?H}?CTTGA8gL@GK:?CTTGAGK:?\}?y.J?@f?\Mi?:9.LP@=RaV@{. ?(?TGACTA^&/zP@g'?TGACTg'?<%?+jro?Aҧ?M?'XF5O@ClV@Ov7?HPsׂ?GACTTpO@a7?GACTTa7?C J?iӥJ?Q6û?}_"m?KUK@1nV@eaMg@`Q{?ACTTT)tK@e!?ACTTTe!?oy>#*Y=kc3?Q|?,3{nJ@> ףpV@e73??CTTTGJ@W>'ы?CTTTGW>'ы?,)d z>^l>C>"e?@/?S&K@sV@Unz-?y&1?TTTGGZJzL@˓?TTTGG˓?XЀ^>z$ -?O?1[?AJBO@sV@ёt4?H}}?TTGGA!CKO@Ό?TTGGT:ьX?K?R(D??8(A?7OR@ɃV@e*@ZӼ?GGAGT)ak S@ ,T?GGAGT ,T?x?ΌtF??>L@ClV@7?0*?GAGTCm"N@Kp?TGGTTIhp?ar{&z>,{u?- Ŧ?:?sgP@jqV@x?q?GTCGTnP@9T~AW?GTCGT9T~AW?Q| ?aٌ0K ?`?G`˕@!?V M@V@,J?S㥛?TATCC#RQ=*M@ K?TATCC K? B/Y"?Fδ b?!?7dOL?:^HO@nV@_{J?ǘ?ATCCGYP@ g_?ATCCG g_?v?ŏK?aRj?~K?շKR@`V@ s ?J4?TCCGAO ,R@uww?TGGAAϛV?a?c ?]b?8 dE?T >T@AfV@i?`Qڋ?CGAAG$*S@T_j?GGAAG `? 0?2B?G]Ӥ?3{ >GxQ@,eV@k? o_Ι?GAAGCpEQ@;)?GAAGC;)?yg?bQgƤ?S.?;Df??s?#P@=UV@?/nr?AAGCAxJP@!i ?AAGCA!i ?Iqb?X?j^ ln?fTxpd?m_R@"uV@$z?Q|a2?AGCAG@MR@,;;?AGCAG,;;?ī?5??n3QC?eCRR@0'V@/?I +?GCAGGɻЌR]R@^!?GCAGG^!? kU=?W^W?ی0?m*?D!O@{V@2Vd?_L?CAGGCa1bP@mMˁ?CAGGCmMˁ?Z??M?63?FUP@uV@ \tf ?0 ;?tqѯL@XW@Y;?ͪզ?GTGCTqkM@aSuf?GATCAz?W@I?_Sp?IB?=~?A&P@?dW@Ň {?b2U0*?TGCTG./*IQ@cKAWܤ?TGCTC(+?@5v?% \r?^:?r$-$ ?;DCO@3U0*iW@fr?mxz,C?GCTGAyO@:?CAACG1|?zk?eD0?&|?r Ȋ? ףP@镲lW@0dO?/n?CTGAAHP@)T?CTGAA)T?>ҳ?37?q\??M-w?.+R@K4qW@3]_?_vO~?TGAAC$>Q@JV?TGAACJV??&OK?L;?M I?L{O@HPsW@'Z/?Mb?GAACT]6 O@BM?CATAC 2?Qt"4?àHn?%8<׭?Qz? dgP@^)W@'f?HPsג?AACTA^"8P@!%d?AACTA!%d?T`PP@[ӼW@+^?ʡE?CTATA,yP@&U?CTATA&U?."?}o?Fċ?(?ˈYO@^)W@1%#'?q?TATAC{=պnO@r2,?TATACr2,?Seݔ?po?zL?݁>[?GᩃP@(W@gNݘ?L=U?ATACAs)P@cT?ATACAcT?6Oʮ?NS!\?Ll?7=?)sQ@ZӼW@P]?&†?ACAGC6zQ@X?TGAGCZm ַ?6N?! R?Vغ?0k?DMP@W@SQd?:v?CAGCAqޱP@!d ?CAGCA!d ?[׮!?ؗu 3?C-j?vn;?PdR@tW@~ ⲫ?Aǘ?AGCATulR@FqR?AGCATFqR?_Tꔀ?41?h5/?G#/LWp?ӌ9IQ@mW@[?j+ݓ?GCATA4n4Q@'?GCATA'?r/?sq?$M5?)G/?%O@aW@K'?{Gz?CATACid3O@;\1?CATAC;\1?_K?,|?ρf־?~U?-^-P@6W@chŵ?a+e?ATACT5^bP@%?wD?ATACC:?ֹ 0[?U*?88*}?no$?ڧ#P@\W@lN??TACTGUP@ۀLޝ?TACCG||?g+*?q&?b?}v,>j?|[Q(}O@JYW@@&S?CTGGA4OMP@6N x?CTGCGfx\?~X̗?x|[ō?Zl?-9X?r0R@/W@8?Zd;O?TGGAG Q@&,Ǜ?ACGCA-s?}V?u5Q@`TRX@qM?_Le?GAGGTˋezQ@@KH?GAGGT@KH?nY?A?lR_?OxJ?㥛D&O@#X@8s?Mbp?AGGTG P@ͯgh?AGGTGͯgh?y i?6E?0"s4?̷f?p M@ X@LF0Q?:b CS?-a?*O|Q?ʶI@MJ X@>=qӁ?/n?TGTTGͫI@i?TGTTGi?GRZ:KM>@1L 3`>JNK?NV؋Y?)Gb2K@X@ʣ F?ZӼ?GTTGTy)K@m)?GTTGTm)?KJ\>H%??9Rz?UsngL@PnX@yP|0$ @"u?TTGTCj)K@{ /?TGGTTEf+?Re;>C? n?AE{?+E$J@3X@Qv?gs?TGTCGvuJ@9y?TGTCG9y?z@>s?9R4f??ӐsP@i|X@k|?y&1?GTCGT'-~P@!ȡ?GTCGT!ȡ?p0`?7xvy?*R">?9yƀѠ?_,\I@&X@]O%?_vO?CGTTAfjeGI@ه%JC?CGTTAه%JC?l+݈>ȀCY>*H/*?7?/t8M@k)X@{T?b2U0*?GTTACoKL@/K8?GTTAC/K8?jhiH??6Uˬ?y (?5!,GP@N@3X@U+?_vO?TTACTt OP@t?TTACTt? َ?vu?)i`F?{Mg?cQ@p= 7X@0ȁ?ǘ?TACTG ߮P@UŜ?TACTGUŜ?[ ?s ?y?K`?yD=O@V/;X@fc?{?ACTGAnˈO@?ACTGA?kRz.?# >?m$?+_;G?[!P@eCX@䈋!u?ψ ?CTGAAFCAP@&N?CTGAA&N?%648T? ?{?ǙC?H 3?*g}S@VMX@ΧL?0*?TGAAA 1S@V^$ִ?BL?4a ՟H@,sX@w4?S!uq?CTTTClvH@K?CTTTCK?.3z=oI=ٗw?Z?WƩPJ@KwX@UƐ?(?TTTCTd- J@߉v?TTTCT߉v?ƝO8->%%@,>N2%?p?0O@?|X@u(?mxz,C?TCTCT`ZlO@I?TCTCTI?ϲQA<6?r]?(:޷r?At?P@q= ׃X@?+699?ׁsF?CTCTGnP@&7?CTCTG&7?df'?\?'t,¹?]?"LkqO@X@w'?HPsע?TCTGAmanO@Zf?TCTGAZf?  Ⱥ?w/?_X?LL?$'@$S@e`TX@)j*?OU8]R@X@`Ћ?@ǘ?GAAATBHdAQ@6jc?GAAAT6jc?< kx?a4qF*?(/c?SD&>8tL@I.!X@U_{??ܵ|?AATCCeœKL@1LD?AATCC1LD?>Z?$oq?(HA?ϖ ?dnhQ@&䃞X@p91?_vO?TCCGC෎Q@V[uc?TCCGCV[uc?XBDO??^mld *?_?})oSQ@VX@5%qR?j+ݣ?CCGCGP؂Q@ʔٲ?CCGCGʔٲ?? Ⱦ?Ke?f1Ɔ?l4(é?Ce-R@lwX@DE?_vO?CGCGCJSR@ס?CGCGCס?*[[?cf[R@ X@רgS?w?GCAAG.k(-R@zV[ڸ?GCAAGzV[ڸ?h倰C?AŮ?Y)?Ow?\VP?TQ@uX@8:_g?i|?5?CAAGGĨpQ@!v?CAAGG!v?GTA?ÙC.?<?,<a4?(->Q@n4X@C"?_L?AAGGA{'peQ@BCz?AAGGG@d+B?]G?L@O?8/?/H-|?ڊ(R@O@aX@Q?i|?5?AGGAG )S@-AҦ?AGGGAh;d'??CB?4j?8$?GzM]nR@uX@D'x?_vOv?GAGAA8c{R@Lܐ?GAGAALܐ?g G??'\-:OHR@ۊeX@&9DJ?S㥫?AGAACz2R@fRd?AGAACfRd?-V?|η])~?7?W}?ȅP@48Y@Jߠ+? ?GAACAu:O@?GAACA?J]?JU?'Di`?0GnR? %8Q@3U0* Y@= ??UN@?AACAAz2cZQ@g ?AACAAg ?';?Tp?!GY?"ׁ!;?Œ/P@): Y@m]?b2U0*?ACAAC%(nzP@xv9:V?ACAACxv9:V?7Eر?*K?p26??%]??4Cr]?p47?CyV_v?8QR@߾,Q@?GGCTG?8(k%?JS-?Fk?=]?NVۺM@僞jY@2z?Ǻ?GCTGCOdopM@vq~?GCTGCvq~?U[<~?y p?gFR@GzY@|+?kt?GCCGA31@R@9BE?GCCGA9BE?7Q@Nq?[?ٞ+?{b?1R@A`Y@9 :?|a2U?CCGAA&/R@b G?CCGAAb G?|#?ĖӁW?}Œ8(?@7#K>+S@:Y@]~/,s??CGAAAV#S@,~?CGAAA,~?[5{?m? ؍vO?nه> ףpQ@W2Y@čF?1*D?GAAAT Q@9MSN&?GAAGT V^?sY?fPƦh?hPX?c?-3O@}a2UY@ε?ZӼ?AAATCA/ɁN@- ?AAGTA.?P8 ?Kn|z? b!?wY?~w7M@Y@&+-?@ǘ?AATCAs_c LM@7U˙&?AGTAC鋽C?D͂?+?>?TO(Y?F'GP@x#Y@d??W[?ATCAA|XQ@zڳ?GTACA6xź?U ry?a(&?ȧ6? G?]1wQ@ψY@cl{BU?/$?TCAAAҽQ@q?TCGCT%g ? wm?F5ك?i-?a@a?P@=UY@QV? QI?CAAACi2Y,@P@;zY?CACTC g?8?L?&sl?0i??CMO@\CY@7a.?/nr?AAACAK>}O@V{l?GACCC0w?|AZu3?^?g!߷?:z?@5^PVQ@ZdY@NWi?Mbp?AACAAN]ZQ@IS-?CTCCAa?:B*?@N.?>0ߢ?"sg?ɹ.pR@~jY@TGV?J4?ACAAA8_Q@=sΧ?CTAAA?3 S@?Q3?(4^?*2Q?|;H|P@%Y@}OW?=U?CAAACGE?P@gLNE?CAAACgLNE?0m.? Q?\/?-G~ ?K4onO@fY@bb?a+e?AAACGubO@w?AAACA/ha?),v-? ɹ? =KEj?و] ?־a"P@[ AY@P,8? ?AACGC& P@D{6mc?AACGCD{6mc?#?Ʈ?a?/?y5uCQ@|a2Y@v|? o_Ή?ACGCC-;Q@Ý?ACGCCÝ?UI6y?U❒?Q/]Z?Kj??ףp-hQ@ h"lY@>m?b2U0*?CGCCTFQ@wuM?CGCCTwuM?v.[?(?aN?,*ͷ?q= ]P@GY@{0?-C6?GCCTTHQ@,\yi?GCCTT,\yi??S)?Q_? eLV?L@hoZ@:$dR?HP?CCTTC*J@؁#=?CCTTTjξ?E9 M>Ğ$0:>z?e#o?q J@qZ@o|?_vO?CTTCAd>LJK@!+G?CTTTA ci:?DG]>!#@>sNᓐ?q4?M޷P@`TRZ@~r?ZӼ?TTCATP@l?TTCATl?Uohg|?LIY"?*V?o ?k~P@ Z@0!c?NSt$?TCATCLEP@M>E?TCATCM>E?⽩?oby?o`?ag?A~N@$Z@rm?eX?CATCA?.N@Wx?TATCAy8ϲ?r ?}-Ÿ?Uϒ,?%z \?W/ZCQ@Oё\Z@]T? ?ATCAAeQ@l&Z?ATCAAl&Z?6i;??'u?ײ~1?;rCTS?,/qQ@?&Z@`s?_L?TCAAT}؁Q@ת;p?CTAAT+l?r`Q? ?ꖱ+? ?t@NN@A`0Z@U[d?~jt?AATAC򨬋N@}W?AATAC}W?;FI?2F4wМ?O;s??ףp}CP@/=Z@+?Ǻv?TACTTu׍P@_?TACTT_?qdl?d,4y?83|U ?},ԛ?[K@>Z@481V?&S?ACTTT1\usK@ +B%O?ACTTT +B%O?>>\瞖m?9&V 5f?f붆a?G "?Q@:pNZ@佾?q?TCAAChs6P@U?TCAACU??EF?V?r,?gO@"lVZ@Dn?}гY?CAACT? ;wR@d`Z@+v?a4?GCAAA*e'R@1*Ug?GCAAA1*Ug?Y7%?YX$צ?z?^ @!?H-{Q@e;OZ@!TW?]'?zȈrG?rMMJ@[B>Z@2J?J +?AGTTAM2K@E!?AGTTAE!?s˼>a9>s SCs? I?؅#M@ׁs[@C?NSt$?GTTAT^@M@y?GTTATy?5"(O>T ܖ?Mw4\Ӫ?m)?MtDO@< [@ ߹M`?( 0?TTATT?P@㦠F?TTATT㦠F??dNz?ʆ?=޽ܙ?nLJ@;pΈ[@_p??/$?TATTT;qxK@!1d|?TATTT!1d|?bŕ]>-cF4>\Q{W?ie=?n?H@s[@??~jt?ATTTCRNH@_4o?ATTTC_4o?D(=}vد=~>w`Zr?s327 K@~[@l9&? ^)ː?TTTCT?`J@0xR?TTTCT0xR?u[5>R< >6P-?7Ř?'*uO@H.[@W)F?"u?TTCTG`O@f}'B?TTCTGf}'B?)[zk?\|y?8faf}?cK?߁L@%#[@#љ? ^)ˠ?TCTGC_Eq!M@H;M?TCTGCH;M?/Ҽa ?UTr(7~9?d?99D?NPM@t+[@ o?b2U0*?CTGCC&}"LM@Tݻx?CTGCCTݻx?!&a?^u?×]9v?ߵq@?ࡓATQ@:p.[@q??W[?TGCCG$?[Q@?TGCCG?(r?g/:v?Tn*,O?Vk2V?h1ER@j+6[@% R?HP?GCCGA\Tb@R@ka=?GCCGAka=?I?c-?U`Q?[=1?gxR@~j<[@*7x!?+eX?CCGAGIa6R@ȁu;^?CCGAGȁu;^?^o?LYuu?z8}?$>?,Q@5@B[@+U?UN@?CGAGCB YcQ@\]?CAGGGl8:?doZ(?[K?H?>ޥ?ܑR@_)G[@bH$?S㥛?AGCGT;R@qа`Z?AGGGTk |?SF?:&?sz9?GK?M@]CM[@U:@n?GCGTGd5 O@= V?GGGTCѡ?b9cx? _J!?Jbq?T2R?FǢwJ@ݵ|P[@qF+̢?w?CGTGGl K@*2d?CGTGG*2d?;[c>t>!^v?c(K?|N@.Q[@6#?`Qk?GTGGCi_1-pN@GxU'r&?TTGGCֻ}?,Iu~?Ut1y?~?"?-q}gP@sR[@.n^?_vO?TGGCA 'P@!84?TGGCA!84?B2+ֺ?x+Ln?v* ?":n? MR@_X[@S ,7?&S?GGCATc 1S@GlY(?GGCATGlY(?_cٻ?9w ?A?rzK?˗Q@^K][@Nz ?Dl?GCATTp`~1RQ@a ?GCATTa ?`~Ι?keocW??܌?|'p:?&% fL@2ın[@IX?"u?CATTG] L@u?CATTGu?hq%B"?Pxc>5@T?-9s'?s J@HPs[@\?I +?ATTGC]fEK@Bm!4@?ATTGCBm!4@?,ah>Ci>)5%g?/T?|PB2ËV>wxp?P9;L?ʅAVlN@Pn[@Wm?L=U?GTCCTC5tN@82Ӑ?GTCCT82Ӑ?O)N1?=6߶N?&am@_?mP?CҔP@\C[@l8?~jtx?TCCTT{P@?TCCTT?rZ??)D?=@d?Os ? BA؂J@Y5͛[@z? 0*?CCTTC^bJ@?TATTC vfx?0? >\~>K8?bQFQ? Q@qΈҞ[@ @ͪզ?TTCGCJJoP@uwK?TTCAG)3? 0%?WP?!ؖ"?=ϸtS?\$ܻQ@ףp=[@dbS_?y):?TCGCAI nQ@o?TCAGA*'a?ԦY'? ?`@?c?PQ@Qkw[@4 G?8d`?CGCAC6gR@Wo?CGCTAwpL/? lvm?UW?nF?e[e?i8l 2?CCACT>8l 2?CQ?G?X;9$?}é?h$hP@sF[@1~?K?U2ij?N[K,?]p0?NJy$M@RI\@pQ@46<=\@RM??Ƭ?AGCTC;qP@&g-?TGAGCBX?%^IB?7L??[`?A-P@=UK\@??Aǘ?GCTCAqO@du>ˣ?GCTCAdu>ˣ?Q??ec?Is,?,b F?P nR@ cZb\@7׃Fl? ?CTCAG4\FQ@?i?GGCTA1?Hfߢ?>7?~>m?*u?Q%P@r\@̧e?NSt$?CAGCT!P@'Ĺ?CAGCT'Ĺ?Gݻ?uHvlS? ?T?PݍZ ? &Q@sw\@}?HPsג?AGCTG@"9>Q@V?AGCTGV?6~?(qy?6_H?gOx?K:O@|\@O"?z6>W?GCTGAO@xmx?GCTCGJj?so?~?k&Fa-?ˆޠ?kxQ@MJ\@ Ϻ@_vO~?CTGAA ?P@"?CTGAA"?R52? 4?u6y;}?IQ'\?+D )S@K{/\@Mb?gs?TGAAA9S@{D?TGAAA{D?^Wa? {x?0d? C_>SLQ@u\@F*~+?(?GAAAC 3Q@>?GAAAC>?NV?ʚy?,)e?hڦ51<]?I+N@X\@)/?|Pk?AAACGJTbO@I?CATCGB??:Ѿl?v8d1?p7щ?{FP@|/L\@Qm?ZӼ?AACGAE #Q@5l?ATCGAY??G?I@?}Ulg?ە Q@\@m.Y? ^)ˠ?ACGATT/NR@$?TCGATak̥q?:.?vH/?k#?rb?^nP@6;N\@ΰ@H}?CGATAL)зP@-tdP)?CGATA-tdP)?%?Wnnʱ?18V)?w~?I O@F\@]ge@G?N@aó?GATAT$ZO@ }?GATAT }?z;n?]*LҘ?㑙t?/Qz?hHO@T\@ u ?J4?ATATCasOO@9?ATATC9?oIa?R۳?Y>Wi@޹?wd?T>cM@f\@Y?Q|a2?TATCT~]M@BE?TATCTBE?۝(@x?mZs?Q>?a3o.L}?0.?]`?k]Q@2ıN]@EƤC?/$?ATCAGW,Q@P?ATCAGP? Ct?Ml$?er`?xAw? +Q@W2d]@RTq@ ףp]@0@H}m?AGTCCd-J@9Z?AGTGC):?ZBx>WBj>?Lh a7?^{OO@ŏq]@\N\?J4q?GTCCTN܄N@9Ͷ?GTCCT9Ͷ?uz?)ڛ?Z)N?v˵?n,Q@&Sr]@#ź?cZB>?TCCTGS(Q@ &U?TCCTG &U?5??P?`j$?f?yQzO@C]@7Qf(?vq -?CCTGGܝ^JO@S?GCTGG'"?8Z׌?b?jOU?ww xB?ǴN@Ș]@.[9^?&S?CTGGCOv,N@"$q98?CTGGC"$q98?Z[U?~"P?? a?X oO@9]@YV_? o_Ή?TGGCCroO@pC}@?TGGCCpC}@?Z4G?7b?(Ɯd?p)my?s6&h-Q@ׁs]@}? ^)ˠ?GGCCCR?Q@Qmͺ?TGGCA0R?79?:?+X"?3HY?*cS@+ٮ]@@?+eX?CCCAT-geR@?CCCAT?j؎?;?3 W?O'>yTJ P@ޓ]@ě?Ǻ?CCATCZ2P@?CCATC?{0{?Ns??yoĎʣ?:\(h?2N@L]@/5?/n?CATCT1sRN@YmO?CATCTYmO?+Mmb?)7u?XJ}Ή?߿`u ?xwwVP@M ]@{|&6?~jt?ATCTAΨ P@d3?ATCTAd3?D»? ?S=ԥ?}C-?܃3aP@l ]@/ ?:v?TCTAC=DP@otN?TCTACotN?9AP??ACi?!o?6\XYP@E]@DFG8Q?Ǻ?CTACC P@>u5?CTACC>u5?czB1?1~?8DyY'6?+j?|{{{P@{]@G? rh?TACCT .7gP@h?TACCTh?;?" ?4ڲl?i-OE?oQ@' ]@?J4?ACCTT< 7P@q?ACCTTq?߷?RҠʨ?1Ĥ? 4?)WK@NbX]@M?Z8m?CCTTCJ@Ca>?CCTTT:ac?u\>G]Eqj>ta ?JO!?(\+J@8 ^@άP?+eX?CTTCT9J@Gۜ?CTTCTGۜ?];Jn4>F U>\lHsW?|(f:?ZO@^@uV\q?䥛 ?TCTGG&rO@7n:}.?TCTGG7n:}.?{: ?s6?[ < Ǵ??;oN@|/L&^@b֦?~:?CTGGCiױN@"YG?CTGGC"YG?a8?Pga֡?3 ?_|?7pP@ +6^@PM.>?Ǻ?TGGCGɛ˃P@)wuh?TGGCG)wuh?VG\?gܟ?bd2?WJ?<xR@ǺF^@_y\?ǘ?GGCGAa7S@B;?GGCGAB;?TSU=x?:??}] O?n ?MVR@gJ^@)z??GCGAA9TR@U@\?GCGAAU@\?zKlZ?qY?k"?Dhu>2 R@`Q^@I_=>?&S?CGAACOEQ@ ^γ?CGAAC ^γ??K=6x?UrWh?lwȷk>ht+O@PkZ^@)?:pΈ?GAACA++R@Ϊv^@7q ! t?z`P?CCGTG=FS?-K!?\HD? y&~?vʠ?beK@C>ٌ^@pH7D?@ǘ?GATTAbgL@yo?AATTA S.H=?vυ>R2?)Ԡ?~?UuN@ ^@Fg@`Q{?ATTAAlxN@ ʜ?ATTATi%?fYc ?LZ?s3I?q?FfiP@pɔ^@{?=U?TTAACP@җl?TTATA?*]?8ۋ%?g Bwve?~<+8?"9O@[ ^@m @Mb?TAACGӊ@ P@;_2g?GGACC0w?T. ?)G?u?'.?/Y,nP@yz,^@@!K?I +?AACGG2W4P@Hǖ?GACGGP_?wR4?iht?eN?7ґ?Q@ڊ^@ᐓw5?/n?ACGGG3y&0Q@6M5?ACGGG6M5?q?ge?vԕa?G? P@#~^@q?q?CGGGA Ì{P@m=}?CGGGAm=}?$~?'K#C? &Ʌ?}Tű?o6dR@h"lx^@eDd_?Mbp?GGGATyۿR@4?ACGAT}V?x~?[H0?ƞVyl?*P6?q= WP@~^@b ?b2U0*?GGATGiF@Q@N?CGATG.\?#?941$?,:?^?lj?%y6M@E^@3?:pΈҮ?GATGT,;M@MC=?GATGTMC=?SP2?*B6[?jx??Hw ?p(RM@ڬ\^@Ch?Q|a2?ATGTGCrL@'|8?ATGTG'|8?l{=lf?!ъYM?j߄?FP@&S^@27E@n?TGCTG dIQ@[!J?TGCTT`#?_}^?&?Vd/b?d젹pM?AHM@ݓ^@"'@(?GCTGCUp 8pM@ 8?GCTTAP,o{?~bΒ?rÄՋ?H{tH?:?U 0O@I ^@p=?H?CTGCA~ťN@ǂc`?CTGCAǂc`?/ *w?[=?t,6#?3@ă?1'ͫR@&^@+ ??TGCAC꣣0R@'C?TGCAC'C?)$d?U1?c?1e/av?ըNP@`vO^@2#?0*?GCACA]~&QQ@[8+?CAGCAVuk_?؟?V?O tm?+[)?fL2n|R@h_@>R@~?ACAGG~?I??NaU? Agk?!F_?Q@v_@uuO#?HPsr?CAGGTb3G6Q@AL?CAGGTAL?C|Mz?r ϻ? ZY?$>?z.8O@?_@oa?_Lu?AGGTT骚` N@KSi ?AGGTTKSi ? MaC?c ?<?]2L'?x ^J@ݓ_@7?<,Ԫ?GGTTAcUtK@?GGTTA?n}>Qd >&8ު?;?vM@F_@>Ro@~jth?GTTATmM@c2}v?TTTAT _?> y#L?N֣5?OC?!'?bfUP@)\_@fX:?+eX?TTATT2qP@~ί俰?TTATT~ί俰?̯%? ?r~ɸ?? AtJ@V_@gd5?`Q{?TATTC@KJ@TRF?TATTCTRF?b>b>!4+Y? Ѓ?%bP@Pk_@HN?y):?TTCGA]*P@b?TTCGAb?ʿjƺ?>A?r?*4?ZbQ@"_@Y`?"u?TCGACӤ-jQ@c|$?TCGACc|$? V?:Ml?cw﫾?y|{t?FO@O@a#_@IL?ǘ?CGACCgPz*1P@-ި?CGACC-ި?gI?7uL?g#? Q-?r FKO@&†'_@F6b?Biޱ?GACCCm[O@y4?GACCCy4?T?* ?f~?o(D ?n!Q@+e9_@^,,?_@&^?b2U0*?CCCATT%R@~[ r?CCCAT~[ r?c2?Y?)&݉ػ?5 ?0)Q@"u@_@9`?F%u?CCATGFlQ@)fC?CCATG)fC?5?uĶ?5??&~Oy?N@q= C_@~r?ZӼ?CATGGDKO@n)h?CATGGn)h?[B>6?tgE0?oM?.(?ugO@ׁsF_@w7䄾4??ATGGT!xѰ}P@akG?AACTT4r?/$5?{2~??Ezr?jtL@e`TR_@ݙ?Mb`?TGGTTA=^M@#oJ?TATCCT/է?V5?p\B?Cx{7?皜?H@[J@sR_@?&†?GGTTG\FTK@Hw@Ê?CTTTA!Ƭ ?D>6>KJH?؟E+?w,P@#~j_@{Ei@?Ǻv?TTGGG5NCuO@R?TTATGBߙN?&01.~??.?Ÿ|?`?GGGGAApGscۘb>"+> &_ 5ZxV:S(V@k y_@\@n?GGAAG:~e T@p s"G?GGAAGp s"G?į`?èF'>@?FGGAAAsׁ>>E>TbMA=?aA>! ];Ulw\J@qۈ_@LR%R@St$?AAGTCL@T>CGGTC$[;/X?źԜo/>Ȯ>( o?qwsX?dSM@>W[_@ @S???\WQ@V0*_@>ߨ?L=U?TCATAsq7EQ@00?TGCTA@G6?z#[5? ( ?'K?/?Fh? uP@~_@o吙?w-!l?CATAC6#O@RSE?GCTACeF4 ڰ?"~ ?9Ƅ?=?1 a{?-P@( _@ pc1?"u?TACTGP@(F `?CTCTGgaa?G؁t?tOuCCGTGH24I?טs4/?ޑLX>:Om?-WS%?fA"K@_@dH4?gs?CTGTT{iBK@%1+{J?CTGTT%1+{J?e"N3>k76>ZP8W?юK?[lJ@J +_@ WMbt>^ wk?mn$+S?r%zM@HP_@ d?y&1?GTTAAݤ#M@&T?TTTAA0?1?Q?OE?}xU?PQ@mV}_@Q֓?a+e?TTAACۮP@p?TTAACp?x+?(?ӭ å?vOϴ?b)M}O@"_@@zD?7d?TAACThZO@1P1?TAACT1P1?J?1{Tx'?Fh>?w?ީ?@O@V/_@4/?Q?AACTCvcO@?Ժ?AACTC?Ժ?D̫o?o`?y?2؋~Ȼ? AP@uq `@2?M O?ACTCAWc=P@+?CTGAG PD ?lXC?.ؐ?CJ??70?qR@8EG`@m-?Mb?CTCAG!(Q@o|$?TGAGA]8ص?]^?T4"?JH`?dk?iR@NS`@wT?n?CAGAA83R@w`8O?CAGAAw`8O?Y?)Eп?3@?j@8ъY?|ZS@Ϊ`@9Sa?Q?AGAAA2_RS@U?AGAAAU?@W?S@?'?+<?'>'N7R@?٬`@8n?F%u?GAAAA6qE"R@j%JX?GAAAAj%JX?ʤJ?_miLz5?p?T}O?DAQ@y&1(`@'(?I +?AAAAAPGi|Q@?AAAAA?I ?z[ϕ?tou?@?yYP@-`@\?F%u?AAAAC }P@l8?AAAACl8?>1-Z?]?`w7F?P}_?S#&O@K41`@E@Mb?AAACGIbO@S 4=o? dh? k}J@Q>`@E? h"lxz?CGTCAE ?gJ@9i}'?GTTGCۧ o-?6a>i#>\!hi?vAO?mg[@O@Bi`@hW`?2%䃮?GTCATU2dP@eỷ?TTGCT.Ph?q13.ɧ? ?U8Qy?=gP?OOP@4x`@<?H?TCATC[P@rg^?TGCTCYS??MaGA?Ы?pJФ~?оcPN@N@`@0s?ψ ?CATCG:S[GN@G`OȮ?GCTCC_9G?n?ClHZ?ľ%?[ƦF?ZsP@Z8օ`@|,?5;Nё?ATCGCwNӂP@ІTg^?ATCGCІTg^?[`?}+?af?/_Ư?eągQ@MJ`@pyEo'? 0*?TCGCTOM^DQ@ ]ќ&}?TCGCT ]ќ&}??AO?[U?K+]?aQ@e;O`@vU ա?q?CGCTAlQ@;tH?CGCTA;tH?y()?&?>W?!4-?F]4DQ@M O`@a6E i?F%u?GCTAAN-|%Q@Pʡ?GCTAAPʡ?5SB?hI\f?=[?x)P/?)~R[Q@4`@]&*?j+ݓ?CTAAC9,|!Q@mNʟ?CTAACmNʟ?f&?O?_T2(?.k&ɩ?wkxO@v`@_?y&1?TAACTH?d1N@`@ )T?&u?ACTCCi O@QOG?ACTCCQOG?h %m? E`o?aDF? rB?gP@/$`@/G# ?a+e?CTCCGh7P@?Vk?CTCCG?Vk?=8?>DEk ?C"k? 9מ?s,BR@sײ`@?eX?TCCGTtQ@BB?TCCGTBB?u#?sh?Er89?^H XJ?i]xdK@n`@8WxBW@n?CGTGAB4K@1o?CCGTCțȣ?:Ћ?ӧQ>֡.*?''ӄ?SgO@o`@oVռ?b2U0*?GTGAC%SdN@hsvc?GTCACLC>}i?\Ƭ?!rM@`@x )?Mb?TTGCA 1`AN@lJ?TTGCAlJ?4ՊG?̩T?i&^?*@iՠ?@XR@>yX`@t95?n?TGCAA GR@ߗwF?TGCAAߗwF?F?}xk?xd$?Uw>> [(R@?٬`@p"?-C6?GCAATdž R@E?GCAATE?AE?*?ô?<k$?U*P@:a@ͭ\?_L?CAATG戥 VP@cd?CAATGcd?&ô?/G#?O@ߤ"?So,O?G_M@%a@p$y?ZӼ?AATGGiJN@~?AATGG~?Ȫv{?1Fy?P'9?N[7k?GJN@RIa@%̶?=U?ATGGCmPwN@0C1L?ATGGC0C1L?a$;?Gͽ?5Z?Ylcc?{bP@sa@ 1bկ?j+ݣ?TGGCAP@C8?TGGCAC8? فع?>r?Q?7e?Gc$?A`eOR@?a@&j?{Gz?GGCACj/?R@2?GGCAC2?~;A?L%O?/ة?Rk K?QP@=Ua@v?b2U0*?CACTGU?_j$??IXy?Y-oiP@/'/a@+G6T?Ǻ?CTGGA3MP@1?CTGGA1?Bj *?<|?a4ԄP?QoOɅ?Q΃.R@[Ӽ4a@A=\?q?TGGAA|@OIR@LZ?TGGAALZ?wBj?@bCn?9M?B67?oS@,e8a@/iX?H}?GGAAAe T@ŷz?GGAAAŷz? ?{}[?#aT?.81>O &R@Q@HS?AAAATHS?/i!?f.5?!&v?^W?t0#^L@^a@UƓ?ZӼ?AATCTX"?L@=n?AATCA ,)?P8>?UxDs~?o?q ?Y7?*HP@.naa@' ?0' ?ATCTAHRP P@M?ATCACee?֚A+?4L?WQ&H?֜?)RP@M a@n?M O?TCTAA˅^Q@B7(#]?TCGCC?uT8?3M'K?խ#?bW*?u0PQ@cX9a@[wK?ZӼ?CTAAGA1R@b/^Z?CGCCTy?8@4?ܪ?hsep?%f?NQ@ۗa@;Zz? rh?TAAGGsMQ@V?GCCTAL?U[o?ׇ\ v?s ?-Χ ?"؂P@-a@KU? rh?AAGGCjP@(?CCTAC!ҙ&?B+?s ??=7?7?|l&?NI6Gx?>r%N@1a@z8 ? c?CGGGC ^6qN@dW?CGGGCdW?:i?bg&^?iT2 ?Sq?0];R@fc]a@e" ?z?GGGCAs-Q@@>?AGGAG0Kw?_F?%A )?tƒ׹e@5;Nё?GGCACHZX 8R@*Ѧ—?GGAGCVh?$$trh? ٺ?\٢?|\%G>MbPrP@Kb@8V?Mb?GCACA[ݬQQ@hz?GAGGC#˽??Y<@?*at?R~h?legQ@Zdb@NPƿ?w-!l?CACAGN'jMR@nhd?AGCGAZ5 Ǧ?-mB*?Ei S?]?fLU6t?\Tߎ1iR@=,Ԛ&b@*)?J4?ACAGTTMA$R@@zN_?ACAGT@zN_?/5?~6=?ZJ?tpЛ?4)HN@T(b@Y?JY8?CAGTA< GGO@i%?CAGTAi%?w}b>?cxӠ?ir?5Gj?ɮ]ZP@,3b@X?:v?AGTAAAG;O@jS?AGTAAjS? O?? ? x"޲?GQMGW?SQ@ޓ:b@,L?$N@yIb@׾&{@ŏ1w-!?AAATC^X\N@;?AAATC;?&4ib?zC?/'ߏ? r~5?j\rMM@ŏQb@@4Ȓ?䃞ͪϵ?AATCGLn:?%? BP@Rkb@|ǭz?&S?CGGCAŒrP@nz?CGGCAnz?e[{ڰ?m(:?ϻ'3o?ވU7?r$S@ -pb@6C?Mb?GGCAGJ1hGS@bIloͩ?AGCAGap;?1/%?|&?h߸?'Y9?S +Q@46|b@V:pK?ψ ?GCAGT_$IR@?GCAGT?d?q'?œ ?QQ:ZC?\.N@k b@o{]Ï @-C6j?CAGTTp6M@*\ÿ ?CAGTT*\ÿ ?AC?>H|?)qp?2qaJ@ʁb@ci4?&u?AGTTC#II@(lp?AGTTGx+ !>?UM>)ET_>t?R>j?եK@Qb@\E?_vO?GTTCT'"J@ |?ATTCTL?3KU>`I*?!p?9oX?=|1P@_Lb@@׏?`Qڋ?TTCTG/sO@5Uu?TTCTG5Uu?A5u?P?J?kY?WaTO@b@uTC?j+ݓ?TCTGGyrO@?TCTGG?I"@?=8?4sCE?ѲH?N@$b@^euc-?<,Ԫ?CTGGCߩ-N@>}/w?CTGGC>}/w?r?=Uk?U/ch=?ٹ/9?cX;QP@sb@]L1G?ŏ1w-!?TGGCA (PP@!?TGGCA!?2"7?v?Vp?i݃?9R@%b@hݭ?]m{?GGCAA͜SS@A<-?ACCAAi$*?SТ? sc?@?(`?^>Q@_b@ub%W:m?2 fO?$H??C}O@-b@]<ũ6?0*?ATGACr O@NlQ_?ATGACNlQ_?N=E?<&?iA?pM8?p. c{P@Ǻb@mJsP?ŏ1w-!?TGACAP@.Zz?TGACA.Zz?6?oC6?.?Kj?P T Q@ub@LQ?M O?GACATY{ SQ@TP?CTACA5{?&!?;?'j?鬲?t)-)R@b@vkX@y&1?ACATCFMP@M IQ?ACCAT=v?,Mq ?"R?0x߷?~"I?UN@ b@ף?Y5;N?CATCAqN@3/-U?CATCA3/-U?ҁX?>?у#?r?8B6Q@y&1c@G?&S?ATCATeQ@0m?ATCAT0m?}( ?/?Mjc?e$ŗ?sfOP@C> c@|'z?ׁsF?TCATC{GP@hx?TCATChx?Ùd?th?cޓ|/?RC;?۾/4"N@/!c@jf$?St$?CATCT~wRN@h M?CATCTh M?5L??F9"y?=RO?j>?hiO@i|c@yN -,?q?ATCTG~҉O@X)w?ATCTGX)w?̗?i[p?J_?tѧl?򑅿M@_v/c@v?&S?TCTGC Z!M@4ċ?TCTGC4ċ?~,|6?-YػZ??VH6L?3Ŋ?tT N@x-!4c@HтOh?X9v?CTGCC|+,LM@"J?CTGCC"J?{NE|?tdS?ʿ|^*.?a??%S]Q@ґ\Cc@Zlx?/nr?TGCCA5tQ@DR?TGCCADR?t>??h?ߥ?fd|?O R@QEc@Ȅ%?ׁ?GCCAT+w۲HR@sj[;?CCCATw? T?+?xY ?u@$?$!xĦQ@-Xc@C???CCATAemВ,Q@ {?CCATA {?[C?׉?#YRx?fߕ X?]tх)DP@ rhc@iZuk?F%u?CATAG)짝7P@_-0?CATAG_-0?*`0?]*p)?0?Cd?8X9Q@"uc@i6?&S?ATAGT`BGQ@>w?ATAGT>w?Йnd?H^?8A֥?CE+?c[=O@vzc@\]n?gs?TAGTAY@^,O@`#Tl1?TAGTA`#Tl1?L?P.RY?OXp>g??pNO@,:Q?GTACC,:Q?^??l4c?؝w?>>\?t@ VP@_c@3?ZӼ?TACCAu^CP@v3??TACCAv3??yZ?KDKkk?'u?{?. N{R@;Nёc@?J4?ACCAG٫M6sR@VďE:?ACCAGVďE:?+p?qlp$?ך\Ȫ?p֩x?1&R@c@a9|@&S?CCAGT N:TR@&zoG ?CCAGT&zoG ?g{[?Y?ƚJ:?~`6?{t|L@-c@G?J4q?CAGTC4PL@a:??CAGTCa:??jzJ?b S>sM?~fT'?V^J@|гc@I!ey??AGTCCoJ@yĺ ?AGTCCyĺ ?݁x>%׃I>Vo?zCT?PAO@'1c@縼A? 0*?GTCCG ii!N@9A`I?GTCCG9A`I?~w?^^A%}?ZG?\C?ECMQ@?W[c@-]?vq -?TCCGAEp-+R@j?TCCGAj?RB???k9k?d.蓭R@ZӼc@r?z6>W?CCGAA)R@?CCGAA?}? ?u -?VZ|@F?Bg>S@!rhc@1/h?_vO?CGAAGK -*S@"?CGAAG"?qDL9?1K?*ȕN=-?Q]>`yɜQ@|a2c@R?HPsׂ?GAAGAQ@JI?GAAGAJI?)SCJ?ACCCT>SCJ?x?D?[ 7˘?3J_?P;Q@Qc@Bԝ?:pΈҮ?CCCTCH/Q@yԥ|d?CCCTCyԥ|d?y$g͠?h?L,?CG? ף0xP@$c@O@?~jt?CCTCG^ճgP@,&?CCTCG,&?F`p3?{?'<|K?vq?:m^Q@Pkc@8ҠO@߾c@6 jK?ZӼ?GAATC'\O@o;?GAATCo;?B+^?E/Bb?+c?yLe?>sxJ M@?W[c@(}j? 0*?AATCGݓ;nwQ@DS?AGCTGDS?Ii?M]5?j&Tt?/5j?)j7P@I.!}d@<}@vq -?CTGGALP@^+?CGGCG/#9?(?ry? j?6 ?_ȏR@1w-d@ZB>?ec]?TGGAA3IR@ ^f?ACGAA&?tfv?◯K?ٌ?{A2|?l~~S@[B>d@?]K=?GGAACQj*R@7 ^_?CGAAADм?F?5?K?0U%\>!O@n4d@⤁B?J4?GAACT,O@ЂA"?GAACTЂA"? (.?Nu?Ժݡ? ?HgHP@d@=VN,?ǘ?AACTAh,lv8P@~ҵ?AACTA~ҵ?S?-?q$?5?v Q@鷯d@w|:?@ǘ?ACTAGޣ%s_bQ@cՎ7 ?ACTAA)Ruo?ӂO?Х?rR?6?SY3R@zX5d@{0U?]m{?CTAGAɼ[.R@@s?CTAAG̦??&T6?xoDc?;c-?UP@?W[d@QjT?jM?TAGACEP@иբ?TAAAC? [P[?@fh=?@1i?Ɩ?[R@N@d@Kj ?v/?AGACAͽDP@)P~?~?GGCTADe(/?v 9-?/+?E=?Trߧp?}vi3P@hDioe@S ʻ?Ǻ?AGACAy0CP@3i?CAGCC}oTt?(S|?#F>4?Py? c?uQ@Dle@T߷??GACAGcQ@@&"?AGCCA.B ?_0?]nK?=C?:\Ӷ?AiXR@X9(e@pV?"u?ACAGG=Ok>R@\?ACAGG\?'? Z"?$?m?1U?A?f!Q@f*e@$?Q?CAGGAyŐQ@i "8Ω?CAGGAi "8Ω?9?1'?T-X?=8y?,78R@,3e@?w %?n?GGAAC 'R@k ?GGAACk ?(ҡ?'a-?, ?q"l?\CO@-Ԛ=e@ U ?ZӼ?GAACA'`LO@oݶ?CATGAn3R?6t?ٹ?N\{5?.̪n?:(NwR@=yXHe@䭫 y @ͪզ?AACAGbKRQ@m ^aG?ACCAG9˨??a?ruцO?kc?JGd[]?w1ap.R@AaSe@ces? 0*?ACAGTu$R@`䴨S۬?CCAGTKP?_7Ym?Yb?ջ|?K/&?-O@_e@HI3@Ǻ?CAGTAaPGO@&A\?GAACT>??4ς?NTU?ȷN$?ߧO@Oee@{Q@7>We@3?{Pk?GAAACi E3Q@v'?GAAGTNx)l?s(R;?<$:Tʈ?U  ?lfO]B?uqTD?DL?+80Q@^Ke@MB+?n?TCAAAQ@Π:$?CCGCC=Cc?ݡ{C?RӋ?*}A$#?5?h4Q@_I e@Ҟr@ F%u?CAAAGi_;Q@؅#mL?CACAC9? qU?=X^? Nޢ?}{?o\^Q@e@Q7+?~jt?AAAGGw` NQ@?CACGCWl*q?SZI?aY?s?xܞ?y0Q@=Ue@im6?/$?AAGGAj eQ@ZA۵?AAGGAZA۵?, R?` D?^O?C=)r?lS6\rS@_e@Ƒ&g? ^)ˀ?AGGAA"_S@.b"ܺ?CGCGAą cm%?0s?;b?uU?gQ>eΒR@=ye@ z? g?GGAAC"R@-Cy?GGAAC-Cy?QFj1?d?J-?(>Gx'P@!Ace@r8A? 0*?GAACAGmO@\A?GAACA\A?e@f?e ?[0Dc?~?LQ@9gDie@߄I5a? o_Ή?AACAG"sFRQ@|c[ٯ?AGCCT1tpCܵ?޳~d?qb?M71?H%?.BcP@&Se@ ?S!uq?AACAG+;ZFRQ@X|?GCCTC=p?j(j?vj?F5?Jv?W2qIQ@4e@L^?{Gz?ACAGCF\yQ@i9?ACAGCi9? Ok?Gj3*?;Q7ƿ?0v֔?UL:P@-e@g?/n?CAGCAE%NP@%£'w?CAGCA%£'w?:/z? b5 g?w'xe?t[?6$R@.nf@Oh&?ψ ?AGCACT7 R@pt,?AGCACpt,?dj*?l3? 7Ͼ?%Ss? cP@gffff@V4?NSt$?GCACC[WP@V|?GCACCV|?Q?@_'?H|XOa??pQ@.f@[APrp?n?CACCAY5Q@ϗ˵4y?CACCAϗ˵4y?e:<>?3?׈?=]xZ2ۭ?Y|_?(UR@0L &f@UJ?HPsr?ACCAA' AR@j?ACAAG!~?X{?B8%|?Dh?0ds?A*uXQ@}8'f@L?46o?lo6`l?U5<}?m ?dž(R@9#J;f@qU?_vO?AGGCArRQ@Yv\?AGGCAYv\?Vm?nO??ڜ@cwb?Fq(|S@iqJf@ou?ŏ1w-!?GGCAASS@,>Hw]?GGCAA,>Hw]?DGU?&?Y=ȸ?dA>`u&Q@VNf@}?S!uq?GCAATaFt R@U?GCAATU?x%?OG ?lƙ:? U{O@6(Tsv?CAATC6(Tsv?qUg?-=s{?D?)+^|G?էSOM@PkWf@|? 0*?AATCTLL@c9?AATCTc9?܀b?rѠ5?8iu5?!CT!?(vqXO@]f@!?8gDio?ATCTCN@Rl4rv?ATCTCRl4rv?Q\?eP?ߏ-?d?JP@%~f@jU?{Gz?TCTCTKeO@3y4ͼ?TACTC%8}Q?U6(?&BF?ize]?+> ?9џO@wf@|%?F%u?TCTCTMO@3rLE?TCTCT3rLE?*/:? TO?,SbP?)?4ao3P@鷯f@ i#K?+?CTCTC: P@JNh?CTCTCJNh?m9?.?KmM{?iX/6?5 `/O@~f@w˼?HP?TCTCCO@<vF?TCTCC<vF?#Jh?ЀG?Y砐,?-?׬P@:f@9k?&S?CTCCT;P@(g?CTCCA?'$?s1O$?CF?a]H?L"Q@Sf@g? o_Ι?TCCTAփTQ@ncz?TCCAC"c?wLw?~-u?ǒ=?B\4Òy? qsHQ@Vf@??J4?CCTAA)݀Q@.be?CCACA`ж?c/ܟd?}U?e h '?[x *?Q@lV}f@T-X?&S?CTAAT\(Q@᮵I?CCTAT$lJ? ~?D?{2֭?B,\*?D)jP@&f@>q&?`Q{?TAATGfZYP@6櫿 ,?CTATC ,>So?Gr?Ywb`?b[?D)?#SM@[Ӽf@F:8&?J4?AATGGIN@Ս?TATCTZ ? 3ԛ?@US`?ݨ?~N0 ?>W[O@p= f@JDiX?{Gz?ATGGGUP@\!?ATCTGN=?7Mׅz?q33<>_z? &? M@?f@Қ.T?"u?GTGCT]az M@Ҭ\Y?GTGCTҬ\Y?kx=\?O2?0?ʣT?V^5Q@ׁsf@Jca?UN@?TGCTT<Q@TZd[ ?TGCTTTZd[ ?Jp_i-?{a?K:+?7v‰?xsM@qf@wJ$@Y5;N?GCTTG˫G>D5M@EdSY@?GCTTGEdSY@?zީd?0o)@B?269?! ?XL@ f@ތh+@HP?GCTTG7DC5M@}?CTTGTnТ?ِ ?a?{sm?A%?JHK@f@mD?NSt$?CTTGCVd2K@ =t?CTTGC =t?;F>0y?6Ͽ?)h?&N@f@XM1?_vO?TTGCC8ܥZM@U/?TTGCA{h?N?? ?ԩD ?? ףQ@Ǻf@;h4 @-C6z?TGCCGO^ZQ@~`~?TGGAG' r??=?G2?]p?z ?qR@y&1f@Y  @ QI?TGCCG]QZQ@}WpT?TGCAA 0C.?OD?fknI?_5eށ?*>KQ@Ϊf@bq]?tF_?GCCGC61Q@b?GCCGCb?;!a?Z?S?p5?4o? Q6R@shf@`}? ?CCGCAf>Q@O?CCGCAO?F"? SA7?gy>?1'n's?鵂lS@ψg@2{? rh?CGCAA|SS@ECD?CGCAAECD?0rO?Zb?'[Ä?F*Cџ>AD_R@48g@|P?HPsׂ?GCAAA_͌'R@g:n̉ ?GAAAA]n?Zݛ]?Ұ?mi%[ ?BSgn?=͡JCQ@ݓg@|\-Y?^K=?CAAATltFQ@6kU?AAAATDZ?85?LicΖ?zM?: _U?vL@|ag@9bAѰ?gs?AATCA6KM@4`?AATCA4`?Ӥ? f;?7F?pɊ?HcP@Bf'g@2W"b?HPsr?ATCAGQ@P.[[$ܵ?ATCAGP.[[$ܵ?s`vTi?D??%L?4H?)X#Q@)g@? ^)ː?TCAGT>n Q@=,?TCAGT=,?]?b&鉰?e>BV?殳5B?eYe N@zX5-g@;&c2? o_Ή?CAGTTl-M@JH J?GCTTG'HH?@ڳƢ?'{-;?&_??}!?rGz K@hDio0g@sx`?ǘ?AGTTA_2K@"׾D?AGTTA"׾D?MO/>5>G/?oa=?M@*4g@1K0?HPsג?GTTAAgtM@ O$/?GTTAA O$/?^;d?@E?]kyA-?1?z~P@J9g@Fi0?-C6j?TTAACVP@y`?TGCTCp#s?!_?[p?/ ?Oa೛?_,O@2:g@ 肵?b2U0*s?TAACA^EP@ĀW ?TAACT8;=?ۆLl?Ʒ?Ϳ~^Q??QL`O@7>W;g@7ĥ?%~?AACATa\OPQ@f}?GCTCA~*$?]ƒ]?B??f?t4}? DQ@6sd>h%cu? I?JI+J@僞ͪg@qx?H}}?CTTTG+֍J@ķ|_C?CTTTGķ|_C?d5m>:pe>)?z[?K~K@mxzg@OF?St$?TTTGCޢK@\jv?>?TTTGC\jv?>?ਔgZ[>?,-`?Y!x?-O@ F%g@kJ@@ǘ?TTGCGw?5N@gCr(?TTGCGgCr(??Zx?xfN?>݂ǹ}? FQ@7>Wg@!H?F%u?TGCGCGQ@cR5?TGCGCcR5?2<`?)n5?W X.?-RL?+)5Q@Qg@cHЇj?j+ݓ?GCGCA뗃Q@sDp?GCGCAsDp?$y)?S?Rӥ7?Utrݏ[?R@鷯g@òQ?I +?CGCATE"tS@X?CGCATX?u.9?-BM?`֛?M;9>ańP@jMg@1@F%u?GCATC@P@oѮL?GCATCoѮL?y/#?70]5x?aS?|"ݭ_r?ՠNN@e`Tg@t Q?o_?CATCTAQN@d?CATCTd?RV9̜7?{K? Ë?qX~?pe,/M@Gg@m~?2%䃞?TCTTAIM@ ose?TCTTA ose?b{6=?2E?x?X?{?QN@@g@ix W?+eX?CTTAA3|I7N@=V(?CTTAA=V(?z,4i5?t׆4??id?j$Q@\mg@ ܨ#?gs?TTAAT.F`Q@Tk?TTAATTk?4?bpӰ#?AI.Ķ?sfe?FdO@x $g@9?w?TAATCO@ORA.?TAATCORA.?|pGB?K'?S,t??_^KL@UR'g@:9?gj+?AATCTEL@v ?AATCTv ?.;J?MSր%?ґ*?i;?U9O@-g@f*9/@"u?ATCTC9uN@:5ex?ATGCT|Go? V?}kM?K? *t/?/CN@Jg@⽐?V-?TCTCC/~YO@ٜ?TCTCCٜ?K?D8O?h7m?9}EWJ?#z˽P@"uqg@Q~?/$?CTCCTމrP@@V?CTCCT@V?Y?bm3?mkd߸?#݉?E?͍qQ@{h@̔?HPs?TCCTT>XP@ܿ.k?TCCTTܿ.k?jp?(fÛc?O??@Nu?bv6N@'1h@,? rh?CCTTAh _M@DkɳvP?CCTTADkɳvP?T?nA?/ z?;g?t WpL@8A`%h@e@ 0*?CTTACNFM@)?CTTAC)?J?AzZ?E(?8b?59P@Oe(h@*G ?Q?TTACAvpP@rr@y?GTACAAJ?zݝ?rU?9y*?(+?Q@1*0h@ĵm?gs?TACATڅ*2Q@?TACAT?DO?;?R~P@&†gh@&@Mbp?GAATG]@PP@>H?GAATG>H?ބG?iV?Γ˅D?d,4?kVM)N@hh@BiV?a+e?AATGG:%N@Ը?AATGGԸ?G<9?? =?35U?ڧ㙐O@1nh@h??ATGGT"4P@F@Rf?ATGGTF@Rf?>ʱ?V%)+?m?3?|'K@_Luh@w՘@/n?TGGTCd/4L@>M?TGGTC>M?K|Sx>D37(L>\6*?9?eapJ@p_yh@*hY?{Gz?GGTCGSZUK@s=''D?GGTCGs=''D?zs<%Z> :u>>f?å^'?hO@fc]|h@RB8 &?&?^Vp'l?cM@[d;h@!h?"u?GTGGTh'O@#7?GTGTG _?5NR??統?M=x?sHPU?GjTʙN@_vOh@O3g@ ^)ˀ?TGGTG֠eN@(Q=?TGGTG(Q=?w\̵?N*a)?M"?榬E?`N NM@hi@c5?,eX?GTGCG'߷M@Xw ʸ?GTGCGXw ʸ?f_?JV۔?(f>-?4p+? ]R@m4i@7e ?H}}?TGCGT_FR@5R?TGCGT5R? 8_a?uHw"?6ܼ??KWP@NbXi@hD@Mb?GCGTG DO@\Ͳ?GCGTG\Ͳ?6A?1R?aGӁ?b?VZrP@Zdi@,? ^)ˠ?GTGGGxZ9$vO@|ښ?GTGGG|ښ?/7?L?Y@ I?S%?Q@#i@(Qܛk@/n?TGGGAPb:Q@d)(?TGGGAd)(?Iy`?>[(?տIk?'w?yoQ@ͪ5i@˯p @ ^)ˀ?GGGATՕD⇿R@ן?GGGATן?f4 Ȧ?U?| ?8t.?'Q@s7i@u@ ?GGATCZ|P@^9ؕ?GGATC^9ؕ?J>? @Zs?ބ?Cdn?PR2ZnL@d@i@ӵ#?y&1?GATCTg=3L@@>?a?GATCT@>?a?a|E?O0? ;?%Tq?Z5Z>jO@?Di@Y?J4?ATCTAmM P@Hњ?TTACCּ??!<`?Aj?FUN?N,EP@gfffFi@e\?Pkw?TCTAGb0Q@~Y"?TACCAcm c?R Tf?t&?M*K?Oܕ?sι}Q@;MMi@Qx?~NQ@lwbi@TR4M?2%䃞?GCGGTlKQ@*M?CCGGT f?J>:?lx [?L;?Tt_NU?|V N@ףp=ji@- &@St$?CGGTG-V&fM@ShUJĽ?CGGTAw ì?&N?mZ1@<>?NI'?=B ?~ѹN@lV}ni@݄/?S!uq?GGTGAƟy]N@݂e޽?GGTATDw?seQ?W?a? ed?[?RP@}гYui@E?( 0?GTGATצ/O@|7B?GTATAXzRҼ?9'?R4?VlҔ?HK$?_P@jqi@Jtz@ŏ1w-!?TGATA&6ⷣP@4D?TGATA4D?/#? f?fU{o ?^SIV? ף4P@ݵ|i@jIް?Mb?GATAA2PEO@Bʮ?GATAABʮ?p?WJm[R?ߎȕ??W?433P@ψޠi@E*?HPsג?ATAAC'yiJP@nU`ȧ?ATAACnU`ȧ?nU3^?6g?>HL?NjU?v~AP@Oi@ ?Mb?TAACAC2P@q9?TAACAq9?5u;O?Ta?*FF?3'T?z_Q@l i@('?"u?AACAG(RQ@Duy?AACAGDuy?kw?_P?ԲZ*/?TbWG?g-Q@&1i@՜@ZӼ?ACAGC0ħyQ@U*?ACAGCU*? j ?Pae^m?u؇#?6Oj?~5P@Ti@Κ@?<,Ԛ?CAGCGZ ĢP@$IjP@Vi@@Bi?GAGGCDO1P@-*?GAGGC-*?S2ô? 4?ս8$?<.v?=Q@2w-!i@aO?_vO?AGGCA KԏQ@"?AGGCGF=w?–F??~G(:?ö G?׳_OS@ei@0@O?l?GGCAA SS@  =Ƶ?GGCGA~\[?m?Z?Г7?ƪqb> O@c]i@T9Yc@<,Ԛ?CAACGfaP@ R{?AAGCA}?j?#H 6?9?!M?4R@wi@vE'aE/?W}b?ACGAT3:MR@h?GCGATd}?a ?))a˩??d+yv?5-WMP@Qi@<z:@Aǘ?CGATGA)P@uB@?GCATCx Ax?~c?G#s?Oץ?'$Hr?pDN@K7j@aC?HPsׂ?GATGAXcnN@95Ϳ?AATGA;b0?}G]|D?:lτ?`8$ɜ?a?M O?ATGAC9 O@wx?ATGACwx?i%=Pp?jSG?OX?D?HPsׂ?TGACTѼJqzP@;?TGACT;?>s?Q]r??xe?dgAKhP@gj j@J{?a+e?GACTAD9>P@⺉&?CCTCA6%?[ag?cBĉ?w]q?-0O?(9<Q@Oj@q? 0*?ACTAA Z JQ@?ACTAA?[G!'F?41q'? r~?G'?fpxP@uj@N,&'?UN@?CTAAC~0!Q@DB?CTAACDB?lmX?b??Τ=/?r<|?XO@"lj@0|3?I +?TAACCk&O@Jר"?CAACCgAk?4?Oi\$EKR@ڊ%j@$4B?mxz,C?GCGAT;ԉwR@.J}?GCGAT.J}?Y3?<:?ra)?T+(?gfffoP@jo)j@]L?mxz,C?ATAGCxXP@Z\9X?ATAACŏ q?==U?j?i̲?F?E+O@ ZDj@k?䃞ͪϵ?TAGCAש-P@?TAGCCq7"?4| i?V7?'5?xc?qR@y)Zj@q_@{Gzt?AGCACukR@fJA?AGCACfJA?jV[?LA?mwI?˳%J4*f?AiG9Q@"uq[j@9?ŏ1w-!?GCACG.>@Q@)Sc ߤ?GCACA&?Ӎ>??}(C?C 9?hp8rR@ec]j@?̋A?"u?CACGAH8yR@ 8˶?CACAA V?h!?j??bo/N?e]8T?ʚttQ@aj@0?mxz,C?ACGACoIQ@xP?CCGAC?k<d?LA?yw?U9Gcc?~`KP@qhj@'?:v?CGACC0P@O# S2?CGACCO# S2?GTM?ed#?t^]Y?Ե? sO@$J{oj@HD? ?GACCCRT`kZO@C?GACCCC?f+A&q?f?C11?%$5?(RQ@ۊewj@S]?vq -?ACCCG'̷rQ@PIU?ACCCGPIU? e(?Y~wlK@H}j@q@ rh?CCGTCI 6rL@q?CCGTCq?<,P?y$?dj+?J??՟'!N@+ej@yt.?HPsׂ?GTCCGjN@uE?GTCCGuE?%;?*D?A?F?lQ@Stj@K0^ ?~jt?TCCGTD*1sQ@7V:9?TCCGT7V:9?HP*!p?ud ?8~w"?t?A`K@0j@A::^@Mb?CCGTC;6rL@,+8?CCGTC,+8?w/ S>$3:7>ވ&)?MOa?xK\EJ@2ıj@'9?_vO?CGTCTSI@n0|#?CGTCTn0|#?YXZ`><>@h}:r?P܈f? M@!uj@<4?<,Ԛ?GTCTGU٘N@@?GTCTCÍSK?\m:?JgU?5; ?~>?E!whFO@0*j@Vn ?ea?TCTGG\WrO@03ah?TCTCCtf"x? ө* ?>Q?w"??ܼ[P@:#J{j@.&Z?j+ݓ?CTGGA,LP@dX*̹?CTCCAm4< ?Cs{J?GGAAT>{J?eHh"?E?E\Ґ?@K*6=x!zkN@Fj@Ad? ^)ˠ?GAATC?EO@KH ~?CATCG2X!?vIS?n z?q2??3?X#P@ecj@I~?b2U0*?ATCGCpӁP@3E ?ATCGC3E ?H?%??ۃ?z-MS?i VQ@ؿj@/xQ?ŏ1w-!?TCGCT\Gw DQ@>Ԑ?TCGCT>Ԑ?BK?h ?(TNL?`?~KfR@ZӼj@_ 4?HP?CGCTG4׏Q@g+~?CGCTGg+~? ^?Dy?߾=?= O?x]O@c]j@`?0*?GCTGG-O@ _?GCTGG _?< T?)R?K)?Ţ!??@5^zDP@ h"j@'? rh?CTGGA0cLP@aU^?CTGGAaU^?.o?w\HDI?rG?ޛY$r?i1Q@ڊj@0o/N@Q?TGGAT,pO7Q@pÍ>TGGATpÍ>ɉቁ> W>Ԏ>w4HT g=6yQ@j@h+?"u?GGATAcYfQ@m$#?TGAACC0J?r\~?%kK?1zp?{hWR?%N@wj@2@[?ZӼ?GATAC j;}N@ؚĘH?GAACCs .?8/6K?C ?? Ņ?_Հ O@6@?8 ?T B?_ק?v3َ?zՁ,O@yz,Ck@N~?gs?CAACCheO@-@I?CAACC-@I? F!rh???xx?b̤?tK-Q@SEk@ U?ŏ1w-!?ACCCG ^rQ@|^)l?ACCCG|^)l?)œ?BE?5?a,?f!&?vr}R@BfGk@P}?:v?CCCGTHmrR@6Tf?CCCGT6Tf?̌L/M?KLF?!F?pY|"?\K@^)Kk@4U?"u?CCGTCJ?*rL@&y?CCGTC&y?hJc1?KCֱ>xKE?|Z+U?pJ@|aRk@A1?M O?CGTCGb9I@?e?CGTCG?e?f-N>VND>lڦ@?(aR?OuPO@6bu?M;" t?*7Pu?Uo?P'q5Q@)~kk@:Ō? rh?GTAGTwWQ@u蝄W?GTAGTu蝄W?\C-?q?dGL?n1? JO@1*pk@7/?_vO?TAGTGO@V?TAGTGV?$hŌ?x "?+ ?ɏ?FX<6M@,sk@l??AGTGAFm}M@fL?AGTGAfL?_ (P?sZ?kష?E?ʡ;P@Ϊvk@#fS?Mbp?GTGAA7agTP@lU.?GTGAAlU.? \G?8v4?>}?ru?so$nQ@wk@gl?"u?TGAAC@ Q@Vsh?TGAACVsh?ǖ9u?iWH?l2DwHk?=}?^ZT\P@zk@˞~-?+eX?GAACGNO@j`/?GAACGj`/?߮B(?-B?h?2?]t2?բ/P@٬|k@=4sb?ZӼ?AACGCe9}P@¿D?AACGC¿D?1n B,?.ud?Ҷ{R.>3Vi?H?@$N@Aǘk@ ? 0*?GTGCToM@w &3?GTGCTw &3?-KZ?kz5?դ?ؖb?:4Q@qΈҞk@ _RSQi?+eX?TGCTTtQ@3?TGCTT3?3?$Z*#?;.~?GWo}p?1WFK@k@7#@ŏ1w-!?GCTTC&g/K@a?GCTTCa?}}#?s [?o%?ɋ?eM?A Q@jok@zA\?H}?TTCGCSnP@P[p?TTCAAT?ڴ|T? /ަ?-c^?_tQ?V2Q@zX5k@?Mb?CGCTA8Q@’dR?CGCTA’dR?[K H?C?ֺ6k?mOWk@. n?b2U0*?AATGGJ$N@-L*?AATGALg2?oUӜ?&~?"=J?M̳8?tBP@L7Ak@ 6͂>:?ŏ1w-!?TGGCTSebqP@·?ATGAAzKĈ?,Xc6? z?aY?2tu?*hQ@ k@Omg@5;Nё?GGCTT2+Q@ԙL?TGAACM3?tͫ?)e`?xB?:H@?#N@ $(~k@IhW?Q?GCTTApr3bM@$ޣ?GAACCT6z?Dx?-۸#y? EI!?@&?NJ7O@<,k@h?Td?_L?CTTAAcN@?CTTAA?rE?eXT?pJ?lC{Z?uv28Q@qΈk@v=e??TTAAGQ@v\$?GTAAA>]Ĭ?v$M7?z|i?k,? r?/qz Q@48l@1Ql?+eX?TAAGCP@p:?TAAACj|I?j?3?}1K? 8V%?z0LqUO@x $l@˂?46?N?s?k?dZm?9O4U?2YgK@Pkl@hhK)?V-?CGTGGEK@A⋺?CGTGGA⋺?F-x->OH#>)=[@?. ?FԱN@!l@CW?G1TL@ŏ1w-l@?Ae?oŏ?GATTAsG4 L@Z?GATTAZ?A.?'ph ?[>?r.]>?~j!O@G?l@-EuG?I +?ATTAGyVdN@m\4?ATTAGm\4?O?E?wm(JT?iBS?KgER@TDl@1=?HPsׂ?TAGAAo]z?R@ɭ~ѽ?TGGAAz覆?Dަ?.fL?y 0*?nY5>(?N[S@鷯Gl@A[5?ŏ1w-!o?AGAAAgc,RS@<>?AGAAA<>?Ճ@?u5P?ΕL?׮TT>AP?Q@#Gl@Rph@"u?GAAACL.3Q@h?GAAACh?aԹR?QF?ףѶ^?n Ѳ7?QN@b2U0Jl@d$!?_L?AAACC=GaN@@\lHo?AAACG-9uf?V?+?-CD?H?nWQ@C>Ll@ʫ=0~?"u?ACCCCKg@LQ@Pt1?ACCCCPt1?o ?9y˨?Ad?9[?+!UR@M Ol@5(W?S!uq?CCCCA9,R@Y))W?CCCCAY))W??Sr?{Ԅ?`(U?L'H?AoFegR@{Rl@s9ğ4&?_vO?CCCATZF'R@d?CCCATd?0h?^ W[?:0?31Q@Zl@Sva@j+ݓ?CCATG,Q@ujS?CCATGujS?cO\*?n E)1?ut?Y.R/?~L@G_l@/p?<,Ԫ?CATGC/IUL@g-?CATGCg-?t7? ???(գ?!S?p NO@ qll@2Y3F$?@ǘ?ATGCTb N@ashb?ATGCTashb?^@X%N?W˾$}?a?)|?7 MjuQ@&Srl@Gaz?J4?TGCTGz>TIQ@aUB?TGCTGaUB?tEf|?>[?)Ie?a>?60O@ptl@ B?b2U0*?GCTGG/ih'O@, ?GCTGG, ?K84T?⁄Σ"?p* -?`?3O@z6>wl@CȜ,?eX?CTGGT{P@ owli?CTGGT owli?c?>V? 6ʁ?DȤ?dhN@6l@n?H}?TGGTG1GheN@b^JT?TGATC"%?R?Eko?=PN"?zAU*?kRG} L@Ƀl@*ҲY? QI?GGTGAC3,N@%]?GATCCxp&d?ِ?W?~&?GATCGCE{?*6_w?nZǃ-1h?gY?ZJ ? 7m>KRP@Xl@_B?|гY?AAGCArs`ݚP@F޻?GAGCAY!I?vq?7?"5:M ?XWp?y&qxS@ ql@`Vވ?Mbp?AGCAG1mR@n\?AGCAGn\?hR@ŏ1wl@`d ?/n?GCAGCZQ@Q?GCAGCQ?dpo5?ᆑH?>`?M?L? ͦ0P@l@{>6?St$?CAGCARP@RLS?CAGCARLS?<9h3?LϵJ?]I?dyB|t? +R@l@ ?St$?AGCAAхҥR@h`Q?AGCAAh`Q?5!?γjg?,e?.)?[,OR@Qkwl@ ta5?:v?GCAAGyׯ,R@\ë?GCAAG\ë?xRQ?:qt?Vݯ?2S2?hLQ@ l@dW?:v?CAAGTC;lQ@ ?CAAGT ?6sC?2y?._?iZA?`N@yl@Tȩ?{Pk?AAGTAMPO@3oQ|?AAGTA3oQ|?P}|?}t?=A?ꩤ ? FN@Mbl@N(??5;Nѡ?AGTAGv \KO@_Lw?AGTAG_Lw?d,ߧ?vqg?UY@S?Dμ$?IS*8 Q@Jl@gfǡ?S㥛?GTAGCYP@(l3?GTAGC(l3? p ?>_兲?Rr?J?D{P@m4m@jf? c?TAGCTX9P@oEA?TAGCToEA?Β`p?1?^z e?|v? [Q@U m@Nh^S?Mb?AGCTAIE]%pQ@$E^3?AGCTA$E^3?(х?i?UFO?[ %?VSevP@X2m@Y T?CTACC>Y T?sD9*?Ξ |?㪨?//X-?i\3BP@ONm@?"I4?Mb?TACCA*P@9f?TACCCJ}__?vK ?ޤ?Ϯ]?æ?|/R@> ףPm@ ?S㥫?ACCAGNWrR@Q"P1?ACCGAC7[l?BӢ?׬>#?ƪ ?֎TW? 8mR@:v^m@~?a+e?CCAGAv3R@z?CCGATyK뼛?V?~X?UM)?? ?LwP@+dm@'T?Ǻ?CAGACN].ċP@V],?CGATA {?C=Ӈ?eͬǔ?Ewvi?d>c~`?~7/O@zgm@wצ?ˡE?GACTTΓO@Poj?GACTTPoj?wP\7Ι>jJ?}?ۜ;^P@{m@y;? rh?TTCATux P@ ?TTCGAM F9? 4?I-]G?d ?IpEП?2lQ@Tm@nJDb?_vO?TCATAb*EQ@S?TCATAS?:? 3$?djx?N}?{s]O@Clm@G?"u?CATACWO@M?CATACM?ÚƘ?.ZX=?{7?5maBK@7m@>H6?_vO?CTTCGV=z'K@ϠW?CTTCAM3?(MǏ>U(4?j?]O?]rP@om@a^?Pkw?TTCGG/sP@`nE:5?TTCACN)??R?04G@?t-j?V8t?vL`neP@C>٬m@e?~jt?TCGGCs-PP@$1?TCACC,:߬?)]%q?'?d?JKՋǸ?OqOzR@]mm@F=b@HP?GGCTG<7ŠQ@?@~?GGCGC|x?Vx?Ԁ?(??`Bǽ%? ףDL@`vOm@ev@Mb?GCTGCAKoM@+聎?CGTAGvF?ҡF? ͸r?sH?7 4&?\+Q@0*m@˂6?Zd;O?TGCGA%["R@C`?TGCAC#?=?#R{?/?@ttE?Я[?t8SR@\ Am@"qo5@Mb?GCGACI*Q@k7?CGCAC1$?X2 AK??h?`&?ϪyP@ڊm@+`bK?UN@?CGACG#&^P@u^Ep?GCACC~]?k %?$\5K?>LU?Fhߖ?A#_)Q@Oem@#?HP?GACGANT-Q@BI\?GACGABI\?HW5?X*՚?6LQ?sEf3?R@Rm@޴cB? 0*?ACGATף3MR@~+WX?ACGAT~+WX?̵߸?z*?TV?2Jh ?CATCC8> ?;f?/4RcJ|?o4T?^wߪ?jtVP@S%n@6?Mbp?ATCCGqP@9>?GTACG6Pú?1?TGriu?:m?a?;$*MQ@x&n@J`T?:v?TCCGTY5VQ@lK}C?TACGTOh2?Թ0D?O^D=?Yq7?juw?{\N@cX94n@lP[?Zd;O?CCGTTrCM@ [H@@n@(W@?"?⻘ WO@[ӼTn@=dJr?0*?TTATCFoIO@{ꭱ?TTATC{ꭱ?t=4 ?mawJ t?Uة+^e?Mz?KM@H._n@h"A?b2U0*?TATCA'N@R7$?TATCAR7$?ypFc?NӘ ?s?T7?^)Q@.nan@c> ?y?n9X?CpAO@gsn@&|?a+e?ATGCA~gO@ xZ?ATGCA xZ?c(?*X/(?,2?r'2? ?S@QIn@C V;?ZӼ?TGCAAcfAR@ }L?TGCAG`8??la?=ݝ?9IW?ƑM> E`P@0'n@ȸꤔ? F%u?CAACGf<P@cet?CAGCC?"iZ?tF?ظڴ?R?[XО?{Q@ŏn@ yth?n?AACGAE $D#Q@{Jb?AACGC:-?jE?(v~?vϣ?!Bk?n]Q@sFn@8 >?lw#?ACGAA!R@sm?ACGCAS?f?sP?Hz??Yxz?CuZS@鷯n@b VS>? o_Ή?CGAAGCB`)S@?CGCAG/BBX?zPz?|Uz?*c?r'>x=uQ@n@2+Ӗ??߾?GAAGA a(Q@ ?Sݸ?CAGGGC w?Gzu&?n>?Ì.?撠؀?'''F R@( o@CILYD4?`Q{?AAGAA OdR@Q^aہ?AAGAAQ^aہ?@?UP?.#?Z{`?!gPS@ͪo@Xp?3U0*?AGAAT,wS@,w?AGAAT,w?{mk?~H,??Ce>W ıP@3o@H.?F%u{?GAATA{85qP@r)E?GAATAr)E?UfD?U]?plU2?)[6}o?ei M@+eo@g,? ^)ˀ?AATAC0>N@(,L7?AATAC(,L7?๜Z?J?}Z?665?_fvP@~o@fp ?HP?ATACC!R]P@Q(?\*hި?GRDP@9m4o@9$?0*?TAACGp6 P@" }?ACTACRA}Q?.D?8\?Oۖ1I?Qw?UڢP@|г9o@βF ?gs?AACGCk_P@OʑL?AACGCOʑL?(uF?S]v?s̝?o|I6?`,EQ@2w-!?o@ <@?~jt?ACGCTIK2tQ@i?ACGCTi?˽?s-?S0Š?p?dp,]Q@3Bo@k ?0*?CGCTTtXDQ@qq¼u?CGCTTqq¼u?DMxP?y]?o[?BY ?rlL@ yGo@g7_R?Mb?GCTTTK@®X?CCTTT,u? 9?Q>t? z??I@Wo@K.?_vO?CTTTTۧQFI@*?CTTTT*?xb=/t.=wJ7?=ʥ?mxz,C?TTTTA<=*BJ@׃CG"?TTTTA׃CG"?@IxO>]AG>dGV?u9+b y?k{M@H._o@ȟppc?_vO?TTTACA=yL@KX{?TTGCCe׬L?b͋!?0?Ց+? "?C/PlQ@7bo@)?q?TTACAv"]d ?GCCATq? l6?I.r?IT,?4g?d==P@iqo@譱?J4?ACATCP@+nq?CCATC48-? c?9t?.9S?gG ?#_0N@@߾o@ s?UN@?CATCAjmذN@ޑ/:2?CATCAޑ/:2?8?O[m1C? ?J#?x#Q@x&o@J?eX?ATCAA7XQ@~ ?ATCAA~ ?_?0?g?gxBR?zi?qO@F%uo@z ?F%u{?CAACAP@Z5N@/I ?AATAC/I ?Ӄ?AOk1?ZG~ ?Iwv?1#O@@5^o@Z?b?a+e?ATACCh%XP@7Z~?ATACC7Z~?q۩?^%?_s)x?۔SC?ۀP@1*o@.' ?<,Ԛ?TACCGEP@ ?TACCG ?,&?iD?:?,^}?>FQR@|гo@ߝBf?ׁsF?ACCGG|jT\.R@ \?ACCGG \?8`FW?G`s??ϳJў? BQ@,eo@[%?RQ?CCGGA^5Q@?CCGGA??&h?JE6?Q¹?]?#0R@K4o@ v?5;Nё?CGGAAY -WR@ -?CGGAA -?~0?D`[Ⱥ?s?Tgv? v:T@>yXo@8w?I +?GGAAGFAT@kE ?AGAAGmƃ?$fq?J?!XL|?%>P̑iqQ@=yo@5g=\@J4?GAAGTDеQ@a=C?GAAGTa=C?? q?Vv}?k6-?϶c6K@vo@5?HP?AAGTCsL@<"!P?AAGTC<"!P?WzQ?ÑhӬ>Umo?o-Jq+?j6;O@ψo@Ъϡ?ZӼ?GTCCG{q]N@~ c9?GTCCG~ c9?PUʵ'? ?vDz:@?@<]z?ŜQ@:#J{o@Q?Aǘ?TCCGTE*\HQ@nV=W?TCCGTnV=W?Tfٲ̤? \L?Xӽ8&?>@$A?CE:M@3U0*o@y+~@y):?CCGTTj(M@Ϥv?CCGTTϤv?@_%?[u͵>%bf?.Um?)\bG@Ǻo@=Zm`?-C6?CGTTCG@p%U?CGTTCp%U?W{G=昰i< ?2M>?߀iI@؁sFo@ ۋ?( 0?GTTCC-5I@m?GTTCCm?X=Pm#>BO?anC?|z8N@To@AY<?NSt$?TTCCGNIO@'?TTCCCs#Y?s#kse?<~p?E z?gnT9?]P~R@7[p@۲??߾?TCCGGԡ`R@n#J?TCCGGn#J?I]?<|?n\h?h4?K r(R@ o_p@L̕>M?eX?CCGGA@Ȃ3Q@ @>?CCGGA @>?Jk< ?D{?eBcƲ?ɫ"\E?̧47R@~:p@r;z?Q?CGGAGQ@ đlm?CGGAG đlm?=}r?X?TJn >?Y |)?inYR@sp@i@HPsׂ?GGAGAΤS@ŋ(ʰc?AGAGA >#j?$pf"?'9Ny?&P4?v> +1R@\Cp@x9iK?I +?GAGAAV{R@Mė?GAGAAMė?JTB?)f??zr9?;=WR@p@ fkU?ׁsF?AGAACDzR@#tn?AGAAC#tn?\%$A? IB`?5y?7)`>E#tO@e$p@`?H}?GAACA 5g O@F?GAACAF?ck?)[pޱ?`n?.Z?,Q@V,p@UB I?F%u?ACAGCjsyQ@#y?ATAGC^z?sB@?i|M?Ioi?N'?%!>[P@HP3p@}$h?ŏ1w-!?CAGCC)P@cJ>P[?TAGCCqLD ?9gE0?m?Woc?Q(?}F1Q@' 5p@?/$?AGCCGFrJQ@D?AGCCGD?>d~HF?B3u?_Z?aTQ?[f6R@Pk:p@\?n̿?ZӼ?GCCGAo?R@42?GCCGA42?O?lni?._?R5 $=? 0XR@( >p@MDÆ?y&1?CCGAAWiR@QhWM?CCGAAQhWM?vk |?jh_?P}-?^J>Q@.nAp@ ? ?CGAAC{:Q@sx2?CGAACsx2?$RN? Dr?+g?j:j ?>O@8dJp@Vu? QI?GAACGa솳O@Cm6%?GAGCCa?0?8[?S?=?mR@XQp@0$r?J4q?AACGAt.6#Q@&L?GCCGA*S?O&0j?_8?}+s?/Ew?c{rR@WRp@oa?HP?ACGAT MR@{˅?CCGAT И6p@? O$?+dI? ?a?@4*ݛO@Up@AA@(?CGATCApO@=?CGATC=?rM?": &w?͐?J'?䂦o.P@ψ`p@P^P\q?L9:5R@0L p@u,?UN@?ACCAAo+6AR@x%?ACCAAx%?8g?0:?I}=1? K?sQ@ͪp@\{ ?"u?CCAATQ@tR?CCGACj^?rWo??"7 ?t^O?Ә?@ 'P@Cp@V;;?_vO?CAATA1bHoP@rm ?CGACCk i ???*yj?($ ?z?jO@M Op@Nd?S㥛?AATAGq2O@b ?G5?AAACG7^t?.?]c? S?B0v?:6)+Q@KY8p@M'?Mb?ATAGCHiP@c2?AACGG;!?>7m?YU̻"?5~B?T:w?ƶP@Dp@N$?<,Ԛ?TAGCGJ6P@T?CGGCAvܱ?P??f?QS\;?Eٛ?AR@/np@U?vq -?AGCGAsR@v]m?GGCAC!0ߋi?m5@W?jq?GACAAV^$eQ@uaBZ?GACAAuaBZ?tS@?@v?2$ \?}q?0GP@k+p@@, K??W[?ACAACXE P@]1֣?ACAAC]1֣?4?ŕη?q/?b?jOgLN@&Sp@1&bc?P@`c?GCATC`c? <$w?+DR/?x1"?M8K?}XdM@RI&q@TPC?&?CATCCߥM@o?CATCCo?^?u~q?b6?\^r?rRO@1*0q@9)O? -?ATCCCjeO@=~;+?ATCCC=~;+?|u|??^ɱDk?i^u'?1ץR@_I Bq@&D]=A@HPsׂ?TCCCA OlQ@8A:)?TGGAAl?sKp?ӠR!e QR@~8gDq@/ ??CCCATs[R@R>?CCCATR>?p?>v?wU,@? ?_.O@ o_Gq@@4-?UN@?CATGAHvYGO@A-?CATGAA-?=J"?Y%a`*?iN?OǺ@?C P@yIq@.+R?H}}?ATGATM;nrYP@@DZ?ATGAT@DZ?v9/آ?s[(B?-tqw?2*m?:[2 N@=UKq@gF$g?<,Ԛ?TGATC*W(O@gS} ?TGATCgS} ?bWS ??C|[?+?ZL@(\Oq@:('[j?HPsג?GATCT+d7L@~ 6N?GATCT~ 6N?pS*?=h $?4zض?)̧ ?ZҢxO@Tq@t"? 0*?ATCTGB?O@\C?ATCTG\C?y+I? )?HT,}!?b?wb'PN@2Zq@ >?_L?TCTGT]5IN@dh@?TCTGTdh@?ZYȂ?k7n?=Q*?t*v?[:NL@7dq@.Sh^?St$?CTGTGۡ^L@Xv7?ATGTTpU?ФR>>)R?yUĬ? 1|IJ@iq@3? ?TGTGC#J@Y}`?TGTGCY}`??$>k?>5l?,{Gl?3N@X2qq@eGq? ?GTGCT*_M@,!eF?GTGCT,!eF?xh[?`md?7??ں?QP@K7q@F?Ǻ?TGCTCm8P@[Q?TGCTC[Q?9HP#??܍?^i`?}AN@~8gq@h?<,?GCTCGHJO@X]/?GCTCC+^0.?P2?4c\DҪ?طQ?Z?uBpQ@lV}q@}f?ZӼ?CTCGGQ@ ط?CTCGG ط?av?gAM??TEea?hHQ@ˡEq@SH?V-?TCGGTd]JQ@cPX?TCGGTcPX?Uo?P!)?S)b?iú?EUJ@a"q@WurF@X9v?CGGTTG]L@VR?CGGTTVR?>2gN>k'?.?ŋkK@nq@ZkDuM?<,?GGTTTD=^J@D_%?GGTTTD_%?}>>1;?H&?m?z3qZH@(q@yq?<,Ԛ?GTTTC-]H@d2Ӻ?TGTTC[\o7?*jpD-=ƛ=M()/?l~?|гm6J@A`q@?{Gzt?TTTCG$_K@"s?GTTCGr?=3Iʢ>jE?sn? M@V-q@~O` @a+ey?TCGTCӂ[ML@6*?TCGTC6*?,-%>۸j?tT?+ٴh?:ſI@Aaóq@t$r`?Q|a2?CGTCTn*I@7s?CGTCT7s?,8Vr>t*f>k*bf?d]i ?_LN@Oё\q@?r?GTCTT郘aN@$^(?GTCTT$^(?J? ֧>D?SBJ)? ߀?ZC;_M@ݵ|q@q??ܵ|?TCTTTUW`K@0QP:?TCTTG&Ӻ ?˃??M?g?§'?"y(K@ǘq@hGx?y&1?CTTTAvhBJ@k?CTTGC _?8Uƻ>=i>g?Ԍ?(.M@r@}]M?-C6j?TTTATkM@ N.Fn?GTTAT=?v#LE?(~?E4x?E?pE?GکCP@%r@kA?-C6z?TTATGzBJP@ ?TTATG ?#?͓WWy?%ҽB6?τN'?ԿvL@48r@O8?QI&?TATGC`5M@ ڑ?TATGC ڑ?y'*?9Ӆ5?1e ?egW?َ~N@jo)r@?Mb?ATGCC/ ;N@g?ATGCCg?獾R??<&ӷ?}s1?IP3u?P@):+r@, @ ?TGCCAfk_tQ@1IÖ+v?TGGCGUK>x~?"TK?{ |?Mؽn?,VG>~$JR@7>W;r@tU???GCCAT2͒;HR@̍N1h?TGCAC~J??ݙQ??-@j<{&?T4}A? Q@^)Kr@~} ?j+?CCATGqjԁQ@8Q?CCATG8Q?Ӯ;+?vſ/_T??xpN)l?~pqM@ѳYYr@ ?S!uq?CATGCJVOL@<ba?CATGC<ba?Rɿ?̿l?;'La?Ya?'f'R@ec]r@$  ?S!uq?TGCCAl4e^tQ@W&kF3?TGCCAW&kF3?/o.ΐ?C5?H~2б? M}?3Q@Y`r@+l|m?_vO?GCCACFaQ@(r]?GCCAC(r]?Qz?$isK?P?f2Uv? ڲwnQ@JYfr@ǔ0?0*?CCACT Ja˞XQ@Pܵ?CCACTPܵ?G,W?u9?&MȄs?| ?&1HLP@=Ukr@:/X?Mb?CACTT'̦&P@?CACTT?^I?)7:?T6?_?%ؒM@Umr@K98ڨ?~jt?ACTTA#hy*M@'3?GATAC}p??|W}? Dz?S ??j1P@) pr@; YA?Mb?TTATA$yQ^P@:Qi-j?TTAGCF^J,?fM"fc?)>BWS@r@^ޥ?]K=?GGAGTB!6 S@j?GGAGTj?u~Ql_I?φ??(lru??T>v4M@Hr@‘c@F@J4?GAGTT$O@Ht?GAGTTHt?X?F>%>iw?>UkȒ?XqH@_I r@??AGTTT^1J@/&?AGTTT/&? &n="_d=oAzI> %?Gz#H@or@+?b2U0*?GTTTCd\NH@buBje|?GTTTCbuBje|?r/YD=uH`S=N۬O>7'?%;Y-J@r@uet?Ǻ?TTTCC0 @J@k?TTTCCk?oo0E>:}-c>k7T.?(j?EԵN@Afr@9?Aǘ?TTCCCg&v,O@?TTCCC?Yž3?4&|,?HA?'U?!O ,?Q@䥛r@E'|?ׁsF?TCCCG%hdQ@ ?TCCCG ?Xiа?= ?V L?G*?ZR@Z8r@B?HPsׂ?CCCGTިqR@] ?CCCGT] ?wN??}?a]b?OxV?]@BO@y&1r@Q ?Ǻv?CCGTA(Uƕ]O@v`[>?CCGTAv`[>?KB+?kxT?¸?nR]?XL@UR'r@Ńʎ?~jt?CGTAT $N>!M@XL?CGTATXL?[Ei(?bc?lDz%o?:'_?!/O@lV}r@dG?+?de1Ӎ?J(?d{zML@Qkwr@?:pΈҮ?TGTGA`'ŸL@h?TGTGAh?Ls>~5L7?f=?WMy?O@r@[d?"u?GTGAT@O@5BT?GTGAT5BT?tE{!?N+w?,be?=q?Hz`mP@Hr@-\2?-C6?TGATAKgmP@aa?TGATAaa?Z(z(?4?}@a: P?Ϛut?𿾿 O@Ϊr@$&s?"u?GATAGfO}O@B%"?ACTCC?F)Ʋ?Lwj?ns'VV?Log?oQ@L=r@kZN?Eioɤ?ATAGAs|Q@R^-6?CTCCT7K{s?d$D?!K?7?[&/?)B?dxqP@ʡs@6?_vO~?TAGACPP@Ao?TAGACAo??r?*B?O1?t`P@&†s@G?sh|??GACTA=P@uVr?GACTAuVr?OX?} ?ޠ2N? 4dC?_-[Q@?s@_N|?cZB>?ACTATK4=P@ W7?ATCGT'>W7?[;Ʉ0?Pd?(m?!(e?l'L@W2s@H}%'@-C6j?TCGTC!ȸ5L@>f?TCGTC>f?Cg`>15r>ӥ?Q~˞?eLI@3s@0`|?ZӼ?CGTCTI@oI@Kñ=?CGTCTKñ=?ǘbn=O#>Ӝ_XB/?[?3w7s@H~o%K?0*?GTCTGPON@eUq?GTCTGeUq?Sl?uQV?.N@T㥛Ds@ TJ?I +?CTGGCP NN@页?CTGGC页?չ}?'Y+??ئ֦?̼`Q@ףp=Js@'-Π?Mb?TGGCA!xP@UD?TCCCAGma8?>dO?LK+?٣C ?T#X?u?R@PnRs@qI?J4?GGCAG' FS@JD?CCCAG΅L?Fv魱?Xd*?:'?%mH?QnQ@ǘVs@Oz?_L?GCAGC :iQ@I?ݎ?CCAGC^eQP?eAE?RR~ ?C;C`?sxNT? իP@faas@H*?jq?CAGCArޜP@1?CAGCG0߳j?fS?zy?)R?A$!?/7z_R@J +s@-??<,Ԫ?AGCATϩDR@SW_?AGCATSW_?<?g?p ?3\?܃P@*s@i]e@+eX?GCATT'$]pQQ@j1x?GCATTj1x?}k?`6է?,?{$PT?[s `)J@m4s@gg?r?ATTCC 'J@[O?ATTCC[O?fu>J>I9}?% m?~P@6s@6k?b2U0*?TTCCAdO@}?TTCCA}?`nL ?W"1l?4u?*BD]?0Q@Os@R@?:pΈ?TCCACY,Q@ t?TCCAC t?l?N?결?V:98?ỹRQ@I}s@ `b?a+e?CCACAl[+yQ@|e?CCACA|e?.£x?[۫?|w?g_剠?}JQ@9#Js@o%@'?ZӼ?CACACUqAQ@GD?CACACGD?M'?cs?"Z߻?T3 ?mpP@-Ԛs@O?\ Ac̭?ACACCE P@S+2?TGAGCǣ;e??BB}r?p??@VcPP@,t@Jm?( 0?TCGCG(蛪BVQ@*sx;?GAGCGcIM?{ ?̈ ?0B?Ӥd?UN!R@43333t@t@6?=U?CGCGCr)R@\U?AGCGCΈ!2?zr͹?a?x鐰?`#_?+%KQ@ ?t@*/? o_Ι?GCGCTr+jQ@{?GCGCT{?ί,[?"?]+?@ͥ'? ̫Q@ڊEt@T E@q?CGCTTwGZCQ@M̳?CGCTTM̳?T[g?XB}y?l+OA:?^xP?BۢIL@lIt@L 4?&S?GCTTGOTl4M@?GCTTG?bM?e '>@:?sk?T>_L@UNt@䮵 ?n?CTTGT8lAL@~S;?CTTGT~S;?3FG>Y3gQ?t?s?mDK@V0*St@ӯpF3?ZӼ?TTGTT7_D~ L@ ?TTGTCD2+ ,b?32>~6ӗ>tN!??.EhJ@cZt@ܱd? ^)ˀ?TGTTAǦJ@0Ȥ?TGTCTQ/,w?ZD%$V>3Z} >âʱ?}?{N@^K]t@?-C6z?GTTAARp3ǜM@Df?GTCTAXE?+޽s?}YY?*.U?J +Q@ yt@_pR@Mbp?GAAAT pQ@0/?GAAAT0/?N)?f^N ?c6o?,f#?;v)P@;t@|3qZ?ʡE?AAATGPO@i"ӓ?AAATT{?}C?q 7?>h\$?iˆ?szK@46t@O|O?H?AATGCjIqRL@b-g?AATTA %?*k>Ϟ>6&?7J?qCN@ Zt@}7? o_Ή?ATGCTͤ`MN@+Ȃ?ATTAA^9x?szz%?>?&!#? 2C?"Q@ݓt@LM 1?ψ ?TGCTCP@VoM?TGCTCVoM??FFM?Z}?AW?0XO@Vt@V2B?HP?GCTCA,vO@Sg7yO?GCTCASg7yO?#Bh ?~ݣ?r?k4=?] =Q@_vt@;E@-C6?TCAGCB*NQ@1 ?TCAGC1 ??!Y?j?VH`?tb P@6}C?i\kv Y?Gb1N@ct@G8@-C6j?CCGTTPٜM@֖@?CCGTT֖@?16?';?5!?")g?? tI@6t@O-?Uد?CGTTG:*@I@9m?CGTTG9m?\јR>Ul g1>6u| ?O?p= DK@ qt@>ʺ?-C6z?GTTGTМK@ki?GTTGTki?\0>P>. ?!?/?TL@e;Ot@OA?HP?TTGTGFXɿL@l"&z?TTGTGl"&z?c^s>蘿9 T?~iO?tdj__?CO@jMt@L2rX?<,Ԛ?GTGGAROO@Ǣ.b?GTGGAǢ.b?ܚ\?c`|?8r?ÃM?HzT<(R@vt@~52@-C6j?TGGAAq;IR@(?TGGAA(?uݭ]?׼OCI?[x?н-?ET@Qt@bE鱢[?{Gzt?GGAAG0eT@(/L?GGAAG(/L?*mk?4S9y??+>+\? R@I.!t@e??߾?GAAGAp,Q@ l?GAAGA l?Y c?D?L~?-?Q9#OKM@^) u@Sg>@=U?AAGAG_"+R@R.O`>AAATC:?.ۢ?&=?2T?0!Q?aݢ+YR@m4u@{]t? o_Ή?AGAGGVR@Z#?AGAGC7 ?"Au͢?[D@?b&@?&R??KB'P@Yu@Q?ݓZ?GAGGC>P@Ǭ2G۰?GAGCA{??y)?;Å?cNg?R@~8g$u@rH;?`Qڋ?AGGCA%izQ@X?AGCAT"PW?}/^#?= q=?A9/? _O&?F .S@@'u@!4@ rh?GGCAAO>SS@f4u9?GGAAAi?H2?r?-?(N9>433C&P@<,u@庫Oj?-C6?GCAACF1=Q@Ghfݷ?GAAACUH5?E~(?b':? $?bl}?+N@$J{/u@?Pkw?CAACC$tLO@ cf?CAACC cf?-E w?6c?U > ?;?l;P@a6u@뎌?d`T?AACCTErP@Y?AACGC0?O5?ƙ䌅?pSv?U8ԕ4?R@.nu@pDlp?ψ ?AGCAG?VR@i,/?GGCGG"HNjӺ??l L?Ԯ^?mB?ujQ@^)u@_#?@ǘ?GCAGC9VQ@hx?GCGGG|hU?LT? y>?gݑ?a?frP@>W[u@fH?Q?CAGCAM+ѻP@؞V ?CGGGGrnԮm,?K&y?=_۷?=PN?śwJ?OǒCR@d]Fu@?:pΈ?AGCAT| rR@.G ??AGCAT.G ??/"1?k N?6M/:,w?7N?UR@Cu@۶`@J4?AGCAT 55(R@D?GGGAT&_kR?'Y*?E2?c?>(H0Q@2ıu@St4?"u?GCATT^QQ@nA?GCATTnA?S1?mF.v?a2?7Kt?XXL@A`u@`ZLW@ ^)ˀ?CATTA'L@r*R?CATTAr*R?C`.p?,Q?(?E?48EN@]mu@3eIj?{Gz?ATTAA BnN@^0Ժ?CTTAA,T'?݂{و?9?f`+?I5ɘq?xf6dQ@I}u@V?Mbp?TTAATK^_Q@<]4?TTAAT<]4?v?k=;?G^4Y?޳?K79FP@x#u@W?Mbp?TAATA`yuP@=M?TAATA=M?6y]?-J/Ҥ?ZƏL;?3?p3P@y)u@* ޥ?46*2|N@2v@ypo?UN@?GAGTC=4Q N@* ?GAGTC* ?Iѳ?"ͥw?$6J? !=?d9RL@\v@1AS@q?AGTCG-K@U|@C?GATCGz?Tܘf?UXSug?2?H` ?6RP@D v@?ǘ?GTCGTYP@?ATCGTZ R?] &? Y t?,O?4 {?VmcJO@v%v@,g_?a+ey?TCGTGmVckN@e )i?TCGTGe )i?S.nJ2?_U7?b Y3?b?GK@&v@o-'!?_vO?CGTGGΥtK@`lC?CGTGG`lC?i->-UA>$Q?=Zl?+4O@?8 u?r= i?K@HPv@?T㥛 ?GATTT6n K@k?TCTTTD:?0 >G1e>J|h?҉ ?/@J@h`v@;o? ^)ː?ATTTGBFJ@7ζ?CTTTAv瘺?M<-`B>̋;-> ?ow ?> ۓsJ@T㥛dv@Ä W? ^)ˠ?TTTGC SK@6. ?TGTCTfM? mB2>}c.>' g8V?;7L,?Z2$N@:mv@R? -?TTGCCLEZM@'FSi?TTTAG>C?3]=tQ@G/?CTAAGC`K?ȋ?#(i)?5}?A ^?N!]P@ v@Ӿ?~jt?CAGCG HKP@sO?CAGCAN?&I? .?Aٔ2{? .A?hR@Fv@I ?UN@?AGCGA4RR@(0?AGCAAա\?Z+:?-鬊??V?hV?p޹SP@v@?tF_?CGATAߓUP@a7b?CAGACSL$?<ަ ?ܣ v?Ԣ+_?;$4;9h?6]P@?ܵv@j{'?y&1?GATAAcaYO@"?AAGCGkh?ï" 3?wE?R?)Lخ_?J Q@d]Kv@cz;?ŏ1w-!o?ATAATvQ@L+?ATAATL+? V?k?]@?}B?&;O@8gDv@'q!ct!@Ǻf?TAATC_hO@$x?TAATC$x?͌?^ #iCq?iK^t?L?XGWVL@lv@_~?HP?AATCT={sL@??AATCT??'L<$>?*D?lئ?ymN@uqv@&?K?ATCTC(N@*e?ATCTC*e?l?9h?" ??t^N@~8gv@uwQ~?(?TCTCCgW4O@xJ?TCTCCxJ?SՀD?kfȣ?Y9?)N@.?YԲP@v@$9?S!uq?CTCCT]P@$e ?TGGCT.y?2y?ʌ {?X?$Ukd?E?!}Q@e;Ov@9[f(J?Q?TCCTT%gP@h*?GGCTT7ʖ?~?d?I??[}1Ue?#PK@x&v@D-;?HPsע?CCTTT'HK@ u?CCTTT u?v&>E.`s>HV>.FC,j?r2?6` N@nv@yg:?Oё\C?TTTAT :M@a;!?TTTATa;!?m?O3E?W`&T?k?OML@ lVv@`?@ǘ?TATCC8(M@BV?TATCCBV?Xi?c}?q:?`a$z_?gUO@ew@q?UN@?ATCCG!0(VP@CF?ATCCCz?ۣA{?y?Xnu?Du?TPQ@Eiow@ǩ?w???^.T?['rJJ@sFvw@Z,B?Zd;O?CGTCG>DhI@?AGTTT3L?K!1~>=>'Bu? uS?{WlRfO@Qkw|w@Mx]@ǘ?GTCGTLP@^|&?GTCGT^|&?#? Kx?}drܼ?Z?[NI@7„w@ |?HPsr?CGTTAXS}I@d?GTTTAI2Îr?Pe>n U?#ڍT?>cJPN@Eiow@)0l? ^)ː?GTTATʵ7M@aYav?TTTAT\z[?Nu?U?jG ?xaX?/C3rO@9#w@PJWv2? rh?TTATC!O@Aڃ%?TTATCAڃ%?ZDN/h?G<[[?ooLv8?t^?=)N@sגw@UU?V_?TATCG|hN@x8Y?TATCGx8Y?=Bi?dƵjϔ?P1We*?<8*1?69jP@K7w@Q05+}@Q?ATCGCP@^՗?ATCGC^՗?K?ih?8dG@?9:3?'eQ@Vw@ j5%?St$?TCGCAjmQ@Wk2?TCGCG״?l?w E?'Ø?uBzVs?!maR@6;Nw@þ|uU?y&1|?CGCATbS@ ?CGCGTz >?z!?=T ϸ?v??B;$kP@HPw@x@LCYQ?Ǻ?TGGTC P3L@S"Į_?TGGTCS"Į_?6't6?/-D>$CQ?d>b?}Z.K@N@Ax@UD?/n?GGTCAQ(%K@.?GGTCA.? Sһ>7&>U2?є?0 P@OEx@8l*5?5;Nё?GTCAG &?GTCAG>&?R0l;J?v-s?;< ?7p+[ ?zQ@ Jx@# @?H}m?TCAGCqK>NQ@4 ?TCAGC4 ?"Lg?y5x? ?Pjcv]7o?S`?Mh%?bP@o_nx@G(@L=U?GTCGTه|P@? Ft?GTCAThɴ?R?:\U?-G?:j" vŽ?c?sK@?ux@"V @J4q?CGTGARK@x 3?TCGTC܋Gf֞?[>vb\>+e$a?`)?6TP@vx@@H}}?GTGAAQ?TP@Y,np?GTCATٍ3?G ?"!nP?Ph?ǝk?( uR@Axx@A)"L@~jtx?TGAAT,R@Z.bγ>GGGATLiK>TW>/ۼ>1N> ,i='P@Qzx@x?ǘ?GAATG"p?PP@Rzc?TCATC`Q-=2?m>J?<`?#vB? ?_JBEtN@:v~x@Lv#?+eX?AATGAS2N@(Q?CATCG!jY?;F̀:ҵ?_r? 苺?:`}?:FQ@fax@OY?n?ATGATGm9YP@1`R?ATCGTFο?kf ?07b?k3|?:h?sL@gjx@s?_vO?GATCT0KċL@ p?m?GATCT p?m?^`Z?d,? gzԸ?2e? ףp O@{x@dž:?_vO?ATCTA/kj P@]rZ?TTGGG4?NT??Se?<_ ?m{z?7%P@zx@SS?"u?TCTAT`pP@$33K?TGGGTok4?$=l?24?"?!x?;DP@Vx@rxs?`Qڋ?CTATTfjP@p|J?CTATTp|J??̑M?j}?w阑>?#8Y7FJ@(x@:0?+?TATTChĴJ@c|?TATTCc|?KT|>]I\Q>@k?pp(?9v*M@/$x@ڲz?~jth?ATTCG5K@zسS?TTTAC$^U?4_tf?fHw?KȺ?Pg?/{GP@xx@(?( 0?TTCGCvVcnP@D6?TTACAaߺ?$T߼i?oK?8xUz?w};? GR@zX5x@62Ӈ!?Pkw?CGCGCvR@j?TACAGa? @$\??[?T]ސB?5Eh?lQ@NSx@8&? ^)ˀ?GCGCGizivQ@v?GCGCGv?X.?\?P} ?E)~ ?6&?2TRR@"lx@X3?H}m?CGCGT-MDhR@^LV?CGCGT^LV?:A?eM?i?(pmX?oiM@fXx@'8Xg)?_vO?GCGTT$;̟N@8?GCGTCg_4?,a?վA O@?'.D?%?@LI@2x@< 0=j? 0*?CGTTA?}I@/0Y2?CGTTA/0Y2?)i>|PAR>dg?p Y?|޳M@I.!x@ {j?/nr?GTTATFR$M@r?GTTATr?2R?Ge? IxJ?!{V?{G:P@dZBx@&Ml?Ǻv?TTATGNPbJP@MZ9?TTATGMZ9?? /?]?s\B?Pt~?HzCQ@Qx@}hl&@Ǻ?GCGGC2P@8-ynm?GCGGC8-ynm?:?ޝi:?oM?ur{?E&P@K{/x@@ ? @ 0*?CGGCCR߅O@Kf[?GGGCC5Vq?|B?ЫUp4r?Idƕ?;efKP?9՝Q@z):x@hE3E?GGATTs5>,ø>]3>T6>1p=gffޖO@faAy@{9^@-C6?GGATTCQ@K?GCGTT/w)"?+Վg'?rx->;B>?K4>NPL@TDy@Y]qR?_vO?ATTGG秳̼L@AN˘?GATGCl W ?Ol:@:?h:b?0g?oZ? UN@ClGy@_@r@"u?TTGGC?3^ކN@Qbv?ATGCGvt?^q?\l?"oo?~?.؂P@~:Py@Q, @H}}?TGGCGpP@}O\]?TGGAT -%z?60S{?]~n,Ԟ?9fǨ?>>?lR+Q@sRy@GAATT%??*P?(>L c,?qkOgIa>&eu8Q@Q~y@y @1*D?ATCGT_BP@IV'/Z?GAATT`9?D E?o)^/?.?l?ՐO@Zڊy@VR/+@A`"?TCGTAg콿]O@WȼJ1?CCGTA Nhe_? V?T/?[Ѵr?>yW>;61M@ڊy@fY?z6>?CGTATLR; M@1O?CGTAT1O?vYκ\?d6{^? ,Ï?ĵ2Q?S㥛N@uy@j?3?I +?GTATCbA/&O@٧{?GTATC٧{?_ ?Z??6̀?K\B N@9my@B4? ?TATCTM@oMtÖ?TATCToMtÖ?jN?Vc??-1?p?$-O@_y@sJF?J4?ATCTTo;RO@G?GTGGTmE?Ժ/Г?dF}?"X?Ԝv?DgύM@ޓy@%ߴO`@ 0*?TCTTAg#eM@j>L"?TGGTG-+?(qOp?$?1VZR?^V?O?uN@ڊy@Ȃo?ZӼ?CTTATc8!N@/?TGGTAULʪ?g ߴ?\?"$Mg?udE?d0N@1w-y@b@n?TATCGtN@h7ZF?CTGACd)?iJ?'X ݍ?|0}`?wBt?cQڃP@鷯y@K$$?&†?ATCGG7u!P@3բ?TGACG?^N?l ? ?fV?0? V[3Q@7>Wy@d(sU@5;Nѡ?TCGGG_O5kQ@Z1?TGAGClAώ??+Wɤ? _L3$?Wi?n ~P@?y@Y?eX?CGGGG$0P@gg[?GACGGc+ϯ? /V?`58Hj?dVX?WOl? Q@uqy@e>?J4?GGGGG &OR@L寢?ACGGAz2?ς?&w~L?L-%f?'nAD?^PY1R@sy@1=O@l?GGGGAZݟKR@ѝj7P@y&1z@vn @`Qڋ?GGATTu7=Q@%7p>GGATT%7p>~mx>ޣU=©GW>T728<Յ9]N@ q z@yD!@"u?GGATTss=Q@_ fZ=GCGTC^]>_H!>p=+^]WSm>/ecO=CLMP@1*z@k>@Mb?GGATT1Us=Q@ 1`f>GAATTp'6h>x>%$۵=jtRew>]_ki =MJ@z@c`F\ @Ǻv?GATTG5EK@ L f>CGGTC Hha?„|>IaKq>!?>e^4Jq?DlCL@jMz@CUZX @y):?ATTGGcϿL@>R`?GCGTCGw?B?+Q?qϩ?~3̇?ˀWO@I}z@ N@BvdQ@,e8z@*?a+ey?GGCTGpf\&Q@;L̴:?GGCTG;L̴:?'K?C._؈U?ؠH=?t;8(l?{xP@h"lx:z@6SɟM?y&1?GCTGG |$O@{`?CAATAAC,?S0?J?^*?٦g?uw|P@.nAz@^=r?ŏ1w-!?CTGGGbQP@?ATGGG6РŸ?98(;?gE`?ٜK?B\.?^s!IQ@%Cz@ad?~jtx?TGGGGgYP@0?TGGGG0?vA?%eQ(KR@t#'?GGGGAt#'?;=?O ?7|Y/?^b>t@S@1Nz@b@ o_Ή?GGGAG.U'S@5>?AGGAG*7?,p?׭$?fEO|?z?5>R@Rz@Lh R@p= Wz@&*??GAGGAŒQ@?&?GAGGA?&?U{?[l8??(G5>4(rzT@٬\z@/@_vO?AGGAGi o(S@@wBV?AGGAG@wBV?)ud?N@?{_?^=l7GR@v_z@#8Xu@gs?AGGAGqub(S@+2ܹ?AGGAG+2ܹ?bs?UTXC?IM?NB? # T@ F%ubz@-?"c@ŏ1w-!?GGAGGh6AS@F{?GGAGGF{?Je*]?V6vC3u?O>?Xs( uA>E Q@JYfz@F;?/n?GAGGC2ԬP@$:?GAGGC$:?.f)E]?1h^?RR?f?guQ@&uhz@<| @{Pk?GGCTTQ@<"t?AGGGT,a?1v?{\I?X4+?WW?C4I@ktxz@F@ 0*?GCTTTdK@(<2 ?CGGTCEJ?2y"fe>(V[;Q=T}_?rD*G?]-iL@~z@p߀?_vO~?GCTTT-K@EB?CTTGTPl԰?[-Mt,?b>V?yB8?Sh4o?3J@nz@ ma @5;Nё?GCTTTK@v2) x?TCGTC??j>h(ԙ?̖ ? I@ez@.6?5;Nё?CTTTA;.̗AJ@]rAL?TGTTA>ܼ'Q?kz>9W]Ө>2c?$?gFM@kz@})@tF_?TTTATmM@u{?GTTAG,Ԏp? G t(b?P?Y}?~?+]aL(FO@$J{z@ghb?HP?TTATCNubO@ʊ]Q?TAGTGW6?o?;mT'??e?8kM@)\•z@()U@ݓZ?TATCTU M@T?p?AGTGG.Qڹ?ϭr?1Db=?nӸl? _r1?#O@oz@ILk@S!uq?ATCTGO@j|C?GTGGTE6 ?D{?].v[?G@?8S?N@ޢz@1.@H}}?TCTGCM@ovt#?TGGTGn]*?Rbؚ?9ai?=#'??OVM@?ܵz@eK@ ^)ː?CTGCGD6CN@OxaG!?CTGCGOxaG!?]@KY?4Tg2ʒ?|R?!t?rjFR@z@c}=5H?ǘ?TGCGGt1WR@2?TGCGG2?Ef?甀?ݠtu?|FA?ŜQ@Vz@IE@ZӼ?GCGGGA@мQ@m?g?GCGGA.)v;>?Mj?i~?oz?W,%?!Q@{z@XH@<,Ԫ?GGGGG_7R@. D?GAGGGxl??شc?#hE?qV1Q?^cj!iJE.R@Sz@Sh{M@0B_77S@wz@u@L@_L?GGGAG9V'S@Lq?GGAGGO.?`G?#Z` ?2u?ڽ>? S@z@Y0 d @F%u?GGAGA WNOS@*뫈|>?GGAGA*뫈|>?> s?w{%?-?T7=vR@nz@F?7@Mb?GAGAGR`iyUR@S?fVS@(\z@ 9f?mxz,C?AGAGG(R@uQj?GGAGG ?Fvg"^?s?P?n7>JKovR@z@\@O5@ׁsF?AGGAG;(S@|0!f?AGGAG|0!f?q?G+\> fv?vb > 0f#S@^)z@VWD@a+e?GGAGGS AS@\,ڈN?GGAGG\,ڈN?2͢?iچ?%ö#޺?QgQ>Jz~JP@z@L@5;Nё?GAGGCKP@C+}>GAATCS%F?3?+ig>̓m|>zj7>`qQ@HPz@l@Ǻ?AGGCG.EhQ@Б?GAGGG}V?7@Iv?y?~[h~? LPA?2uR@_I {@ S@_L?GGCGGӁOR@&jVo#?AGGGGïV?S8*6?A՛js?\`\?t>\ Q@?ܵ{@f@/n?GCGGA#Q@or=?GGGGAlS ?_ܖ?҃Qs?Z?S? -pkR@Ǻ {@%e@ψ ?CGGAGXQ@]i?GGGAG$]ec?2#1?~!!?pFC?4m`=>"S@z6>{@ۉ9@ZӼ?GGAGGYAS@NVQX?GGAGGNVQX?O?H#?b?cT?:P>Ӑsf R@Qkw{@ (-&?J4?GAGGAcQ@us?GAAGG;'~?Z~k?vsm`?+ͧj?b/e'?1Jl#S@{@/ܸ_o@?W[?AGGAGp,(S@]p?AGGAG]p?&g?a߲*>?F?adAGGAG5K>("=c>p>:6^? }pz=(vS@0*{@7hׅ@Mb?AGGAG(S@- ?AGGAG- ?Ḽ?] `?Ԓ?jf8>l(#/S@mxz,{@7o@Zd;O?AGGAGZK(S@6?AGGAG6?mV@?L5ct?t!Ϝ?$ g7p>[̋R@;pΈ2{@d 1QW@Q|a2?GGAGGxAS@j/٫?GGAGTk3c:?u9?Tp a?]H?MHv>S@I.!={@ldb?Ϯ-?}8ڊ?G3=yh+R@+eB{@uu @_vO?GGAGG>AS@p*[?GGAGTj\Ujw??1o]?֕?;j>Ec}hvQ@SE{@o kEXV@n?AGGAGM(S@Ϧ2;P>GGATT[>#p=:>qԊ`>*S>&+=RLi#5S@OeH{@ƶan @gs?GGAGG^] AS@c`!?GGAGGc`!?Aa8?Bjc?Hc8?oSyhV>,b9R@M{@Q@ o_Ή?AGGAG:(S@mJk ?GGAGGRg'?k,5DE?f>\=0W=?Bnݣ=VR@ꕲ Q{@Fr@-C6?GGAGG[AS@M>GGATTyʬ >sW>ٛY0>@j>q Z_=hQ@NST{@s$@UN@?GAGGA)kބQ@*dw0:U?GGGGG^?3&?hI]??TM?DZ,?r\ Q@ǘV{@x3@kt?AGGAGQ=(S@kt6Z?GGGGG2]G?&6?r5ՈĮ?SObl? 4U?$,#R@a{@rʙ@ ^)ˠ?GGAGG C?BAS@0!?GAAGGlYd?R?A?GOC?´zU?ǁ{!.Q@9#j{@Tqw?n?GAGGG^Q@Kr33?GAGGGKr33?{^LI?%Ƴ?˘FL?Яɣ?/8ykP@mxzl{@V.q_?_vO?AGGGC͂ OQP@?AGGGC?pٛɖ?sƷ?Ǿ?<q?Ƿ1Q@hDiop{@pBǐ?~jt?GGGCGP@ѵ?GACGA(a{X?G?{Y ?鎛^rw?Qn^h?ZxR@_Lu{@mDs@j+ݓ?GGCGGڸR@ 12u?GGCGG 12u?% Xk??N9X?@_vO?CGGAGĘQ@V,?GGGGAG4? ?*M?KЌ?f;>R@ׁ{@c$/1@a+e?GGAGGB;BAS@Uy_?GGAGGUy_?&@z? ?lV<_?{'>0hQ/S@o{@ש=@ QI?GGAGGm(AS@ R ?GGAGG R ??Gb?ĜTU?EbtL?M F>3UXqS@V{@!} @St$?AGGAGF%(S@?AGGAG?xȑ?v0?V|f? ~=鄐FS@ lV{@!+F@ׁsF?GGAGAHS@S9?GGAGAS9?r?tG3}?HCno?hG>qSoR@ h{@679I?vq -?GAGAA;ޤzR@W6?8?q?4ieL?&`?UUI\>rOGySS@ׁs{@e8D"@ec]?AGAAGE5tlS@V?GGAGGwm8?'Ǧ?)P?u"?jyf>elP@3{@ T@&u?GAAGC$dlDQ@ &?GAATC5YD?:|V? 4?I&?szƘ> j+Q@({@& ?@Ǩ?AGCGGϷYR@.o?GAGGG=+'?ʱzt?HCe~ ?I?$IZ?r'ʒQ@{@5@0*?GCGGA= Q@ }V?AGGATȵ6?SQm?vWߛ?OyH?wQ?oP6Q@{@ã+@x $(~?CGGAT8{bQ@kb?GGATG8? x R?p6qP?n:n?4T:?%W+Q@ o_{@wӞ@y):?GGATGJP?Q@ӷ\?GGATGӷ\?Xj?""/?0Oq?$_?9KGM@C{@_0+@^K=?GATGCy'L@iM?GCTGC? a?ACYR@'1{@6Q@Q|@NjN @~jt?GCGGGnsļQ@aYaT?GCGGCjK?miy?/]=oa!?*F'?D>#*SP@H.|@`!M @X9v?CGGGGdgP@J?CGGGAwb?~?iX?g?9vQq??sR@՚'|@v@?W[?GGGGABn`KR@KI|?GGGGAKI|?FŢ?J W?ky?O!C>R@+.|@秐X @HPsע?GGGAGEa'S@1ۜ?GGGAG1ۜ?AH?:Bo V?Z?ק(>EzeS@D8|@'I(?M O?GGGAGy'S@R5k?GGGAGR5k?Ꭸ"1?v?,7?,\>Ǣ9S@ ףp=|@?s @?GGAGTY S@ƻ?GGAGTƻ?U9.?^L?v ]?I>sM7N@q= C|@M@I +?AGTGA>dUM@K4?GAGTC=4Y?n?9?)k?5ԗ?^`? nP@wO|@1w$ :@X9v?GTGAG/{P@gS?GTCGAO ?.4d а?ȕ ?d ?{V{?p=R@p= W|@[@ ?TGAGAV!UmR@vxvi?TGAGAvxvi?uf?װ=U?c_r?qA H>[֥Q@\^|@=@HP?GAGAGfmUR@_է?TGGAG=qL? l^p?D@?v?v>ktSeR@_I b|@|۫?n~G?Oq?|??&Hc >nQC.Q@td|@7@_vO?GAGTC8, N@ ?GGATTΧ~?;%?u؊}3?.n?SPyД>gN@c]f|@>!@/n?GAGTC\ N@n?GAATC8: 9?glk?grmY?;(?:?q?O$7\L@i|@5#h?F%u{?AGTCAqvK@JG?AATCCJLDź?,:A32?,x޿s?aK?H?&G?+iQ@僞j|@b@(*?GTCAG>(*?n >VfC1?0!H?o>-ޤQR@FGro|@߱~?X9v?TCAGGOkt)Q@ 㛿l?TGCAC ?oyHH??/l~{?DA4dT?vL{ F?hj^Q@sw|@E_6?:v?CAGGAg Q@BY~?GCACA 01)?^M?1h ?{pD?\4 Cq?v+R%R@L={|@wk? ^)ː?AGGATi4״R@34@?CACAG^9-~?\jA?9f?a¾!?)n49?_Q@o|@8yt+@+eX?GGATGv?Q@5=?GCGGT V?ey?D,wW?ƩWh?EQy>^rTL@ cZ|@]@ ?GATGC2L@n^+?CAGTClp6?DImd?@k?i?1`J?V N@|/L|@on0@Q@468aQ@=U|@>&&@?GCGGGPQ@dž[?TGGATσx̚?[)zU?_X?*7c?bE~G?>0P@z6|@?@St$?CGGGT0rP@i+x?GTCAA1ۦ?` 4#?IR:?*ol?*C?{`P@_v|@? ? F%u?GGGTG4F\P@M?TCAAC)%'?7??2d?Ց?O@"|@Κf?"u?GGTGGؘM@i9?CAACC0"(?7U?ѩٺC?qyV``?b ? \ 1P@0*|@D`'?ǘ?GTGGGPhtO@1w?ATGGT\?`?v-2?AW?\{)?gffP@X[|@\5 @H}?TGGGG8f;rDP@j/^xL?TGATGZA"k?wR?.GW?6d?giX?U}fQ@hDio|@|ݡ@ ףp= ?GGGGT(,Q@ɡ|e>GGATTW]" ?\oJ%?V x>rT?dj#>4 ^O@|@ @H}?GGGTGm-hD\P@]FpL?CCGTA\˜?*;3?rNW?A?jP?8N@?|@qJ?_vO~?GGTGG#AM@ћ?TGGTG?r+0ǒ?Z,,T?k@_?\56?gLSgO@K7}@p K @_L?GTGGT"BO@ބ!Hć?GTGGTބ!Hć?i\w?'ZoQ?gEu?f[ o?s`DdN@c]}@g @ψ ?TGGTGXUMadN@)?TGGTG)?d2?!ޅ?BS?+?t&M@Mb}@zKԌJ?-EQ@J +'}@%VQ(?n?TGGGG:WBP@ Gi"?TGGATgٝ?6?v~2r>?f u?.rV?Z7WP@K{/,}@\as@_L?GGGGTẦ**Q@[h?GGATCmZ˿?Uӹ?Mh?w >?D33?m gQ@+.}@'@HPsׂ?GGGGT2k*Q@%D?GGGGT%D?m!X[?5fE?cƥ4!9[?b>luLuZP@K41}@3k9@~jt?GGGTG`B\P@yb?GGGTGyb?],J?>bK?\ށe|?;2|t?5N@؁sF4}@ƫk_?_vO?GGTGGv?M@4di?TGGTA36[Ly~?Ǚ۸?r udf?jb?h}?݉O@Mb8}@&@ ^)ˠ?TGGCCUwO@Rf?TGGCCRf??݀?N.lg?lx(.?5E?^P@"u@}@$ײ?46Q@/كd?GGCCC/كd?q}?Cw?J?G]/?2AKQ@0L F}@/c֭?vq -?GCCCG!nQ@A;?TAGGT,,;? d??YGGATTΊ_U?UX?y?SEI4?ʈsi>6;*UO@HP}@;kW< @ǘ?CCGTT^QRM@pg>CCGTTpg>3?*e>a8a=WP>;=QJ@ktX}@@-C6z?CCGTTARM@c"j?CCGTCX!=?+͗[#>6م=?9?u7]?| 0I@6Z}@P$ ? ^)ˀ?CGTTGЩ:@I@e4u?CGTCGf?, ه>C6v>8*?뙏?6K@HP\}@S[X @_vO?GTTGAr%L@T dX?ATTCAAz?(F>+ ?8OE?אh?e1 Q@ o_g}@m,@J4?TTGAG:'&P@r1>Y?TTCGG?W?bM?)km?m-?U`PI-? OP@joi}@a[@F%u{?TTGAGS('&P@f+?TTGGAxO+b5?Z?k ?B?UGЀ?GEǝQ@z6k}@-1_1@{?TTGAG@a'&P@z%{?TTCAGW4?';?yjg?47&z?Q?CN@}@Fv? o_Ή?GGTGCosL@a^x?CGGTGY&0L?<?.?я#?*`ff? Ֆ>M@ }@7`@ o_Ι?GTGCGM@e`Oq?GGTGTKڱO5?cr?Cˀ?0C&?UYb?=%ȓ)P@ }@*.@/n?GCGTCz`M@`3>GCGTC`3>Jl>H''>yA4>1GE4=OL@Hz}@zm#@q?GCGTC472`M@#l`>GCGTC#l`> S+="+?; >h*N@1*}@ͱQ? 0*?GTCTG⸪N@翏d?GTCTTg[E?ڇI?F?&fa?rS.?8K@HP}@ @HPsׂ?CTGCGJN@=I-\?ATGTTzui??e!?baE?*qLe?t9 O?/4L@hs}@}[ ~@`Qڋ?GCGTC`,`M@Szh>GCGTCSzh>%)`8Q >8=.e&>2OY>`M@4}@lC@_Lu?GCGTC(`M@#[9>GCGTC#[9>QV>@ >ڣT>&Z)t&>8cˢGP@\C}@i@w?GCGTC o`M@ v+g>GCGTC v+g>h 3@|Z>tu[_ > >w[;=PkP@6}@` @{Gzt?GTCAG UZP@Ӫ*x?GTCAGӪ*x?|U5s?db?炰BԠ?x?\Q@^K}@nu@J +?TCAGG%g Q@ |m?TGCGGh?X\?fk?w?TAAGG>w?8l?(??|/?Ȏ?E5Q@QI}@C46?333333?AAGGGDO64Q@Q~Q?AAGGGQ~Q???|3ہ?N|?";$J?-;Q@ݵ|}@'yѓ?F%u?AGGGGE)Q@fk?AGGGT̘fz?<3^?fZr?sE?0`j?NQ`P@}@Ci~@]K=?GGGGC5VQ@7e^?GGGTG}w 1?]Ϟ?Yp? 44?Vd˺?E'.aQ@+}@$uv}@Ǻ?GGGCGV\P@+{{?GGATTP8?hpQ?^$,LT?e Q%?[E?.& (*P@z}@\Cأ@ 0*?GCGTG$=ˇO@ wk9?dIy>_{?WCY?5v?B(>mO@8EG}@H ug? ?GTGGG6?tO@s6?GTGGA DLG^\?܄a%?Z?n9+?v H? Q@KY8}@l5H^ @a+e?GGGCGGNP@y}0![?TGCGT,G>h?~qar?\v!ry?oOu݋?;>9˦N@+e}@c(S{ @_L?GGGCGy7lP@l`c#B?GCGTC\'$^|?s?{I a?It?~Op?@ɱ#R@Q}@|Gp|@?GGCGTskAR@p}Dp?TGAGGBϗS?.e?k?>H&?bl[%?(\-P@T~@_$ @J4q?GCGTGʇO@[Ԭp?GCGTG[Ԭp?̛p?]d?Yj U?%?;?rN@o~@|0o @z6>W[?GTGGATFO@8iw?CGGGCʟb?O*u?*)۶?C,?mp?[aQ@X~@oC@ ^)ˀ?TGGAG.Q@Z|ܮ?GGGCGUکxW?xa8??|4Ւ?)r?R@ 0~@z_@3U0*?GGAGG@S@Wg3?GGAGGWg3? }?T?:77?ʈՃ=?A`Q@8gD)~@4x?Mb?GAGGGPQ@3^SKٕ?GAGGG3^SKٕ?^DM#?7?̍F?Jg9?paR@|P+~@l2@ rh?AGGGG T|Q@Vn>t?AGAGAO?tM~A?۳AQK?DZ?O Y?>e{@yJR@ͪ/~@/aI~@b=y?GGGGA)~KR@)`B?GGGGA)`B?cZ`O?pَ?Rދy?b4ݸ>G`R@Dl;~@zsENR?Mb?GGGAG!M'S@kc?GGGAGkc?B?4詴?D{?R1o> VcR@E=~@UCXN@\mE~@BL0V@_vO~?GAGTGX1]&O@9"?GAGTG9"?͕H{?>?V&q?/y ?E?oW]HR@`TRG~@^C2٫@_Lu?GAGTGGl?&O@Sy)?>GGATG$DYq7?儆W??|~T@?w:c>vuN@H~@l ?ŏ1w-!o?GTGGG"ttO@%Qλ?GTGGG%Qλ? `8+?݆gj?1? T?JQ@UR'I~@G@a+e?TGGGAJ4vQ@d,p?TGGAGH??R?%R~?'Rvo]S?Zd qR@L~@F1tY@Mb?GGGAGgd'S@EI D?GGGAGEI D?ըw?v?p5B?zee>ݹXS@A`P~@T$@gs?GGAGG9@S@xJg&?GGAGGxJg&?OUUu/?7EfR@6#S@}?5^Z~@G~@9m4?GGAGT3q S@3v?GGAGT3v? dV?|"ݍ?F/t? *>xf\O@Ciq~@[@Mb?GAGTC!^ N@N?g>GAATTz8.?RQc3?̭VWJ>ON7,!?q8/=߷4K@gs~@q$@HPsׂ?GAGTCv^ N@l,S?GAGTCl,S?= ?wSnR`>El?yr}(?2+AS@ʡEv~@^f @ 0*?GGAGTۈ S@a\?GGAGTa\?\GO 2?E_?5h[?qUz:>2L@ cZ~@и@_L?GAGTTC$O@m嬿~?GAGTCKi?#`?X.6>i13?M{UvL@ -~@y5Gꅧ@58EGr?CATGCq3L@PәG`?GTGCA0Β? N(?]e3g?a]}?Jh?־a;R@UR'~@GIk@ׁsF?TGCAT5R@%}?TGCAT%}?<fz?>^?Ob^&?w#?澿Q@2ı~@c:?J4?GCATGD[{Q@Kx!?CGAACWesŴ?Q?kqn?r^"?[RLj?׎BO@]m~@$ր'?ׁsF?CATGA hFO@༁B?GAACASOG?G}?Aʮ?Ǧ??/?P"Q@Mb~@Ij6?46?m?uѴ?Z!z6?^JtR@S'~@MC9?0*?AGGGG0E/wQ@?}?AGGGAʽDzR?̣a?Uؓ? r;O?xvz>/ pS@ͪ~@\5@5;Nѡ?GGGGAsxKR@1J{?GGGAA7?]IX?&}?d9Ug? $BT~>s#7rhS@Q~@^/pA @&S?GGGAA\U\TS@7|̓?GGGAA7|̓??m?P?dB?#=7B T@O@a~@г ?~jt?GGAAT/yS@Jn2PU?GGAATJn2PU?\?4s?գB?ϻ 0>2\P@jo~@Ik@~jt?GAATG PP@ &+?GAATG &+?OWF?2?x?ӈY$?a/xC?A0$fO@ͪ~@شI?_vO?ATGGCxƚN@<Ғ?AAACGdDMC?`?햇uE?o ?i ?VP@Pn~@>@y&1?TGGCT1pP@x?GAATT ?#TBȹ?W9s?SL?פ S?}PZQ@u~@A&oH @"u?GGCTT5yQ@~AO3v?GGCTT~AO3v????a?T?Fa?ӵ>_}=K@qΈ~@ @_vO~?GCTTC.K@%)}>ACGTCk>ߋH_>vƬU=[Q}?ڔV>l+! Q@n4@c/ =@{Pk?TTCGT=P@sU>GGATT+"9M0(?W6?@_F~vָ>hR>zg=a1:M@( @ @(?TCGTGjN@çM?CCTTG`T??P?AN?P?19L@ g@ D?{Gz?CGTGG K@}#?CTTGG%a#߫?}Z>ܣN?TnR`?z?t|N@"@R@_Lu?GTGGGtީtO@iXLN?TTGGGSj8~?GCGTAWK ?'P?s?%U?}c_?Z?-QƃM@]m2@*c4?mxz,C?GGTGGK(qM@1RÞ?CGTATK;o?agI?f'?S?3>?{O@:@5dm?ea?GTGGG#jtO@'e?ATGGG[Z?Mg?TcGGATTjl0!?WN}k+?tS>DHq*?]Txs>"ﻈ%R@pʉ?*5x>XKXQ@]CM@#Z ">nDV:?^ >z~ZR@l g@o?-C6j?CGCGT.hR@`%?GCAGT?9q??eX?#f?%1?˗d1M@ rh@!@ZӼ?GCGTC`M@+?GAGTCe?b? S?J?0 td?q.[qy?#YpDO@0'k@`͆@ZӼ?GCGTC2mz`M@2V0l?GCGTC2V0l? @Cd?{@?ֵ/?B ma>ZdO@2ın@b<^ @ rh?GTCGTeDP@⬌t?GTCGT⬌t?(W?H9뤧?J?7v "*7?shQVM@ s@' 'i@Mb?TCGTCQrL@|Z8?GCGTCF-i? x? X6?&@?" ^??2O@1*u@@^@{Pk?GTCGG0P@|Hg?GTCAGMe?_s?k߶?[,?);s?]CP@n{@mR6 @{Gzt?CGGGGɘjP@FIeU?GGATT kf]? E}?Ju,s?>L`{?P1L> DR@٬|@H @"~j?GGGGGqR@N0?TGGAGr쿿X?k~|?fjԝo?(t0?Yڽ>sP@+e@`@Mb?GGGGC'VQ@Zb?GGATTҾï6T?Kݐvq?5ճ1b?>Sp?O7">ꇚ<'R@"uq@{& @/n?GGGCGLfP@Pt,P;?TGGAGТ^T?hX㽀m?8$9u\?Mgv?> #{>J`P@V-@D+@GTCAGtgl>oo?D>'֤?l-]>HRGR@@}@Mb?GGCGG}R@?TGCGGo>?=I?x,= ?e2?Q5Z+?zUQ@_I @0C??GCGGGCQ@$%DbqP?GCGGG$%DbqP?߉ֱ?."??P؀t?'O1P@o@yc@0*?CGGGGEOiP@k=?CGGGGk=?}}_?̫?RmzRQ@ec@"Q2@H?GGGGGz&oR@"d?GGGCGƊ_? :L?S?1%)+?w%FIl?[3JR@U@q@:v?GGGGGvNpoR@ 1?GGCGTV8,O@qΈ@E7@y):?GGGTC+YsN@km?GCGTG"%?f?I6L?f:?rm2?MIO@O@a@Ct@2%䃞?GGGTCsN@`W?GCGTGP!%?wH?݆?PW?O%ce?(SK@I @ȣYI?Mbp?GGTCG+tߠK@qp⑶?CGTGG򶫳늲?2[<>ra5>Nt?Ud?o= O@&1@r@/nr?GTCGTZ@P@dBZ2>GCGTCKO:>D>~fo3>h8cz>΂F>s>9P@(@c]r@&S?GTCGT%ھ@P@2u?GTCGT2u??V8 {?;޿?0%W?-"P@;N@㻽@_vO?GTCGT뱙@P@Lpk?TCGTGG`/ת?9 _?[SR*?zCt?Nѭf? ΊN@=@KE"ڱ @ ^)ˀ?TCGTC(E/jL@9 s?TCGTG?CŲ8?^q?*R?ܹ9?RuYP@3@1(q@-C6?GTCGTj@P@P’f?TTCGTd?p9Ȫ?R~?2b?';<0?$p?N@~@a&? ^)ː?TCGTA3T]O@ژ?CGGGCȣ?<5^?}!/?+ ? ^?L9tN@H.@k2@?CGTAA>,M@x?CTGCG'SZ?[K޴?^Vɸ?Ԉ?Ie?4e_kQ@Q@0.z ?*Dذ?GTAAA|1KQ@݊&?TGCGCDtZ"?4K?( Y5[?yو???KR@kt@c"?y&1?AAAGA.{Q@+k?CGCGC\q?_3?,e!?v46_?r?RD%ۍQ@(@jլ4?HP?AAGAGp*R@! la?GCGCGr@Nu?DQj#?E %?n?Sڨt?j!S@H@-?ŏ1w-!o?AGAGGk.mR@Ν'E?CGCGG:Or?xI?E' ?S?z?(Q@L7A @ek?I +?GAGGG/3RQ@{ձ\?GAGGG{ձ\?*Ub8j:?|R?S&4?kQ?, R@X96@4~?H}?AGGGG"DlQ@do XV?AGGGGdo XV?V ?Ss?nr˾? tj^?SƟ/ R@QI=@S@ o_Ή?GGGGANBmKR@}?GGGGA}?R:Wd?n_kb?4c@Ş?t_.>5ӢS@n@@z@tF_?GGGAAhfWTS@kTBY?GGAATۼ?VS+7?sD6Έ?k=@? \@"X>g^S@=,ԚF@LN @@ǘ?GGAATnS@ ;V8?GGAAT ;V8?>^,?%:P@?e~6Ҙ?:EL> 6Q@L@`Fu@<,Ԛ?GAATGb/PP@ы?GAATTPVţ?j?.ȵ9?'?vL%?!"""@O@؁sFT@1֋@F%u?GAATGPP@rMOS?GAATGrMOS?!o?z?6^?O?9v?!N@'†W@ ? -?AATGG{DMfVN@CF?AATGAhC?+%k? ?A N?%!?45P@UR'i@>$@St$?ATGGA iv"$?1Ǚ9>EbQ@A`p@f5ߒ@HPsׂ?GGATTB Q@Wb>GGATTWb>V~@>Kx{g&> ҍ5o>bN<ǹ^%L@N@s@y?Ǻ?ATTGATiXL@%?GATCGGQ;L?. o?zx?:ؓ%?U?ͱ[P@Q~@z< @F%u?TTGAA< ߃yP@ͫ>GGATTI>؇>5;E>aj!B>'K=)R@+e@KC8+ @I +?TGAAT#WޱR@Fubw?TGGAT)\{?c…?Ӛ;Ǒ??*2m>i!揔vN@Jꄀ@;@ŏ1w-!?GAATCX&O@:D>GCGTT8i?~?6>rH>2?(gpz>gQ6IQ@c]܆@_- @vq -?GAATC+ԔO@\ E`?GGATCn豫UٖM@f犀@;5a?S!uq?AATCA(=IM@M?GTGCT"Ou"?c,U?$pZ?u?^3[A?%' Q@V@>@Af?ATCATmQ@Haګ?TGCTTgӅ)? nI?e1bW?2˪?ĄKc?tM@k @T/n/ ?gs?CATGC[L@| 5?GCTTA@?eDd(Hr?$V?Id?SW&?yM@6@Gx??W[?ATGCG-N@, Z?CTTAGlJXo?c2t?Lj~?*We?2?Fu?:XQ@:#J{@'@Mb?TGCGTZ~R@Uϱ?Ur?S@an?i:?=g?$Q@ݓ@zk'@(?GCGTG^2O@*#LC?GCGGC g`? Tos?|E*/@?uƉz?[:.>9 D,kO@ݵ|@i`@ F%u?GTGGG4tO@;q?GCTGA(x,?Wԃ׶?01d?Lu?0OO?MڙQ@/!@ɋ'}@ 0*?TGGGA#~Q@nm#?TGAGC쓢iJ?7gt?QiY&?E52?aMs?1{BwR@F%u@ yJz @+?GGGAGm%'S@."Hj?AGGAG|/ *l?w&?Se~_h?F-[?^8`>:"R@ґ\À@!q @:v?GGAGGWR@S@Tvľd?GGAGC7q9Gm?SA?ҳ>j?JQ ~R@6;Nр@ +vh@V-?AGGAG.(S@֎//?GGAGGTI=?ے`?n,?p$U?TkT>g S@Ǻ؀@ޞae@"u?GGAGGRZ@S@r,+D?GGAAGN?b؎Ԑc?9պB ?B?j5=$I+8Q@cڀ@S9Ux?Ǻ?GAGGG͙CQ@5T?TCGGGJ'?3i/?`'(?M8p?h%?0hP@d@O9?*Dذ?AGGGCE%P@؂6?AGGGC؂6?GGAGCQ1?2P@Oё\@#?J4q?CGGCG̨#_P@dg?CGGCGdg?"?G?.,9?.?wQR@o@OI]?\XÝQ@ Q?GGAAC⼹q?b3?,A?0Zb?iZtr>LVO@RI@Ch?ψ ?CGGGG4=L^P@?CGGGG?3^?i3T?`-yP?p?~RP@C @t+p@0*?GGGGG恋eR@)?TGGGG8gC?@?9C`,3?Kkj?T%m>dכUR@S'@#ݸ-; @$ۧ?GGGGGm\saeR@:}J{?TGAGGN?F8ƫ*? ?٧?0*dZ>1{Q@Qkw@O_@a+e?GGGGGOeR@F6ӌ?GGGGGF6ӌ?OK?f*w?-?Tk2?]|VR@B`"@6tE(?r?GGGGAlĢfKR@H/% ?AGGAGkJӎZ?5]7?ȡQ?=YS?p$-(W>ʰS@+@89@gs?GGGAG1T'S@KmT?GGAGGow$z?YX?Eo?3eF>ϊR@O.@#>@H}}?GGAGG@S@&E>AGGAG /> >`0 >DNO><: S@hDio0@}:\@Mb?AGGAG҆(S@.20?AGGAG.20?D?z]q?"?n7 8>(v4S@Y@@n@J +?GGAGGd>o@S@?GGAGG?Z#?]tt?@P?K >[UO@ڬ\M@ǜ)7%@b2U0*?AGGCGΝhQ@모'=GAATTJo>̱>R65>Uv>ܻ=qsS@O@> ?a+ey?GGCGG 0 R@zxg?GGAGGo'Jܺ?*~t?A6à?rQ?g>5y>/|ITO@!rhQ@@ @HPsr?CGGGGLQ[P@ +>GAATCz?p!?.ƺWEF?p=ԥ?LW??*kAQS@R@UO@3U0*?GGGGA%eKR@?/cT?AGGAG ?DhW?̋Uf?Sr?{lS>"rP@vZ@7Z @Mb?GGGAA̐TS@m7d>GAATT}>? `̲?_9x?WC?"?q#] ?DaS@Q^@$@_vO?GGAATy&S@!K?GGAAT!K?f/?e?$ ?(82 >z=O@@b@j,uD @St$?GAATT&a:P@e!ڲ?GAATC#W6?yƌY?˻bi?1`2?~_?OusP@&f@ތ@+eX?GAATTBa:P@:=2|?GAATT:=2|?'b?f^OR:?"9e?o:]^>L&IQ@_l@"6@?GAATTga:P@8۠B>GGATTX>³>ȿ'u÷v>@ɥ>H:=~jN@o@/iw@Mb?ATTCA;bxK@J C>GAATCgtf?v?+f!TJ?`2?$߲Q8?t;P@uq@@C)@S!uq?TTCAGGGATT~<1>>S1 q>qQ>ɬ<=Х=R@=yx@)@+eX?TTCAG(sP@ Ӝl?TGCGGG$C?SR,ʷ?;M)x?Zd?G9N?뙢P@Zd{@}-4 d@-C6?TTCAG=sP@\ (: ?GGATTC?'C}1M?k $?$t^7?up>'89Q@z6~@Bg@a+ey?TCAGT NQ@D"&))?TGGATrQLF?rh?!j_?Ԗuۦ?|#%X?l{pP@L7A@@Mb?CAGTG.s"O@D^GCGTTYU?ѭ^> -*P@jq@7V@{Gz?CAGTGS"O@f>GGATTAW?0EzHb?yK ?1gF?V`#><1:O@`@+Qle @<,Ԛ?CAGTG)g"O@g?CAGTGg?MJ[4m? U=Qz?q#&?;g{?"h8=M@a֔@$? 0*?AGTGGPfɄM@kj.'p?AGTGGkj.'p? /i{?֗q?s&b?S$;? "N@ۗ@ko|@?GTGGGztO@ן?TGTAA9QgŶ?Q"?ZdMu?O>@?2?4)RQ@Bc̝@]? rh?TGGGGP@lA2?GTAAGq?V?4W?Oo@? . ׁ?T}Q@RI@8&?Q?GGGGGk|`R@֨ӷ?TAAGG4myG?{3?9I?ԉy?luz?"ҟP@ÆW@..w?Mb?GGGGGTܖ`R@?CGGGGA~?y5/?tILb?:? 8'?))Q@!Ac@ɧ?M O?GGGGCh0dVQ@ǯ> ?GGGGCǯ> ?hᏓ??7߳xu?%z?eXP@ŏ@3#u@n?GGGCT=*yP@gܶ?GGGCTgܶ?FL?2 ? R1? Wp? Q@sF@o @tF_?GGCTGm%Q@r?GGCTT[@?$%4Z?ϙNA3?Is3Ȫ?\IP>gGN@'1@x@_vO~?CTGCTBгiN@Ce~gz?GCTGT;V;?k3c?R?pZM?Xy?*\vPQ@%@Jס0b@ZӼ?TGCTT 'Q@?GGCTTX/T?9{%?lVZ?1ta?5oX?~4L@1w-@9 ,@p= ף?GCTTT@a^K@@+kLg?GCTTT@+kLg?:?'yL4?;`ڂy?% N?;L]VM@;Nс@$Û@H}?GCTTTW]K@>t2?GCGTT΃g?]jS>WE>*Un?{:3?Fy`H@$Ձ@Im?ZӼ?CTTTCnlH@#YP@s?CTTTC#YP@s?-ූ=?=j&6?q<? NOLL@I}؁@6f@n?TTTCG2)K@{ʝi=CGGTT9oth>/pRP>W~o=N4H>h6(>|GK@J&⁽@X?gs?TTTCG҉K@$}?TTTCA8?'> ?>W/?{{?OLM@/䁽@R7@<,Ԛ?TCGTCw:SKL@b:PN?TCGTCb:PN?m矙>77?Z`?v*t,>NL@&u聽@$$ @~jt?TCGTCqSKL@7(D?TCGTC7(D?ix&!?g|f?Vx"Ǡ?)&F\?rY1:'O@ q끽@[Rd@St$?GTCGAT@P@wEl?TCGTTIТAG?!K?FْLR?$/hv?)2?:Y%Q@V@7~a4 @ q?TCGAT`ݎQ@ vE"V?TTCAAbR?C[?b~:?&bh?xv?2P@V-@f?a'?<,Ԛ?CGATAoѥP@/xt?TCAACXt?/(?hݡi?2ܚ ?Y!G5Vj?uf1P@ho@@? ?GATAG[ߍO@P?GATAGP?zSֳi?@v?id? 3?P@8A`@۶Hb?Mb?ATAGGSHnQ@(%b?ATAGG(%b?&?]/n?W?0$5Ұ?[VH}P@Cl@- ?M O?TAGGCkTP@>ȋ?TAGGC>ȋ?Zi?>Lj#?0?esD???Q@X2@j^@HPsג?AGGCGhǔhQ@U̻?AGGCGU̻?G"w$?Tjd?Q ??@EW m?#fR@z@65^F@ŏ1w-!?GGCGGSٗR@zDUͿ?GGCGGzDUͿ?|Sû?L?"?T#?(\¬Q@dZB@R,4@Ǻ?GCGGC߭P@s9. ?GGATT% »P?¤nY? &o+>_ah8?"o5>-`PR@[ !@@@<,Ԛ?GGCGTބr R@YͲ)8?GGAGT}I?Kvg?  A?~rWV?qt3>O|sM@/$@Qڷ:@ψ ?GCGTCc|`M@ =?CGGGC82_?o֊?k ix? e?娜׾?;!'Q@ c.@d@&u?GTCAGsIr1ZP@ɍ ?GGGCTZܛ?*4?:A~?|EW?buy?jU_aQ@5@ @ rh?TCAGTaHQ@x*+~?GGCTT,SL8?q!׺?@ T)p4?ݳ ?uUY:?:ÊFM@\C:@ƶ @Ǻ?CAGTCMpjL@6%@y?GCGTCdSo4z?m;D/i?Ϻc A]?X|˪?{?j*;kQ@@@s?UN@?GTCGGu{P@4/Ni?CTCGGt*Վ? xt?h{?ݎ ?* p?F?\_M@ hB@ v `@UN@?GTCGGDhP@ V?CGGTAq0?Z|>2#p?G.ul?ã?jɒ?){_6?䃞ͪϥ?GGTCC|k9J@o(eؼ?TGTCC׬Y?6V3\>sr>JO?uif?SێN@^)k@qҫ,?H}m?GTCCG܂d 6N@f߹I?GTCCGf߹I?Z?F)?, ?G?,@)oQ@_Ll@dvGM?;pΈ?TCCGTEQ@m1?TCCGTm1?IV]?'D޼s?b?nr0_?tKM@ҍ@f@+eX?CCGTT/M@'?CCGTT'?ڲ=T c?wf>Xk92?625C?'II@V0*@_Hc?_L?CGTTAWg|I@?)?CGTTA?)?LNk>1>]0?Nq(x!?HM@_vO@xq%;?_vO?GTTAASsM@d2L)?GTTAAd2L)?xg*2?4?"s!U?- ?,OP@N@@HF§W6?ŏ1w-!?TTAACxlުP@ñR?TTAACñR?)_G ?Q?>5 2?E!skU?V8O@qۨ@~:?gj+?TAACT}(O@?TAACT?8k{?1jj?aE?m>5?XzqJ@+ٮ@OJkwe? ^)ː?ACTTCX7C]J@ ?ACTTC ?:9ha>-d]5>iф҅?D?jwI@ @E?_vO?CTTCC^%J@c|?CTTCCc|? ^'U>䗌Pah>aG?d|4 ?٪9ρ+P@ͪϵ@B%?~jt?TTCCC6zw+O@|{w?TTCCC|{w?M`^β?xE?r%[?|Z?$WQ@ @O6?ZӼ?TCCCAC2$lQ@u?TCCCAu?=O^?sJ?U g?{M?KR@J&‚@j薰?H}?CCCACx 5R@ #8?CCCAC #8?x?姧\?K_0?/z?(\-Q@Z8ł@i`>?-C6?CCACCumP@?^[?CCGCC8MP?)$Ҍ?Q#?4?\U#|?6lQ@ɂ@s?{Gz?CACCC]3'Q@2˒?CGCCTh.i?[5?F?ej&?JH ?˗d1?P@5;΂@S;E#?`Qk?ACCCCZhKQ@A|-H?CATAAu?N!U`?7V?f\]=?T?2E)IQ@wς@d1?F%u?CCCCT `R@B7X?CGCCT\W?@|ۦ?)7Bi?d?/q?Fk.P@܂@SW?J4?CCCTC2R.Q@b^#~?GCCTC6!5/?Ѻ? ?Z?T;?֎O@D@9H?:v?CCTCCZZ*O@aS#?CCTCCaS#?\N?W=+?XF? ?p|evdQ@ݓ炽@B~?vq -?CTCCA>ڧP@I p?AGCCATnx?rn?oB?}u1#?\.WW? ] tR@ͪ@bA?St$?TCCAA;$3R@5~4?GCCAAlz9 ?qĩ?D0p?TͿ?%eiX?gNQ@g@W?`Qڋ?CCAAGQ-dR@4jD?CCCAC ְ?E@&?WuA?raG?+} k?`,UQ@ۊe@?8?b2U0*?CAAGA |fQ@YÿY?CAAAG0(B? ? o:?Cb?\J6E?gP/ R@"@,‹?M O?AAGAG/o*R@ij?AAAGASBГ?Ҹ?AMի?@{R?AUn?x/R@W2@$?#u@ZӼ?AGAGA/3 R@Ğ?AGAGAĞ?fD?l?|Y?ЊS>أQ@Bf@4w1a?Mb?GAGACWEQ@u??GAGGT(3X?w ?1;?F?Q%X?$[#NP@C @-~?0*?AGACTnP@L ?AAAAC>{?a3?z4?|$`?dµT\?”N@n @M?1*D?GACTCD.rO@?`Q{?ATGCAdO@ i ?ATGCA i ?IO?Bs][?}ҥT?ŔQ?Ҩ1UR@{,C@b/?NSt$?TGCAA!Y2R@=?TGCAA=?۬T?1H/'?;?U= ^@?~-`KQ@_I ƒ@-?HPsׂ?CAAGGwTSQ@&?CAAAA^\??@Gε? ?Gl?VaQ@~8gă@0X< ?Pkw?AAGGTQ@f?AAAATl:c?2}?W@ ?q ?.̶?p=ifO@R˃@~j ?~jt?AGGTGҝR P@e0¶?AAATG/?y_R6H?X?4}??-9d??^7M@O΃@-+L!>?n?GGTGC] sL@*sv?AATGG]?ʝ^?Zm*?T??N@`у@U_?HPs?GTGCG4M@8;/?CTGCG>d 7?qjӧ?8b?xUe{?H'?jQ@能@=z^@ŏ1w-!o?TGCGTRjjR@L?TGCGTL?dz[?*E?҅wɳ?R=z{A?]1@M@jo都@{^@ZӼ?GCGTCÓ`M@~?GCTTTc.?߈Ibw?oI?zߨ? '%?G,iJ@Mb@}}dӌ?ZӼ?CGTCAus-J@(D?CTTTA4M?58>d6T+N>(|?0+I?]fVQ@=U@`@"u?TCATTP@HJ.+?TCGGTsuv?g=wYC?)?b?dQ`?ˡL@x $@/dnS? ףp= ?CATTADmL@ʅ ?TTTAC*1 ?Ie`?-+Ӄ?.?Ra{?YhRìP@V0*@ k6? o_Ή?TTACAU\oP@Hm?TTACAHm?Q?S~W6%?qta?hyMw? BQ@D@_?4?vq -?TACAGQ@[XЫ?TACAG[XЫ?HK?Bmi?T?t[7>~?]ZR@"@ @@ǘ?ACAGT;X#R@JU_?ACAGTJU_?̥8?"Kְ?ߌ"?:v >Sf9L@a+%@O @j+ݓ?CAGTCeԫL@W9?CAGTCW9?7Hrld?}ꐦ!>J;&+?^pki~?J}L)nP@9#*@qu?St$?GTCAG!ZP@0Ϥ?CCTCAv̱C?5D"?N;C6?ց2?[,?`Q@ c.@q?{Gzt?TCAGC#ghNQ@g ?CTCAC0RF?+G?vr?sL9??~˪P@ͪ/@kRQ+?Mb?CAGCGiޯP@CK?CAGCGCK?V"?*)ʎ?Y?5擾?\Q@X1@Ĩ??AGCGT4+ĀR@Uf$Z?AGCGTUf$Z?Hq?N9?3m?WwAw?&W]O@'†7@,D @{Gzt?GCGTC~i|`M@?GCGTC?&to%?ouJ?iGB?΢OL?2%䃞?CGTCG}I@"?CGTCG"??EJN$z>;E>-^i?"/Zy?5OsP@-@@ :?:pΈ?TCGGCW'CgP@Ⱥ[?TCGGCȺ[?b~?82T?D^u?kB?-O@+I@[x4?468F0FQ@Af@ᆞ҉?J4q?GGATCviú{P@ez?GGATCez?5?y:T2 ?ޒ8?ޞ;o? jlL@@g@ ?<,Ԛ?GATCG"rL@a~uN?GATGCdT?\{ C?P׻?T8?C\ݩk?aO@=Uk@4R?3U0*?ATCGGgA&0P@m~c?TTGGGNX(m?ͻo?bk?Oky?~ξ?IS*8 Q@V0*s@KO@V:% ?I3?߮/Q:?-L@$J{@W*;>>?HPsג?TGTGA'師L@ y ?TGTGA y ?Gg9? 0c(,y?t+2?_Q?=:O@cX9@ɘ@?HPsr?GTGAASP@cE3%?GTGAAcE3%?MU?ZB?F?D\?P܊1R@Af@ut?F%u?TGAAG1S@!LcC?TGAAG!LcC?>{c?7҉;)?? w3?O@(@ #??AAGCAZNۯP@<~:Y?AAGCA<~:Y? P? [?(ho?-V?aQ3R@(\„@}M?ŏ1w-!?AGCAAY+rR@ ;fV?AGCAA ;fV?⩄p???do<`^ ?'?Z?)e R@ioĄ@;{S?~jth?GCAAA<葟&R@J?GCAAAJ?ldhHU?)?M?i[җf?r.TP@M Fń@Þ~?L=U?CAAACޅrP@}g!W?CAAAC}g!W?~s[ϟ?Ne{?zͅ^? ?R'N@uq̈́@V\u?0*?AAACC_N@dž?AAACCdž?o'k(D?Q?LLS?қ?&FN@ۊeׄ@ÊS-@+e?AACCT8佣P@[3q_?AACCT[3q_?]ϕd?NW ??#%/?5%bQ@q= ㄽ@fb?ˡE?ACCTG۩5Q@:XQl?ACCTG:XQl?QZ?`4?I4j?&Ё?4,9O@@p̟=?_vO?CCTGT)O@\oP>?CCTGT\oP>?p~#?p9Џ?!B?k??dK@ǘ@?~jt?CTGTTցK@ώA ?CTGTCW 3AK?X7Rk>u1it>fc?<+ DvQ???.G!N@@!jMk?HP?GTTAAK(g]M@?TTTAA &?YV?yX ?n*zn?uPb?~9F-Q@c@P^?`?<,?TTAAT^_Q@)G?TTAAT)G?h ?g)i}?2YT?DĠܫ?Cl O@o%@K`)?~jt?TAATA^tP@pշ?AAATAWc$?rH ?ˮ$?NC~?j?M`O@)@Z$t?M O?AATAGUKO@0σ??AATAG0σ??0ޡ<?XXR;1?ʀ?@p?O+ԻQ@M /@B7?d`T?ATAGGC./nQ@jO!?ATAGGjO!?t\?^B"?6 ?}UĂ?%P@ˡES@g)?j+ݣ?TAGGCIc:P@By̑?TAGGCBy̑?[,?X%e;y?(?.S?@7,Q@]@f6*?"u?AGGCTcbQ@]@"&[?AGGCT]@"&[?IO?w"f|?aPz?7&h?1]_*R@_I b@Q 4?H?GGCTA7~R@L*C?GGCTAL*C?|?b)/?f? Qr?o@P@b2U0j@? ^)ˀ?GCTATߓ$2P@7m?GCTAT7m??}Ŀث?+"ŕ?k2Ǜq?A!4zO@6^Il@,{^@?F%u{?CTATC % P@ &?CTATC &?50?=a?t:s#L?F/?-\X?;(P@Kw@0A9Q??ATCCTGO@FzՁ?ATCCTFzՁ?1ܯ?~?^Ѿ{?oe?*T͗Q@\Cz@!:_?<,Ԛ?TCCTTQаmP@0I?TCCTT0I??I?#ق[?Zg ?l4J@~@ezG?mxz,C?CCTTC'WuJ@x4\?CGTCAR>X?> >m>^k@?'֗?Q9GQ@K7@g~??őphP@(퍅@W_C?ݓ?CGGCT&O\P@wcy?CGGCTwcy?D)MsE?Rp?$h?z0?/R@V/@&4\R@m@dqa&c??CTAAG.)x0R@Gz?CTAAGGz?bjD?9m ?M܇ݡ? '?@4w&,Q@mх@n?q?TAAGG`fŒQ@A͛?CAAGGI /?q}޾?~Sܷ?+V=K?QXqt?\+2Q@>yXՅ@%ѩ?@Ǩ?AAGGApȵ dQ@>IK?AAGGA>IK?˜U'?GTI?&7?Y?s?Q-S@_I ⅽ@ @ZӼ?AGGAA~"^S@~?AGGAA~?9?0Q?||W U@1兽@ҙO?/n?GGAAA6-T@?GGAAA?-ǚq:??[?Ҷ\gp=gWC~R@-煽@8Qv?:v?GAAAAjH!R@D?GAAAG*"?O4?"(T?d?韙?(\-P@C녽@Ń_?y&1?AAAACr|P@E#;4?AGATGn/y? )? n?ȬC?8Ϟlja?.d㈰M@+@`?j+ݓ?AAACCU_N@I?AAACCI?Oi? wYS?By?}??wN@|@ zL?"u?AACCTktP@$?TGTAA ??V?Pۀy?t%>9?D9:?eeQ@5@@VU&E?`Qk?ACCTGH츽5Q@}gT?TGCTG  ?6 o?$7?=?[BX?mO@ @X?HPsr?CCTGG>O@~KE ?GCTGG,t?\Fn`?L虖?I,?,u1?w'MjO@:M@n ?J +?TGGGC;uMO@0.L?TGGGC0.L?u?J\?X#?Q?i&R@D@oWz[8??GGGCTDmP@zq^{ǣ?TGGAG*u7^?Mb?_j?Oԩ?D3f?j^R@|@OxE?Q?GGCTAe#R@_@C?GGCTA_@C?F4k?qD?Ƀb?4N(P?$NKoP@'†@s}?:v?GCTACdWP@Y 5ĸ?CAGAC6ԪJ?~(?&̫?Cϒ^i?`e?{@ Q@_vO@pI[v?&S?CTACTIP@\-9?CTACT\-9?8Q]?Wbl?8FmD-?COw1?_,P@7"@.z?w?TACTC( |IP@ܣ ?TAACT8Cғ#?M@?<ץbd?\tq?v8*:c?@ԽN@St$@)?n?ACTCCjO@ ?ACTCC ?cVu?xk??SNa?? ףaP@tF&@Õ?b2U0*?CTCCA P@ W:Uv?CTCCA W:Uv?(: ?S?)^?SA?  R@k)@'QG?W}b?TCCAG'FR@Qa?TCCGA9%̶?+`?坕 ?d2s?%Ge?WmR@-CB@DvaDb?ψ ?CCAGT4SR@7}?CCAGT7}?n;i?\N?MJ?6)?=yjO@zG@xe̜??߾?CAGTAl)'DEO@3bo?GAGTADD: ?xK ?{54?P>?~"+?߹-N@sU@u^?b2U0*?AGTACz 6}M@Z),?AGTACZ),?W.?bޤ?J?)4&?*nO@0*X@Q P?"u?GTACG }P@g@{?TGGCC? ѫ ?z*?j0?f AH?!rf5Q@}?5^Z@<{#R-~?Mb?TACGC؋,$Q@3ؽ?TACGC3ؽ?ɕ?Qݥ?ͪ=9?O/iK~o?~Q@(\b@C Y?5;Nё?ACGCGT_Q@?GCCCGiI?,TPH?tH?} s?r3?lR@鷯g@CP? ^)ˀ?CGCGTi gR@#:?CCCGTH~P?'Ƚ?,8?"r?kJL4?6;jM@i@2xY?&u?GCGTGNCDO@H?CCGTG _m/?[?[k? ףp@*ݫ?Mb?CGTGGR3pK@ui?CGTGGui?Ix_>u2R{$?'?Ьž?sq}N@ r@b=? ?GTGGCrJmN@_?GTGGC_?{Z?p?#I?n?n"ZP@"uq{@Yr?`Q{?TGGCA݇?߻?+y[O@u$@Z{]?Mb?CACCC'Q@6x#?CATGAԵ무? G^2?pd`Bt?-?྘}?ycj$Q@1*@ l(?3?x&?CCCGAImrR@S?CCCGAS?%k?}M?T?k-? Q@Zڪ@I?Mb?CCGAC5iQ@Ƿ?CCGACǷ?3ACT?!{(Y$?O][?ȀwX?qYP@jM󮆽@pW;?Mb?CGACG٦~P@@ ?CGACG@ ?:`֙?qtc?x.ڄ??XhP@u$@&+2"g?j^ڈ?¯eT?s\+O@ ߆@q;]?y&1|?ATCTTluiQO@:j?ATCTT:j?iep?~ ?CbS?>D?-RM@Tᆽ@oS}#?Q|a2?TCTTAUM@LXd2?TCTTGN?[g3B?h̭?Ǥc;?ц@?LL@C놽@sLu@5;Nё?CTTAC?hM@QG ?CTTGG XV,%?z+?Ⱦy>*?~,K?ͤ$O?OSQpO@Mb@+F?X9v?TTACG,$.]P@n⺏t?GTCGCG<?FHĚ?쩲[?Ntl? ?-~Q@L7A@V?y&1|?TACGA^8);Q@iٯ?TACGAiٯ?wᢸ?Ìy?^QX?IAO\?z;R@_I @5T< ?/$?ACGAA b3R@U}>?ACGAAU}>?j?2,﷓?yCl ?Q ?HPsג?CACCT2H{$Q@T'?CACCTT'?It??gnG?ay?0?7VvQ@k @{? o_Ή?ACCTGm5Q@Q/m?ACCTGQ/m?r\?/ ?0zb?9MwǴ?!+M@{,C@ct9z>@{Gz?CCTGCUF.\M@ ){?CCTGC ){?9?(+'?Hv?\aj?5TQ@qΈ@eAPt?ZӼ?TGCTGfrHQ@%:?CTAACŸoqt=?<*?ܝ#UI?[?AOC?XIN@ho!@?v?b2U0*?CTGGCG3JN@N~?GCTCCb[?!@?^ څ?nl?"X?d NP@C+@XV j?_L?TGGCGh*PP@(Mjw?AACCG2_t?նɭ?l8?+`h:t?SYz?ZլR@Ș0@RdԒ?/$?GGCGTHkR@M?GGCGTM?F?( =C?h_̲?F@UE?gCگPM@7>W;@lIm?S!uq?GCGTCL`M@V?CCGTCh???]:41?*7(?t_V? MeSJ@\m>@"?Ǻ?CGTCA`!2J@3+?CGTCA3+?Sm>c%T$>?jq?mP@.nA@;C,?Pkw?GTCAC>P@ ?GTCAC ?䎬?qSV=?í-!4?T8?6%Q@[d;O@\A%шw??TCACAN;Q@$Z|j?TCACA$Z|j?:MW?C*]?ae;? 9c?E8M#R@sR@O?46?W'R@r@g]0?ŏ1w-!?ACCGA6[:k>R@]|?ACCGA]|??^j?}5?(z9GD?zeIR@uv@@|m?y&1|?CCGAA',R@L?CAGAA=g?0G?E ǨjQ@ y@]yE?"u?GAAGC౳A+DQ@ōzǼ?GAGAC5UMM?~ >?.- ?pYҹ.?*1j]?j5P@( ~@p ?Aǘ?AAGCGzP@RR!r?AAGCGRR!r?Ҧ8?+?4$?Yi:*?TOHR@k@Ʒc?5;Nѡ?AGCGT*qؑR@\1?AGCGT\1?DN?= ?? u?bx%M?AxyO@e`T@5H@Eioɴ?GCGTAgVP@y?CGATCqӁg?G+b Kg? z?م?ɓ?L@՚@OkP?`Q{?CGTAC2zL@1?GATCTn?9{׭?h.I?.?{7k=?C?VO@qۨ@?<,Ԛ?GTACTf/88O@]~?ATCTAdL@?Ma%?3o?xMŌ?6\!?SwwP@_@oʹ e?&u?TACTTRlP@ph:?TCTAT"Mqe?A(7H:-? r?z9?T?W6VM@x-!@ S^m8?ec]?ACTTA^##)M@уA?TATCTL؅?sn5`k?wH?p e?5x[]w?gLS P@M‡@=?:v?CTTATl N@ ^J?ATCTG|9?/uٷ?ĩݯ?. ?D?#6ܬN@-χ@b?0*?TTATCm O@\ ?TGGTAӝH?ֳ? eZ?ܾ?$HNt?H}kM@[B>ه@=E$?3U0*?TATCG`q8N@D}?TATCGD}?Uh` ?j o{?X)qX??o5P@sᇽ@ 7KȖ?3U0*?ATCGC YiP@ r8?ATCGC r8?:nfs?,@D?AI?μiLX?'MQ@l釽@@o.??߾?TCGCA>(~mQ@W=y?TCGCAW=y?ǹ? Z=@?+F? !?ft|R@u$@Պ;,?mxz,C?CGCACdH]fR@l?CGCACl?%igv?qKIa?מ?$?mƸ"CQ@$@Jg2,]??_?=6}oL@Qkw@5$@M O?ACGTCY`L@cU2?ACGTCcU2?aü(A?dU> >? b?mNiI@.n@Q|0ș>|m>L?V {??ymO@#~ @]nK@I +?GTCTT~ `N@Nӝi?GTCGTYA ?~? 2?5N?Y#?ߥ4mM@e;O @R{?aTR'?TCTTAP5M@Iy񨜭?TTTAC8֖#\?)Ke?A?JJí?K(&?yvO@b@̋d?k?ZӼ?TTACG`ɩ]P@?TTACG?\7ᖳ>z֬哸?ʻ2?>%?HQ@;Mm@ ψ??TGCTGeEuHQ@ܑZ ?TGCTGܑZ ? DM+??DA?dL =x?(I6M@jts@Ж>Dp?kt?GCTGC,@mM@\W?GCTGC\W?0L@b?jzm+\:?D`?K 9?jbON@:v~@o @ec]?CTGCAkN@k%L?CTGCAk%L?bb-vC$r?) ? V?-PҶ?ʡR@mxz@{Ga?{Gzt?TGCAA8v R@~:g?TGCATcD?"L/FFo?N]?iK?xl>l2N@(퍈@]G?{?CAACCą O@;AJ?CATCGUՕռ?DڎBf?U ?+@p"?bK?[&P@@|F?F%u?AACCA}Ѹ>P@+Tʃ?GGCCCQ?nIMR@镲@?0mw?JY8?CCAGTuobtSR@̂rr?CCCGTy?S. VN?.삛^?@lp?);[:? ۓO@η@nTÆ@ ^)ː?CAGTGUWe"O@,tR?CAGTG,tR?q;?VC?ɳ?Ghۏ?AiǜK@/n@g@+eX?AGTGCǛ\K@38-?AGTGC38-?E3 S?i?)OEm?ل?hdL@\쾈@s٘9=?~jt?GTGCTH M@=ee `?GTGCT=ee `?0Ղa#?8?ߥc?`uO? _Z)Q@È@ŗs?2%䃞?TGCTC=l P@ۇ?TGCTCۇ?ܼ?A,(?DpRA?ɟS?IBP@gjˈ@zcH?ǘ?GCTCGbFO@𘆩"?GCTCG𘆩"?Tfs?CDS?]\PL?a?`Q@ψ@[@0U?%dY8?oi()O@@̱d?aTR'?CTATCɷ P@S8?CCTGT_uC|?L\?7:>?j[D??1>z?mI%brj?ֱ?j?mQ@t$@mNQ? rh?CCCTT;t,kQ@'skAh?CCCTT'skAh? U4T?4=VzJ?G1?Nd?mK@ r(@֩.@:v?CCTTCQ:J@^?CGGTCC$K?&b}t>T:&L>6mJ??셴EpJ@+@݉h٩?y):?CTTCC9nI%J@S-aS?GGTCCiDOj?~Xp>?>M[3s?Vd?]$M@}a2U0@!? #??v?lͤL?]{E>Q@4@J@.?jM?TCCCCJ Q@,[?TCCCC,[?q^ ?2VU3?[q?ܕ:?y?^sQ@b=@{5"? o_Ή?CCCCC{6Q@(9?CCCCC(9?0W5?w#?G̘͈?G?֦.R@N@A@~ͯ?+eX?CCCCA+&FR@7SR?CCCCA7SR?`4d7?o?h1^J;?Z<ˬ?i:cR@X[L@DE?W[Q@Ҿ?˭#?AATCC>˭#?s?;O}*??B$r]? RVO@(\b@? ?u?~jth?ATCCG_:P@o>f?ATCCGo>f?G-?D?b5,)?٭s ?59AUR@Sc@fb@5;Nѡ?TCCGTw}Q@p=?TGCGTε?8Nd?y2?r?9j?GzM@Q@W2@/޶? rh?ACGCTQ@T^^?CTCGGS?# ]?Vt@(v?NPA¼?jn2W?X9Ü`Q@猉@ƹ~I? ?CGCTG\)Q@˺y/R?TCGGTN5?by7o/M?|9?|5ƅO?4~{w?/bBM@Dؐ@(Z~?H}}?GCTGC=xmM@Zb/,?CGGTAS}-?KeDR/u?S!a?,Z ?$]m?Q8WQ@ @h-m?J4?TGCCTR]-`Q@M ?TGCCTM ?7aF?saf ?iHwv9?MWb^O@-@s>?_L?CCTCCc[(O@L1G?CCTCCL1G?᝗.?I[V ? ٝ?ȹ?h",Q@9#J@J?~jt?CTCCGVP@W@ʦ?AACGG1Q?Nr?H?}_)є?(ٯ?ks[Q@ho@aU?(?TCCGTj+{Q@K?TAGGT~!f?ϴkz? ?TkE?J 1+?bC,ljM@x馉@۲@a+e?CCGTGt?bN@V8' [Cx?;f?K@B@f? ^)ˀ?CGTGGdp62@C#?q59?}E?(xPO@(\@?/nr?GTGGÃ4B]O@4J?GTCGC?3o8C?ƻ:?u?԰?(hQ@ݵ|@$G?S㥛?TGGAA㲼uHR@! ?TCGCAҠռ?«B?M<-_?$'?Ć@b݋t?q= wS@ۊe@E+Q?-C6?GGAAG3ٿT@0gQ?CGCAA(8R@?٬@bk?y&1?GAAGAYPQ@ILC?GAAGAILC?.s?i Ͳ?zj ?Z(c?vG7Q@dZB@]d|>?UN@?AAGACkԣ/P@PYp?AAGACPYp?:i?/vɬ鑩?1E?/*ғ?R!MzP@@lj@͗p?{Gz?AGACAR޽P@0?AGACA0?wgz?:w=+?Ư9?#?EQ@:͉@u`? ^)ː?GACAGt*BbQ@=2w?GACAG=2w?. c/ͼ? }w?5o:?sZ?]uR@K4щ@[ ?Mb?ACAGADOR@Üb?ACAGAÜb?(%;?FBl?rI?Zv'$8?e9ݪQ@N@Ӊ@Vmv9?"u?CAGAG{Q@S?CAGAGS?cR?P?ګ?2z)?ϪR@hsՉ@g?j+ݓ?AGAGT:(R@f?AGAGTf?oOy?IȿUO?y?:`-_>arN@Pkډ@@Gt?H}}?GAGTT&Th#O@mv5?GAGTTmv5?9wg?h.{?^?Q9?3J@{,C܉@aX@ ^)ˀ?AGTTGO߬J@Lգ?AGTTGLգ?܊TbM?CU>q:?r| *?K@Oё\މ@uS?H}?GTTGA^$UL@dԟ^'?GTTGAdԟ^'?WHz<>k&Ɍ?k,^?p?E SO>и)O??V#kJ@j+V@ xL9[]?ZӼ?ATTTAzrnJ@ƴPI?ATTTAƴPI?&{>t#>@Vv?(%?c9CN@Zd[@/C#zW?_vO?TTTAT?'M@UP?TTTATUP?aG/J?'Ɓ?I㦚?öc?R4P@H._@xbB?-C6z?TTATT;P@:?TTATT:?ثV?7xv? f?fB{Y?~@ L@Y`@ PF? g?TATTAL@p?TATTAp?ŠI">1? F6`?|$ʊv? >qEN@~jt@Z\f]?`Qk?ATTAAGҽ%N@W6?ATTAAW6?ICO?+?l&?1΅ ? ɪ,Q@=u@_i?1%?TTAATGo[3_Q@?TTAAT?s+?#I /?<4б??Rǡzn?!P@ec@KL ?0?L=U?TAATTZ~N.P@kzj?GCCTTl[?7F?y.7?3]ъ?F?'l2K@48@e 8?@ǘ?AATTTўJ@8 ۽?CCTTTՆ5G?D>A.z>4jڦ?#E `?3}I@gj@'Ԯ?q?ATTTGMEJ@Í??CTTTGjyiw5?V'8>݆fsO>P8I?^ c?g^VK@9gDi@OTL??w-!l?TTTGT wJ L@z?TTTGTz?F=N>*7з?ar ?eҕ@.?̬KRI@v@z>Z?-C6?TGTTT>wI@R6?TGTTTR6?6R=D5>ws[?!o?aqWJ@-Ԛ潊@?"u?GTTTCΝH@'`?TTTTG%M|?#;>4U>Qj?Fu{?֣p=J@6@m7e?( 0?TTTCA'K@5?TTTGCRX?P /h> ?Tv?M-J?G Q@gfffƊ@h6W?Mb?TTCAAv$ P@ʝ\?TTCAAʝ\??2)??w?98Q@ rȊ@ ??ܵ?TCAAT8TQ@$K?TCAAT$K?6Ineq?!K?J;c?ت}?DgbP@_vOފ@߀n~?J +?CAATC4yO@ j?CAATT3~H@?aY?>nn?F-=?$f3f?VL@Zꊽ@x$#??AATCT c;iL@uο.?GATCTgne?3,)?c)7>=4l?m[?/O@St@Me ?Aǘ?ATCTTwg'QO@ ݽ?TTATT6IF?i=?d?nCl?YLӠ(?< /8K@9# @?HP?TCTTT͎K@m?TATTTw\g?/,>ق֘{>9 F? U\*?sH@ #@b{?HPsג?CTTTC جH@`;U3?ATTTCH:M?*_F=)87=LKI+H?@Eaa?}&rJ@Bf'@kN%_?"u?TTTCCv٩>J@t?TTTCCt?-U >4L^>;^R5?nϷ?N[O@M /@t ?b2U0*s?TTCCT9&O@O?TTCCTO?ҶaH?Ao?_`W?>]t?[7ZQ@H0@)ܳ?V-?TCCTA *lSQ@OY?TCCTAOY?}Ə?'.<)?h]陱?TR>?xiP@ F%uB@Lt_>$?3U0*?CCTAC~FJP@M?CCTACM?g p?Nm)?dQ&?dU?cG?Q@#~J@N ?St$?CTACANyP@+N?CTACA+N?/{?El6?V+ik?fМ?Ūw$R@]mR@˰-?n{?TACATn4TQ@?TACAT?Jŗ?1@Ω:(?B?]? :P@\ Ac@xq?0*?ACATCƆ P@׉5?ACATC׉5?ecB??NR?"ڸ7?}ͧLhN@5;n@Y?a+e?CATCAN@h?CATCAh?RЭ?T?Qy7?Ug?ietP@!rhq@V-@?a+e?ATCAT Q@VLqK?ATCATVLqK?MFS?s2d?;zJ?E:?PT_Q@w@-?a+e?TCATCͿP@sb?TCAATJsT ݸ?N>o??LݦS?qe~n?PN@cz@.PX?Biޱ?CATCTl9>ON@%?CATCT%?d?ām#o?4FM?4?O@̌@(xBW?_L?ATCTT99 QO@K,?ATCTTK,?@F8 ?ܝv 8?):Qԝ?z՛>?t1k qL@@"#? , ?UN@?TCTTAeIM@y(I?TATTALdž@?(~??)Yxfg5?3?YKs?7}\M@6@@Ml;?/nr?CTTAC.xM@Q?ATCTChIvA?Nq?[?8&0?@ z?(U,N@u@}'?gj+?TTACC~y/ O@0>?TCTCCѩ1?sxG?h(>??.l-?l՜xQ@ޢ@El?ŏ1w-!?TACCG~fP@_`?CTCCGlF?o/#A?t^Z?30h?Zd&?Hz`9R@&¦@Wy;?-C6?ACCGAR@~^?CCCCAf'a?1nYK?H6?sЛ?M&?Fڱ"#S@ @D?ŏ1w-!?CCGAGu~R@fKp@?CCGAA X?9?7?\qT!?@ >[OR@;Nѱ@ڤ?H}?CGAGTlER@!!0Ǻ?CGAGT!!0Ǻ?l(pQK?HJ5d?w?Et{>'6O@$@NyWe?j+ݓ?GAGTA޶XP@?t?GAGTA?t?%?Ӫ1s4^?x*QJm?*״?rN@h"lx@)5?n?AGTAGpIO@Y߿/?AGTAAIč ?MMŸ?JSFw?Q碩?%"?N똒Q@jq΋@͹|d?b2U0*?GTAGG%twQ@Bg`>?ATAGGlQ?ˌR^?? -?ۊN@ @Qp??Ƭ?GCTCCE\N@AG?GCTCCAG??Wu9"?aBӲ?_O:?k.$P@9#J@)?~jtx?CTCCAjE{P@ct̿?CTCCAct̿?ba=?J*p?a#?/&?ًaR@Z@8?S!uq?TCCAA|@2R@ځv _?TCCAAځv _?2d3?ٛ?Wр?h}?~\U5R@L7A @&Kk?HP?CCAAA y@FQ@ւW??CCGCAi???Hao\?͌?]ٶGq?tR@RI&@|cפ?<,Ԛ?CCAAAWoSFQ@wK?CCAAAwK?D?I?y ~?$Q$2?{`Q@ףp=*@ar?St$?CAAAGQ@6 a?CAAAA ? k[;Z?$ r:?ۦ?-&_w?UuQ@lV}.@ U?a4?AAAGGqҸMQ@%?AAAAGU:=;?V9 ?H8?.Z??W#z?B6HQ@ClG@Sx^? 0*?AAGGAߛcQ@W?AAGGAW?"5L?7j?VI?2osc?;NT:S@ׁS@՟J@ŏ1w-!?AGGAGP:(S@~Xh?AGGAG~Xh?u4x?[.\?bXtp?N@>xrR@ۊeW@U?"u?GGAGG@S@Q?GGAGGQ?â8?')QH9?Q.?9` ?v!R@Y@ PY?M O?GAGGAne!Q@=d?GAGGA=d?&?|? 47?23+>&R@\m^@c @"~j?AGGAAҼ]S@Oڹ?AGAAT?.?(ͣ?d[g}?R?Ja.Új>SR@V/{@>N@vq -?GGAAT0S@Of>?AGAAT=W:Q?58?合R ?z8?B->Q*P@Zd;@9vy @:v?GAATCdP<ՇO@ U@?GAATC U@?,#D?)+ ?Pg̵?dL ?SKlM@(\@3?]K=?AATCA@\HM@n4?AATCAn4?(FԦj? #u^?q4o\?塻?/,,)Q@ ^@ctxڝ?"u?ATCACS KxИP@JGTEw?y/M@@eZ3?/n?ACGTAj4O@ F)?TAGTC t?Jb?:")?j=/?86 Hw?m]L@HP@C5X4?/n?CGTACd%L@`?CTGCClD? hD?X_cp???;nP@%@YW4?`Q{?GTACGvttP@tl l?TTACA#?i&?1D?qZa?Dv?>{4BR@¨N@0_lRz*?mxz,C?TACGAX3 Q@r;+q6?TACAAΈ?1]?~GO?>O?ZzP?c/VAvS@:p@ĺ=@H}}?ACGAGY ;R@7 ?GGAAA&yH?nR^d?f/ ?[v:?TL=TR@H@9B?C?GAGAToYR@R?ACAAA>?#B?|ƚX?] U8?Bp v?s Q@ *@hk,q?a+ey?AGATG+آP@`W&?ACATGLW #?[;M>좉GO>:3rn{?>L?uXM@xF@~?v/?TTGTGGA^yL@V?TTGTGV?gW?8CW?^^!?cxM?1u&K@$U@-i>?q?TGTGCSk J@ˆ|?TGTGCˆ|?>\y>]%Kc?- t?_neM@m4W@1_?<,Ԛ?GTGCGd%M@q?GTGCGq? UT64?cEP*?$xX?VYk>?ʸ&Q@|?5^@حs?V/'?TGCGCCQ@6v?TGCGC6v?M>G?$mr]?.ӝP@%@D?_L?GCACCW &P@"T\d?GCACC"T\d?MtِY?F֚?;J?}]e?|'P@:@cF?H}?CACCA&us4Q@0^_$3?CACCA0^_$3?y?*?- қ?Bz~pk?9k hR@FGr@I,(?ZӼ?ACCATOR@Si?ACCATSi?4/?U狁?4?y,q@?0fDQ@@ؘ%@+eX?CCATT7GZ@Q@0xx?CCATT0xx?AӪ?`tRr? [3?I'+%?ύpJ@$@ɢ?tF_?ATTTA`9bnJ@_8$%?ATTTA_8$%?o$>^ĝ>Om?}`?NNN@ǘ@̫?b2U0*?TTTAT;EȪM@&2gq?TTTAT&2gq?xNIs?$z!?j8>̣??3P@( @0$d?q?TTATT\xP@ J‹?TTATT J‹?yB?^UOh?%? t?\?HˆL@vq @=V?S㥛?TATTG]L@5~^?TATTA]8?kjaL2>tr<; ?qyҒe?b,yU?,N@tF&@vd|v ?Aǘ?TTGGTpmO@0?TTGGT0?}F5?L/f?$II:?4%?OUN@e`T2@7?Y5;N?TGGTA?,UN@P?TGGTAP?h?~3?ZG8?>?{wN@~:@ ?^K=?TGGTAsE)˨N@zz,?TGGTAzz,?P^?AR?ⲋ]?Xr?Q63M@E@m2 ?Mb?GGTAC)N@og]?GGTACog]? 2G?jt{j?5Gb?FO?sp]KP@BfG@[ۋ?46?1>㍪P@7>W{@0? ^)ˀ?TGATAAmhP@@N^?CTATAA`j?O?>Rs?:`?!S\(?S8P@ ףp}@fjd?Mb?GATAAcJO3O@UT?CCTCT`M?gA?Y?kND6J? L?olP@i|@WTe;?jMS?ATAACuAĮP@Fb ?ATAACFb ?ϴ"?CvH_?32V?@o?CP@x $@ȴ??ܵ|?TAACTDwO@Vr˭W?TAACTVr˭W?Sc?k?B#]?N;=? ]HO@Mb@]|?+?ACTCGMP@p?ACTCGp?E:R?^!C?K:?&?YCQ@}?5^@%U?&u?CTCGTKoQ@?CTCGT?C;?7~@?dوzn>إ_؄?Ln/l?Gr-N@ͪώ@(9?z6>W[?GTGATAi/O@6ަJ?ATTAT?+xn?3{K)aw>Hgm?;j?f%TN@Mb@=4C(?HPsr?ATTAGq<@ ҐN@#E,f?TTGCTO;?8^kt?8I'r?:.?~*? C Q@ŏ@='?H}}?TTAGT*K>Q@~?TCCTTa\)R?V%$?v*?ʙm?Fҝ?,9K@ g@C?a+ey?AGTCT@T,K@w)?CTTCT`a>~!g?4L?%JrN@F@l;(6?a+ey?GTCTT|Ӥ`N@"nj?TTCTTD@?<?h??fws>?t"x?;Y-yJ@sF@?Y?Ǻ?TCTTCysګJ@OH?TCTTCOH?sSI;> c ;> S}v?<")0?i|YO@9EGr@\~? rh?TTCTAKdIO@dXN?TTCTAdXN?} ]?Mu6.?M.?Ψ ?L4P@Bc@[w¦Yt?Oё\C?TCTAT(UP@ L?TCTAT L?9-?DXM_?W3!g?wG.q?<^ P@Mb@?NSt$?CTATCHh P@7t׵?TATATD?n;"?+ע?DzR?LjG`?L!g}O@b4/@ycX@Ǻ?CTATC!F2h P@ 0!?CTATC 0!?d?o)?4m_6?13qh?L1N@s2@:s/I?tF_?TATCA rvN@)9^k?CTGAC|&?YSޑ?dGzJ@/LJ@9 z?Ǻ?CATTT@jpK@p ?ACTTTӜ,?,]>FwaS>TG?c6?н{I@;MM@ I? ^)ˀ?ATTTANnJ@q?TGTCCh\◬?Q=>3Z:>Up.g=?a=Z?#bN@-O@& )>?V-?TTTAGj/N@ưG?TTTAGưG?{ؽV?m;?UD(#?LHCx?D2\Q@p= W@\ ?M O?TTAGC/P@L郬?TTAGGJ ?x?Gʡ?>??*Y>hP@faa@'6@?dݒ>tr?fʙ=X?u(I@qh@ ]?S!uq?ATTCGʖK@==?ATTTC9.j ?DbK5>28f>TL?Q?~?P@6^Il@7`ش@_vOv?TTCGTB!$P@0D,I?TTCGT0D,I?8.1?yɹN-?T>3?{v$?B|H(L@Um@Ɇ?y):?TCGTTM@bC\?TCGTTbC\?P; 6>Lu?:?.$m?M dG@z):r@|a?=U?CGTTT<8DUtH@Nf?CGTTTNf?6ax8=2F[ f=K>_^z?I@%~@r&%xɛ?_vO?GTTTAmI@lN?GTTTAlN?N/=g.>N(+?{*?C[KM@t@w@?ܵ|?TTTATϱM@Q?TTTATQ?Jw1tM?S?r P?/ `WX?@ M@V@ub?b2U0*?TATCTo.6M@.~i?TTTATR&w?\u`R0j?xAq?F?|iǝ?=MN@ˎ@,`>?X9v?ATCTTv PO@(O`?TATGTY14\S?p k?UT?K(?]ņw? jJ@z6@2: a`?_L?TCTTC>ϫJ@1?TGTCTGT4?zC1̅>I6>cӪ?X8V6?GzzN@T@V?-C6j?TTCTTA7O@(?GTCTTzǕ?ς?E@(?DY?zR?mc6{J@J&@S?a+e?CTTCCX[$J@" *?CTTCC" *?K/, >xf>p8?;QM `?.olyP@;@0\r@Mbp?TTCCGmmwO@\8W?TTCCG\8W?n"p?(>Ό?I ?[gY;?΅R@jo@Ԫ ? ^)ˀ?TCCGA:sE*R@,sι?TCCGA,sι?G["?hN?li#?җ?d6XQ@=U@A|O?a+e?CCGACoQ@w?CCGACw?7' ?:ɝΧ?0 Kq? K jL?r{9P@ˮ@jԐ ?:v?CGACGfkOP@x7&(\?CGACGx7&(\?-&T?W9Dֵ?DV?-?3&9Q@@*K]?46oN@F,/_?CGGGCF,/_?]vceʳ?\`L?CbŚ?|Ӧ p?&cAQ@ۊe׏@`QaLR?HPsׂ?GGGCA V{m Q@mYk٪?GGGCAmYk٪?Q k?PrC?FK?  c?LR@ُ@ _{?ZӼ?GGCAAk5iRS@xQ?GGCAAxQ?#Eq?105?7$?_+X> zQ@fc]܏@8F ?{Gz?GCAAT(R@!%st?GCAAAjj?+ߔ?!L9?؂b8?39?:mNP@Q|ᏽ@~Z?H}?CAATGv3IUP@AO?CAAACvxl$?$?z?2?ԩk:? ףpifN@q菽@=?Mb?AATGA%1N@?K"?AAACCVZ?7t ?fw?VMu1?+@ ?ჲl%O@fꏽ@)^??3U0*?ATGAA F@P@L!T?AACCC옊? 7Ŀ?>Z+lW?MZy? -{h?L<~Q@@ z??ܵ|?TGAAC.9Q@5d ?TGAAC5d ?^?1t?{jͶ?jˉ?eyjO@V/@HWB'?镲 ?GAACGY^O@MK?CCTGG":?S㊌?z7Š?oAqȺ?]B' ?ktCvP@QI@4#7S?Mb?AACGCj!YP@ ?AACGC ?/>>!?(?n?|?0Mù?>g??UN@?ACGCAY(8Q@Vѹ?ACGCAVѹ???(ͣ?,?usˡ?܈P@?ܵ$@&A?Oec?CAAAC翎P@WAz ?GCATC@ ?WP!?;@?$6?9+v,?/f?N@ g3@F/J?~jtx?AAACC2 _N@J8P?AAACCJ8P?M,c?hRf?Dhv??F; P@D4@'ejh?"u?AACCTV;P@`Bp#%?AACCT`Bp#%?vBt?nyo?r:Z?^<>?߫xP@St$7@HN=@&1?ACCTTP@%pǝB?ACCTT%pǝB?hzyr?̫݃?xE r?G&~?-rJ@W2D@(u"?k g?CTTCA ;GK@?CTTCA?V>l|.>n?Rȴ?eL8P@PkW@ᔷ;0x?Q?TTCAG/k"P@ab4O?TTCAGab4O?B?0c_?^1?aҎA?r &nQ@-`@{B("%?`Qڋ?TCAGCm$NQ@P??TCAGCP??-V43?!w=r??\?ֆzv?kO@Gx d@&&tS?ψ ?CAGCCpP@D]?CAGCCD]?R?jbԖ?3??cآ Q@rhm@`խ?Q?AGCCGu=rIQ@%O4?AGCCG%O4? u?Ŷߚ?I?Қ??`PR@ +v@ưӑ?:pΈ?GCCGCl?ЯQ@C%ב?CCCGCȶW!?VqC?*=?>D?Ey`s?PڥQ@*:@ X?"u?CCGCA]CwQ@ Iv?CCGCA Iv?Eym?sٜ?&`?k,xe?L=S@H.@pB2^?_L?CGCAGG 1S@\5%?CGCAG\5%?wEXG?:'?қvZ?-z>GR@`TR@;DpA?H}?GCAGTϨGR@'b=?GCAGT'b=?&̠?q ?aobȇ?q FP?:m_M@I @ZNn@r?CAGTA?quDO@?:[߻?CAGTA?:[߻?l1?n?M?n;^??O#0F`?4333&IP@@L׌?_L?AGTAAKMZ XO@L ?AGTAAL ?ܴv?i*?[?8O>Nc?حBx8Q@ǘ@ _?"u?GTAAAiv[KQ@"@?GTAAA"@?0BO-?bz?IcP&O?,5#?B\sQ@4@fO?M O?TAAAGIQ@Pz?CACGGz?(;?]xNk?r?jZQlij?W_*h8Q@@5Ѭ??AAAGGprjrMQ@sך ?AAAGGsך ?̛mD?咠0S?ʗ5"?#AF?[jPlP@Gx @\#І$?V-?AAGGC@fiP@KR?AAGGCKR?NP ?!uD?yA>?Bߦ? ޔQ@Fx@8r̽@j+ݓ?AGGCT;aQ@P5Щ?TGAGCOs?j$I?܌k?[!?=8w>|?Hz`P@hDio@9AsBA?Mb?AGGCTnaQ@lR1?CAGCT!Aɥ?v^?|ӗ?!?㶽?z~P@-@[xkGf@b2U0*?GGCTTגQ@px e?AGCTTռx? c?Yʚ ??Y\?0Xy?ijerI@ F%u@bν@H}?GCTTT oK@6y?GCTTT6y?vv{f>(9m=u{~"?2?J@+ɐ@aO? ?CTTTG$ J@8fs?CTTTG8fs?q >g>Ϥt? VI?IqmK@8͐@-?eX?TTTGCN K@')ڛ?TTTGC')ڛ?[W>MPlb?[ ?JmO?| R@a֐@)1 hl?~jt?TGCAC&/R@`HB?TGCAC`HB?C2ӆ?X'M? #,?+A^o>?%b+P@|гِ@n:?Oec?GCACC_P@yH]v?GCACCyH]v?2p~?M[4?2l;V?K7jo?D2N4Q@Oe落@k*?/n?CACCGkQ@Y@g?ACCCG"?5?d?̏Q?:vA?GΜR@/Lꐽ@ +b?-C6?ACCGTm]Q@9)\?CCCGTS+?EG 0?rH:~M?j>3? (>QxjL@(퐽@Rљu@ŏ1w-!?CCGTCUoL@)#o?CCGTC)#o?[8@?.q>]*4c?&!j탏?̌I@s@&A4@-C6j?CGTCGhW2I@7WJ?CGTCG7WJ?laQ>;Z8"l>E?bP?_?L@ +@"hv?I +?TCGTT:tM@'K9s?TCGTT'K9s?hz>t?}c?ĵ1q(?&,G@V @6L{jv?_L?CGTTC"WG@ o?CGTTC o?Cr7=r7fe=ΐtʲ?gE|9?I@3@rhm?~jt?GTTCTVw J@3?GTTCT3?O@7 >'E>S? o?#+N@ґ\#@}? F%u?TTCTTy7O@sH ?TTCTTsH ?p?mD~E?Kx6ݑ?%?~J@#~*@5ک+s?5;Nё?TCTTCtdQJ@PϺp9?TCTTCPϺp9?<ma>Nm>-.?Cϣ&3?y&q P@jM.@`-@Mb?TTCGG^PWP@(jx!?TTCGG(jx!?q2Ņ?׳ji1?)T4?rԶzx?*(*P@u$0@kĪ?J4?TCGGCBP@(=?TCGGC(=?S$?=o?v}l2?xʦ[?}oP@9@|I?46?[w?>?Vgfo?woS@H.?@YfH?j+ݣ?GGCAC-׿R@$g?GGCAC$g?Iѕd?Wbމ?aX?zA?2fK@#@K?@?mxz,C?CTTGC6J/K@P#w?CTTGCP#w?>!?\T[sm۴?6 ?^0R@Zڪ@ Pc13@HPsr?TGCATB1R@Bz??TGCGT\Z?zx?.H?"5j? V?_),D>ryqEP@&1@2?HPs?GCATT k_bPQ@4?TGATTv ?4,lh??a[X8?L?XJ@@8eժ?J4?CATTT3>pK@g"?GATTTy?mտAб>Ld,>SEy`?! ?_ EH@[B>蹑@dJs?6;Nё?ATTTCWH@-L-?ATTTC-L-?3yG=sEs =Wt"?vj?%@K@z֑@:vV?gs?TTTCG,K@0]?TTTCG0]?vD첯L>0z_? I?^? _?^sǒP@ 0ّ@@= @~jtx?TTCGT6P@%#C?TTCGT%#C?Ɋh?;?J`}r~?\>p=jJK@Yڑ@7U@-C6z?TCGTCLL@0Pн?TCGTC0Pн?dS />c9>UV@?. `?zw,?ףpTQ@ᑽ@x?b2U0*?TCACA6Q@!G4?TCACA!G4?d8^?P}?*&?/3:?8 KR@?䑽@)Z?"u?CACATƊ>,R@(4?CACAT(4?E9G0>_j?Vt?=)I@f @ v?a+e?TGTTAՐJ@:+?TGTTT8"?a{x=}H">l<4?"B?(M@Pk@ #~[?Ǻ?GTTATj٬M@^?TTTAT"fc?j(? h?%X!?F"?JOlP@ lV@eLv?`Qڛ?TTATT[,O|XP@X?TTATTX?mu?҃Y&?1?r?7XK@:M$@R?mxz,C?TATTT$OuK@LWX?TATTTLWX?*>N.>'\?4?#@ґkI@Bf'@eD?{Pk?ATTTG =EJ@[?ATTTT=Q?LEl =]=#僇[1?PKOe?p=J@:p.@");?-C6?TTTGC.( K@' ?TTTGC' ?=5>q >EDn?ݎ~h?PۇL@F4@Z)y?]K=?TTGCGx;b3N@MS?TTGCGMS?>A4K8?|,W?ơZyu?[ PQ@Y5;@|F0@`i>9?*K@{R@xV>T?HPsג?TTTGTŪt{T L@o"Β?TTTGTo"Β?nN!>XGP?:Ol?8p?9L@ŏ1W@) ? ^)ˀ?TTGTG(L@1?TTGTG1?:G>>&!?=dEڦ?ER;J@JY@˺wm?w?TGTGC5FoJ@w?TGTGCw?N>/ec>UPS?u2?Or+M@*Z@lM ?n?GTGCG41LM@ nXǃ?GTGCG nXǃ?!?9Jƒ?-x?*/:? lR@QI]@ g@a+e?TGCGAٛR@7$Ѕ*?TGCAGp=ʌ/R@"u`@71?H}?GCGAG78R@, ?TGCGA1?'ZMԀ?'5?Ju顔?R8}%?ϖ,R@Bfg@O6?~?/n?CGAGAJIR@=7X?GCGAG9~ULJ?!UC?͈?+A?`ƺԭ>01zR@wOj@?<,Ԛ?GAGAA>3yR@;E?CAGAAYQ?J+?{P?w,?ۧc-I>/Fb^Q@m@:gY? ^)ː?AGAAC|bohR@&LQ?AGAAC&LQ?!^#?|3?^4?+fP݃> TN@r@=\H"?ZӼ?GAACCz ԼN@D@A??GAACCD@A??_+r?ɬ?E?ظd߸?&i Q@>yXu@ 3I? o_Ή?AACCAkXj>P@c_G?AACCAc_G??Ϟu?hՏ+?Ub?8& R@,ex@y3??{Q@V/{@Ԋ?F%u?CCAACDqP@޻P,?CCAAC޻P,?`?+5p?Xrh?`?Pa%?ATCTGMJ>?[7B?<]?.-?T=CϏ?ȁՉM@ꕲ @am7&?y):?TCTGCzbdM@a5`?CATCC@x¯?+w}?u/q&̱?-4?7n?vTQ@=@Uin?jq?TGCCA$s\sQ@olig?TGCCAolig?A[.?ӭ75A@??Ȥ?,侬?c=8R@;Ȓ@H0Tղ?Ǻ?GCCAGJ2ܺSR@pR?GCCGA<3?v5\?ݞ?[د?yՀs?4 OuQ@Ӓ@n?<,Ԛ?CCAGCHQ@y?CCGAC/֓9`?̼S?fV??Q?+s_?P081Q@3ג@fO?q?CAGCG(iP@672?CGACAI9?[?(3?+#Ý?i8?їxQ@|гْ@,v ??ܵ|?AGCGCwQ@8F?AGCGC8F?*Er?7i?uY?'3? [Q@sᒽ@#m/?:v?GCGCT,o9 jQ@dFa?GCGCTdFa?A{D?SE30-?*0? \?sT=P@&u蒽@A!&?ψ ?CGCTC,SP@\JPW'?CGCTC\JPW'?$i|p;?5&{,?i\ R ?(VC?b]TJO@ڬ\풽@qoIY?+e?GCTCGF$O@͡?GCTCG͡?ۦ?T?hl?}?{B|#Q@p_@r0"?S!uq?CTCGC/:Q@t#Ty͒?CTCGCt#Ty͒?gX?2?፸?VH ?Q@46<@1(?:v?TCGCA͵%mQ@;v?TAGAAgy?] ? ?$?o=s?̔&٫S@-@QikNS?ǘ?CGCAGҸ~1p1S@K25#B?CGCAGK25#B?|U DR@?ܵ@!;u@$?"u?GCAGG Ar[R@h?GAAAA{?s=T?4?B?9B>?ko_mQ@ @`SG'?J4?CAGGAp XQ@Tv8?AAAAAh?0i?*N?9^?3v?/p%6R@C @m(}?2P@ ?GGACT ?g?\Tn?nGD?|?"&ęO@X2@"oY.??GACTT91PO@#e68?GACTT#e68?,?Ogx?D捸?b_M?ȍNJ@@ +2M?_L?ACTTC(WJ@of?ACTTCof?`NJ>K}h6>A'?R?+ J@7"@KZ?_vO?CTTCG{1#%K@ao?CTTCGao?Xi>1ϑp?tTՓ?i\3BP@o%@J@Mb?TTCGT}/nP@W?TTCGTW?!x?G3Ҫ?ct?bɰ? M}?tU֝)O@]K'@c?5;Nё?TCGTA &9"\O@[*;?TCGTA[*;?ޡ,`?$X` (?`??b(?ʡ!L@<,@V] U?Mb?CGTACIL@R,?CGTACR,?H8>6@3 ?CP?8?$D N@H.@U?F%u?GTACGsYqP@Ow?GTACGOw?՟~v?fa?^K5?6:z?1 7yQ@' 5@l$?Ǻv?TACGT^!^Q@k)В.K?TTAGT5"2? B2x?MR?x3?\xYAt?3z[քNO@z6@li \g@~jtx?ACGTTMCM@6qf3?TAGTTӂ?cM?c\C?>̖?.^ܦ?p= I@^F8@O<0?mxz,C?CGTTG >I@Hl)?CGTTA7H$?%;?>`9c@>SOn{Y?]M?ѝjL@ q;@eܮa?`Qk?GTTGAeJL@H2,?GTTAC%Lf3?N>ִK?~uJ?o%;$?(XFX0P@~j<@Ǝ?mxz,C?TTGAAZixP@@6 ?TTACAb?0?ΛIϴ?>4?B_?2eQ@?@ú?UN@?TGAAC *ѨQ@G8?TGAACG8?klzK?v`?i?[h& %?Q63O@7D@}ɓ?ZӼ?GAACC:ƼN@v<?GCTCTz(*?V1\?&:Q$ܶ?K;?q#v?bP@OeH@ntW???ACCTTvq}P@s:P?ACCTTs:P?*?Q_? |ֲS?p Y׋?P$ L@47X@yH|b?j+ݓ?CCTTGz2'M@O.?CCTTGO.?3S?{%? ?Zf1+?4L@/]@"?+eX?CTTGTT=?L@Zb%?CTTGTZb%?8%h1>j?%yڱ?0f(?Ձ L@6`@?gs?TTGTG]L@ nl?TTGTG nl?µPLJ>uN`?l$?E0q?LK>K@B`b@.[[?v/?GTGTC>3K@^,?TGTGC%?һ2~t>|3?>;$m? ?uEJ@!rhq@e{5? QI?TGTCG-K rJ@/H20?TGTGC3Pzx?xms(>'[> ;?iP`.?ONhTN@Ǻx@ϻQ ?_Le?GTCGA:Y^@P@>Q `?GTGCG] w?<ۇJY:?~2?~b:?0nN?]b۟=R@+ey@y-{ԟ?F%u?TCGAAڅN`R@=?TGCGC (?.?fL&IQ@\m~@5k?/n?GAAAC]ً1Q@5 yJU!?GAAAC5 yJU!?Y .x? g(?¼?Ė=Ac`?׷zaO@0$@ `m?"u?AAACT4O@Fю7?AAACTFю7?q?dOp? aWP?$Q-?ޖ{P@\m@&'ё?~jtx?AACTT䪇ԡO@MM?AACTGf~jԾ??=?ko?ζ=S@ @{UK.?_L?GGCGAG5S@̮?GGCGA̮???jH?ayM?9LK[>%SBboR@#@fd?/n?GCGATC>vR@`\cP?GCGAT`\cP?Ɖ?RL?KS?>ekT?m̥P@ףp=@w࠴f@q?CGATGޣݕP@͎?CGATG͎?[f?S҆?1R¬?i(a,b?~[bN@<@耒)O? ?GATGA,lN@OKS?GATGAOKS?:5¢?YEX?ͬ?4 ?q>Q@ -@;Exň?a+ey?ATGAG;v?ZP@!۩??ATGAG!۩??r]?PzV-?3\ S?usXt?T,zR@X2ı@u&?_vO~?TGAGG$=HR@xN,?TGAGGxN,?i\@qU?R?_0?[Ō(d?@"W?GAGGC P@U2?GAGGCU2?5?%Ge[?fn?#?K`Q@T@ vF?q?AGGCA vEQ@:I?AGCACt\_E?p?) (F}?MF^I?"p?.Q@SÓ@Fu?H}}?GCACA4ӻ PQ@*ch2?GCACA*ch2?" ?nÃ+?帣?m6r? GQ@a+œ@Bc(?NSt$?CACAT5/,R@z#.?CACATz#.??Re1?SpX?rv ?hb?<O@Pkړ@\-i?H?ATGGC &MN@<4r(?ATGGC<4r(?€?q])?EeB?fx?iP@gꓽ@]??TGGCG`[P@ga?TGGCAWhUAQU?ev`C??>yfG?C$??q3R@> ף@ҌF?&S?GGCGC_Ձ`R@ `0?GGCGC `0?+g}v?Ox_[?StWఴ?za?9f Q@_L@?gj+?GCGCTIjQ@S?GCGCTS?+Odd?˜P??qt?E']zP@{G@C*?|a2U?CGCTTlLKBQ@ AY?CGCTT AY?duѲ?n.?XM?0P&A?ۣnM@u@?-C6?GCTTGĘq2M@M?GCTTTY$]1?`g|?Xgqh#?n?n?0J@[Ӽ@v?HPsr?CTTGCt2/K@$|?CGTGC?)r?d7 C}>WG] ?tzn?#L@4@Z?_vOv?TTGCTxT\!N@A=k|?GTGCTF8{9?j.A>r 95?L?gvi?DUQ@Qs@g%˜??TGCTT hքQ@q^"N?TGCTTq^"N?8W5?.*-?Aݢ?ws?yM@b@v&? ?GCTTAl__M@8n)?GCTTA8n)?ae+Hˆ?oW?K(?[珯'?a0Bj O@&䃞-@oP[?mxz,C?CTTAA8btN@ͦ;2?CTTAAͦ;2?˗?C걳?u?/(L?dqsQ@ O4@VyB?d`T?TTAATF^Q@x󦪛?TTAGTQ?"j?FčZ?cZ"?E"?=^N@鷯G@>ns?Z8m?TAATC+6O@ov?TAGTAg?G~º?L?#=%n?kj?6?[?Q5:-N@"uq[@?F%u?AATCA l)3dHM@b?AGTAC ?wһF?;gU2?חR?(?h1R R@qΈ^@M ?JY8?ATCAG& %Q@^@3H?TACAA9l?2,&?qz/y?z%ٱ$?VT}?43Q@' u@?F%u{?TCAGC|MQ@V)UQ?ACAACg&+?VI?r~$&?eu}u?9Z?S8P@ǘv@}?Mb?CAGCCw(P@m+8?CAGCCm+8?AR`{X?kNfٴ?]?o1ٵ;?ϴlP@Ax@_%??߾?AGCCC1)vR@5@@K?Q?GCGAA% CR@n?GCGAAn? C??i? {o??>ή!'JS@z6@W?<,?CGAAA39!S@Nf+硇?CGAAANf+硇?=9>?kj]p?׹K?5[Vץ>p=ʌ/R@_L@Le?/n?GAAAGX"R@ٸ1=?GAAAGٸ1=?v5?,A封?0  ?2j.>lljQ@X 2?`(9@? Fm?/M`N@xƔ@4E? ףp= ?GATGAS lN@oe?GATGAoe?O ?}?Ģ?+*pq?MWC?t||K@( 攽@|o*?q?ATGTTXL@2?ATGTT2?|^ʼ|VK>.%T?>4/u?uP?˻H@X9蔽@ԴF? 0*?TGTTC2xH@_/?TGTTC_/?#BV=o.%=kK0%?KR?^LI@)~딽@ȖS?d`T?GTTCThJ@pa.?GTTCTpa.?h.@=u4o`O>l1g$?Y:ttW?Q:wO@[Ӽ@?Zϰ?c]F?TTCTTK]7O@I>>@Y?TTCTTI>>@Y?TX^B?HmB ?HG?ԵWЯ?VK@ @лy(?:v?TCTTC \yJ@ m`?TCTTC m`?>Zv>'gKt?5͎?9Hh*P@jM@r+@+eX?TTCGT P@Cݐ-??TTCGTCݐ-??Y9 n?o,y?Sl? ?p[N@+e@J?Ǻ?TCGTAJ{A8\O@?Ɵ?TCGTA?Ɵ?C?xd:W0?=_?2kL?vL@2w-!@^ڧ4?y&1|?CGTAC<՛ΣL@S?CGTACS?п&Ƒ?F??rV)A?B?HpP@D @vI?NSt$?GTACTEcaO@2?GTCATyT?@K?;Z? ?ACTTT6|pK@}ٌ':V?ACTTT}ٌ':V?'r}>+Nlq[>!0?:%М?i-I@2%@J?Y5;N?CTTTGC J@ '}x?CTTTTU\k hV{>=]#a? ~^?n`pN@ŏ@tD@Ǻ?TTGCTrG!N@nEֱ"?TTGCTnEֱ"?[-=?D?E*?o B?e[J@K@@a+e?TTGCTp=!N@䷂z?CGTCA2A|?y5>S`? ?Gִ?CpQ@@?HPsג?TGCTGg HQ@R)rI?TGCTGR)rI?#Bl?<?U]?%|?_?(N@ cZ@]wYT@gj+?GCTGCFjlM@ '?GCTGC '?c8$?81o?A ?/?[@uN@=yX@XJl?mxz,C?CTGCTVahN@lH;9?CTGCTlH;9?BRU-?75?)? 6?W_Q@૕@.'?i|?5?TGCTGO3>| HQ@;w?TGCTG;w?(?Cpf7?&R?ɱ?ˡE?CGGAT.\aQ@KZ%U?CGGATKZ%U?BF?$.?6ԱM?i;`g? qɿQ@%@ 5j@r?GGATApeQ@~^׸:?GGCTGt@?{]?F:B}>U&I?ZCP]?+YN@H.@,}iZ:?HPsr?ATTATsQ N@mY?ATTATmY?;~?}vW?'p#?c0>?ιfN@7[ @r7?j+?ATTAT N@sSN?ATTATsSN?S?Hn?bE-? B?: O@/'/@8&??ܵ|?TTATC&7O@B1{?TTATCB1{?zt?s r?ry?!?xoM@ۊe7@)W?@߾?TATCTM@"?TATCT"?8q* @?nj?dv ?;4H?gLO@I K@1+?q?ATCTGYYO@Cyyс?ATCTGCyyс?SYܫ?Uq0m?:BR:?<-?Jim'O@hO@mi?<,Ԛ?TCTGG35doO@"?TCTGG"?{!?̝hJ?i?"|5?N@sU@*^?:v?CTGGCHWN@ Y1m?CTGGC Y1m?(r0h|?!Vu~?~J B?rsxG?uDlP@k Y@2 s?y):?TGGCGר?C P@ȶE%?TGGCGȶE%?Z?R?~?RvW?N#TR@k+]@;Y?b2U0*?GGCGTR@',/1?GGCGT',/1?pt0:?3ʥ?>m-0?MOe1?GǘN@@b@lp3@n{?GCGTC)[_M@6H~,k?GCGTC6H~,k?.{ڟt?/4- >5^?gb ? {I@jts@:\?0*?CGTCC I@f1{%?CGTCCf1{%?oIf">BĈ%U>v2^`?O ?79N@ @X?_L?GTCCG @N@7?GTCCG7?QJ|?/#$B? vܬg?c+H?p=hQ@ڬ\@z@-C6j?TCCGT|Q@/?TCCGT/?|?e^?:}q݇?io ?Ch0QN@3ı.@_F@F%u?CCGTA; 0[[O@`D?CCGTA`D?`WhX?<5^^?aӡg?kՀ?333mL@n@5nC? ^)ˠ?CGTAT M@b?CGTATb?k/C ?I4?MA?2r$R?vG.#?]u#%P@t@RRe?_L?GTATT-O@-e?GTATT-e?Y?QBq?Z~?.u{?CMK@k@ }xAk;>K H?+:?Vn[dJ@ q@飏0?y):?ATTTGxDJ@)1EL?ATTTG)1EL?HkN{>kv>֠?Hmug??$pK@-Ԛ潖@@`c@?y&1?TTTGCO]K@:x?TTTGC:x? KFT>X??+??˜N@Q|@uَ?{Pk?TTGCGw)2N@}2i?TTGCG}2i?_u?5y? iO@ -Ж@I/-Bk?l?GCGTAP@r z?GCGTAr z?#C?5 .}? ?UNƧ?ZM@ ٖ@2Nk?b2U0*?CGTATjM@ۆ?CGTATۆ?%3ca?Pw?f~AN?2TJu?B%XP@%ޖ@ykf?6?GTATGvE}P@7p?GTATG7p?-y1E?G]trǕ?̷A\?# ?z.M@ q얽@m}{?b2U0*c?TATGTUO9N@56lxM?TATGT56lxM?E)eH?)Xf?&i?&_?MI@V햽@ ?)\(?ATGTCJ$ .K@'ۥU^?ATGTC'ۥU^?x1>0w>> ?LI?`{F:TJ@a"@!;o?oŏ1?TGTCGG4qJ@Pi0?TGTCGPi0?{&=<9>!;>dP֚w??6 O@jo)@{B?_vO?GTCGAo}A@P@zJa?TTGCGV! ?#rRi?~p?W)?p_?g R@M /@0Y@N@aã?TCGATZ Q@#?TGCGTehj?@v պ?ȕ?%A?ڑ5a>lP@48@el@}гY?CGATGr!P@xނl?GAATGts? M ?fT3Z?_DO@B?>g.cf?-T[L@|/LF@FW\Z?F%u{?GATGC$jL@"=8 |?GATGC"=8 |?ZxQT ?rr0?䲳֘Ġ?Gk? ' #bO@#G@ie@M O?ATGCA[2O@#1?ATGCA#1?N?vl?7C?V6]?PVt?'\œO@(M@Ye@Ǻ?ATGCAA۷O@uqm?ATGCAuqm?v?gH?K ?mICg?NyJS@P@ {T?5;Nё?TGCAAR z8R@)>TNC.R@GzT@ ?+eX?GCAAG!=5+R@44?GCAAG44?"?bT?:к`?\eIlK?iWR@QZ@%0緛?S!uq?GCAAG,5+R@j0"?GCAAGj0"?+c?ѝq?؃?&M8>MQʔBQ@H]@: e?F%u?CAAGTqjQ@L{7?CAAGTL{7?˅W?T6W?nK'?P(У@?W8N@[ a@2 Q@Aǘ?AAGTGc8s8N@u-?AAGTGu-?XlIj?V\;@?S>i? F?dK@Af@C|T??AGTGT7 M@>15?J?AGTGT>15?J?7vT>gI ?/IK?yr?Ew4L@s@\o9?N@aó?GTGTTkk1eL@zg7?TTGTTb:?׿>vjre?3-?ٚ?o2H@ o_@^?~jt?TGTTCwH@.H2%?TGTTC.H2%?#N;=b`l\2=Zݤ&2? ?GzJ@iq@yUmI|? 0*?GTTCG˵_J@S2?GTTCA,[?qzmv>sYC>,c?8#Zm?oHVP@ +@p3}?/n?TTCGCO;8lmP@yQI?TTCACWxR?M?9?λI?ǵj=.)?jZ/Q@ @}OB?gs?TCGCTIBQ@׏S?TCTAA2 ?[!?·O??"_?c=wI?#QQ@5@@x ?~jt?CGCTAmd+Q@m<,X ?CTAACH?Vz-?Ƞ?TT=?.?F?GCTAC/nU>F?Y?I/?AKe?q$W?{JP@T@:m!?]K=?CTACG?mP@l6$Ƥ?CTACAB gI?AV?f-P?o? Z|X?Q@@t?5;Nё?TACGCA Q$Q@?TACACuܮ?y}k\?^]B?(9CO^?7_I?)1MNQ@J@Ad?J4?ACGCTdl1Q@8{?GCGCTIs ?;b?Mr? J]?d#Ժ?HeQ@wOʗ@S?_L?CGCTG:oQ@Y0ƒP?CGCTGY0ƒP??Jp6?au7?> Oӡ?)eO@9gDiϗ@XE@x&?GCTGTm ?O@tI0?GCTGTtI0?+Ұ[?9FN?(~?{ H?OM@-@ Q+=?/n?CTGTAڶ1M@?CTGTA?y HA?Ks5d?6L&?? 68N@B`◽@8#?46ű?CAGCT>ű?u?'SŰ?ut?d ?|a25Q@D6@Vd*?{Gz?AGCTG*%DB?GCTGC8'/lM@#C?GCTGC#C?kQ?s#w?P` ?J8?:m*^R@X[L@e1J ?ZӼ?TGCATR@ '^f?GCCATųN?;Z"?qh'k?G?Ln8D?f1Q@MbP@W*2j?9m4?GCATAۉQ@WyW?CCATA;霫|?d N?4){&???Z!T?HfP@@g@Is,Yw?:pΈҮ?CATAT).eP@! onO@#ZK?ATCCT#ZK??S?M~JЂ?T?ڬP?5 Q@ˡE@I?rj?J4?TCCTGž&Q@bn?TCCTGbn?J8rB?¨+6v?Ѣb?iB?kFO@?ܕ@y?ψ ?CCTGG|L!O@x)?CCTGGx)?yҫ?`^?ۣ?? )ȡN@v@X+?J +?CTGGT'{( P@S[˨?TGGTG$>?sV#˜?bZ0W?+|$?EH?N ?9 f(L@n@LUE?HPsג?GATCCWK@" ?GATCC" ?y?t!thq?]?^J?#4q8Q@h@Sw@?46K,?HP?TCCACynQ@^4ȇ?GCCTAsܘ?[m?8?:m ?B?3m?G7Q@{Ҙ@â?-C6?CCACAQouxQ@=^?GCTAAWy?R {Z?y:?K{?8"?\ ]?R@Tt$ߘ@ ??W[?CACATS,R@~ &?CTAATI?y?,l#?'A ?ZnFk?6lM@M @Bn ?~jt?CATCC:eM@t(?CATCCt(?K2_?UH6e?B+|?~=??w3CP@g@1>N?gj+?ATCCThahO@L?ATCCTL?t)t ?2gʿ?Ƞ;,m?)Q?H:Q@[B>@GO?L=U?TCCTGKϖ&Q@dަ?TACGT?e)?V€e?Ð H?H{&?*/rN@@˺k@F%u?CCTGCV[M@rGZ?CGGGCιBHѦ?t?4h2\>9?"+gf?M ֠?6B P@Q@$[Nyh?gs?CTGCA N@dJ{:?GTACA}vt?ւ?1?ט0s?Jy؆?+R@L @¸? ?GCAAAj}%R@LʾԞ?CTCAAs΂m?FWCm?a? Rġ?u?~?w!eQ@lV}@? ^)ː?CAAAT8}OEQ@;n?CAAAT;n?{7Z?9@{?|Q?埧?L.P@ @0 ?Bi?AAATG" O@!Tv?AAATG!Tv?TuE}?>"J?fE3?"9?U޿M@e!@Y8?:v?AATGTA+8M@9]?AATGT9]?g fb?Ie? d.?,su?Vu,M@(@T0;? rh?ATGTA֩EM@@La?ATGTA@La?. R?`Ӏ?Ci?;R#L?@7,wM@,@A|K?"u?TGTATLb-%M@ {5?TGTAT {5?mj*?6?m)?[a?8O@6;N1@M))?+eX?GTATAP@EYc?GTATAEYc?#$& ??|6Ŧ?hVnV?S1P@cX94@O羴?Mb?TATATt)+.P@.U?TATAT.U?i?5?9١?0^?N@ʡE6@$a?+?TATGGf]N@(YWS2?TCTCC^" ?op$?CD9?J??餵J?Q@L7A@@ -?a+ey?TGGATbűQ@DTݒ?CTCCTiE?)?@?_?ҵ ?pf_?#|'R@A@J3Z 2 @:v?GGATTDQ@*G`?GGATT*G`?C*md?+a?$$u??T.>co L@a+E@F&Z?Uد?GATTT2KT@K@, ?CCTTTf?PUM?bad>gև?#?DCI@1*U@ѬVt?UN@?ATTTTrMfI@ ?CTTTT8?j (=8xHq=-R9O?`Ԏ ?_7"%J@m4W@݇h5m?gs?TTTTA(?J@yS"?TTTTAyS"?w["n> >'C?9'?nO@ cZb@IV?vq -?TTTAAýfFN@"O:?TTTAA"O:?@쌇?#)?jiLמ?El?!S_P@gffff@yp?ZӼ?TTAAC(P@\o?TTAAC\o?.PM ?}4SVX?R?'?хaO@=Uk@hA ?&u?TAACC#O@G?TGGGCOPͬ?ic+?ο.G?Z?P??xR@&s@l?0L F%?ACCGGd-R@}L 4?TGAAGqJ?mѣ\?E\?yNx1?(^V?ÍQ@d]K@Cx':?J4?CCGGGEĀQ@k>pդ?CCGAC`??2?Sj?9o?\SP@iq@'}?2%䃞?CGGGG ɚP@h X?AAGGG}H?~Ѹ?r?! _{?ެM?/aQ@s@b*)x@I +?GGGGT)bGQ@FW?AGGGT=r?tp?I)i8? /?Զ@?"uO@[Ӽ㔙@V. B>@_vO?GGGTG(W`[P@ ?GGGTT~ˑ?_6?3jP?^4?Tlz?~jtL@V@f*r?{Gzt?GGTGTЁM@2-?GTGTG2oϺ?N?Û7X?6e8?د ?`K@ѳY@a#?-C6j?GTGTGSbL@Pp`?TGTGT(L?@6-`>sAs.>hG;?U%+?p= M@*ǚ@KƜy?-C6j?TGTGA&_\L@}V?TGTGA}V?T}T=?\tM?W)o?5?YBgP@ǘ@e? ?TGATG_"P@E{?TGATGE{?HBa?ar)N? ?`H?IM@ Z@@5<$@H}m?GATGA7պkN@Vc!̰?GATGAVc!̰?N]Ӫ?b Wa?W? j?{oiQP@M F@z'p?_vOv?ATGAGr+P@ ?ATGAG ?x?t?F*?p?Ce-R@罹@&??H}m?TGAGT I)R@DSh~?TGAGTDSh~?Y>?S?*{??AATTA8/?m8JK>)u޿ƨ>%G?H|\+?lRM@S㥻@?_L?GTTAG0pgM@PB%?ATTAGg!,## ?/nr?TAGACLcP@Td|?TAGACTd|?tan~?]'K?y? Y#F?Q@ho@MR~!?p= ף?AGACGFLCP@% ܺ?AGACG% ܺ?r"?K?V9D1?e`T?)Ù Q@sҙ@ t=@?߾?GACGA+Q@=ߨ+?GACGA=ߨ+?UDm?R3?+e?14?׼PЯR@R!@r3?Aǘ?ACGAA}k!{R@eܮ?ACGAAeܮ?Lή?,E? FTe?)1)?J%S@|@U{? ^)ˀ?CGAAA-?!S@I&?CGAAAI&?Q|?Mf?r?1sYf>_f>_Q@@A?镲 ?GAAAC/Tփ1Q@*&?CGAAC;??\`B?sy?/" ?QWO@tF@v!7?/n?AAACTĸ4O@zUi?GAACT9?#_)X?Jp ?ȡZm?է?kN@FGr@ ?_vO?AACTG$P@=R~?AACTT}S,5?겘7?KI}(?-)L?qƩ?L@Aa@^:?/$?ACTGCbv?M@nҋM?ACTTA,E޵??C8?n)VFH?,|?i`x?lVR@%@@` Q@ #@s 1?ψ ?GCGGGu,RYջQ@,ͽ?TTAGGu??bb>?*P>?j@?YP@@'@7lX?F%u?CGGGGj7═P@I?AAGGGx9ַ?gyg?3g<<{?v{݆?1gY;T@H.?@`W?n?GGAAG><T@^sv?GGAAAy{m\? ؚ;?0F1h??CBOG=cJuRR@W2D@!s?gs?GAAGAօQ@ M7?GAAAGA ?aE;?!.,P?ҽ?yZt0?FhQ@UR'I@t~?+eX?AAGAC*겫P@7[8-?AAGAC7[8-?pf_?œ זŖ?X?љz?/P@_vO@bD?_L?AGACA 2P@ibP?AAGCG +m?7O/o?)K?iH&?+>_?N-[Q@pT@kI@Ҩ??GACAGaQ@hDAȗ?AGCGCޒ?S؈?&JMp?did?LxY?&/Q@V/[@s$!?Ǻ?CAGATy8`JQ@2 ?GCCGT =é? .?£n?_ܼT?ņ!|?H'M@( ^@ IXa @0*?AGATC?O@WiF?AGATCWiF?M#eͺ?ȑy>7c?& ףp@]l_ˆ? F%u?TCGTCRìL@G2n?TCGTCG2n?]s?bkӠp?yJ4?Ձ?,VIJ@St$w@y\k ?gs?CGTCT|I@|T"?TGTCTTZ=&?i^>UjS>^J5?vl?\C(O@R?Q@RIƚ@.Ue[? o_Ή?GAAGCLVCQ@v9ο?GAAGCv9ο?K;$?gE#a??04? ?s O@@5^ɚ@w~j?HPsr?AAGCC_|I3P@lR9A?AAGCClR9A?<{^?4P?˳?hC2?"""b*Q@fʚ@Ȇ?b2U0*?AGCCC4P@aN?AGCCCaN?Cv?|P?5g? ? CQ@ڬ\͚@@*?H}?GCCCCrڸQ@σ4?GCCCCσ4??_.??{t#?cHm0Q@ꕲ њ@_??CCCCG R@ͺg`?CCCCGͺg`?K\y?`?=n~\?֑H?R@/!֚@kpL?N@aã?CCCGG (v@R@ҽO U?CCCGGҽO U??r3$?Qq5?a[$0?'@,/d?̭`,X?imq?m2u?2EIQ@( @Ƃ?sF?CAAAT @EQ@n??CAAATn??P??9H?p+?ςM?Gz7O@rh @|QX9?ݵ|г?AAATAҨO@PuO?AAATAPuO? wGq?4?d~ɩ?>V?+x4T%O@Pk@.r ?@ǘ?AATATz,yO@ U] ?AATAT U] ?! tT?gj+?TATCGԑ1N@<;m4$?TATCG<;m4$?bvc"?>x?j&h]?O\Q ?Dʋp˗P@?@(+?46OTF5G>VTֳ?xf?[d;زO@`TRG@ϥV?Mb?GTGAA=RP@6Kjxq?GTGAA6Kjxq??LwMZ?6;a?'—?NPϺ?):.S@gjK@[L?gs?TGAAG~r}S@R?TGCAAUbvV?ҫ?!K?tױ6%?r66h?J[+&R@R!N@j,!7?UN@?GAAGTXuQ@kUί?GCAGTt?G#?p"}V?.b}?k? |("?=q^O@W@&=)޹? ?AAGTAO@9J?CAGTA%߈@?F?Rx?_ݚ?S?q{~N@n[@?vq -?GTATCP=$O@5?GTATC5? *0s?q{D?'Mu?gGY?pfM@v_@ǎV?A`"?TATCC5 `%M@q?TATCCq?o?^i^?Tq$L?#2?!Q@e;Om@B"?St$?ATCCG"BX4P@GНʵ?TCCCCt0M?2ݓ?3? 䯯?%7u\v?^B{R@猛@!1UK?_vO?TCCGA?*)R@6X?CCCCAAD?D4?U*??i?x ("?$IR@ͪ@MoS3?J4?CCGAG~5R@7-5zN?CCGAG7-5zN?1:?Dq?M[_?m!?v21R@;Nё@h/-?St$?GAGAGltTR@aS?CGAGG]W?5Rw?K٪?w0L?.Ԓ\F>gm[S@4@䰣@ZӼ?AGAGG]$#R@K ?AGAGGK ?+cZ]?z+SG2?qůuۚ?DQ^>FP@ lV@m@Mb?GAGGC P@0'6e?GAGGC0'6e?ZRZ?X<)??Nf?m+Q@~b@ ? 0*?AGGCG|gQ@Ӆ4?AGGCGӅ4?AN=.?cᣲ?ly?Hy NO ?'1iWS@]+R@@?Zd;O?GCGAA|f R@uq?GCGAAuq?*b ?az]S?C;M?jK[>તXtS@i|@7?ׁsF?CGAAGCn(S@J5d?CGAAGJ5d?g?pa?2: ?nۏ>}"Q@qě@R>?tF_?GAAGC}lCQ@Xņ?GAAGCXņ?J&r?˩Kd?98ѻ?ɹ{.?R3~nP@/Lʛ@ ?? rh?AAGCAn#P@S?AAGCAS?1?BE??(^<?2}![?W-R@hϛ@F5?Mb?AGCAA#'/R@,ګ?AGCAA,ګ?ڨ?-h?;-??ȫ12?6Q@ꕲ ћ@d?Oec?GCAAG+R@4+?GCAAG4+?sG?j̶?'狮?gY?E@dQ@vߛ@Lw?a+e?CAAGA{SQ@?CAAGA?g!J?sN?d?oS6?K~S@-C⛽@*V?Mb?AAGAGЏC)R@2 {R@e䛽@)l?ݓ?AGAGT7AטR@&'?GGAGTxgi?mCe?sM"?6?O\]>a|P@z):@FR?vq -?GAGTA\P@f5]~p?GAGTAf5]~p?#?^H$Z?,\L??y[N? `N@Q@b?Mb?AGTATQdYAN@*$'?AGTAT*$'?+_Z??HYc?:|?QP@fc]@8]a?-C6z?GTATG|N3FTP@n L>?GTATGn L>?@1???*na? a?ڸe?ΖN@@p%?/n?TATGA1uO@VnFB?TATGAVnFB??-#ţ?>?L L?|GɪP@鷯@,_R!1?gs?ATGAGtP@<л?ATGAA ўY?_N?lo?1sm?g{?xS@Ci@F.?/n?TGAGA IpR@e?TGAAG2hO?~"6??㒭?w5tN?7'|,2?Q@_@ǞYó?DJ?GAGAA yR@3ԥ`?CAGAA&?pC?>\߰?^?U?&;S@&S#@DppT?Ǻ?AGAAGFlqkS@|^Ξ?AGAAG|^Ξ?{?]v?0q=l?qZ>j|rQ@S%@̾-?S!uq?GAAGA1Q@:a?GAAGA:a?"nj?`hUd?kK? y؅u?_,y7ZR@Q)@w\>;@Q@j+7@Ad+?/nr?GAAATpQ@N~~s?GAAATN~~s??fex? &%?d $!?vJO@+9@bk??W[?AAATAȏ)O@$(Jѝ?GATAT\#F?U?m+`X+X?Zд?)8?~h9Α>w?2TK?*VI@ÆW@d9?X9v?CTTTG)B J@ 4?CTTTG 4?Ǽ>&=9M?a^9?NtuL@8EG@x?b2U0*?TTTGA,27L@LFm?TTTGALFm?ڴ}>%f?chf?}Ga#J?98gYP@~j@# `?_vO?TTGAA"xP@퓠?TTGAA퓠?z#?})?"DP?!miq`?q= WQ@m4@ߤ ?H}}?TGAACC(Q@[bjo?TGAAC[bjo?If qL?-?(?2fV?i+Pl3[>_y+w?Bgf=?1d$g O@,C@] ?:v?TTCCGl*O@pR?TTGCGK?$?lT?HvQ??=Q@X2ı@wc>+f?j+ݓ?TCCGGTeR@Aq?TCCGGAq?)1?'K,?O"?;?%V”P@ǘ@]l4?ψ ?CCGGCS~V P@|?<?Nċ?_a?6?¿ UN@;M͜@es?~jt?ACTCCnO@l?ACTCCl?J?ւE޿? /EU;?3I?5i{k6Q@|aҜ@cF?S㥛?CTCCAP@(g?CTCCA(g?u|"k?1S}j?p=0?ih?=gR@Jٜ@?ґ?{Gz?TCCAAm.V2R@ a?TCCAA a?yW2A? 52?tK?!š7J?~@FQ@Qۜ@Z0??W[?CCAAT ͊Q@@?CCAAT@?k]?jrr?4 Q?q;+6e?>q%O@%㜽@ljOo?`Qڋ?CAATC&y=wO@?CAATC?|T#?23}?"N?ߺU?^bM@_)眽@}_?q?AATCAGM@cnF?AATCAcnF?ܠcv?Wl?_η?t(k?/MQ@0'뜽@eHG?ѳY?TCAGC\ MQ@ F ?GTAGGE剽?90k?g?M❨?:i\/?GᩃP@䥛 @ fg02?/n?CAGCAITMP@BM8?TAGGCdR 24?>?" ?=? x?="`JsR@&S#@=:,?S!uq?AGCACKMR@'He?AGCAC'He?[ܛ?NA?w??iR?p +SQ@) 0@ ͭ?tF_?GCACAsOQ@Q^ ?GCACAQ^ ?vbd?` U?D?t? R@Ϊ6@Ҿs?Mb?CACATʉi+R@^5?CACAT^5?WJ0E|@? R9}?UZe?@ "f?|)Q@,e8@p?y&1|?ACATTqQ@ 2?ACATT 2? ?u$%P?9e1?8^| ?ῘEI@?٬:@͡?rh|?ATTTGDJ@-Q?ATTTT؏I0?Lj^>`> &P>vl Kv?iE?RfM@y)Z@<5ћ?j+ݓ?TTGGGNfbO@3p?CATGT>6?cx'J?_??gN?ujW@m@5Pz@{:V@Pnr@aP{@<,?GGAAT<S@B>GGAATB>jآ> _"=eh$V>U;~ jK@=,Ԛ@%I?Uد?AATTG7{͠K@zLX?TGTGTփx?[:i>hp?9W?;?zM@ +@fX?Q|?TTGTA-BM@/nלɺ?TTGTA/nלɺ?^< iU?'Ô?O?pܽ?MbX@ M@b@W/iVH?{Gz?TGTACaL@Pi?TGTACPi?@-?>) }?2!P$?"o?2*O@߾@zB˟?~jt?GTACAOP@߇w C?GTACA߇w C?Ħ|?HA?iR?@?z=Q@2w-!@1xS?_L?TACACE[uQ@eJ?TACACeJ?Π*?9L#?)}2?` B?C4&P@@i1kN?Eioɤ?ACACCŋR [P@?A?ACACC?A?ѦY? ]"?!}bB?H?fw,Q@K{/̝@Z;Ք?y&1|?CACCT#Q@`C-?CACCT`C-?Nj?d?ZA%?oS?saP@]C͝@f~?a+ey?ACCTC"uP@euZ?ACCTCeuZ?@C?'SB?݅?RP;?z/P@ϝ@%o%?/n?CCTCGJSMNJeP@;5?CCTCTX?cݰ*?Xl ׵?1?7,>*`?F_P@ԝ@/>?+eX?CTCGT%goQ@q@v?CTCTG)ܼ?5n4|?Nw? ٪?phL֯?mON@[B>ٝ@*?a+e?CGTAG$\9M@!]?CGTAG!]?.өl?n݈?|dBn?k:-?BI)Q@Լݝ@ >y]?5;Nё?GTAGG,|vQ@ D?GTAGG D?V3D?cЫ#]?n*? ?xviP@K7᝽@3 q}?jMS?TAGGC@XMvP@^X2k?TAGGC^X2k??Ѱ?Ӓ?ıX?=$2~Q@?@Zѻ9?w?AGGCG`YgQ@Q ?AGGCGQ ?pÓ*?sm5u?1Y?7a?Ή~R@fX@lZYh?St$?GGCGT^MsBR@4z#?GGCGT4z#?V?Uѕ?,펡?f^ڱ>Y6sM@=yX@Wخ @_Lu?GCGTGU~˅O@)n?CAGTT0f)?څ{?C:>aв??dHOQ?[jJ@B @NBt?6?CGTGTbN>K@> ?CGTGT> ?v}V>>e?A?GzT=(L@]4;?x[k?Bz?xH@<,@ \9b?"u?TGTTCL wH@A4ZU?TGTTCA4ZU?܊v=k0=DۋV?6p{,%?ڇpI@Zd;@۵.1-C>{ 3?ټq?KP@8A`%@ǪAr@q?TTCAT%eP@a-?TTCATa-?<1K?<.?x-E)P?"r?L@ ^)@tpK?ψ ?CATTAFqL@N\k?CATTAN\k?rNSk?BR?Akd?϶T? nM@R!.@,?St$?ATTAAh\H$N@ =?ATTAA =?)3p?l"?}?چ?y;Q@a6@c2`@0*?TTAAA0=qQ@ɬm?TGCCT ?V8A?I n?Z(:?Om!E?0~%CjQ@Dl;@Cm"? F%u?TAAATgrQ@'m?TAAAT'm?/>d1$?khl?hB?px?WKM@ hB@_1?Mb?AATCA BGM@ '?AATCA '?oz^#?[xB?lj'?jڬ?7nQ@:pN@H ز?Ǻ?ATCAG=Q@?jyظ2?ATCAG?jyظ2?f?ɠ?]\?!H?LR@[B>Y@\5T@ ^)ˀ?TCAGT\gQ@N\}(ݽ?TCAGTN\}(ݽ?6?b\,b? ű?r,UE?cf=nO@/n\@ ,ي?+eX?CAGTG) !O@][uu?CAGTG][uu?ԁ@?(-8~?Kx!?Zzd?EL@\^@}ޘ?~jtx?AGTGAӫ"YM@Ջ8?AGTGAՋ8?w%? + +8?Ob3J?T,((?"=itP@"u`@*?M O?GTGAARP@=#;9?GTGAA=#;9?-m?.7F3?BtD?-AYx?)F Q@ʡe@%1?_vOv?TGAACNwQ@DXM?TGAACDXM?kz6?׹?o>!?՟?-?s("gR@{p@F[@"u?CGCGTLkgR@W#8?CGCGTW#8?%;+?铕?V>?6c=B ?} 1L@0*x@RL?H?CGTGG73K@/17?GATCTE?U]֥88?U$'>mk?g?fO@ r@ ?/$?GTGGTхO@C?ATCTG I? w\?ÈV?|ȪD?U˜?hcN@ҍ@bB?UN@?TGGTAnN@ *._?TCTGT_,??Ub!oD??v9N? VOL@~:@/wlW?gj+?GGTACBUESN@ţS?TGTAC*F? =6?ٗV W?[{=&?C߲?6P@KY8@#HV?I +?GTACG'P@JYo?GTACA'j-?aZ4???Շ?mp?zF2R@k @6ڕMA?`Qڛ?TACGG=|ғQ@M?#o?TACGGM?#o?Ǹn?$)?+h?v?%گP@@ň@?b2U0*?ACGGCgBP@t; 7?ACGGCt; 7?:g{?KDA?B$"?+Zڨ?6ZP@ F%u@o.?~jt?CGGCAi0ݩpP@7zf?CGGCA7zf?Z{?>1?8M!?=_&w)y?Y S@`TR@$?cZB>?GGCAT+.S@:x?AGCATwi}? y&ƒ?i7?EVT?HP(?-kQ@؁sF@ W? o_Ή?GCATG<ܺ?JUMA?igN@m4@Yؠ]?M O?CATGA>HDO@F?CATGAF?i?Bږ?fp.?5eH?atP@'1@[cr?_L?ATGAAeP@}b?ATGAA}b?o㹥?~6r ?QOnV?aC6u?d4)S@=U@̯?F%u?TGAAA *>S@!?TGAAA!?<b?vT?V\8W?>)v>qkP@W}ž@lM+?_vO?GAAAC( 2<}1Q@!)?GCATC]9?{?!PE?6.?y:?- FN@#lxzŞ@xf;x?Zd;O?AAACCÓ"^N@FW?AAACCFW?hJQ?k.xI?Yfi?D\?JO@c]˞@Sd?ZӼ?AACCTM&P@Nxv?TCTCAt[T?7j<?pX1b?%e7?+X?Oe@rQ@]C͞@q7C{?0*?ACCTTʚ2P@@[T@”?CTCAA9{0hJ?=C?%q?o`sv?]х?G#$K@(\➽@H?ׁsF?CTTCA=uRQFK@Wټ@?CTTCAWټ@?H~R/>ca>|JQɇ?RD?mQ@镲잽@< @F%u?TCAAA/ԕQ@BWS?TCAAABWS?ۅ?hK"?ͰLb?wN8Lܖ?+GQ@1*@@xz?q?CAAATf EQ@k±?CAAATk±?cW;?/p?S#?Z:?xRcN@s@?Q?AAATCkݔ|N@qU?AAATCqU?h P?ccS? XU?hj}?4&L@@_l??Ƭ?AATCCOGL@m%?AATCCm%?[ g9>ƌ54[ ??0n?GIgOP@x $@,H?Q|a2?ATCCA"݈L$P@%?ATCCA%?ذc?8?,EC.?, ?͘e2^\R@ lV@K?ZӼ?TCCAAܗD2R@ c]?TCCAA c]??tC$?O_]?O5~`?Q R@@ B>_?ݵ|г?CCAATnxQ@^ UR?CCAAT^ UR? =)?l? :=? Q?ӑ=O@,@S-%%i?1*D?AATAAD#P@VGaE?GATAAEPo?kiN?wV8i? vCa.k?zS?wQ@48@[?n?ATAATtQ@vk?ATAATvk?#nUH}`?1$i? "+*?EG?P@:M@Pͱ@L? o_Ή?TAATG x-XP@D?TAATGD?+F?ckZ ?i?Ud祄?!K@~:P@o!??AATGC. CTCPL@3h~?AATGC3h~?i>Z?TO[,\>tUU?pa4Y?=c!FO@4333S@;?^K=?ATGCA[O@9ؓW?ATGCA9ؓW? $qd?LϨm?o4?Z?QS@^@<ʠ1?ZӼ?TGCAAnEUR@g_?TGCAAg_?`\ս? ~8r?>p&?;\+>ߧdMR@9c@8?HP?GCAAT R@qj=?GCAATqj=?SHl?dTf?3S^ ?R8?GJO@JYf@t[? ?CAATG_*pTP@P45?AAATG(9>p?ɗ`?=5J`?Yu?~pٝ? ?M@wo@z0C?ǘ?AATGA<.0N@5?AATGA5?yV%?v?L>Ԡ?TQ#?SP@ۊew@utן0?`Qڛ?ATGAGP@Di?ATGAGDi?zƉG?.i?%= ?Ypfz?4=n)Q@Oё\~@[Z;@"u?TGAGTvR@bv?TGAGTbv?SQ?œs ?oԼfg?RNGZJ?=2lَO@Â@Y@gs?GAGTT k/"O@ο,(ֻ?GAGTTο,(ֻ?ub-?غCŠ=T?\S"?5Htv?Q涰O@y&1@@,C?GAGTTe)"O@rr?GAGTTrr?c'T1?=?.3j?'?]"ҟK@@r}"(?<,Ԛ?AGTTGbQJ@̈?AATTG̶ H&?}>\m>sJS?;?AC G>L@Ǻ@*H?ǘ?GTTGAj9L@kv?ATTGAótߪ?J?zwGb?vvMb6??2-M@+ٮ@#z(AR??TTGAC32}N@?w&?TTGAC?w&?K0?+y $?(?y?AtP@;Nѱ@^MZ?a+e?TGACA-"P@Z?TGACAZ?K =R?{۾?GZP?fhoZ?'լP@0*@G2?y&1?GACACtP@ ,1:?GACAC ,1:?ے՘?Ѯf8.?ߪ!?;}R.?2:oQ@6@%'H? ^)ˠ?ACACT!!}BMQ@cmC Q@V-ҟ@ 0f?Mb?CTCATH`Q@eRߞ?AACATt.6H?ܖdR?a?'̛s?9u?tP@|?5ޟ@?~|?Aǘ?TCATC^ %P@o?ACATC1e?6D}Y?";g?,?#DZ?S2pN@%㟽@I T?Oec?CATCG [TN@Hs?CATCGHs?y$Ǿ?-Sy?Ŋw V?Z&s? P@@-e?(?ATCGC~ـP@w?ATCGCw?t?M}?lBe?ʉ?ҊQ@Mb@=??vq -?TCGCAzRlQ@7?TCGCA7?p=q;?ꋚZ?h?t:F?P S@Q@k `?I +?CGCATF&dzS@rbd?CGCATrbd?7?>?:ڔS?arb>MJP@@,x@ZӼ?GCATCiP@P?.Q@V/@Az5?vq -?ATCGA&P@fH(#%?TGAACwi϶?7!!??MQ]?kб[d??cO@Zd;@v?_L?ATCGAN!ˆP@nA%?GAACGx:?̉Bv? y$?ճ |?J*z?YCR@q$@-?ׁsF?TCGAA}_R@BsY?ACGAA%? @"?0ky?ٱk ?7aj-QQ@.@Aa8?1*D?GAAGT"NQ@La?GAAGTLa?wLf?"??=pU?FnM@_)G@:<?Aǘ?AAGTT̈M@THU?AAGTTTHU?9D7?0@?Z?qXx?J@PnR@J?z6>W[?AGTTGAFJ@і ?AGTTGі ?}ªj>Dc(J?)}l?o\ڲ+K@c@ӹiU?_vO?GTTGCϛEJ@C#_?GTTGCC#_?֜jr>BX=?^T7˗?Ņn? M4O@ݓg@)b, ?Ǻf?TTGCGLV.2N@ic{?TTGCGic{?ӻ ܒc?8}/?Ɩ?wGB&y?xYR@d]Kh@u#B?a+e?TGCGTY #R@OwaX?TGCGTOwaX?'?&J ?*d?sJ?c0N@Fxk@Rds]t @`Qk?GCGTT1&N@Pio6?GCGTTPio6?zXĚ?8Y~>?L&4?ΡO?!QEH@Vl@#9?:v?CGTTG!O >I@m?CGTTGm?Q3}4>xԄ= ;l&?Ơv;Y?$K@]mr@$OX?Ǻ?GTTGTcK@?GTTGT?3~njI>fl3?:UQ.t?{j+Y{?T&s[?l+Ud?K^?h3k yP@n{@~?#?GTCAT>{M`3bP@$[ls?GTCAT$[ls?>`g?|.(>?nKc? IZ? GP@~:@ǎm?UN@?TCATCkiP@fg?TCATCfg?Pkg?A?HfŞ9B?5*?HzvN@&S@=Um?HP?CATCAGDʭN@?CATCA?-k`?p%{?MC't?rM?"0R@o@lWF?i|?5?TCAGT޾+UQ@`;?TCAGT`;?d'}B?&Rz?MJʾ?.HՆW?N@aִ@Nه@{Gzt?CAGTT\{ݔVM@,Q?CAGTT,Q?X&ƾ?|>k P>?@ƣo?Nψin?PYI@`vO@ I?_vO?AGTTTv>)J@g?AGTTTg? T8$>{č>SE?ڠU=Y?Sc}I@[B>蹠@,H?Mb?GTTTC.]oH@ $*h?GTTTC $*h?/=3StY=7R?Eۊې`?@XK@@rpa?~jt?TTTCAŜd{&K@-U?TTTCA-U?J o;>w{ ?_W:Jy?{W~J?*kʚ P@Y@ސ-l?"u?TTCAA]P@h?TTCAAh?~o??sq?\x?D렠Q@48Š@;60I?{Gz?TCAAA 2ƕQ@r?TCAAG/?z1 |?`>r?U 1;?<?5vQ@]KǠ@M?I +?CAAAC^N P@rA?CAAGC(ϣ?|?]DGm?_^:)?fhŧ?M瀭W۠@hb?"u?AACAA'XQ@.ƞ?CTCCAIR?B":X?Jg*?S=c? p`?DR@vߠ@ӄMJ?ZӼ?ACAAAIۥ Q@nH0?CTAAAdw?ai@?w㫜?!o?^ũ|q?vyuQ@ cZ⠽@6u?Uد?CAAAT2EQ@|#YR@?CCATG8?%+?_F͕?FW1?:/y?H.N@8EG@vd?{Gz?AAATCYt|N@3j{t?AAATC3j{t?.1?#`s?wKT?w9a?fRE6M@a@)KW?"u?AATCG ")9M@"޸?AATCAukB?K c?݂?SdD??mXHQ@p= @75ZG?N@aó?ATCGCu>aрP@6?GTAGGfQ? E!?28?i{s?LЊ?%rpfP@僞 @-?^K=?TCGCC96P@Yޟա?TAGGCj?Κ?KŸ@?@Ğq??/x8dR@=@15I?M O?CGCCAp}oQ@?AGCGA/&Iڰ?sQ?8V-?#t?ca?2f oMR@*@oؘ?y&1?GCCAGL@HSR@UzgT?GCCAGUzgT??yBUK?ack?5^Sz ?'6qR@s!@2 ? 0*?CCAGTr-URR@JRN?AGAGTa"n?lPo{?"á$U?JU?q>b TM@#'@"z:@>Ǡ?dE9??zjK?jJ@MJ*@'?F%u?AGTCG#V`K@Q'r;?AGTTG+SH?J`?>S#?ԍ ?Ó?oP@U-@eq?S!uq?GTCGTՏ7P@]?GTCGT]?n:q?!~A? ]?)?s~_+1K@Zd;@w?"u?CGTGTe*\=K@8j(?CGTGT8j(?ZB>PM$<> G"?L7?sFK@k+=@?vq -?GTGTC9VK@kc?GTGTCkc?qG,Q>'6D?kC??o+ H@.nA@ZjgZ?&†?TGTCC\I@;C?TGTCC;C?>:=AV)>lsD:??m?xs79?M@JY@?eߵ@( 0?GTCCGHN@ϸug?GTCCGϸug?#x<?m0?\ĺ?@޿?VzjQ@Tt$_@٤?{?NSt$?TCCGTdQ@dSFZ?TCCGTdSFZ?\3??J7F!U?7(P_'?2 j?uP@ǘv@0E@"u?CCGTGGIPN@Tb?CCGTGTb?˽ *?m9=i?tN?'?+lַK@a"{@n+0?W2ı?CGTGT>tc=K@ʒKj3?CGTGTʒKj3?dFVO ?偛>R)y[?\Q4?-}M@猡@o?+eX?GTGTA1!M@~?~%?GTGTA~?~%?vm?ޕB?1Ν?%5?kJBM@ҏ@:Z?ZӼ?TGTAGJN@Xr F?TGTAGXr F?i?9D?[A@?]DĦ?KP@X@!H[l?b2U0*?GTAGC LP@/Lռ?GTAGC/Lռ?YŰ?C?4s? ?㥛$P@$(~@g ?I +?TAGCTsP@}Ma?TAGCT}Ma?!~b?Ao.?z,A?Aok#? KQ@fc]@DZh? ?AGCTC /oP@l%?AGCTA fBe?Th?=W k?:_?Y2?U{P@Q@C&Yr?^K=?GCTCT`͞pO@> s?GCTAC!$#{ջ?9}6?W[3)? {jsT?m&o?4P@V쯡@d<-{?`Qڋ?CTCTT9UP@G\?CTCTGx? G?"5Q'?E\#?+{?j3 M@ g@d݈?UN@?TCTTAշ=M@"ǘsu?CCTTAͅ(?a7ٱ|?lE? K?#GA?rlN@ͪϵ@#?gj+?CTTAG+wN@ O?CTTAG O?6\n?׀FJ?ae?@_?$וQ@Y5ͻ@,~?ׁsF?TTAGGӃdQ@)'?GTAGG kӳ?.??%?3İǘ?GLIdP@ψ@K16T?mxz,C?TAGGC{kWP@ʤ}?TAGGCʤ}?"VÞ?88k? 7 d??&XrHkQ@~8gġ@R&@H}?AGGCTpQ]1aQ@=(L@:vޡ@gV@n?GCTTT(^K@Bމ?CATTTTn?]C?$!H+>=?6???nvnJ@k ࡽ@ ^)?ׁsF?CTTTG#~] J@,v ?ATTTGw[$?m\b>Y%LП>Y ED?v(TL_?_,~L@0L 桽@c ?*z~]?p?ca?hx?L.K@=yX衽@t?ZӼ?TTGTT.AL@=oAV?TTGTT=oAV?P>!ږ ?@h?}!?333KI@E꡽@Y E?-C6z?TGTTA+J@O>b?TGTCC7"?87 7>qn6j>NXFww?I3?_P@_졽@GyZ?w@ )?n?ACATGNRQ@4P?ACATT͈l`?xG?6n?©TZY?|G?fL@y@ q?F%u?CATGCi"L@ؿ8"?CATTAV2(?G ej?׷̅?3p_}׺??4BsP@n@M| @/nr?ATGCTR֭N@}%pR?TTCGTwe\?&.&Ic?{?ڃ|RVx?22(h ?kaM@.n@5ե?_Lu?GCTTAģ^M@zβ?ATTAT?-G?|?Py?4:Ƌ?-a|M@7@!?ZӼ?CTTAC:3Y M@vG?CTTACvG?g :w?g8?`\}?6}? d #wP@O@93x?_Lu?TTACGxF5\P@Td=?TTACANE82?@)oM/?7ԭ?ԝ~?رs?{_R@x醢@آA?Mbp?TACGGt~Q@Zoب?TACGGZoب?C(?I$?F'H?2m.U?cX”P@-@q?Mb?CGGGGySP@It?CGATGm?f|D?pÁ?o,.c?YƳJ颜?433#R@ @H#=@-C6j?GGGGCJ UQ@ZrZ?GGGAAbS%?#??j?= ?dw>}kMO@{򐢽@A1@b2U0*?GGGCGu HP@/?CGGCA|5 ?ńl?控#?[u?p@H?K %1T@ g@MVxY?+?GGCGAYy@5S@jtO?GGCGAjtO?bw?ᒓ?~whq?82 .>R R@ec@|M?ݓ?GCGAAStR@2A~?GGCAT 󿶲?1*?ft'?]?"L?YAIQ@/L@+H# ?I +?CGAACj*$Q@rk%6?GCATGFz?}?H ä?桪%? `?Ũo?O@ŏ1w@*v?_vO?AACTCܨ^O@!(Z4r?CATGG% ڿ??p9#?k%R?Kֱ?cJ N@~:@QX?X9v?ACTCCqLO@0g?ACTCC0g?gd3?sEȚ?'"?r?MbP@0*@] WR?`Qk?CTCCA۸P@_Q@?梽@`\C#x?H?TAAGC^hg`P@(L?TAAGC(L?"qO+?M?vY׊D?Jj㑧?znLP@ c@az?b2U0*?AAGCTT66zP@K?CCTCGixEv?_?Ro?CZa?qN?QX5Q@D@-G ? ^)ˀ?AGCTT+Q@OLMº?AGCTTOLMº?, ?*{絭?uKC|?ú? $}M@@(#B? ?GCTTAI&l^M@ȷu?TAATCaC'l?&?!"-?gj>? ١c'?\,L@<,@Y`l%?+eX?CTTACtM@\&?AATCCA?5= ?Y?ߟǡ?dDe?GᩃP@RI@Sۧ?~jtx?TTACA7m^nP@8Wc?ATCCAM䣬|?8לA?",b?u?w:i?]z撎R@ @dX? 0*?TACAA-Q@.W?TACAA.W?ڨR?^$t?J?W?M #b?gQ@0' @ȸ"?Q?ACAAA2Q@ƼJ?CCATAgھ?|jI?l?P.?EWB_;?5lEP@1@*.#8? F%u?CAAACﲙP@H?CATAT=?Js6U?j??.Ia?xwM?ڊO@Af@H^(C?{Gz?AAACAfPxO@u<"c?ATATT#r`d ?Šn?C_?zi?>~s]l?uӥLQ@j+@52:[@HPsr?ACATTpiQ@Nh?CCATT޼#ɞ?ýPʵ?vO ??PF+u7*?NK@x#@+%?H}?CATTGc6L@D5t?TATTG:?hK?Sa A6>G p)?u6 ?j̥]K@n @"ݶe?Zd;O?ATTGCb@K@_guG?ATTGC_guG?~q> )&H>6`gX?J]?LLO@6^I,@&BnQ?HPsג?TTGCA9%`=N@9zI](`?TTGCA9zI](`?TS[p? .Qu?-!e?aIi?&IS@u$0@ c}D?{Gz?TGCAA :|7R@dNV?TGCAAdNV?xMH?`?EZO?]aV>D51EO@X7@'3u?d`T?CAATCK3wO@5J M?CAATC5J M?Ag?6i?Ox?pqf?mY.M@L7A@@ j9?~jt?AATCGۏ8M@?AATCG?WBslz?6L{;?tJ?a?c*棌P@SC@\'S?/n?ATCGA&|P@DB?ATCGADB?Z b?B;^?M`YA8?X?? Q)R@VL@zGx??TCGATVhPQ@4?TCGAT4?Р?FӺÕ?SV?-+zn?͠EO@M OO@ >?_vO?GATATA UO@P?GCTGGqIQ?uŠ'MR?$?i]|?h^?6O 2P@sR@FUl?mxz,C?ATATT5P@Z?ATATTZ?)V?gt?7 ? jX7$?333sp[K@x#Y@xҀ w?Mb?TATTC- J@v'?GGTTAԳ?)'?FIO{>g̸?sD2?<{M?@OyNI?F'q?G-P@(\b@<{?J4?TCCTCB $P@qL?TTAGC:\$?<АW?Gs?^j?NZ<}?+JrP@?ܵd@Zw?Q?CCTCA fP@0?CCTCA0?ˍ-?j1p$?ӗL?oN?j8f%Q@t@:?+eX?CTCATpKQ@ Y0?CTCAT Y0?BC?2ۑ?k"ض?u^@?m6VQ@[B>y@kc/?eX?TCATAݑ{CQ@am5?TCATAam5??Eݐ?pl^V?Ӕ#?wwO@Â@VE/?@ǘ?CATAC&|O@sd?CATACsd?EP0?R#?֐ſ?@a?KOP@]@MfPL?tF_?ATACTo i`P@Z>b3t?CTCTC.K߻??H ?p?f zu?= #O@M @\ ?Mb?TACTA}P@ CW|v?TATAC x?2? zB#v ?ByU=?ޮW?[РP@`@,4:?+eX?ACTAAs>AHQ@K1m?CTCCA^K;?YrTF;?]bf?5QO?F;T;?gQ@?Ɯ@@?J4?CTAAAr R@tD2?CTAAT?5"C? 7}?(F?ǽH?sq6?M9cP@N@@c 汴?mxz,C?TAAACJcs9P@,ų?CAAAC ?b ^?9r?RC?Y?"-CxN@T㥛@ U+?ǘ?AAACC3]N@V5?AAACCV5?k@hL?0磫?dUҥ?Diq?&#Z_xP@T@$+|?ǘ?AACCC#O@fTn?ATACGfYg?N?R?͕^8jm?ɖ?"Q@NbX@Ē(?"u?ACCCGkY#,pQ@t[l?TACGAtf?)6?/E?1?X*E h?T2E"S@]Kǣ@̧=*F?F%u?CCCGGfgR@} ɪ?CGCAGG#Y?D?X G]? 2cw?~j>`EO@^)ˣ@h,@St$?CGGCT^[P@00H?CGGCT00H?i$?S֔;?W1?PJ?ہR@9gDiϣ@8[?d`T?GGCTG#ġ9Q@DSR?CGAACyά?$?j;Rr?˱H?Ol?!kR?'YO@ktأ@i6:jD?_L?GCTGAZMO@/ha?CAGGC@2?Q ?Sg_M?qFb:?1z7d?;& S@-Ԛݣ@0 y/?UN@?TGAAG^O9S@h?GGCAT+DQٿ?~vRw?bì*?!5Y?{?yspXQ@¨Nࣽ@S`]u?oŏ?GAAGTgS1Q@G:?GCATG#b?:Ur@=-?1?S֟p?ݠ9?o^M|N@Ci@߼1?H}?AAGTT>M@ zC?AAGTT zC?m7s[?oi??Z3, ?-JJ@S!@.w{P??AGTTGX J@GF?AGTTGGF?Ƙof>XiO?$jKK?Ss3oK@~@AN?ׁsF?GTTGAR!zL@uVH?GTTAC,/p@L)?y+q>=o5?%?(Y5?|?;?T!}?{Q$? (I@RI@OV?y):?AGTTC,EI@Lp?CGTTG=]?2#A>*}Z>dJlWO?M_3?4K@0' @ק?jM?GTTCA=kJ@S?GTTCAS?=֜>+Xi?ggO?,nK/?6'P@a@t 1?{Pk?TCATC[P@+_a8?TCATC+_a8?i9k&?>Y'?3 @?pFt?>iuN@_I "@|tGU?H}}?CATCAڑN@UҪ?CATCAUҪ?$H*?W..?h`U?O?gmu(vQ@%#@E?kt?ATCAGfHQ@n n'?ATCAGn n'?# 2?+?'$%?J?Jø6R@1.@wZ?HPsג?TCAGTs9Q@)$y?TCAGT)$y?|Ng3?G?v?UJ? :XN@3@h& @F%u{?CAGTTiQM@Kw?CAGTTKw?IU Pǖ?{jߌ?2"h;q?A0q?`X(I@_L5@7lM?M O?AGTTCh/EI@Hf?AGTTCHf? pڑ>(S<=i~'n7b?c9=?J@h"lx:@V&v?V-?GTTCTkX@J@ ?GTTCT ?D>|>(r?O#.?0QkO@eA@E)?:v?TTCTAY҆O@N ?TTCTAN ?mwa<5?Y7*??WJ?hSG?W"Q@48E@Mj?H}?TCTAANJQ@K6W?TCTAAK6W?Iua?&jc?(%?k!?X\gR@_L@, ?+eX?CTAAA) R@ʺ?CTAAAʺ?MXߎ?2Z 3?4oV?t'?  TQ@$J{O@F?&S?TAAAT6rQ@A~JۇP?TAAATA~JۇP?;?d?&Vo?dKX?F-QO@<,T@>m%?@ǘ?AAATAO@1?GCTCA|D?~M?~̱?3 q.?< D?ۋEjR@}?5^Z@@C?N@aã?ATAAGԥcQ@v-i?TGAGG ?3\?Z- ]?$Z?Sps?ntzQ@?d@&[?Pkw?TAAGTqըQ@DO&?TAAGTDO&?Vk?/[q_?y35?&##r?O#M@c]k@V%By@`Q{?AAGTC픀*}L@H}E?AAGTCH}E?e{?Akngq>J%?Rd>?{UJ@uqm@Jf}@HPsׂ?AGTCAw`b7qK@82!?GGTCA.0Ӟ?XI>MJ>n?bM?/Ol?c5P@_vo@:nͻ?w?GTCACi>P@}ZAP?GTCAC}ZAP?ߟ;?3 ')?q(g.ߧ?F4?z_Q@{p@{çV?UN@?TCACTtkUeP@MW?TCACTMW?e7??,=bH?K`?v{Q@Zs@ga?}гY?CACTG?5P@XR$?CACTGXR$?uQ?? ?G?t2^V?$ZN@n4@4Wg@?~jth?ACTGC>ބ>M@H2,ѽ?ACTGCH2,ѽ?DDd?l? } ?3"?#f {L@R|@5|T7?gj+?CTGCC$EvHM@d?CTGCCd? 䪠?dٸn?Ngw?SO?]3`nQ@ y@EE??l?TGCCAWaVrQ@:8ږ?TGCCA:8ږ? "?lӴr? ;Y??~TR@{򐤽@p?n?GCCATeCFR@ y?GCCAT y?Z$)?N+?;U+?#).?!<0 Q@jt@#xx3@"u?CCATT9(?Q@o?CCATTo?F?n/J?09%:aν?o*,.G?JYI@?٬@^b[?8m4?CATTCoHJ@\?CATTC\?qCq>l'6= ą?seF?EK@s@\;ޏ??ATTCTd CK@j &Uq?ATTCTj &Uq?Va6>Y> ^o?U3y?59ȼO@( @l?}Ӭa?d`T?TTCTGi"TO@!W_?TTCTT&L'?+Й?w}Z=?nʶ?Π|?L$zK@}8Ǥ@#um??TCTGC1CM@mdZ?TCTGCmdZ?֔ԃ>3%=?B0yΥ?Q0s?gE#7@O@&䃞ͤ@G?gj+?CTGCGgS}N@*Ğ?CTGCAwfp?BE?']?w!/?-瑱?uRR@٤@ l?/n?TGCGTR@\?TGCGT\?yư?3?(}s?t+?7NcP@Qۤ@C? 0*?GCGTA&lP@ ą?GCGTA ą?F*"?!ɭ֒?oZ?&D?Fd4N@?ޤ@d2c?{Pk?CGTAAFxM@JhQc$?CGTAAJhQc$?G[ԫ?k?5_#΍??0cP@#lxz夽@94A?~jtx?GTAAC0b&#P@U%T=?GTAACU%T=?V.K?r9?N?Z'w?ףp}iN@鷯礽@q(?Mb?TAACCQA&#O@bO6?TAACCbO6?BT?Z?1wVq$n?{y?JuO@Hr餽@S@v?#~j?AACCAi3=P@Ey?AACCAEy?' D`?l'? 3? kI?n:T0R@Bc@qz4XI? rh?ACCAA篽?R@T ?ACCAAT ?Pl?eu͊?H6l1?,/S?P@RI@x? ^)ˠ?CCAAC)aP@TM??CCAACTM??a3Yy?ie?`?9L?[El%QP@1@RM?Q?CAACGH8/P@kI2?GACTA H?Է?Rv?Q@J׼?Q)ٵ'?bhdP@sF@K4(?X9v?AACGAzAY!Q@{1˰?AACGA{1˰?KD8?S#l?XYM?4#H?$UR@ׁs&@\o!+?{Gz?ACGAT3KR@FxF?ACGATFxF?O@gxu?4*/?'jt?kh?O08)yP@)@o>?q?CGATA0,P@E?CGATAE?$?kY?Ϗ9e?#ʍ?;N@I +@%ɄM?UN@?GATATUO@2x?CATCTüCl?OY )?1 'օ?ɦ?d %2?;]O@/@{O9 ?sh|??ATATC3R KO@䪠+Z?ATATC䪠+Z? p?K?uwJ>c?r?ĚT M@vE@<[.w?y&1?TATCCV%M@S ?TATCCS ?'QN=W?2 k`k?*9g?RSJ ?cP@ gS@[ v??ATCCC/1QbO@dɬ-@?ATCCG17Rμ?%<-?utm?gq?n[?OQ@{r@sJv?/n?TCCCAjQ@xPfٷ?TCGCAʧ]=?ı?~8?[c6?V?9US@/!v@n8?0*?CCCAT,>`R@o^*M=?CCCAGt]^o?#ĹPAҭ?+1?^GCo?2?fh2P@{,C|@Pe?d`T?CATAA0-!P@6w;?CATAA6w;? *?bȲ?B>n?*%#?eAB,R@O@j?tF_?ATAATÐ#tQ@f?ATAATf?^h?E K?\.?UՄ`ur?\P@ O@ެ?+?TAATCܪ> ΌO@r:Ӽ?CAATC3\L0?~O?B?H%E?QPJ4?pYM@z6@Av?Q|a2?AATCAPGM@GI.6?AATCAGI.6? $v?@,?+Fms&?SYLq?6Q@Hrɥ@TxL?X9v?ATCAT螆Q@;~܎/?ATCAT;~܎/?[? ;?D͠ `?q ?>tP@u$Х@M?gj+?TCATCNP@EEG?TCATCEEG?7%?~9?O9Y?W!]?"ץM@٬ܥ@YQt:k?kt?CATCTmoMN@dg.?CATCTdg.?C'Z?\z9?m?su,}?JcO@#祽@}6r?Ǻ?ATCTT{zOO@Z ?ATCTTZ ?O?6? r?T?L@Ǻ@ulM%?q?TCTTTI2!K@&Va?TCTTT&Va?i@:s>$6>D?rMS.?~-'iJ@ʡE@r?HPsג?TTTCT/ J@sg8?TTTCTsg8?5!YG=9^pc>H'n@)?H б?jyc&O@~@e?J4?TTCTGe>O@[w?TTCTT,:?#.β?kz?'? ?H"L@I.!@!$7?H?TCTGC .M@Ge¡?TCTTA0Z}?uʷ$!?vp??T?Ɯ++4?O,+GQ@M F%@s-&?b2U0*?TGCTAlQ@Rs=Q?TGCTARs=Q?ޞQp?_?wq?S5?A MP@b2U0*@PQW?HPsג?GCTAT<-P@ԫ(c?GCTATԫ(c?`QQe?LviҬ?.?p'?P1P@1.@mЕ? ?CTATGWs3P@ 1e?CTATC׽? Bv=?ע?3?eս&?ѣM@s2@ Zn?b2U0*?TATGC/M@,fZmC۬?ACTGCLF?7?ȎV?SFYɱ?ZIPB?bSiXP@[B>9@O? o_Ή?TGCTCx5P@;r?TGCTC;r?@?7!"?OU=?Q?~O@I.!=@C@o?ű.n?GCTCCM;N@Qwx?GCTCCQwx?)?1,}?5Y?E(d?u d 6EQ@x#Y@mp?_L?CTCCG3/9y?ÄZ?͛:?.~j?$~P@ea@ˎMJ@ 0*?CGGCG^P@o?CGGCGo?~QM?3ώߗ?ma?%[?6R@]Cm@??ܵ|?GGCGT$~R@Hq?GGCGTHq?ŻAv]?%{?&w95?- ?RiSuO@:v~@ 1@ ?GCGTTY ŢN@U?GAGTT?ʞH?LLއ^?qcB?kEPi?6[:NI@ h@79P?n?CGTTTirH@22J?ATTTTXr~?8P=ulַ=20??]tQH@ q@e%/?/n?GTTTT6P)I@30$?TTTTT Gw?,p(&O=u=>o?&Jv-I@2ı@3?w?TTTTG&_J@vF> ?TTTTGvF> ?&/c=I$=Th>cT?R3J@ -@X?St$?TTTGCl+VK@tt2?TTTGCtt2?2E=G"OS>(`?G? YrM@9m@?pz?cZB>?TTGCAD)=N@'?TTGCA'?}>Rg8|?Qo?L??&R@V@,!p?St$?TGCAGeξR@BV?TGCAGBV?cl?c^?]-4?]É1>3|8 dR@镲@ۆ#э?a+e?GCAGA3R@)K?GCAGA)K?jC ?*?QضpQ?%?RQ@)\µ@x3?gs?CAGAT,VQ@q"-}_?CAGATq"-}_?YgD?/6O?9*?cΘ4?o= GסO@V/@ U@b2U0*?AGATTMB(JP@o?AGATTo?zg|?^>壆?dg?cy? #J@6@r(k?/n?GATTCXOSJ@PF?GATTCPF?RG>jpZJn>xIA^?kY/?>) /m?zl<?O,?JJQ@ZB>Ȧ@9?ׁ?TTCACc]P@>Ys?TTCAC>Ys?}H ?WQY%?>A۸?$0Ư? [P@6ۦ@>?/$?TCACC{LP@R"?CAGCC.6?Fg ? 06?d>O?-Xj?G}Q@[ ᦽ@+,?-C6?CACCA(U3Q@ [ ׳?AGCCA+~>?`?Z8}?l: ?N[??P&Q@~8g䦽@z?S]?n?ACCAC(# 9Q@`RŶ?GCCAC{??9̧?td{?H?E,/Œ?Ug Q@x榽@VIR?<,?CCACA~:,wQ@tʔ?CCACAtʔ?Yy?C??, ??MR@s@R~)&?Q?CACATrѕ+R@q:&+?CACATq:&+?s?^[L9?r,?(?Wm7Q@\@jo?a+e?ACATTɱIQ@\ ?ACATT\ ?u$R?xK?J=J?@Tm?gLK@+e@3]?_L?CATTT,poK@6ݦ?CATTT6ݦ?CR >_|>C_?6?=-6J@7@73?I +?ATTTG̅CJ@RD?ATTTGRD?LMsY>w>~> Kt?e 2?Ir\K@8d @mҨ? rh?TTTGC HfK@p?TTTGCp?rcZH>a4K?Rg?j?Wy?أp=hfR@HP@˒Rn? ^)ː?TGCGGJSVR@F ?TGCGGF ?,?ςo^Q?Ѵ`_?ٰ~ >':O@K@6A? ?CGGCGROP^P@swE?TTGCAvV/ ?AO?x̴?KN=?@}?fXR@H.@a :i^?tF_?GCGAA߂R@9ޮ?TGCAAdٙ?׷uͿ?Rc?62&?TRcls?+y9R@c]+@g!?a+e?CGAAC$IQ@lF?CGAAClF?R#?ebmk?U?ʌ6?K O@X1@mKݿ?Mb?GAACC.VN@C"2¸?GAACCC"2¸?~?C?Tf)?>"`?el)>Q@+eB@OD?&u?ACCCGYpQ@]?ACCCG]? WH?Z${a?Y ?֫E9IɃ?;!͏R@UR'I@uі?&S?CCCGG!ݦR@T p?CCCGGT p?JvGN??B?_>?oK[Q@R@wQM-7[?ZӼ?CCGGG6Q@9?CCGGG9?KR?@8?1˽?晎D?*;lM@sFV@@@H}?CGGGCS4mN@6 m-?CGGGC6 m-?|_ ?LnB?c-?Fqnj?pP@E]@AAOK? o_Ή?GGGCC$vRfP@ŵ?GGGCCŵ?F7?o̦?lqL?jAqq?Z%AdVQ@1w-a@1+?/$?GGCCAQ@]XH?GCCCAo̕ʧ?u g?A9?$E?1d0?sPQ@Ǻf@ H0??GCCACgE<=Q@ y?CACACX#x? ֆ?MD(?Uְؕ?MKNdԅ?KQ@ $(~l@*=o?_vO?CCACG/gQ@66??CCGCC!E?.7e^?:G?^?w??CQ@JFS@H@mS?W2ı?AGAAA*M(^PS@+=?AGAAA+=?Cn-?kth!?3$?x2 7e>q R@_I @ՠ;?Eioɤ?GAAAG5R@kX?GAAAGkX?M\H'?yR\'s?sy?P!SG>ɭ)?xFYi^[?J@@hVX"?46^:k> _v? ?s 3N@%ç@@3?_vO?TTTAA_ FN@?TTTAA? !"m?y8Zl?QI? %w?̕zJQ@JYƧ@p۫g?y&1|?TTAAT7I^Q@DL?TTAATDL?s?p:C;N?Z6?"Ҡ?NB[GO@x $ȧ@I?HP?TAATC3(O@ߤK?TAATCߤK?-B?7AbD?}?3&Y??/ iM@C˧@Ʊ'?<,?AATCG'8M@FJw?AATCGFJw?SPd? ):-v?6I?a!J?]u+Q@}гYէ@Uw@gs?ATCGA9 P@JF?TGCCA guJU?֧<鈻?" ?}~x?Nm'X?o/u=R@*ڧ@8?gj+?TCGAGq,c6CR@`R֖?GCCAGZ'Y?&??ty???(?-ye?2O^R@&槽@>g^? QI?CGAGGd``R@8?CCAGGƼ?:??ePU?кʸ?|OBQ@Hz@xԑQ!?M O?GAGGT8|/wQ@ Q@Q?CAGGTC?FZ?zz[ܩ??ԏOm?a9r(K@N@@cIy̌?gs?AGGTC fM@ ˫?GGTTCzEvf?m*&?c͍װ>e?2T,t?NUI@V@P LSʫ@_>8h>ſuǒe?Ơ9f?ugo͒O@~@-??GTCTG*N@?VT?TTCTGOO|?$D<_?o&*.?^U&?AG?"N@D@0h{?@ǘ?CTGCGyG+ }N@{Sw?TCTGT&8?l}~?,?ώH?a3?\1 R@՚@ @@`Qk?TGCGTGV]R@ ?GGCTT?8w?̀*/?t;? ?B_J@#@NW%@"u?CGTCAP BJ@v&BWi?TGTCAiV?Iy^>ZQ>tcz?R5?ipP@^)@necR@?ʿN&4?VCus?-kuVP@2%$@|{fA?~jt?CAGCT/zLP@% ?CAGCT% ?(Y?xoC?ő"?ss? /Q@}8'@2j?~jt?AGCTT~ Q@_<$?AGCTT_<$?1Q?6?t3Y>J?;z?`9H@StD@ T|@s?mxz,C?CGTTCxvM G@0 N?CTTTCB?f=i!=lۮ6?Xg?Ѵ&I@#G@S2?gj+?GTTCC:IJI@8:?TTTCCCU? †4=?)>`ݡ0?V >H;h?_{ ?𐨢P@C>ٌ@;p'@_Lu?GTCAG9ptXP@H'?GTCAGH'?c?_?p451?KQ?Ѓ Q@3ı.@?UN@?TCAGC{WhRFMQ@ ?TCAGC ?RB/?m2'!?/?*F$^?ՙ>P@Ș@T\ ?5;Nѱ?CAGCAzx;P@/"nw?CAGCA/"nw?W `ð?l-I?q[?2M?R@ h@"'w''?L=U?AGCATkR@]y ?AGCAT]y ?Un:?Jk|?s2?8B2?!~@aQ@ףp=@`$z@A`"?GCATT OQ@i7p?GCATTi7p? cn?^ǡ?eL?δ >qľL@η@&8PM ?{Gzt?CATTAȳL@S?CATTAS?M:N?A[?ĉQC?Xý5?W6 Q@+@H4??TTAGGLdQ@z ?ATCATWĩ?y?x?P*_? jŠ?Vx{pmP@߾@A$-z ?_L?TAGGCXP@rΉ?TAATGm3D?7 $?[?죧{?N0k?^nۜQ@Q@]e@Oё\C?GGCTT]R +Q@^=?GGCTT^=?-++%?| ߝ>?b"?_E>shm- N@HPب@?w,?Mbp?GCTTGr&1M@gae?GCTTGgae?ʇdݭ?su??*k88?x!K@F%uڨ@xE2t?Q?CTTGCWOwG.K@^V݂.?CTTGC^V݂.??\>&KS&?é)ֽ?>?0?&JM@bݨ@Hf?gj+?TTGCC;VM@xȾ\n?TTGCCxȾ\n?$M+X?/ǧ?Z?'`? Q@q= 㨽@#-"?S㥛?TGCCGwXQ@#9?TGCCA0K?Bwcz?^)8?Μ?KV?JR@o꨽@ 9z?-C6z?CCGCG[p_Q@zX>1?IFGXI@e`T@+<^{?0*?CGTTGt|\=I@w.g?CGTTGw.g?ck>?91=ՙ [I?[6n0?; (L@Pk@$Z?ŏ1w-!o?GTTGAu*L@־?GTTGA־?>݇!,WW?dk%?3w?eP@kt@U@eX?TTGAGsH$P@ZL?TTGAGZL?F_2ܫ?#>7D?7)>oP?ngvv?#ER@ho@m3  ?n?TGAGGXHQHR@ŷ&Z?TGAGGŷ&Z? ci??O `?N@(?GB?NqdQ@\ A@(Y|?S!uq?GAGGAQ@ScN?GAGGAScN?߭@x??Pq?#7?IS@僞 @6Ɏ@HP?AGGAGU'S@,?AGGAG,?ˠ?:Oȝ%?3G_X9? Z>#R@( @sϋ?F%u?GGAGCg]R@Of?GGAGCOf?D0'? xjG?&C?{Ֆ?^9"Q@"uq@6m?5;Nѡ?GAGCA܇P@?GAGCA?U5?b3b?nj?)}H tN?&1'R@ Z$@z?Mb?AGCAA>R@?AGCAA?eɤ?b1?q6?i[o]$?TR@gfff&@Qk?Y?_vO?GCAAT>2_R@1DeE?GCAAT1DeE?k1Ղ??3a6ѡ?瓄w?Qg?;OP@]C-@Pp,?{Gz?CAATTL P@d#Kg ?CAATTd#Kg ?|ƣq?,?!G?j ܜ?5K@S'0@ONX&?_vO?AATTTwJ@g:;?AATTTg:;?ul'Ҁ>%mt}b>6?G> ?'}4I@jM3@R()I[?gj+?ATTTCjYH@Dh?#?ATTTCDh?#?"(==.Z_,?pu@(x?̼`K@J9@i`>?-C6z?TTTCA[%K@a[-?TTTCAa[-?1e[>I5_'?7i=[?a9g?R%0XP@c:@p,?(?TTCAGG6P@};?TTCAG};?( h?Y+`?_8?F?j>R@h@@Њ>?~jtx?TCAGTQ@0?TCAGT0?1W5?ٹ?]ç&Q?OyVa?ws:L@sA@ЈW@?a+e?CAGTT0M@y08?CATTG^yY?AU}?r;C*?G#?;_?@ΕbK@d]KH@D}e9>- ܯ{?ZI(?"w#rSN@0'K@Rp? ^)ː?TTGGCuN@ +j?TTGCT@KӖ?t?H?,?؄?X, P@AO@ؽK@c@_vO?TGGCTQ yoP@T&c?TGGCTT&c?Ì?\ ? *? %?q= AQ@R@j?HP?GGCTCڌֲ8aQ@Rf<ܺ?GGCTCRf<ܺ?QCi?zv*?A2w?Zv?%k~O@ F%U@n?+eX?GCTCT0$pO@G4/?GCTCTG4/? S?u?u ۪?{k?]uP@~Z@@?(?CTCTG{BP@RǩѦ?CTCTGRǩѦ?B?5DɅ&?4rմ?I3 ??#P@"u`@wZ?I +?TCTGGd3nO@V?TCTGGV? B???eρtKq?U֮zO@d]Fc@k3Bs?2%䃞?CTGGCGr3'N@ٞg[?CTGGCٞg[?lg ?x ;i?;$tbI?#o~)?"BQ@fj@YԿ @I +?TGGCANP@ޛ 8w?GGGCAĐ?>B2?~ ^!?@o?K>/˪S@Ǻm@0XMn? QI?GGCAA,l9QS@MN?GGCAAMN?9{?rͧ?Q'-?bl>X:IQ@' u@cF˒?{Pk?GCAAAz%R@.0?GCAAA.0?ci$PS?ųD?E,_?2y?,#Q@S{@M-?HPsׂ?CAAAA+Q@pـ⌿?CAAAApـ⌿?N⇇?j(1?GR\#U?0*?crP@~@#ݩ?{?AAAAC@{O{P@9CNI?AAAAC9CNI?mgG?qKJw?O-#\?1??hO@JY@G#? ?AAACTX#P3O@2|?AAGCC9f?|"^?J  ?Pq_? ?hnP@5;@ k!?m4@?AACTASR6P@uꫜ?AACGCl3(?U+?Li?6 OSЧ?@%]"?5Q@6<@eBj3lZ?mxz,C?ACTAG9`Q@C%?ACGCGő!?x.q?Q)?A$?<ӧD?9BPR@ʡE@?8j?H}?CTAGAWx5,R@s:@?CTAGAs:@?/?΃T^?v{?)ZW?!rHQ@ѳY@w-/?Mb?TAGAAV:MZUR@._3??CAGGAE9?>X?m e?4?'C?>7oR@/n@8Mh?ψ ?AGAACDR@#b7W?AGAAC#b7W?E?:,r ?~+! _?[}(?^ tP@䥛@w 6?_L?GAACAO@6)3?GCACC]S ?L?|´3?pfb~q?R՘ ?*uAQ@Ʃ@>?~jt?AACAAӬWQ@4 IJ?AACAA4 IJ? p???KM9?./BR@Eʩ@ S%'Q?~jt?ACAAAk|Q@?ACAAA?D-|?$ԻK ?%4?H1uT?(\5P@o_Ω@fAI?Ǻ?CAAAC{€P@E?CAAACE? &f\?[-?@k3#s?_?Le*O@A`Щ@?<,Ԛ?AAACG]O@*Wd?AAACG*Wd?t-?ZZhV?W;S|?ҸEa?zڗP@3ԩ@%lv,?UN@?AACGT(X:8P@6m-?AACGT6m-?|?2?a e?ft+K@/$橽@.b?+eX?CGTGT 5R=K@ 8+?CGTGT 8+?(;>a >4Hc?V@?TL@;N@n?Mbp?GTGTA{s!M@7b/?GTGTA7b/?0d3>8j{?n&%#?4L?z.bN@s@X?~jt?TGTAA7>yN@Ìe?TGTAAÌe?%F? B?K?{M@x#@0>? ^)ˀ?AAGTThy'M@ENbV}?AAGTTENbV}?6? J`I?/;?ڷ-|{X?:I@L=@idۇ?}гY?AGTTC^lEI@);rWC?AGTTC);rWC?T9>#Sq>t'jo?3?硘K@&u@mE? F%u?GTTCG?I^J@Iq?GTTCGIq?%⏿> ]J߇? \au?f9L?>WP@w@%?gs?TTCGTl OP@n$?TTCGTn$?v _?DK.*?+t?xf&d?)\L@q$@NCt$?`Q{?TCGTC-\ɫL@k 9?TCGTCk 9?{E7?BIIp?،ߕ?聞w8?-oI@|/L&@QVr?"u?CGTCCTI@>ih?CGTCT?EE>+W>&vI^?=%[?u9@i?NSt$?CTTTA(A>J@!?CTTTA!? pC|P>KԖXt>^Az?ps?a8O@#lxzE@:hS?/nr?TTTAGN@`gU?TTTAAΆ+?E?;?V"EcQ@|?5^@ݳQ@镲 ?TCATG.Q@4x=?TCATG4x=?s?).;1.?)?)E6s?ʡMCN@Ao@Er ?L/>9?3a<_?]^J@]C@@-$?"u?TGTCC[I@;?TGTCTU-?GԠW[9>ylE> ;?Hqo~?)%+N@ -@?&S?GTCCG6N@ 6r?CGCAT>6r?Z&TOO?nc?Qn?`>EFr Q@Dذ@_V&?<,Ԛ?GCATGyQ@-}dGZ?GCATC=sU@?'<P?hŘM@6^I̪@&ɷ?Pkw?ATTACSQ=M@1aj?ATTAC1aj?wH4{?\f??:?\~?&yȎUO@ gӪ@YM?ZӼ?TTACC WO@ތ1y?TTACCތ1y?p$?,&?b޴?x]I?W|EP@p= ת@{nf0|?Ǻ?TACCGfvnP@~I!6?TACCApCC?̌??JGGATTPK?tڱtT?4>CL?ݤ [u>HQ@-諾@H ?HP?CGCTTFk$BQ@]&?CACGT)W>?,Dz%?&gZ?2Y4Z&?Ǚ?}K@?@?^K=?GCTTC$},K@(sZˠ?ACGTC!1 ?O\f#?P>at?%3mz?5^I@d@}[q?5;Nё?CTTCG7#K@2gf1?ATTTC$j?Ԟz7>XB >V)қc?5+ﶧ? 6Q@Q@Z,@d? ^)ˠ?TTCGGl-P@;b2?TTCGG;b2?lͳ??TN٣?d ?a?Nԙ?ⲣ`Q@;M @ -?V-?TCGGTZ,HQ@3vu?TCGGT3vu?o̹l?EDcq5?yY?.ߜ?bM@D@l|@H}m?CGGTGNM@x^А+?CGGTA^ᨵ?ɥjnڋ?WW3??5?'J~4?e.zP@?@4&?]m{?GTGGTQO@+\jz!}?GTGGT+\jz!}?[V?N:?,?^րen??"M@<,:@TM9 ?Mb?TGGTC t0L@s~?TGGTCs~?Pp?OOG?~Ma?҄?:IK@u<@v!0?( 0?GGTCT_<`K@jLա?GGTCTjLա? > =?ZΛĶ?OZe?)kN@xI@`#?"u?GTCTTm8U^N@T?GTCTTT?>HR?uP?ݠw?hiP?",JL@ qK@i0?ZӼ?TCTTTfˌK@@$?TCTTT@$?U6a>܀#?!??x ?M(dJ@M OO@8ɫ?_Lu?CTTTA6_>J@:?CTTTA:?D*D>&QZKp>sۼ b?t5&?n M@> ףP@:N?I +?TTTATkM@"٣?TTTAT"٣?- ̿>P# J@y? 7r]?I?ٷsgP@ʡEV@٧)>?"u?TTATAJ\P@ |?TTATA |?C˻C?+jk+?V tƟ?u!ڰ@?ףpDO@_@I_K?Mb?TATAC2{MǃiO@Ay9?TATACAy9?*4 ?cJ?ox?eD[R?D*-P@[ a@`Մ?I +?ATACG邼puP@nB_?ATACA _<&hM?rR?NWJ?aeq?^ғ?Q!]?ϪקO@b4o@sP?&u?GATAGO@1Z?GATAG1Z?q.?@,֒?W!퍞?*y? $P@ǘv@ojZ?@Ǩ?ATAGCXbyP@Gi?ATAGCGi?tZ??kTj?u۳?^k[?saP@ @v*?@Ǩ?TAGCGIP@\?TAGCG\?bg??u>? |?̌o[R@$J{@TЂj?-C6j?AGCGTdYrR@FC?AGCGTFC?Me.?M?vT?Ej?{{{{AN@}a2U@]?`Q{?GCGTC[ ^M@:+?GCGTC:+?Hz?spCo?l€?t4?\H@s@/oؓ?"u?CGTCCEI@DӐ?CGTCCDӐ?(|>a>rtM?:cЌ?FIpP@?@w$.?ݓZ?TCCTTGE=P@?TCCTT?(ua?!/_?y?])&?r9K@V쯫@K|?~jt?CCTTC6"J@$x;?CCTTC$x;?[U?mǿ ?L܊D?*jU ?QKJ@4@r=?eX?CTTCG_8#K@/[?CTTCA'?)y]O!>tَ?Zq?^\?d}P@\쾫@ ð?{?TTCGTJBBP@l!?TTAACVrVT?d?Aa?o \ը?h8 ա?Ԡm O@58Eǫ@*y`@`Qڛ?TCGTG9N@GrR?TCGTGGrR?5??;?Txo?!skF?<,jO@5;Ϋ@ֶ6??GTGGG+bqO@I G{?CAACGx#q?dC߻L?'j'F? #?<ǟE?dkHxQ@3ԫ@fsy?ec]?TGGGA=A&Q@Sr?AACGA>ϳ9?bz?Y.?dkk?ԑ7f?v> S@B`⫽@x{%?"u?GGGAGuҊ*&S@}y?ACGAAaf?p~?Z)?/89?I$;й>+vS@}8竽@<&v\?`Qڛ?GGAGC yP]R@I.K?CGAAGI?E`5Q?W? \;l?> tP@3ı.@!HN8'?~jt?GAGCTt@`_P@wA?GAAGCbH,?ހn?{?p?Uۡ?4>Q@#Q@ @_˹dX?镲?AGCTAyd;0nQ@o~d?AGCTAo~d?ϖhÄ?uJ ?_,?X???#7P@ʡ@j9+?{Pk?GCTATP@鐝?GCTAT鐝?} ԅ?̷L;:?ԁs?}ӥ;?ፔcO@< @ Uc`?mxz,C?CTATCo P@¬>R?CTATC¬>R?‰ۓ?TK ?` ?eE?#+\N@o@/?Mb?TATCA_;Y N@D{%6?TATCAD{%6?N@R?|a ߺ?܃6?PLw?wiD? RMDڦ?}m?6ϛMH@ͪ5@wc@ZӼ?CGTCGI@?CGTCC"" ?S:G';>Ho3=!ge??.kO@v;@ɺ ΁@DJ?GTCGT,kP@$i.٧?GTCGT$i.٧?[?Kܳ?)? x-kmerlevel_mean ?@4 4level_stdv  ?@4 4sd_mean ?@4 4sd_stdv ?@4 4weight% ?@4 4  deflater- uTTREE'B'7'_'- 8scale ?@4 4pD ? 8shift ?@4 46$Ҥ @ 8drift ?@4 4A1;^? @ scale_sd ?@4 4U ip? 8var_sd ?@4 4゠? 8var ?@4 4,%C{P?x^My ٧hc'y|=4;NK}s)m?EhZ0h8i?/]%5T:J?,}yXwx6@zP&I%FR۵wA()@c9 &w<_unJ׮ ?%qDL8 . [}"`M䒕.TTi妨h.suO|jCW!;㵑[0'];4O5=h^|<SH]ܢK 7NՌ|Ps#蝙!A!KDkKCylI;(6okؐ<".J̙ {:m]<5 Z[6 % O)n!`g&8v,[ji6>6 %oN^&/2 cӏטRѮO:dlm9 bUo ;Ix4$ԅV"w:2jbO p> K&̍Yb^Hd9ge{(?JT ẜwF{uCC lÓ><%vhs!zǓQ: <+uvډ?Lv?E6 rO;g_\Wgſh4Sn-צYogG/aSXZMkSDȌckhHjuC$G %Bm`tRF7)$.ל2 :p/>*ڏuǃ>,(Te'0yO;4d!1:75Bxl5WG^#`d- quwpg] cM7 >u˧05!VeGql4Ể隊l/&|f|_#z,z0{ ئOTp YO7@PE&`UiW`Rpu+$0wgS-NC|$qH6P"-^LmJ'`۱6Qs).(icmK5F!\6HaYYlQM_?ncԦ0vcj:yfѯ@wV[Acf4p!6(dҵB4d; o~9nA|Yd$h5ȥ$0Y$2bh%: u.2boV`Wޡ}D5TKuws VaR`O ,3Px}ihua`.FG]!jQBS(tw^8XͿqIăү%,0CRvJ|i(bT/xZ @K\n@(>n fQrao;w\;EJ.biFX;4ߓm-?!2|*QݙQ" ]yZ%KES*j@Jޕ-ֈwkVϖ h]%ix`A-Yy ,)i6P$E ,F: Ǎ_OM[lε5Nt3UToqQqfqez( T;>Fd O7Dt\ACˍ%R5aMJdkkv!!+Orcb>џoE3b^-E6M Ý-<8?o }O  3>}86R~W'W5q.kR&m'AV.!6% UiR qjK~9}Ԭ̢oݱ}ĠP&|9,@F- $c1+z,pk"t-Aa-!=L82F"q Peȅl8OXz㻜ZS@_DB[S>;7zX>rQH ƈxא(- E{… N˪ pi4e.Ѻq)DGcI#p*x0nUm6?WK'`#ymBW{x`oβ26)kvESHחGwDɇRNBL~5 gOɵn?n#H_;8P4`tc|YVIbg0%.X^|_rl0<^nY,Qi{u^Ff/WϾL՞nLz,H!˜ڪ1\XO G%Kp{QGQa1z`2ⵓ e5UD!1NݴYz8T=j)SBMpn 3xVHL`%#$p{_xˇݲ`y}΋LRW{NGoJsk^ά(& >!<i i#4{=>Ðd&adڑ/ f-{AGG8|@V˭nDq#VpKqʲy~t}k|%=~>Wq]"`rC Kc$ l?qwLOlb70W/x wRu]:0-Ns2yۭAV#ur'3Tܮ|{ 6 ll{8'ni\@ęAХ)ɗe L|yA]vX15dkf+_ !(~!y<=o[< O?ۨeag*y*)LE{2Skg9rӾq*zsL_$_R[=k NF4}&Ł£W>inJ.>L4Jϱ:eiݸ@ ͥ\ʄ1bexb~Q/ݱW`pvm.ߝA5a̸!y^yVqR ѻ& ݘ)^1_.SZSWs϶ G~SJ `` <.ܭI S,B 7Px7]|p#H/;=X_x{ʞqd'=_#^KTt5HkE(,:̓A~ snD 0\7Wԯ]H**VX_8 : 0L(*)|׫*り 7IQ$kJUn<:HgA}O17M0+ =|u<Ə_? f%R#1ȜJ67a K$\1L:DWo7C%oA?䃅ܐx6ܽ7(GrwzSa黊~]\sPe],1&Ϥ aV:kL\\sW`7L 8`I1'U-p|޳=ITmSvn$SvWMBZPm6m*7 if_Z%7'0C.oB b ;尘TljNz8L&)>ڷ s." A.竒Y21Lл^~1003a_0ESC@Ԗf&&D1PP7x '\:]1XO^a [񭐎A/F< T[1ih&GtfqL.zp G ,n3B<%?2l<9?; 0:wZ2R ù$M z = ɷ5IqAzck- P~HM -a5s֋LN GEk?2[;5qQk;`nSӣb" ʢQoɮ"r8c9b'\jWU[Dk>5 gX@_*aT|{?-G{jF!Y9J> bhz,3^cȌ.=,H'/@ArS\<Å',_D9܆u| 6_Є #.0Ŷ,ewh=J1Y{8JddV'騺Kt8^[Fԟ Yn0!%iULa,DG6}Z}goa+r% Z[C@ܲtUHs@8J4 re x[#"*eg(T+?q1kNDr'>A%6D0dijKdd_{.3.PQI8ޟBdm$БguBXz@cA¯.~U,9bg*eVN;ZQ+|fgaIYad -4o%W 03?f "2;"訔Ƚ zhHm.H[/  `e$'WGC FW&)7^~ulsuT*qʇ&V>ΆYc~ix1Kl|xpa Ѫ汧^^216S0[GrP:y m7, S=!}v(:$V;=ɋoƙW6|>寕v `pTjePѲc |1 V2!Pyk<{\m:kl\&\Qq6fkŸ3o4?i+Ep)alA*$dfaA)8R,jAi-»+.j|bE0@/"J46nupa?  o֙v\nxJDBNYE ̟eN}h7z)E?KY"SB[6Aga_. :?[,2ݮ5Ϭ&7Zf> .EFW1 g=K$Jѽ͠x]N8 }n^w7%lW32:©}IL3~I*Oeê_wiqLj羌WrɅ&hfnܒ;O H IK;UkB:UN .>|ڏ{F>a\ Ib__#]`Ny繐k&gfD0%JJ6_Ŗ$La˦_$^XMoGI jZ^l=6 ֵ'\ `': C}t߾R z:k}i8L&36ȃjY̷g&V6zMd7АS#؊]]ןO× mYE3Rs~ ŝXeUW%\|~&w-ų!`W!.7uaĶmiT.|v kmy a ):׼$:nuM ]7ʗ >Cg |yCz3lvf\RLyC#\ 2cj iBq1ܼ, ag&h)4y0s S+@ rTL^kxqopf8IC'qf-6$6v'&`rZTD顽\thq1ʅu,jlxg%eut2M>1Ij^q΅3%{X5{qEA3dpmA&}QPAE )bRG*]y:r?4s4焟b4T$'Lp*/w^ ؼ]EdϦ Tϻ˒]m2_ƚ59,Kc\1,kK3T]#!wp~U /\M5^|7)~ۗ(Nʲy\F;^ϘttQ3,]} /n^3xbszyii"sXUl+xcyE#5cY<vX 5m9L"dF(98,̼IOM&w*K>ClJ<)`dICwͳ;Fx D~Ш. NpBH7;ѠPs֭I5mHBBB$3έrhְwenj< s"陣@8r6/\h [Y0 |l/|ws'۹TSx`3luVЗcpv,43$>m`jݗ? uaUmsZM5ڛO3к%ݰEy*>9`[!WE0b8w/p]'`hGhR.m v{E|8lk$Ajb ̀Go3{?e4 ],̸N´=%tt=j]@ pptmA .{fO˜ܦh[V/{b ^HN8X\ F3Rnv1P [W1sXkA*.s$LeG ёg?cL^!?ےd0W b~n:>y7eøO? c?Hc/{V D,RjaK= vVё}XWo+'&cL겋ҵЩ>`G޲Tb*od ξIcnq0ïj֞X=`[m)Jf}{=T*aG]ʧ?Rrvq+p6q%\3DDa\ХԞaز_XQo´0uB=Z!Z5^<ƒk>ݭe#7H|V`=.Ore&|)~O͔d$ cV>dS9@9B@oӬEd40[I8:nYvǔMSհJQݖ^$Ly9`:J \فJ+^JF/@S!k9jZɂ(Foyk hXL3aN{‡~W;@6\_~!4 sq}j 4 {0|x+Ubʆ‘+2A"g::cp_`rg `Pv& SC?~hv·\_ƭdە ]LGUK5Cq|ϙQ!፠O.+MG͛?KM,,fmUKjBdh4bjS\E?ks˛;Jtup}}0QgTg(lbzw2aдA7!. 4exس$ aZǘ9vF0S (wdl&]8&y[8`6хn$]Fb XCJGc1oէ f R:v[Dl$5ݙ^25So_>MGs%~BRE?mv+48$L֑|Vk,| GlRfޢn,*3xG.Fh,&PR8 WJgt62]{\N tЁGlpWM[+pyS`0}D40W5XvgJJ-;Ɔ;[ ^'aTe/{AvnEڍA kupGQM(fm#p+;੺ƪ|ƕX0qhN 2[D ;cEK=b^/Sf6ae#pOl/EE0ǣv.@ޤfnl{L]>6Dݻx:j*jt;HU" S˾~7^>')cCDrV>i\xr)[N*[[pǓOQS޾ǙwM/+P<#C8e9O(9%ʘC _w,m& T63 pSBDKhyV!9upTDuP(MHs'cao-l̝(jtHհ)1|gn<\T]3F{w%*SZRz5̭gn)gzr1z eîS>2[@O4:Ԥ{0Sc} QeuaR =7pܡcXxA?-Y/Uee|=‚NaXi3yP::)Y/xM?*sd"O^PiC._)!S209%CJ$97 \*ʍ5qsƎ1$L5{Ž/X ~6rvqji:L´eɳHqȽ#`qZʃx3" 12͢?ȷ{ػ_V`օ,pxqʔH$?X3kq&pbO#)8n<?;BhuN_'R-'`m@7[MzaP&Gg %FPfȀ?g z\ oE]͠u~Rpyؗ-||-H/,{lƍ!]3@ڣͮL}UJ^@%>ZG/?!:$a}J sk7'TG=ܤwB8#mėW&aLfEo+ c@5cE@R%mX8JGA;Dfj$lŃk Ej1H/d:>"W 4C- ,GF´ otx{/LoAO,5ݺᷮ *0h34av ŲtD4J/hWAG#w„譛2OIwB7O_ kFv̙a̶df#H-J4p۬&zˊ\po6yy B{eH#V&29U|FKY1g3@*G]Տ1ʳ#"HRl\gSm2<7 q1z< SEB7 Ĭ_fs C֯E4 mpa<s 5FeuK"aLcL^i`sͰZrw⥛rW~q)X#AK˦ax<}:^CK63nmu'k ͫnI_Ʈ@ŰNh zKtn0ͦKynkκYv\rWM&al$(F#ОP.pH\k_*@TJԲW2 tL\8S ɳRZd05Ib/ozqAJW}.6V \շ2FcE{Řz#^69 j͂m)${pmO=>zۋ6x=_; w!&(sKhF[Tdc$2fiNkKe ݩ8c"hܪ}~1-}mYq kb׈L* ӊX760v@Q Ѱn[HU!m@=y>[+n2w2Fnkf >ksx?LԚ52вG6<= f_3<%]Y qr iT]5z)mm ?H"_üܞ@;EɊ'r@gTc=ַd<Õ1T*묲'1\4 6*qa8wL4Be{D$շ+ާYH腥D$Bs8Pq(<\ fύL9D chr.1iIP\$kF_=qqz׺FlL#=?EYoB3,GMU/KK6 <:5lA/ p>a BxFfl]D~i\V<_i8O7^]i=ȑRtjEӢhc`nys_=Su$L|)^X j*\(nd -ZW sx(l 70I!z"9{ Dc>.]/x׾  z8HDQȩzSfPK6<y u 8)V$ߺb~( L'^M`ZJ2PIkE.8x\ɡ9&2mkߋ;7?ʉ. d~{/nυ_3ܩײ*I6A:".Dbuy wC~m_p*iU%3hn;xz~<rJ%H$\}<-[bAB?miek(m߫J}g=b*̢eUzeC{!!2.<{I_Lz#]k8 jXF͙t䬰rFc/l#&5YlA ROґL]bLWrNNunϩ;2wHjHTKdHzX{%n2Y"as'/,?Vl - ~>/YZ2·Z[,tӼ?&m .;xWzp }o,*%^U ͢P.E*n" Bi# D~֗3 굷 UIWO ӈYEKDD$<}H}ѹ}Z#8wHX~-сm 99q .Ga ޶7ܕxQD_d7^IR?g5l0a?Z2/%"#ht̲٪c|U>do< ajFw3 Nǂa?dMKDy$ crWћt>4oyX|)j 6%Q!VL۸QQ]spP)C+~Y$=L 'hB@osLLkZsTޘ  ]'{-T/ayA"mf(ݑ 1o oMmDnxy<7W>~\@~gj2/gKlc@ MCp P)ǹyK|rS{P$MODbvzG ] ܊1̾ۍ.TD;X&jJ"DWbfAW[ֵ*@ؽED>2|6VpEב9V{I: R)I0M{ ..P;"[A3mi!al^RSsia>=S5VlίAy:i7v#\\@'h+N|ٰjSymĜ_hV,̚ٸx7viEs;cQʊyυ߹/qc<wJL L/=7 ee. *~aKv% 20YrSKCg y9q6 >}7Hڜۨ;[vٿ<ޡ,w}fc>qRu,e߿"0Ł 2@5$uDT(_7AG7l%ޝ aݝUXHN^4Lx^Ey<-I"RMI6\c0v3c$([eBdZP,T1c"ٳb{w.}sm Jh'ڳ*QF7OM8aeA^3Q0,[":MnƔLpd٣OgPkP'# 2u駿 j1+"ry]ِ浨易 AV|^0c_"F8L&eoۜ8k4Yzfu[xpD\5\?6+əE݀G]債- vߨsǓ;0EXb#aU.:n]Slds aS* Zkju8] GԀ`Lc;8L!ݩq :V̙vV}r^TԀp֫QGjCS}ڍI8olF8U!8tS>}wBcϺؕ{^ѹ'kyGK3B3(-}?CkIlfM Z`e҆Pf~ FpN?rJ =C!~ʷyӲzcT$+Y!|4e?D,sn7L(B6[v'IEq`f{{.]J1&pA;Q~~xCx 2 EUY'&ǯ0Arr>֪Zp="8%lOęAYQf#ks:?1⯕h„>Tk3^==r :.}Iϓ=6J]  b0ݦt$qLTt - ̸[ .sGDR([QHs_=]<0' I.Lٷ_|щ^ף8ʃ=gh4jsiwN ̫ut$(ҁ> X󡦧F 5_ۄ(gKTf%^&m fK_] RdW|x%&!;pIlC`iVۛLt3 K:x̃i坋d[\ (dT4򍠢S3Şnph@.z`H`@D)&/M;hh.wA<,b.>\EG$ϓerOg\v΂J 6`y60W!hF̍(h {GK'`[+eN:f|o]r8bv?,RY0^l͕j),@ fH˖oO,!1Z:V9軽XMU 嵓H6If4xr'/ b64AsmMƪ-+Ї'8̭& k ǵAb:TYyzF7T&$1-׸2ax)1$yi77`?š̿z'YpDyx9f"x0@a+{pe>veJ{Vؕ6D `SD,`)xt6d,w 2û '=Nv1hDj|t*x3( ǡpEN|xۿ0#BuDs%k$fNհ;Ho<=0!gĥʱ\b;4 )EXU%`*:t&0 ԀOYCDdүSQ"GV'=3Y 40T&OSn=ﻢjE W >2#n,VѵG;kbm}=oJNtt-uPvDĴAk{\/P"IC^} {_I 啌&E޵7륌d2S/U^#[O7q'Wi]>&`F M wxU@;&uchG|$$Mm: bqa׎F8)cA "<}&/\x.^iri^vcνf.4g8 bLCGaqACc@r# !`XvQ0Jܒ 4M%aQXoYQ`[+o#%^tãdr`Z{(I's60yx uYf ؿ sYH;i?̈́d <XLhю/} wո :Zʅ0szi:"L/y0怓K;pTɤঢ়hD_Pr|.7PfFL0*v$`+7PkX|6q`>d Y7 rcweYnMê5hg} U`Cm'"dّZӅ<߹ ht~4ϑ w+\}pBRAb/1VJeLj_hXP?ҔA5pUwJ\f|3tԹIH<ҜdAg}Gn`YEj5` i9^=6me G6cᓋy¨Vr)7Da?xs/ vWwBMP9U:|EAYs> UmnPGQkCh(K,XkyG2.V e &`r{ST$ZeYՕ m]#3di&Vq_ 496E;̣ V0c=?T80t`s'OͣqAICcclYDL&xU)dٵ]3 /^sOV e_%l $#Cڎװռ>jv05}EV=L vhA]O[^֌BҼUE \@'J3 +Fj86`O蛷GXBr{1 [l/7͆2]VԂ֧@x9r]#yB.x2#'YUzHWko7柟(Jr̚sK顳~ J?!` }&z ĵ`ŏZC*ՉOٵa)zͅ qNz^[F7Z gZJC$)}'%4֒wmƧb 7-W2Bz QB\8?{91R]%hc0cpѶu_f*L | >% $-sP}ΟԏG45N &`2KASt+H"By5}?7)qǚAx͌~@p.{eLA{| E iHbmc1EFInSwEÍf^lue0΋+LCtOOMWy>>vt_qd>zA6 S/KJdy-Ttf̱X̢@]['q){/"iM<fFKÂLQKS[ q1TM5L&bT3X%Ea0Yٯ~#<^1 ÒSDZR΀o '^t=3ߝ聆=o̦hӈu|솷*:+qK0r1KX;sGzo~م0Ey44SFd'7o=2 2 mS|:POS@s :!,W(1,pɅWMQԽ+̓O^qsm!Kkw&2.+lZ)~A>,d9zͲBn #`J~yS4Ov27AkA׮3޴h{|X[wޥ10A+NkaBe18L&;ZDCq xf\t5f}.t* ~lPi(mh:i(?>6e: ֘%F#IC{+fy$-igaYO~0=[DCymy#A{_>߶ ǎUsT~0߀} :~bl_ɕ!]߇zVweZujs!Ȃo '\5e>BmS#ZCƓ=<[xzm&/czt!S9(O:٩?t)'!v Y_Й53z͇٪푓Pk"}pcfATrx.HúcjMIoRmW41ۃ+F n膁<oSWudSW3eZ&h0dzFzy%nоKqs[tmO90p _yI*}ihSx x|/ 3-tu0*n? |>==$=!Ta৭;o0K>?2O9e"ZҦ৛&`t~`M{TJ 3vAIBwPhu8K=EF Ml?AaO_.!sҲwOŽŘ6‰|tNz@xHnMNo ^m{9J_hDz: !;EqYb!V7!`JVT(zTAT'8:]K:3q}~s4T{<:DIQ#x.2M ZFi6աi75]U{gYe\RL@-]֛ܔ򧭸cYH̜Y*On-gùuơ+3~\^jQ|2kϪ z7CMmX#mT0N|!1{\m>-vbx&oa{ư K] zQidbv?jr)iԃn{0Mr-5@\LoX~4CN{gNVܜ`Y[G1ZЫt\ZcRTLJe#ˎunE0 ^141`ȷ,Wf;6 5}/^u>2=WS&|(l[/!) ~rxйqҼ9Kx"k fU5ɳvb#ϕ.sS9beTwUc faZ ƌ~7vc١@%sP1k?}j՚-)| ;Y 9[6 " %>W%}dgA;PM? =>3)0[cTZ J\xƸ]x\x1YJd_RK[oVρS*rLv?hBS,n-u&c|FF!u%n@4¯sK3Nwc;G OC]tYf|ɤ{9fn|̃g4]︠GfIq=|U &hA؁k4ɩRJۘO5x 3)B=޿_MEd3 .qZƅUA@f\g& *⎏VU)T=]Wjρs;x`{#9gxq߿u$` "ؚAiVz'GnkuIF0`ine=GKns1t v/tGWq% e(KK@bQͷE!Ԯ>LJyr?*HpN}X)4'>j&$f`ya=u)Nu;P=뼝*0$1_(tA?qKaz \쭅7;aqdx1|MiwgpApM<ҎW0Kl.ͅb+û=Vftm5F׮UzwNy%eǠ0{Ŧu5@Vs+ɗSQlܘPU.L.:m_X?-;5A`ρSfƦcp; 3>Uj:)3."+IH.)~4PR}5?6>|HԒ 7 KHQy^7Z6&>pG&o{tx}Y??[^G>Rs.@v7^đ6Fj#FAO7~..TdAŇƻH&ơ!X3\oU{4+xS~ TVpF8(-ժV޴EOjWO^kMZ9#^sNmxSw3[%Az8,4 7萮gvU, ;p 'bcHAR-?+O4~X3ߎvCs0UQHͫ h+[Bj\w'gyw їMϋCl>TOHQGxog^cqj{/A%,upAwaa8Hn@k`S 7j 2T&!}x(&`6aϤ=@?_<8 /5w P T{3Ua*V:eە.CcndBmfA)ޡr+y!}r*)\::,9OӨаn6KZ;5;ЕB< !)`ڒ-]*6 e݋<9h;̈́#g1ȵ{n^Eo3XqxS &@b rO<:t žk@.m=~ǵ8G;zFf}^59p@_U #7(hLx^-y* cñ\"AqӔvP0S(84$%Rj`1|1mp䚩džxu? Hb`5іD+~]$y0Ɓ}+Y5#@-\3v}Torr&dbW@uTD%^@.eu 7W“_ fꟂrv_r*R(>[ޘv3՜ =a`*lm;C;]rg3UAc4!ltvAA Q*2їsCO*C u<i~XB cKsӹy3_cy.JQE*/5J !LBzŋ#ÿ/ږIܞT#aU[3HhuhݢUwK !U`s>.'alXѴx%;fF@aGupɫ-8L*$9K臙|6}ZLT=1ϩQL5rAN/Kr;R+ປA:*Ė+mm 0nf>WPˆ-w&CR0O,9K<΅X~"^7 #Ah7e ZU$ cQuLtxUͳZ$&{p%%Ŧ- t+ Dx.ߞ[D%n$Lx[1Cza%yI*fezVͥ*F' E}JUv9"W G!!`RbhB(3:K8 D~Q#a%ژ{DBضlRp*ჳhHl|΁t/ ݠQ 7u0PX_v͔)Yඃ$Li7D^_MU0ڔI)B/vKޥVϙ41UB5TṬ_szJUiRțty|Q ڼ+~ćxN|2Th6>,NQ^l8z4 $o #a}ۆ ftWAy&ᓾgԪcSFN"q4*6Nd hAR}8ɉE{ ॄSWL*^{?{"d6!xֺ#?С= SgSw cc;`(-#*_] O8PCO=T`"=f >Z[gʖ@Ylx틎$-tf{b]pd<}6L| Ɂ*QLmBKWQ)e\ !3_V 4ꉮ=ES®#@S#P)b|qbKNJ7C3%aڪ9()[DžU WωCkQZ$%MJ@uvD@: _tN#$ln a\_d\@ftC.lxaN% ϕCQtԺap^Aՠq a}1|I3㹂xѳAOu4 ƥcd\q 7ӫ`,^SLE=)c~Z.>,2(T1'`*Hb EU4Ӵ N>r7' ڒ3%JFKQ4G;W?Mnj>[yHm@9Ftv#]_O&SCV,8vM3gz .lìb`1RL\=\HGvOWWky5w-6^{0cI!;{h}|~7Vǿ{2-TK*hn=ոꍨ? 7TeI# F<j,Ͷ٢sxJ 6LܽC )2C*7&: ConZ{倵OF*0Jd rZ\,xHM}heK̐Vȝ^`?`! +ZT:5GdaBeZz)*Zӝ9Ng@&:0)& /(6Cm\ ܿ%UoWIZG9UPNX6^[UA*hCk< ӖU[1Q4ns*6Uq#ŕH[Ntng"=chG<7qbT]fVaa5R!uL4զy0'@,u ]PBT/g?bF_gm<8X fj4A´ '篊shWAXs?x3-+nKǒ0Fo$0V)_~}9wuxvd٨$ 45l @x5hD3TBHfOYKRǹؼN>jĘâ?6SmU2 cϦEkL$`|jőKqZDZDYD FY#}LK^A]d:^ɁXQgc8 Sկ=K[KWl A?kgh[}I´t Wg5C~SYI&ɨð L?ECsAyF> iM5;6|"6H7-Y͖/eT?ȏ;o>80p|/)X2`Շv}pylQpѩuN$ ~ ;!dTNt @WR}J Mj* cG !KDf נK*m1/%K3d&Hk.cj‡]X!f8ɬq %aaZR&Y81GwC({ҦW…Of0ND:!o xJѿe(DzϸӺ:3ך6+&DŽ07AEذZ^{zi?(5Dfg~%Α4#Yl6qYm?`k{AXP),σibE<+I}0gjKog 4䬆b9]I$I>Ie:M=YfWZ>X Gg/%O2&?WT*0QHʿ8S@ʡA=c}I,/fA)%i𒒳ug?vÕQ1;_wf]K}IBo%e0qܸ.%ڪx0dLl¥ :sk x2"D܏ `y&g3&*$Lb(vvA`C0wWLJٕP0N4fw\HdfO]ؿ |dqf.E$ !{n]Wm),/q-@+`IZNg1][[_…%z$@7H!gQSlRA!24X C&Kche-tnkMOlh΍|Ve+|L;k MIIdn&yo?z/>_DL4;ώQ˸}@,bj) :-+ߓ1MƽƷȫ7Mn}|iL[fʏg˵/:Δ `xi &zj=6&ϒ *}~ }|'߬ts"Qu_\In8wϽXv{!`ϛIKNjI41rU@uH+vlkV_DeU3}b|sٳb%wׁ,g:qy̻a>ir$]:FۜYښRSIZuA>,c|bG`!)$u:2iW+( E!qQ R`zz59 7bYuFxc:۹c@h 뷌OR)}mtl] $I"Vؠ$H2[~dwӑ:q[d˃?t25vm+0MuY yq;A~ü%?PKIÏ+%8, K7D+:Ƈ7`}G!L<׿%rz!)7] ñ1aj^}P,8G0mi lG4 ӞuylRn}߆{E#pi:K[p< c֪5:9[x+ae `Hc>]z ,ڱ!-޴|8-7[ßF5P#aE:^ul1 1H5 \xqo, ~z mo/;&ՒsGhRk4:2s-~1hH"ÍiGs,);c|-x.|$;e9*gS|K`^.-؟CS1"6pi%Rz_c?1 ^;)n[od{w/7h@ȇpOYȴ &L(w&25< ._pa)P"q\$RO&Xkm/!HkFk3שVm(]uJc %ggiz}0fxKGqArxwLqފwJ'n0-OKk0 =-g傺:BB1p]K$J}sabQy m FeNh7C(ܶ͸)/0VU+_1NpO;Gj 4=Z mSn mU%1Q-q;&5?Bυ;*2Թ{5p7o'a̸X˓DYucyvǮa)E-K!+cM"xvepJIo/Rl!$n>!7uI! P gw\ BE[dG,Z<k-¤!GLߜa$Ej{}aEy8ûƸ>QdV7~c5RlƷ7e2`G(4ήg j_]_}Bd7v1̚&=<zF{/a!?w[@Vx)]86w,)# b!gC)e9$02HӨP6׬NE041H,خD]q)rx+iG}pggae {HbH ɘ3Zyo$!ǃ S .lu8 ~]j2ϫ{Q( c~J|H7QmDe^7y^}٨A}S(zG`)*O;tUU;7Ir57A) 2:eGgMMЙB*d Ӟl'k]t!sj{mڼ$)뼎2GS5rH냞q舞b3T5n|10Q4qSzWD!w_P).\q`&†sqb7p<.# 5PV=>:bZI<tiC3NG0@WsZ\XtrXB%L}ρW͛HvE9K$Sj:At: ۶/uޏtlݠ#t;zj6z?wV ؃|l, &s-K90qD Y0(}nPrC "vWEs 1GntQveDZ".ksϮ;yPz.i/7C!x=Jk}'ZTŞݠQ7\DLֵ:?;U].ާëP2h,kϖm2C?b}|OYSk[r}k<6E޿>v9ʗ~ ._gB: MBM>Jׯ s:>k2F 92|MzI'T@1??Ktn~1ҕ!kjIr ၔrk\/'u˜\Yaɣ^X,'~dy\P_)~%=u{T ЍToO|] ZV|!л0Dj/U઴ל91)9Cn +{'2cNTʕȁ~ `8 fd6i)lm HJUGGD2WCSWQ-(OM)Z@އyEu_;n_ΔH[ehUP !ف%J$^D0pLIb/ǖ39pu~*B׎Ɲ"a._>3V)fw嵍ma^|x S-HOc&2ЅS wy?WeV=x)-W acv&j{|Ū#+ ([W<*ZWhu9ن-*ŪA$Lݿw퇪(:*c;;w,}/}HFZ3{^8 ՟K'=xʑ u3y}nW FJdkǁނ+}7pFͳ@^s)pETqRE~?׽eW(TRQ͇'j~<7SG70L"ʖC<4!TTJE"1ҦI 4I7B_UlJ1wgXOq07{٦xSWzvux8#(=:j~ 3vCr lu5UC´I#Nӑz{% x. W(z^C|ox@uTsةt$)U$9d v<"bu5)tZX,@_AQPV@#p ܷ2 S8x1t=MaRJ!')\Ӭ.wn+|AMBx3:Zٳj DzFa!ӬUdCmy%w|A6b@j(5JtKP,J"׌QfjuYM2UCRѤ ~#jJTCTVuYtTr?lyfȹ$t+ɴ—tDfu/S;&}b5b}0L 6QC n1Z`̘Pi?iBpVsI)_™37B $L]R%1ɯ>N* j2|8tE/$^G ^5 tN6$x.i30gs,\s8A?T'eQ|j9`0 {ܒ[U%D /DGRm۝oC⎱D\Rõigr@0G.]aua-K]\SXrE <;Y '/&pD@Q]-=wwFr Dcj}B(jYUf7IFyM:H.||jJvyVo}[ZE5HM9whCAL. 5e֤Q=qDߚt:=1xϜ)+Rǫ`ą-$p)[]JGz>Eix#V1畀\U0 7D<.Z`f{5޿fANb]0 S_H`}_º p:5gXR[e>o z:1wBĆH$M 6fK9s7s#VO Op :ELJ?ىf>z~t*,iGS%5tvg%VK3d9(w:;u戎h!%;3.|,c-'0p_9 1Z+rCHٴCS3}][ àIl6rS̊rJ!`*"䯤)$Uִg`f.Wх4v SUB▚ rnl<|0׉?<`CY3W&( W Sm!2 RroP@E|A*)1OS E{<'e1B45<Ћb͟=X9djٲsܰa;x\&*WX=#&({-mooMlu۴OC. D Dic\k3C .}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~ȓ?Y Q8?ͣ?Zd;EI@KY8@K @~jtx?TGTCC)/I@X?TGTCCX?@E—>zRT?"W^?fCW?nL@@85c@y&1?GTCCAkRGHM@H ?GTCCAH ?aXv?cSt&?}?;&b?t@MP@\@69X?ׁsF?TCCAG8-\Q@E#|gt?TCCAGE#|gt?{fj? 8?'lx?[ m?W6NS@ґ\#@O;բ?j+?CCAGT˂=S@# ?CCAGT# ?p%FŨ?VZ/$?,ݸ?fL[>2H)I9Q@W2@IDW@H?CAGTT WSQ@ÑQ?CAGTTÑQ??W?QG^?)?uC9?AK@c:@*?ŏ1w-!?AGTTGs K@UF-O?AGTTGUF-O?GL>6`,?lͥh?r_K?&O8,K@W}B@&}>p?z6>W[?GTTGAK@|G?GTTGA|G?%q>buL8Z Z?AjG?@C\$?C6$M@T@;? ^)ˀ?TTGAGF N@j@%A?TTGAGj@%A?MvF?Dm2?RRh? h? slS@j+V@ݲy'@`Qڛ?TGAGA7qhS@Q^?TGAAG?׌§?p;3::?OOI?k!Z>v)8MS@I.!]@:Ae?Eioɤ?GAGAG63rR@+J?GAGAG+J?[ }?u雲??r<>Os S@&†g@ Z?Q|a2?AGAGCP9xS@ ?AGAGC ?Y?)}<?@G?/4*0?:Q@#|@OC*?~jtx?AGCCA&Q@=&t?AGCCG:?{Mp?Li ?/H!?+H?=BR@dZB~@vI|?gs?GCCAGdR@ӆ?GCCAGӆ?+$1?f/2?:#FnR@%䃯@hQ U=?<,Ԛ?CAGAA1R@= ^m?AGGAA>A?T%߹?Ͳic?{R?Tx6>e+U@sג@ }{@0*?AGAAGպ*bk&T@(?GGAAC^ssy?ϖ?#sw?mPb?O=oR@I}@2%@Mbp?GAAGC!TRR@/SPK?GAAGC/SPK?]z)c?dDy?&{?QD?\HxO?AGCGAu>O?#Fi`? a*?]Ӡ?o 6`u?*\-R@H@͖phS!?M O?AGCGA^SR@K?GCCAGvx?Ж[? (x?b\k|?'?EnS@-C뢯@J#?/n?GCGAC~B7 S@$=t?GCGAC$=t?k@?8v?I*wY?f{IP@D𴯽@;?ׁsF?CGACGL&}Q@QB?CGACGQB?K{C:?Yv ?`:?4{vjճ?7TacQ@@xR??GACGG:H?Q@gz,?GACGGgz,?|rσ?\0s??&b?p^M'Q@oů@ώY9k?H}?ACGGC.OR@m?ACGGGD?\y ?*?ܠk?>. X?ujP@!Ac̯@r*9 @Mb?CGGCA}>oO@K?CGGCAK?_1nk? Z?^GN?o%9g~?5GR@:pί@\BN?HP?GGCAA: e%S@DإJK?GGCAADإJK?c*?+z{?dcׄY?Ԍ M0?Y鐕R@Cl篽@f$@F%u?GCAATdzR@t3 ?GCAATt3 ?E-+?Ls8?@%I?» ?Ly?]!.[Q@僞꯽@?"u?CAATA[vQ@.+g?CAATA.+g?Q|18? ?͵+$?+-Nʯ? >2N@@HRVR?St$?AATAA"̪EO@h?AATACx?hO?&i)^?"P?%',@?I$P@@k| E?Ǻ?ATAAGڜ!>Q@Vٴ?ATACA#a*?N ?vak?ˆҚ?9? ,R@Y@~I?46t,?ܛa?P@5;.@>?ZӼ?TACATX"IQ@*`?ACTAA:p?5u?>5%?^ALQ?.ކڼM?WOGR@jt3@ ?X9v?ACATGgSWR@N# ?CTAATl:S@{C?TGAAA{C?~+?z ]?: >?ss>YhMS@@5^I@?q?GAAAT^7`ڪR@dմ?GAAATdմ? Ew?l ??ξ?w V*[?WEzx"Q@ǺM@|? 0*?AAATA$˺ 7Q@ rE?AAATA rE?$,s?M^?ģȵh]?oS?A QN@AaS@tZ?X?AATAAlEO@)3?AATAA)3?Ew#}?1,Y?$?Xk0?0hsQ@b@4{?H}}?ATAAGL?Q@Ez?ATAAGEz?q&O?EHG?aݲAƾ?F^?<|R@T㥛d@"M?fj+?TAAGTR@uue?TAAGTuue?-7??ůV"?D)0:K?=wE?/P@*z@ ]@M O?AAGTC6P@FC?CGGTCFb{?~f?klnG?~?XO+x?v)Z@L@@o[@ ^)ˠ?AGTCAƻ:_J@Aآtֲ?CTGCT)*l~?& ?4H?=|?b'?mllloR@=yX@P@ꕲ @I6UB?$ۧ?AGCCC+NQ@?AGCCC?2QJ? ]1?h7S@<@:A?a+e?CCCAGhR@IĺR@9gDi@CG?NSt$?CCAGAES@~e/f]?CCAGA~e/f]?8Dw?&r?RX?3w5,? !nS@|a2@-h"??߾?CCAGA5K+ES@A?CCAGAA?*?˿fKa?P?9>Q@46@'y ?J4?CAGAC[NޢmQ@}Ca?CAGAC}Ca?0 2S?\l?'1~1?+5Ey?ud9R@Oё\@}S1?Mb?AGACG@ܵyQ@%0?AGACG%0?%?Fh?ЊgGA?NOm;?pQ@h@fB? F%u?GACGG?Q@W޹E?GACGGW޹E?։$?н)+?|Mĵ?WB?R@xư@wh?L7A`?ACGGGGGs/3R@!ݑ?ACGGG!ݑ?]@?S ͓?3?H?u8DTV>VLZEP@(\ϰ@4@/n?CGGGC>P@[?CATGCq?wir }S?p,wZ?wdA?V?]:>P@uѰ@}mI@I +?GGGCAMMyP@>7n?TGCGA˚Ri}?0'4һn?;u?$FM{7?})?C^˜R@z6>װ@i@q?GGCAC;S@Ɵ:f[?GGCACƟ:f[?5B?R?R2<:?3fM?S@L=۰@; @~jt?GGCAC {? ?E㻄?6C7ľP@H@!IJ@5;Nѡ?TTATT|P@9;?TTATT9;?ӡ? _K ϣ?9*>p^?ۈ?%򾋩J@@]Uv?`Qڋ?ATTTGRaFI@1"J?ATTTG1"J?J#>anbб?x|Y>wȽ?ȪK@9# @XT+>v?HPsr?TTTGGHBUK@W?TTTGGW?SZSp>찴QH?=ctVP?暥 ? M@|P @Z#F?sF?TTGGA]w>N@j?TTGGAj?9#)?;FDfRm?F!?el?V?G`R@ÆW*@p6!?-C6?TGGAA*82#Q@$6?TGGAA$6?B?fi?0`F6?Y,p?L@aV@bw!v@UN@?AATCC2?, KL@.h?AATCC.h?Ёy?|Mm? @?l8`?O4O@k Y@U?(?ATCCTnN@7Ŋ ?ATCCT7Ŋ ?Ӿv ?\z?.8?oIJW?p]IwQ@%^@z?l?TCCTCqdQ@LJc ?TCCTCLJc ?DUp?!LǨ?c?r4?ī P@#g@.˷#? Zd;?CCTCT`MP@<Џ9?CCTCCa?!?ȹxTJ?S,foK?^}?gffJRP@Pkw@{`=Q?Mb?CTCTCAZnP@6u?CCTCCwU?}v$?~?$BT?#t?Š_;P@ y@qGh?( ?TCTCGq["O@Ks?TCTCGKs?01~?NmV;?^@Ok?I?H݊P@8d@`H-? ^)ˀ?CTCGA00vBQ@}^i9?CTCGA}^i9?N&?I.hF?ȬX?TQ?CpQ@ $(~@f5@HPsג?CTCGAKBQ@s0?CTCGAs0?i&?, ?^? .? @MR@K4@\?n?TCGAAr[ܟXR@p?TCGAAp?  ^l?T2u?a)lx?A *?nJS@ˡE@mZ??CGAACdRS@+s;?CGAAC+s;?t#;??GJ?@4\}>K'P@mV}@U1;W?"u?AACTT5lƸ]P@$]7?AACTT$]7?+M|?&w8N ?3ػ?݋p?݀~ N@,e☱@W乒?:v?ACTTAg%=~O@[-]AO?ACTTA[-]AO?Z[6krL?ۚ$?N?/YՀ$?J-?.@o?AtN͓J@\ A㱽@^s'?`Qڛ?TGTTGDJ@P?TGTTGP?c=4KM?)]V:^?}Mu?dJ@f걽@S:?Bi?TGTTG!GDJ@bfN?TGTTGbfN?3Zx>C@pi`PZ?J!?:ށȕ?rbBxI@2@R? ?GTTGApiBK@e?GTTGAe?v5<(%ZM?Ĩx-2j?݄̾?nQâRM@@G?_vO?TTGACAM@7MǏ5?TTGAC7MǏ5?7Ó?BFP?ٜ? >?ͶX?4°?X)P@ǘ@u.&? 0*?GACCT+]P@\L~{?GCTACemgY?. S? =`?kT?tN?Cn Q@@~r?kt?ACCTAـAQ@S?CTACTZ?˱W=?{ʚ?KF?d6L@ףp=*@.Y|?Ǻ?ATGCTwEL@si?ATGCTsi?BxC>'75?Ga?Mj{|T?CY9R@uq-@){@{Gzt?TGCTGxcQ@D'?TGCTGD'?4m?Su_?:bh?6FQ@B@o?L=U?GCGCAv]%Q@jǏ?GCGCGJk?G?%Zݳ?!S(?w4w?m%S5S@gJ@&m@ŏ1w-!?CGCAGvA7S@(j?CGCAG(j?3@?@?Dġy?gIs7>RAS@ON@#dD@q?GCAGT2q cS@V@?GCAGTV@?%lߙ?ta?Ӊ i?nW> Q@ȘP@YJ @-C6j?CAGTT%HSQ@M%`?ݫ?nz?kדhJ@S@A?_vO?GTTTC 8H@)m?GTTTC)m?}T7A0>l{Hk?I X?WG?iI@G_@+(!?HP?TTTCCH@)?TTTCC)?j0= cx?{ NYD?4g?'9L@J&b@x?St$?TTCCC M@/p6?TTCCC/p6?\H?殨w?P$FY?g %9?p=CP@gffff@Ipf.d?b2U0*?TCCCCL Q@lh;'?TCCCClh;'??H???, ?/=62R@|Pk@B4#?+e?CCCCG#3?R@[o?CCCCG[o?zJ?80?m-^?P=?2LR@w@+V ?Mb?CCCGC\R@ l8?CCCGC l8?2? $? ?|3>y5R@Q{@"&$?H}?CCGCTCQ@lbe}?HP?TAATGQ@[?:B?TAATG[?:B?_s?z?^zh?y?q}M@/n@P@q?AATGGެelN@m5B??AATGGm5B??geT?)9=\R?YS?\W@#?<N@ґ\@dS?~jt?ATGGAkmO@J.QOu?ATGGAJ.QOu?(R:gq?iD?D׶? ?$IQ@_)@n/?UN@?TGGAGPgͱQ@``?TGGAAjP@Y5ͻ@\?"u?GAGTAͿ>Q@ ?GAGTA ?9? V?K2?8 Hw?(FL@m4@[O/6%??AGTAAVM@8>ب?AGTAA8>ب?* ft1?Iy&8?4|gԨ?_mP? m1Q@_L̲@Ú\?+eX?GTAAC\P@c?GTAACc?&q? =?Ͻɠ? LT?9AP@Ѳ@UP?Q?TAACGMmF鉉P@;JV?TAACC}z?D?`i?>] F?M?Q*P@ٲ@.{T2?vq -?AACGC*P@PH䒹?AACCArdQ?ueǍ6? ־?a[=?S­?Q@ݲ@[~yI?z6>W[?ACGCTvQ@6ι?ACGCT6ι?!'?HLA<}?ȡx?Ј?-|r?[k?zU?> k%e?F"T>P@yz,@\hг?~jt?TAACT|{P@l:V?CAACTJ?|:,VH?ֲ?z?m?@qP@a@˄WN?b2U0*?AACTC4MFP@Z`cy?CAACTӵyW?9S?Ϋ۔?Wi p?Ͻi|?p "aLP@+@&Yq@? ?AACTCMFP@޽?AACTC޽?o`?]H? j??& P@^K@"gj!?J4?ACTCAyeO@*gy3?AACTAmةT?]?t9w?߷H~?Xm@?;n!}{P@H.@r?`Qڋ?CTCAA8I^Q@QH˶?-Z?a7O@)@kQ?&u?AACCGZW}O@Ю?AACCGЮ?+99?2]z.?Nj0?P_V?K:>=2R@0*8@p?_L?ACCGA1-Q@S ?ACCGAS ?gdg?VV/X'?p ϐ?TH ?w"6S@H}=@U|J?L7A`?CCGATF%_BS@~q?CCGAT~q?ў ?9\z?7cQ?9$~>Q@EioE@P[?~jt?CGATAaaR@^ag5?CGATA^ag5?X ??\>O ?P:@Y??WnN@僞J@lOFԣ?|гY?GATAGV0`O@)-~?GATAG)-~?q}1?ӢqZ_?Yqa?n?HQQ@aTR'`@>p!!b?"u?ATAGA6Q@/07?ATAGA/07?8+??!d]??f,Ma?@fKR@]h@w$?46^I׫A?rM mt?`;?r5PJ@_vO~@9 ? q?ATTTAavI@uh?ATTTAuh?8 7>)Z3?}WRef?(lX?YM|C?it"Q@I @y?*Dذ?ATAGGGBQ@a΀A?ATAGGa΀A?L?~c?3yQ?}9h?yLQ@Qڻ@?48EG?TAGGA IQ@(?TAGGA(?B{z{?!P]? A?`?1?jU@R!γ@uaj@Ǻ?GGAAAe9U@٧?GGAAA٧?Kp?WľY~?ձⱡ?L{=TXU@u$г@l@ ^)ˠ?GGAAAh-9U@?"?YJhf>#ڰQ@S۳@OF?F%u?AAAGC gQ@!?AAAGC!?S)ޡ?q[g?c?ht4' ?w-!WP@3U0*鳽@D^vE?{Gz?AAGCA{MP@AJ?AAGCAAJ?\?a-I?t+f??U9R@ g@1FAd?Ǻ?AGCAGR@GĴw?AGCAGGĴw?H/?w3)?ռ?>m~G?eiIS@ű.n@%;N? ^)ː?GCAGAeOYS@P&?GCAGAP&?$K_?:m$}?#ΐ?.GW~}-?nn߲Q@l @&y@_vO~?CAGATvz}Q@8?CAGAT8?HstO?@dT?f|?bƣڐ?~j|#gR@jo @vR?Mb?AGATT  S@Ή?ACATTy3cW??y?݊uS?J/5 ?v♸=N?(\ uN@): @E$ ?Ǻ?GATTT?8M@Hg?CATTTݺ?Gy?1xU?Oz){?B_?ẞI@:p@b˓?y&1?ATTTA|I@m?ATTTAm?9=Hc>xT݉>6W`?YTL@?@'ԭh?ˡE?TTTAC'%8K@IJd4?TTTACIJd4?v7/N>aJ?hsZ?xBݬ?yLN@58E'@znY?Af?TTACCW%pVO@g>?TTACCg>?ǟ]?DR:l?˛gF?Q?"3jP@.1@F~=??H?TACCCUd%P@8Q?TACCC8Q?c.?1 ?n֓?!\}?M}Q@5@B@Y?1*D?ACCCCx$Q@<ͫ<4?GACAA^t?qêЩ?㔡2?H}j?B=?,ʢLR@ cN@}>3?q?CCCCGG5\R@&?CCCCG&?|pa? ?fGW?~k?/R@|aR@}?q?CCCGC<ӲR@@?CCCGC@?O^"?]?zȫ?=x'?7ЭQ@d`T@)8-QR@]Kg@ 5?"u?GCACA<|MfQ@uc?GAAAACj?YOJ ? ^?G? /\W?1 Q@K{/l@Ԟ+t?"u?CACAT\>OR@Ow ?GACATl??tE}? ?"?{>o?v? MR@ cn@mx x?"u?ACATGGsWR@)lw?ACATG)lw??4?Ҙ~?9>J?VxP@Șp@?3U0*?CATGGguQP@fB?AAATG>?!C?D x[?Jli?r?eIN@-x@G?0*?ATGGCtO@k?ATGGCk?Uѕ2o? ~?t>[>׉?T*???>O@-Ԛ}@ CbGl?_L?TGGCGxO@tp|?TGGCGtp|??jgZE?hR?kL?4R@-@`K@^K=?GGCGA1S@V f?GGCGAV f?}8U?>̂??g/>4R@c]@V0 q!@{Pk?GCGAG?@S@u*?GCGAGu*?q]?3dU2q?׍,]?J*q ?VlS@.@M t?Mb?CGAGTk, S@W?CGAGTW?Cot?:hr^???Ƒ=><gR@J@R*@UN@?GAGTTd>KVQ@wJZJ?GAGTTwJZJ?F }kZ?;Q"?yRIO4?Z 1?T:ϻ?csK@aTR'@z@46t_?c"b?Z5`=?`B۔K@|P@&P?Mb?GTTAT٢aK@=',yXմ@Vc:?Q?ATGTTVlN@zT?ATGTTzT?;T/H>{f?vꀢ?0o?AbH@bٴ@~N?HP?TGTTCiVI@cʻM ?TGTTCcʻM ?XWX`=ӯSJD!>.T>pV?(H@vߴ@7qbB?ǘ?GTTCC6vqH@XRiQ?GTTCCXRiQ?p< =5j>>7f?S]H@ 贽@Q/?X9v?GTTCC% qH@π `?GTTCCπ `?7S9= A؛P=?iB*>, ?&w4M@FGrﴽ@SNB0?y&1?TTCCC%7M@Y?TTCCCY?/-F?׊3?/ަ0?XI0H?;EQ@_vO@nT?0L F%?TCCCG*|QQ@(s?TCCCG(s?l{?1i?`.F? ?WR@jt@\W @? o_Ω?CCCGT_RXR@ן?CCCGTן?`ܪ?Ig?H?=G>;?`G4R@7[ @8?Q?CCGTA_ R@MX?CCGTAMX?B)sX?z}c?Nj#?w\?~vRL@W2$@"_}@I +?CGTAT=@ K@i9vKic?CGTATi9vKic?7!ߢ>t CJV??&?b90?QPP@+)@YN@ZӼ?GTATT^\-|P@0+?GTATT0+?6ep?Vo3+?'3L?yQuP?I M@ q,@?I +?TATTG[/N@jK@?TATTGjK@??ZT H?=?J?M#6O@37@\Ky@Mb?TATTGir1N@˚v?TATTG˚v?#9??},?2N_?%NXN@9@iZT?ŏ1w-!o?TTGGGFN@-@?ATGGG#+U?Mo?B׃? 9?HWU?v;P@Y:@P ? h"lxz?TGGGCP@0#x?TGGGC0#x?IC0???Vw>?p!Q@1e@Ǖ@a+e?TGGGCE3P@9d6Ѽ?TGGGC9d6Ѽ?ُۚ?~I&?z?.ӁG?wH>N@qh@~q?_L?GGGCG &qyP@!5gMX?GGGCG!5gMX?Zvo?>Ffhr?~U6?q$R?{ffQ@ׁs@XEؙ?$b,?-C6?CGAGCX1S@e ?CGAGCe ?X3?T.qVE?[8@!?H>r)^Q@^K}@N @J4?GAGCTyP@ץf}?GAGCTץf}?;MK? ?]|a[?0V?O/ȬJiR@H.@sP@ZӼ?AGCTT2, WR@.?AGCTT.?Y踭?+|& 5?&!0'??:P@B`Ђ@Z;p @ 0*?GCTTCY {%O@!?GCTTC!?Wf;c?剧g[>?ɉ^?bi?N{PH@Z8օ@g?b2U0*?CTTCC H@2?CTTCC2?ϩ#f8=8qT/?62 ?y+%?ȽBO@d]K@nu36?~jt?TTCCCySQQM@2kE)?TTCCC2kE)?g&t?s `t?'Gqq?456?14יQ@c]@~I;?a+e?TCCCCvKU Q@ Z[?TCCCC Z[?/?35;??_蟦?FmU"R@X@3y?<,Ԛ?CCCCT\S[R@o`ծ?CCCCC?~rb?n@?7PBh?pP?Lag?J,J7R@d@cc"?"u?CCCTA.ӊR@O6B?CCCTAO6B?W4X?LPt?qK2?o?nIږWQ@v@q g? ^)ˀ?CCTAG8oxQ@q?CCTAGq?z ]?=ɡ?P(?g>~ ?" 04R@J +@7=?mxz,C?CTAGG3hLR@JK։?CCCGCV 0?uC(?ᰑ?.?—sd?t*[Q@ű.nõ@p L?0*?TAGGA!zQ@㩙W]?CCGCASc:?K]?prA?5?_׸A?Q-S@X9ȵ@ MsX ?M O?AGGACۗR@e ^?CGCAC踟? ՝e?^?2̈́(?^4>QR@r ͵@~,|2@"u?GGACA&R@Q'H&?GAAGAxhlY?@?MdB5?]k :U?T/?]XiQ@1*е@R5i?I +?GACACYQ@{[9?AAGACʙW?GMl?٩5?/{??h5&Q@rҵ@n0n?ZӼ?ACACC~BRQ@5a?AAGACV?YЉ?qn?i[? ?}Q@$յ@9? F%u?CACCTv}Q@ !?AGACTFbP?/?? 4ro?"0\"4?CP?߈?*qL@a@t_ ,Q?q?TGTGA0\L@D/)?TGTGAD/)?5U>q@D?wN?d0m? M@v@ d?&S?TGTGAȤEL@-7Z?TGTGA-7Z?E?CN?].%y?|ʘs?SAO@H@v y?_vO?GTGAT!=ԚN@"{%?GTGAT"{%?R?(\Cʷ?~cT??j?YFP@_I @Ux @ ?TGATG!CR@C8~TW?TGATGC8~TW?[?ltV?'D?s<R?S$P@ڊ@o}P?~jt?GATGAXO@#??GATGA#??2?"yS?޾??EyO@ h" @@l ?ׁsF?ATGAT5PO@SQ?ATGATSQ?u q?3< /?7??}mhG8?mv^*R@K4@I@b2U0*?TGATCwܹ R@ O2X?TGATC O2X?X1?!oD2J?F?jXA?츅^L@`vO@f@`Qk?GATCTL@J^EVK?GATCTJ^EVK?P%.L?xtՑ?VS#MKa?z)?ƒ_llP@/!@N?b2U0*s?ATCTGH?O@@(?ATCTG@(?Znas?ݦC?Dl8c?VN!? zP@47@2Af?I +?TCTGCzD0P@5VV?TCTGC5VV?}ʐ5?)%%?s?}L?\z L@b@XƹS?ݓZ?CTGCAI@@L@}P?CTGCA}P?B*>h5B?!?BAb?lV= KR@&†'@@{Gz?TGCAA{>d=R@Hr?TGCAAHr? g$~6?A8x?Yݙ??HoyaD?`?WLXfoQ@?D@.yM?HP?ACGCTUszR@!uq@?l^?ʡE?CGCTCRԣ]R@S\79?CGCTCS\79?PMlb? ra? d?g՛=?=$ޭO@9gDi@>4n@_Lu?GCTCCWH 5O@S;]?CATACN,?'?Ou?"J7)?C?+B]KP@) @u0?_Lu?CTCCAgş=>{P@24r?ATACA;;I}?K(#*?5?>H?j8Ϝ?]%]LR@s@Um?F%u?TCCAT` OQ@-p~?TACATQ? ?7)?{[?(6c0?O_ixR@Ԙ@2?:v?CCATG.vԲR@x?CCATCmҭ?/?436?7He? ~ݙ?b2U0*?ATGGGv?O@NST)?ATCGGG\?B0Z#?bK?Jg+??E.Q@eĶ@?_vO?TGGGA#/}Q@,U?TAGGA6z:? \?Rմy5?d?p+r?$PR@W/Ƕ@PM/4?St$?GGGAGF:%YR@@m?AGGAG4OL??Ձ? X??ڪLJ?'Y@U@t˶@WE@ZӼ?GGAGTH{T@2?GGAGT2?@$?Unl?na?1ˁ=E ,Q@K4Ѷ@*2ί@ׁsF?GAGTC!xQ@<\|y?GAGTC<\|y?nN\|?"3[ ?1?9A?]%jz-L@7>W۶@H"`?_vO?AGTCTeidJ@6?AGTCT6?9 h>KG^?S(C]i?v,?su_ K@2w-!߶@HIq{@2%䃞?GTCTG M@鲦?GTCTG鲦?D ?_F?? ^|? u?k8A3MP@&涽@,sSk(?:v?TCTGG}=;pP@нY ?TCTGGнY ?2EŶ?=?Xт^-?_Q2?O@wO궽@-46?ׁsF?CTGGC=qGSO@;->(?CTGGC;->(??YUd?+h/܈?`(ۚ?H 9? sO@/'ﶽ@w`?ׁsF?TGGCGmc)O@47R+?TGGCG47R+?!"O?׮n?o]lܺ? 'R?UZ;S@J@ym@ ^)ˀ?GGCGC瘬lS@ӄ?GGCGCӄ?`ףPu?Jt?:۔??Mg3>Q@Zd@Y̫(@St$?GCGCAtIQ@T?GCGCAT?Xy?)BMޥ?RV?Ss? trS@?@}ui@+eX?CGCAAiwS@R9?CGCATC5?>a?3hb”?ֱb=?k{D>ߠ R@|P @ɯY@a+ey?GCAAC5QylR@tO3?GCATAfZ R?A?OLm5Q?Uy?C?J!P@ @!u?ׁsF?CAACG-_zNP@"jm<?CATAGk a?M:?bm?R3? b>m"RT@¨N @? ?CGAGAw? S@9پ?CGAGA9پ?z?n=?qQ?>έ{&S@Hr)@~7$ @_vO~?GAGAAR@F_C|?GGAGC%?LU\?dy?GH??w E>L=T@E*@4@gs?AGAAA`ppuT@U-@9@a+e?AGAAA8hs7[ Q@J4@YC3@0*?GAAAGR@ v5?GAAAG v5? x?t-?`̏G?R~9?c?BQ@%>@Y%#4?Y5;N?AAAGCQ@KF?AAAGCKF??vЗ?R? $!+X?L#P@}8G@"?2%䃞?AAGCG%NDP@Bjp^$?AAGCGBjp^$? ^`?U?i&?Wa?0:eP@+N@9a?gs?AAGCGeDP@h?AAGCGh?}lq7?aR?T?.?gOH=R@|гY@̓?:v?AGCGTcÆyR@1qCu?AGCGT1qCu?HR?#f?mgu(*?K/>`RQ@^K]@3!@Ǻ?GCGTG/Q@ ?GCGTG ?R v?Q H?Amh?[Rx?[<J@b@v>4@~jtx?CGTGA&R"(K@4O&}?CGTGA4O&}?R2>1_>i?ی? 1k؍?XO@:Md@HS?b2U0*?GTGATt֨N@Mb?GTGATMb?/Du?mM@&1l@C?jM?GATGTGH AO@#?GATGT#?= {.6?d-ぅ?o0V?D7j?,_gO@ͪu@ s@`Qڋ?GATGTU AO@> iT?GATGT> iT?y }?7?Y3'Ip?s ?B1C?:L@7@1o?Y5;N?ATGTCf,5M@xV?ATGTCxV?=f9>*ә2z?2?8gK?ct'M@Q@ǖ@L=U?GTCGCTHN@ A?GTCGC A?$ߵt?˓ ?ON+ɼ?ȧKs?WBQ@aTR'@JH b?q?TCGCGL}GQ@h ?TCGCGh ?oln?!Vι?W?y{0ǐR@ q@EH8 @?GCGTAyy&fR@x۠?GCGTAx۠?7|?1H?칃F?}eV?{~hK@u@ܳG?&S?CGTACPK@c|J?CGTACc|J?@>dX$? /k?@)Q?AʂO@ʡE@#R4?H}?GTACA0c8O@-t?GTACA-t?fXjq?c ? ݳ?<5?=R@ѳY@Jkqf?r?TACAC'Q@; ю?TACAC; ю?b(!X?h Th? ?wy>_(?gb1uQ@&S÷@rb?"u?ACACAu}2Q@jv`?ACACGH:O?z?M?1=wg?-Ӂ?/CQ@ףp=ʷ@?Pkw?CACACb8R@=?CACGCL2H?cj??~ek?>W?!;xkzs?RZظ?Q@>W[ѷ@ೄԷ?q?ACACGHmQ@_3?ACGCCՁR)?ȹU?HS'pW?qڵX5?N.?NR@Zӷ@yؼ.?5;Nё?CACGGB (R@ &M3q?CACGG &M3q??hҳ? M?CZs9?\SR@׷@0Mn??ACGGTsUR@W-5?ACGGTW-5?y_QL?#oP ?%?}9f?uxP@Hݷ@خ6q@I +?CGGTC ;3P@h?CGGTCh?> .w8>05M?Zf?&x=F@O@a㷽@N/? rh?GGTCT[zz&J@d?GGTCTd?1=/3>te>>~I?+c;O@_L췽@:kqDˍ @`Qڋ?GTCTGM\M@?GTCTG?5Iu?ELf?h˜v?5óԜ?L&vP@﷽@c%?<,Ԛ?TCTGGZQpP@@?TCTGG@?r{uV?ˉ?ؽ0v?e1^?~ǻO@%@:*"#_?J4?CTGGT[O@Ie?CTGGTIe? 6M?LU<?3"zi?1\ɕ?ѬP@d@!syC@Mb?TGGTT1<Q@Z\c?TGGTTZ\c?-1?|R7`?T2%?@q?d aL@W}@XÚ@H}?GGTTAײ0L@ҒA?GGTTAҒA?|N&>Gp'k?( tmu?Cu?*G@ K@gfff@W ?St$?GTTACGG1K@)p?GTTAC)p?ثX>ѕk )۞?PA?=]V(?Q^6O@/L @G?H}?TTACGsXO@w9?TTACAc;?Mx?E?w2A?]*^?!?Q@V@{?Zd;O?TACGCef-VR@d @?]?@&S?GCAAT؏sR@0ub?GCAAT0ub?s?d:?P?,+o:?A(HQ@&S%@SI:?8d`?CAATACDwQ@Fo?CAATAFo?K/Ԥ?57?LH*f?}آ?[N@|г9@{Oҩ?q?AATAAwo^leFO@ qajd?AATAA qajd?*+?w'Y?t4??~J9Q@n;@=eg?;?_ѵ ?Z6 P@,Ck@֞rky?&S?AAACC{CiO@i3UPt?AAACCi3UPt?_`?/?mΟt?Mc?y&“N@9mt@?w,?Mb?AAACCϮO@SIK?AAACCSIK?0'?F4kE'?! =m?I>?jqjP@zv@ڒ ?{Gz?AACCG=] :~O@>/r_?AACCG>/r_?X>|?4 ?RE6r?8_f? VxQ@n4@xd? ?ACCGASxQ@F?ACCAG#.{?-*?qq2??{Pk?ATTTT_ CI@q(?CTTTTB?$<'x=>>ʞg>W?g{gI@q@.|?q?TTTTA]+]GI@$"#?TTTTA$"#?+KJ~t=W,ù>z> ?dܧK@Ǻ@:& 5? ?TTTAC|g.K@ЇdMkl?TTTACЇdMkl?fAf7>yWdV?ڃY?J?Y#bP@#~@)?b2U0*?TTACA[xO@u`Y?TTACC3?qR,?(5Ʈ?x)s?P?}@hQ@9gDi@/&?/$?TACAAA~ R@eskb?TACCAI?3o?"A?,eٕ?B緷?e} 3R@y)@ўܿ~7?ec]?ACAAGgHhR@*J!?ACAAG*J!?9-?{݈?3mu{?G0{?[Q@=yXȸ@p?Q?CAAGCLv5Q@A]?CAAGCA]?,y?cA)?έ? 5Q?/Y@QP@K{/̸@?Pkw?AAGCA^NP@-792?AAGCA-792?x"?Էn?[o?Yz߻?;mӢqR@jMӸ@##FÔ?fc]F?AGCATmHR@Ƶ?AGCATƵ?Њ?Hz>?O5?-3<?R@"@A7@:pΈ?GCATT]]uR@JU?CGATTl?qܱ?Ͽ;tz?T"?ur t,?\ug\O@ @| @w?CATTTFcN@(h?CATTT(h?4oڣ>s5r ?F^U.?UHC7?Yy= I@T㥛@$u? F%u?ATTTAJRcI@\ס?ATTTA\ס?sڤ"N=!3C>O? J?J@,C @ JiY??TTTAC_ K@R 2?TTTACR 2?_M >܅?q*ٓ?!~GXt?L¢1P@ꕲ @#?{?TTACGjO@)$?TTACG)$?䠕?G݈s?t[fR@"@9ko9w?TyR@#~*@tl.?F%u{?CGATAsbR@Eng̍?CGATAEng̍?oJ?iVS[?nm?q.{`?|ҨO@K{/,@@?W[?GATAT%n5O@ A?GATAT A?qJ?? uQ.?ax?\hNPP@S;@aS?UN@?ATATCZ0P@]H?ATATC]H?!"#9{?4M?`"7ic?F?򍶏O@( >@"%@?w?TATCA9c 2aN@GeXw?TCTCAC1Ž?c!Z?ˋKIr?d?2˜?^2*Q@ ?@TV?J4q?TCAACQ@j|?TCAACj|?kdZ?U+& ?Y$Yp?Fy]W?{O@QI@@} ?gj+?CAACCUȖ/#P@j3ҧ?CAACCj3ҧ?n\?S;EM?ZbR4{?Hz?c'O@=,ԚF@";b?w-!l?CAACCG0#P@I9\M?CAACCI9\M?'?I/?n@^w?bz?(xPO@;NQ@^Y?Ǻ?AACCC RO@9TD?AACCC9TD?{<2G?Geܱ?aePF?Ql?>KN@ OT@iuf?Ǻ?AACCC歚RO@}{0r,?AACCC}{0r,?@<9?TE?~I? N?CXAP@ @ıR@M F@i@F%u{?GCAAG^\' R@>V&0_?GAAGC4V?cH ?e\?Ë?|WY? zeQ@tF@QBx'@HP?CAAGC?Q@T?^*?GAAGCDL=@?Oy8!?W1?Lp?ny`?N(@5P@wO@^!!?UN@?AAGCTȷ0\P@҇I?AAGCT҇I?JJbE?I#(}?P"?'?U;8R@ˡE@Ѥ@ 0*?AGCTChj+,R@jʆ?AGCTCjʆ?q5/?xk6R?k7?AT2%q?;MFP@ǘ@o|?{Gz?GCTCTt"_O@G:^˳Ŵ?GCTCTG:^˳Ŵ?̝H0?ڕ?{3e?i?':O@Qڛ@o<Z@J4?TCTTA4fɛO@#?TCTTA#?x2[0y?k Bǟ?L?S\'z?WA? K@aTR'@W ?{?CTTAC @+L@) ?CTTAC) ?ﻍu?A~u?%H?2qt:X?$p?Q@;@\? ^)ˀ?TTACTR~VO@O^?TACACS?>_Bp)?Q-|m ?: y? ѧ?rw /Q@0@! |?gs?TACTC]ەjQ@U-5r?TACTCU-5r?j?}*?4?&?Ep{7`Q@e;O@ !7?I +?TACTCUjQ@Hy-?TACTCHy-?Hܭ4{?y-$[?팄?r~ypc?R.P@&S㹽@@ ^)ː?GTAAA]jP@|=?GTAAA|=? b?aWn빖?9LE?nfE8?MZR@}8繽@;^"?Mb?TAAAAAB;R@wܻ?TCGACZ٧{?2#x?;Ֆ?6.?z.>?cmxQ@8gD鹽@U$?o_?AAAAGf;Q@F2ߵ?AAAAGF2ߵ?,?8qU?a?[ -u?_Q@;N@(قn? QI?AAAGAwn&Q@ ~y?AAAGA ~y? &?i=?o0np?߫Ÿ?x\Q@x#@g\lv ?:v?AAGATc}ĭQ@sJ~?AAGATsJ~?"?y^?>,,V_ ?e?5R@Qkw@.?_vOv?AGATT S@Xc@d?AGATTXc@d?T=d?Ƶ8~w??/ 1 >B8{6M@b@ ǧW@ rh?GATTA7ƞM@0Hz?GATTA0Hz?!/g>~rw 3?$O x7?: ??5^:- L@3@rq?Mb?ATTATv2K@H3zN?ATTATH3zN?Ay>FyZ-9?.:g?Y[?)'XL@?@b$k?|a2U?ATTAT4K@{7?ATTAT{7?q5?P-Ӂ ?'$@?FE e?5@&Q@*@l7?vq -?TTATCRH( P@UJP?TTATCUJP?[??#L?|8q{?6du>}?HDN@-@[iU?_L?TATCG^IN@c:; ?TATCGc:; ?!.t?V*'?.t%? 8R`X?4DQO@9#J@hLw? ?ATCGGP@ 1?ATCGG 1??砣?c)>b?rL?x>x?$^<2PR@Gx $@tn?jM?TCGGCͭlR@o?TCGGCo?k0 ? ha?0,dJ?lwD!?هLO@-@IDOA?~jt?CGGCT O@׊?CGGCT׊?F?` ź?3?͈au?eR@A`0@%U?H}?GGCTA?(QS@pOL`?GGCTApOL`?Ma%c?jEe?}kH?y s?W P@*4@mjr?_vO?GCTAC;O Q@N~?GCTACN~? Q?r#;/?FR|?oE?G6+Q@fX7@!?"u?CTACGSAP@^},O%?CTACAvN5?3Q??o?QG-?(4GWsR@6;@^ a?"u?TACGTI]zQ@w{?TACACeDQ\q?ڦ7? gA?-1U?] \/?;ƭQ@aTR'@@z?S!uq?TACGThgûzQ@_ &7M?CCACG 3ֳ? a?+A?X 0a̛?%b?65?R@%C@ evF?(?ACGTC=9G}Q@l)?ACGTCl)?[J?ePS?< ?+3c?ĺH@bY@ j@H?CGTCCw׵/EH@ ' )?CGTCA]?B=4`> G?fN>c^Ce?Ly&OQ@.na@ nq?ZӼ?TCCTA$?Q@]PF?TCACT^nR?w?$|Ѵ?Wɚ?\Qó?cĕAQ@h@lw4?d`T?CCTAC:T/Q@i'ѳ?CACTA}F?Q!?mD3?="?]F>? tqQ@sr@\za"?\ Ac̭?CTACTպE%Q@ ǜ?ACCTAW?@Lʝ?W?Tu"J?" ͛?AʆoQ@k @ALۢ?vq -?TACTAXpƔQ@wXg&?CCTAT4`>V?E-?:c;?F֬?5]j!\?=qQ@x&@!-? ?ACTATاzP@o"?ACTATo"?.s?UK?*?Xc?on?K%?Kh/-O@k+@nal?ǘ?TATGCqO@t,?TATGCt,?q$A˶?RM>{?z׺>HN1}\?Vu?">o?,zS@@jYq?ׁsF?TGCAAshBR@n?B?n?@q>EG S@2%ĺ@Cf$a@3U0*?GCAAT%[R@O'{?GCAATO'{?̫CM?;T;?Y2 r?Hԧ@#?JB2jQ@cX9Ժ@/P?ŏ1w-!o?CAATTڟBQ@H(?CAATTH(?qDf?|Gv?J4_\Y?nSK?iK@|a2պ@֟i?Aǘ?AATTG>"M@!H;?AATTG!H;?\ -Ze>ֆQK@? On?@ ? JK@Gں@[nʇF?UN@?ATTGGFL|K@%Z+8u?ATTGG%Z+8u?dR>g-j:?-u5KE?6 u?o^MN@Z꺽@N (?͍ N@ͪ@3G'@vq -?GATTT{(ᶏM@d \ck?GATTTd \ck?EnĂ1? *!?"?w|?՗ ZI@"@׸@w?GATTTwM@:?ATTCT\R܁g ?\;>s1p?%DW<?L?a|ƭyN@7>W@ՠ@ ^)ˀ?GATTTͷM@`gO?GATTT`gO?0_%?8?:o6?QsBf+?vZI@ ףp@ʄ:V?}гY?ATTTGM{oI@XZl?CTTTGo* ?TτB=ɀV>0>C y*?\u+K@僞 @Y\9?Mb?TTTGAPG K@$1ӄ?TTTGA$1ӄ?]a?#m?d2?2333LN@C> @p`6^?b2U0*s?TTGAG:N@LQR?TTGAGLQR? It?WV-O/v?oT ?T >`,Q@)\@]?S㥛?GAGCG'qP@`?AAGGG G?Ӏ$F? Q{f?R@+?AGGGGCQ?w]2ɴ? H5?#{?& y?z,R@x-!4@Ti@-C6z?GCGGG R@A6gtԁ?GGGGG8jLs?.?g*K?]1wO ?f:?ˡER@)\5@G{@Mb?GCGGGH.R@A~w*h?GGGAT Re?AdW?W+b?wr? CO&?lO@7@Ѡ#@H}?CGGGCJ)>P@8Dɹ?CGGGC8Dɹ?Z))?0J'?%N{? #?ȟ>Q@~;@|!@ ^)ˀ?GGGCT[P@ʬUev?CGGATӒl?,?zϵKG?B?Ń-?TvpS@k+=@qI@H}}?GGCTTE S@ik?GGATT~L6?k\ ?gN?qt?@>dsM@o?@T˖C @_vOv?GCTTCmx&O@ӌ?GATTCb?E~Cq?:Xq>"A?զZ;V?\?܀uI@Y@@>,O?y):?CTTCAIbuI@\0ޓ?ATTCA91ُ? =:=q/k>K t >Yt?>dM@ S@.1@ŏ1w-!?TTCAAKO@oROD?TTCAAoROD?̿eff?*2 m?8i،4v?2aw?bIQ@FT@`omI?"u?TCAAGd'ZR@wc?TCAAGwc?6?saڐF?^?q|kvo?)\" 5R@ŏ1W@B{n?H}?CAAGT0624>R@=j??CAAGT=j??L_엟?- d?y*")?5VcB?ё\P@GZ@@ƕe??{Gzt?AAGTA#P@<?AAGTA<? 9U*?yߤ#?H Gܹ?NOy!?#W hL@(\@J?&_΋L@ۻ@W1 c@a+e?CGTGTj OJ@>t?CGTGCn,?^Iq">RtT?l@?L ?K7H@軽@D t@Mb?CGTGT/*QJ@=߀^?CGTGCaG?9,`=`-)?|^e>?E?%ޑ2K@g껽@*bb@n?GTGTT[ӽM@,rzq.?CGTGCDj{ 4?Mr>1rC? ՟? L?;nVJ@zX5@4?ZӼ?TGTTAgdJ@.V#?GTTTAw|}+?>g2s?<?;?Pꃝ PK@﻽@. @`Qڋ?GTTAA}eC!K@ g[>E{?TTTAGh&(?@ CU>.?J?8; ?T~P@jM@=@M O?TTAAGK Q@C/?TGCCCHVո?zL?.{|?ml3?y(? ISbQ@=y@K7m?/$?TTAAG؃ Q@fe?TCACAl]7?4vJ?rXG~?rp.?Z?tR@9@%zY?ʡE?TAAGAMT}R@gR ?CTAATs󣉴?&fq?\&RR?uqɿ?q vl4?>hZQ@b@6Ρ?Aǘ?AAGATi%Q@Kl%?CCTAT81ϯ?57?C?Q<_a-??5k0sR@H.@U=@ǘ?AGATCY~صR@4\'?GGATCGsi?M*[?NlGF?紥)?1 >?M@S#@VyG?"u?GATCC7הhL@6La ?AATAC:^x?@?mc(2?Jx\?d/?0?YO@L*@C6P?{Gz?ATCCGN@㿛=?ATACGe?W»A?' !M? HL?+1$',?|(R(R@uq-@>F?"u?TCCGA^͵Q@;?TACGA|u*?MJ?{ ?`e'? Q|58?2hR@5@4 w? F%u?CCGAT$S@H (kN!?ACGATj+?T?1MU?8I?ؑ_p>|J=TR@~j<@7@a+e?CGATGpv`R@l ?CGATGl ??=s?b >7?2?ڋ;q? ˔QP@Tt$?@j14@n?GATGGX־}O@ux'X?GATGGux'X?=Y&t?}+?t? `k?@K a?O;~O@+eB@Ԇs3?HP?ATGGA-ˮO@GN3?ATGGAGN3?ܽB?k@ ?(^?a)?BQ@48E@tZ &?5;Nѡ?TGGAT/Q@WT?TGGACʶ?2Ԡ?=)?f-?vK?bS@R!N@ j,?b2U0*?GGATG`eS@ # ݴ?GGACTM,I?Р[0?^ yH? o|?œ ?W̗Q@ S@F̦?d`T?GATGA۝=O@XJ>?GACTG m Kq?Q2;?nP? AM?>כ?]4|O@46\@s=P]?vq -?ATGATK:*O@&+^ ?AGGCTJ?%.?xy&?=)?&Le`?W#rS@L7A`@G u-?A`"?TGATAW9_"R@ە7XZ?GGCTC}7-?/R?,2?Y\bˢ?u> O@m@XRyo?_L?GATAAK̻O@~ګ4?GAGCT_j?|ɝ?I۳2 ?n ?XJe?|TR@&s@nf?1*D?ATAATMJi^Q@ImH,5?AGCTCݳ?Su?lbyz??{J?rc?$Q@H@t,q?Ǻ?TAATApQ@b?AGCTCZٺ??!6Uo?"#? gV׌? m5wWO@J&@e#?HPsׂ?AATAAMGO@ ic?AATAG\zѳ??zoX?aNrm?$?Q@io@hF/)?ˡE?ATAAC9^r3Q@G-?Ȱ?TAGACqIKa?eUF?cG/&?B)_?`],P?VP@h@O1?+eX?TAACG?ZP@l?AGACGdžzܾ?.;?-?åo?yM?7m?q= C0Q@a֔@j?-C6?AACGT^p#P@UЦW?GACGT{u?1?2A#V? ZG!?GOu?t4R@I}@;#W?S㥛?ACGTGHrPQ@ u?ACGTG u?Zt?h ?Yg?;C?EkeJ@G@=X9@y):?CGTGTWoJ@p?CGTGTp?S7M= s>z66?A寵?紁nI@%@eQ?b2U0*?CGTGT-TcpJ@/2 ?CGTGT/2 ?=nW?Ogj?F&ME?(lM@0L @(?;?Ǻ?GTGTCOR,M@YL@?TTGTCZo?kBB)?T~?rwk*ޱ?ln ?=d?ƃM@8ŭ@R`?HP?GTCCAuhJM@s1v_?GTCCCh?R[?-6{ai?jUO2?܁?MP@A`尼@C@!?~k ?TCCATNVmQ@ e>ڥ?TCCCT!j?#?>.1t?DѾM.?A}?@afR@sҼ@_}2? ?CCATGoǓYR@!;?ACATG7 qd??Z~?rjH?օi-_?jO@ǘۼ@Swz7?46gsQ@n@BL?"u?AGACT׵kQ@s.'?AGACTs.'?A?(?vl?nڞg:?iP@M F@cX?/n?GACTCIcP@kȞ?GACTCkȞ?Y0K?Nuz?Ӹk?t8*=?FJO@y @|8N*A?{?ACTCC-"O@w#(kN?ACTCCw#(kN?@k?hL?゗?ӶEgZ?M˝oN@@A?y):?ACTCC8 "O@ ?ACTCC ?E…?EXm?R?;?YBQ@mV}@Viԁ?HPsײ?CTCCAÅ{P@{}?CTCCA{}?9'?Jg{?n/H?\(j-ۄ?⨺P@jo)@_Ǜt?vq -?CTCCAD{P@_?CTCCA_?'+?pb{ ?@)E?.& 2?}ƃQ@rh-@*/$O@:v?TCCAT-@aQ@ɝ24w?CTCATTcn?HU?Zl?m*@?MAi?ZnR@cX94@hc:?ŏ1w-!?CCATTԘkR@x M8?TCATT#i:?{ j/?I d?מM+?WB?贁,N@j+6@E8պ@_vOv?CATTTcfN@ؠ|?CATTTؠ|?K>-3?ks??E XDI@X81PJ>-3XV?@ H@c:@eu01?p= ף?TTTTT B&4I@tK?TTTTTtK?%tNѥ<4>I=?S7$I@):K@g2?S!uq?TTTTAEgHI@sZ?TTTTAsZ?gỬ=,!>KAb`>&l?xC?1K@hO@Ef+P]?<,Ԛ?TTTACfVK@!?TTTAC!?y> *?/ `?{A?n¦O@6?lXx?l? ?na?$.Q@\m^@Ӻg?St$?TACAGQ@ǖ1?TACAGǖ1?Yί?&M?|?+X @O?YmR@58Eg@SRc?Aǘ?ACAGGJ5+R@_{%A?ACAGG_{%A?`r?fӽN?_?Ci>VQ@.!l@ 3s? ?CAGGCbH \Q@V} ~?CAGGCV} ~?S`s3@[??6&?^ ?P@su@/~?Mb?AGGCC<ʑliP@g??AGGCCg??[7?&[?G??gffQ@p_y@cQb@-C6?GGCCGA)R@I?GGCCGI? A= ?p?4mt?rvU:]?"{R@Լ}@Ur? o_Ι?GCCGGLDE>KR@pؖ?GCCGGpؖ?Q2?H[?]?Db D?vp\R@e@pP??CCGGTFR@?CCGGT?r[7-?0xM? _? >5>lP@x@@ŏ1w-!o?CGGTT$V nP@j(?CGGTTj(?YvW#?kf0?78@?Gk)?sxTI@iq@LOF3@S㥛?GGTTGBK@lzΚ)?GGTTGlzΚ)?/|P>I?`00@?]r?cm M@>W[@??ݓZ?TTGATj`N@WefOW?TTGATWefOW?'潹I?a ?QX6?%,R?jR@v@a Z@Ǻ?TGATC[R@7 14?TGATA5Z?)zY?7?<Q4?Ϟ㧋>\µO@RI@e3?Mb?GATCT' PL@k"?CATCTa]?cQϥ?0$??lnZ?C{\?NO@猨@VdMB?gs?ATCTGv~@O@cULq?ATCTGcULq?#G?=]?\vHA2w?ÿ: v?7nyP@C@2l(\r?L=U?TCTGA:KP@S}?TCTGAS}?s񞁮?O ?4V?+{w? WHO@HP@!/?N@9S?ATGTA9S?V md?ÂlA[?Kp`?hc?F M@9#ʽ@ ?_vO?TGTAA!L@|?TGTAA|?i?L2+@?IJұ?'_?۫BQ@ͪϽ@yl?HPsע?GTAAAfCP@ ~[OS?GTAAA ~[OS?/ ;? n?o8gt?D4“?avR@+ٽ@ ?F%u?TAAAA* ;R@,?TAAAA,?E ??6?DZe?L&IQ@Qkwܽ@(xp+J? ^)ː?AAAACl*#wQ@˜ҵ?AAAAC˜ҵ?_}???pF=?>?K1 O@dཽ@Qe?kt?AAACGpP@ai?AAACGai?V}?}Vi?` Ն?4ݣ?iP@ q뽽@ϹԾ?{Gz?AACGCo(RP@ P?AACGC P??c?7>Y?@h?Kif?2XgQ@5;@hE?q?ACGCAM&DxQ@G o?ACGCAG o?XE?Vo?TI_X?e?n?qJl3T@~:@F{|sV?`Qڛ?CGCAT񥁟|S@-d),?CGCAA;,?FVD)?C?YZw?7>MbQ@ŏ1@}Sz?[?Mbp?GCATAЋkR@ݪH]?GCAACvgT,?;g?cY??I8c(L@:!@3Sf??ܵ|?TTGCCi 7K@H ?TTGCCH ?Wk(E>@eH>~?Ѱ+?ӹ_K@X1@o L?Q?TTGCC\QK@Oc?TTGCCOc?M>db=; ?MH?$2?ȍ\ZQ@+e9@9UR?q?TGCCTVQ@3sCiU`?Mb?GCCTA P%R@=2yMz?GCCTA=2yMz?.8?%_?NjBD?,Mܑ?">Q@ I@ Z?Mb?CCTATftQ@h$?CCTATh$?hTzQ? :t?lrsԒa?e)?N _Q@=UK@ -mK?p_Q?CTATCl d_QQ@{t?CTATC{t?` @?BQ ?NP@_v@M?J4?AACTC.BGP@⡡?AACTA 3??B@?-((;?9h?lwUoP@u@yT? ?ACTCAWoΪO@`@?CCTCAwnr;C?a?,ׁ@?MF?)?꿭DP@S!@o8ޢ?a+ey?CTCACSQ@9ea ?CTCAC9ea ? g?W8'#?W.?<2?]?NNQ@St$@v1%@_vO?CTCACm,SQ@S%&,?CTCACS%&,?lu&?9u$?I@?ϲ?gP@[B>虾@D%lT?Ǻ?TCACG-!DQ@ý?TCACGý?Q?V?6FY?i?,Q\R@8A`@~? ^)ˀ?CACGC(NR@pA.0?CACGCpA.0?Yaٶ?=_?H?CD& ?OQ@ y@4?ŏ1w-!?ACGCT싯Q@9K?CCGCT ?[\?P}u?Òb?pWk1?BʮR@k@?H}?CGCTTĞR@}rZA_?CGCTT}rZA_??/Y?K_]?/6>:P@uq@$s4`@n?GCTTA8 lO@t%e?GCTTAt%e?p! ?aG'?>3S 7k?]`*?=>{W2maT(?D9D$2Y?~ᯊ?°NgP@NbX@#@?:v?TTATC'QP@ͽ\?TTATCͽ\?[ΩH? 1Pkd?<?4u?-:FN@@JKFY?~jt?TATCG!mYJN@ J~?TATCAuE&?Kc0!]?Q{y܂?m״|~*?j B?cuM@nþ@SǞ@j+ݓ?ATCGG5\P@x i?ATCAGH?`R}?Y…4?lxϚ(? W[?CCTAC!/Q@G>b?CCTACG>b?N4F?;MٟP`?h:;H?(>.?Q@ᄑ@w?ǘ?ACCCChQ@hT>m?ACGCC 2?? e1??2?~]j7?n۶CR@,@Me1|?Ǻ?CCCCA&R@SK?CGCCAI?<0\ ?WҤ*?9ڠ?2:?XD}TR@@nkU?Y5;N?CCCACւR@s?GCCAC_Q?琁[?7Q"}?%6?!R?| JŨQ@5@@DPa? ^)ː?CCACGkz\\Q@,qF?CCACG,qF?7Z'?|Up?z]?e `?NVBmQ@ׁs@IӽK?~jt?CCACGrQ@*>?CCACG*>?o6 ?Eٗ[?PO5?8H$?. 3R@|P @O9?tF_?CACGTR@d?CACGTd?q?k?_nv?2? ?m]R@鷯#@9?+eX?CACGTR@;8ǿJ?CACGT;8ǿJ?v?G5мL? C?ߪ+7_s>ij?,H@e`T2@h-@+eX?GTTCC2YGsH@ ?GTTCAQm_?$\=m\g?VB'?vˆ(Y?I1P@|?5@-E@~jt?TTCCT_c]M@z޲ƾ?TTCAT&M?1Թe?C}"?KG?H~?LniQ@X9H@?y&1?TCCTT OQ@Bȥp?TCCTTBȥp?ڙZ˺f?Ag?^p} ?ٕVFb?aBO@6^IL@`Ir@V-?CCTTG+]P@$!?CCTTG$!?oT>{?9Nw?5\KM~?#79N?"]L@ˡES@S%TY?J4?CTTGAɮ L@ai#{?CTTGAai#{?RWu>2!W>[^n?˵"h?fjƢL@Q^@E]NZ?5;Nѡ?TTGAA*tN@|9C?TTGAA|9C?T@+?\??:~?oOã?_S@l g@ F@_L?TGAATQ2ѼS@5/C?TGAAT5/C?祾?yUҩ?MK?dnxo>ԑR@MJj@-$@5;Nё?GAATT6bmR@~G?GAATT~G?&KwI?}|?D ?|SMe(?#nK@@߾n@)hI?J4?AATTAd[M@pv%o^?AATTApv%o^?۵]>-S#C`?(.A?!Q!?@6L@ s@}[K?-C6?ATTACNWWK@%@?ATTAC%@?;tD [?’?Z:DY{?X H9?pO@6~?_vO?TACCT~P@X bg?TACCTX bg? w?e0 ?@sskv?o8jv?uEQ@K@%U{?HPsג?TACCTR}4P@x*?K{S:?g0J%?ЪI?"%%N@?@,2,?ׁsF?CTGTG?ibN@ ȑή?CTGTG ȑή?I~^?0cMӃ?Pʤv?tz;?EUTL@?ܵ@V_?( 0?TGTGG#T.L@<&ܯ?TGTGG<&ܯ?iadz>Nk?9n?8?u^OK@I @%KC?Mb?TGTGGfa.L@_0~?TGTGG_0~?zɤ0> R8?3"*v?? GLN@w@#Uʌ?n?GTGGA+mڂN@Hd4Z=?TTGGAը1@?_O3?vtMe?d69?1daj?*ATQ@u@ e?vq -?TGGAT[5{_Q@8T?TGGAT8T?w?vv_?yLG? 5?unS@|г@i˲z@Q?GGATTpS@#Q?GGATT#Q?X4?>Qh1?_aB?ucQh>%SL@ڊ@m?/n?GATTTCM@_+l?GATTT_+l?y\I!j>Ǚ@`?Gᨂ"?Re?bhbI@*:˿@ ;?gs?ATTTGtZI@j֮?GTTTG(?Ae-==IG ??">гGG? uwK@@¿@{9U`?"u?TTTGA*K@ʲ?TTTGAʲ?C!RI>ԾW?qjMV?ԎG?[(N@@5^ɿ@N J@`Qk?TTGAGf̾N@u]-M?TTGAGu]-M?@aFs?N?jU?C1?waa?I޴dgR@0ʿ@bJv@y):?TGAGC]H0ǵR@#_?TGAGC#_?!?!,Pz?˭?{~5>K~D(Q@/'Ͽ@'W?b2U0*?GAGCAq P@^,R~?GAGCA^,R~?Lģ %?>bd?r7.j?3ӭ" w?/ 6umUR@uѿ@Z;@Ǻ?AGCAT~4oR@5{l?AGCAT5{l?^{?x5?P&|??12?rhIR@GzԿ@RW90@Mb?GCATTg%R@-\Ʈ?GCATT-\Ʈ? `?AW?"lڻ?[+?8XPL@ +ֿ@tf@q?CATTC$ Y[M@Gn?CATTCGn?1pUhN>xs:>%jomk?O)I@J?R 6I@ޓڿ@u].?\ Ac̭?ATTCG̃uI@?ATTCAiԸ`?*>ZE?TTCGGRr ?n?J??^X?i7?@R@E꿽@П~?+eX?TCGTC+u}Q@ ?TCAAG3I(Y?Z?\=%? O?:[$)p? O@a@xoÙD @`Qڋ?GTCAGQ(N@*֦m?CGGCCA2S`?1Ɍ?F?y/[?6.?ǰ ?ףp} R@2@[j ?-C6j?TCAGCQlR@MJv?CAAGCxQ ?o$?Ap?k^?Mql}?0rUP@c@?/nr?CAGCC`ȱaP@w˻?AAGCCdR@?rDC?%?O E2?< ?ޡpQ@߾@?q?AGCCG]BQ@fG?AGCCGfG?ryȢ?ߨ* "?0;0?s,i?!iJRBR@vq @4???b2U0*?CCGGA<8R@'(?CCGGA'(?||?|d?;cM? p?*c؊Q@+@.2 @ŏ1w-!?CGGAT%^Q@bRZ|?CGGATbRZ|?0,?%_Q?\L!(?ye6y?U+P@&@ݲmS8@Pn?CGGATDN%^Q@|VP?CGGAT|VP?Zzǣ? =m?tdiz?^ޙ?ףpR@]K'@|+. @Ǻv?GGATAԮS@ꃯ0?GGATAꃯ0??z4G?z\u?t7:;>6iV.O@K7)@D[@b2U0*s?GATAALYO@$i?GATAA$i?|;K?3,?Vd?K=?P@iq*@I? q?ATAAG9[Y@Q@ ?f?ATAAG ?f?zӵQ?"F0xU?ed?)l(w?=4z]R@478@oב?o_?TAAGGnUR@X{2?TAAGGX{2?*bn?s4?HÕА)?!CPB?NbXQ@䥛@@涏?I +?AAGGC 83SQ@?AAGGC?g%a?aNc3@?y0uUQ?CFG?RqYP@%C@9O?-C6?AGGCAwtRzP@'.%?AGGCG#h{?=?2xS?z?+z|v?PɵcS@c]F@JB@j+ݣ?GGCAGb܂S@' 9f?GGCAG' 9f??'?F?`>&ؽS@^)P@f^g?ŏ1w-!?GCAGTdS@SM?GCAGTSM? ?U@C??NB>qbS@6?CAGTCFGPP@FO?GCAGT1Dž.Ӱ?G4?vY?YUΧ?;*g~*?B+yH@Oё\^@M?y):?AGTCT $eJ@Yw?AGTCTYw?|Ez=@,>A$>p*?|e 3N@-Cb@+n@"Q@z6~@vS?HP?TAGAAcR@!c ?TAGAA!c ?#? Yx P?]r ?2Zd[?QS@ʁ@ !U /@S!uq?AGAACS@Z8D{?AGAACZ8D{?< "?.7e?\?rCs>!; 2Q@48@BQ{?a+e?GAACG*tP@*QJC?GAACG*QJC?{ub{?AIg?E/0Z?vfŁ?)4\O@Oe@ʳo?gj+?AACGGYP@M}6s?AACGGM}6s?fzA'?9?,?̷>2?߳νR@d`@J?HPsׂ?ACGGCϬ R@Ʀ?ACGGCƦ?8`?v^oO~?ٜ1&r?z"?dVN@ǘ@5%XF@ZӼ?CGGCGv BO@K,z?CGGCGK,z?`3ۧ-?pqTO?nP? դ0ј?S@}?5^@V@ ^)ˀ?GGCGGQ4XS@{䍑?GGCGG{䍑?3?a~V?ϙv?*ړ>i R@Qkw@dIN@ׁsF?GCGGTnvSR@u2ċ?GCGGTu2ċ?D+r ?ֿ?fz B? `>?y`DaO@K7@몄6E@ea?CGGTAL܋^P@Dg=?CGGTADg=?#?!.{?\Cͪ? ??O@C>٬@߅?(?GGTATHT'$N@a?GGTATa?p(ğ?C?.!R?`[R?UâScP@η@"_!?ŏ1w-!?GTATG坕NP@\ct]?GTATG\ct]?튈;?u]x?1!?ŝ?;mӂP@@ :q?Q?TATGG-P@%?TATGG%?S9.?Х2ﴽ?hgx?>Yc'?1?YO@k+@k*0 ?~jt?TATGG` -P@a^T?TATGGa^T?<mT?ˉqj!?0iLl? '?_v7P@d@@Qȴ? 0*?TATGGʹT-P@2z ??TATGG2z ??O(V?_a?4sZ?h$:?6Y*,O@鷯@c? 0*?ATGGCݯO@pݸ?ATGGCpݸ?އ!!>?8e?kV ?o@?(O@( @P*d?<,Ԛ?TGGCABPuP@E, ?TGGCAE, ? Y'?y*s?>tX?$OՔf?~W FS@3ı.@EGv%@+eX?GGCAG⍯S@_|$?GGCAG_|$?M'H?ς?ӂ?\>OS@`@Y;'?n?GCAGCQW7:S@sB?GCAGA?&Y? r?g?k6^a?4>BL Q@`vO@AE!0@d`T?CAGCTPGP@*:F?CAGAC{񙾖?-?AlN? L.{?QMt? RQ@ r@bl>J@ ^)ˀ?AGCTG3:"0R@:fo?AGACTڱ*?Y@?v?9[Uj? RƝ?rN.P@L@2Iy? 0*?GCTGAƞP@ȡ?GACTC,?=Lӱ?*TP?({?"T?7}O@rh@-6.?ׁsF?CTGATt8}o/O@)UQ:n?ACTCAyk?Uɢԡ?gW՛?? OJ? Վ/R@3@xs?j+ݣ?TGATGN\RR@*#u^;?TGATG*#u^;?h/W?H?gmI[?< VP^? CeO@.n@~; C?H}?GATGG5TO@z C1?GATGGz C1?eF?gr?_ c?D^?4LO@&S@i(? 0*?ATGGA0mzO@?ATGGA?Fx?>?M[^?CO?z`1Q@=yX@(z?Mb?TGGAC=1Q@X2&eG?TGGACX2&eG?#tZo?Nyv?PzT?{=ː?vLQ@8d @*@H?GGACG\CQ@?GGACAKg?3Kv'F?-_g% ?n ٵ?aTt?QizQ@;pΈ@!u]?_L?GGACGQ@?TAGAC5P?9G?"?CACGCe|?ю C?%pȍ?1(L?+$+j?a-Q@Zd;@? o_Ω?GACGCeoD^5Q@9@?GACGC9@?PolD?B3]'*?_ ?,4W?'oQ@ h",@}.x0?ZӼ?ACGCC1cLQ@,lv?ACGCC,lv?tX?^Hl?2M?M\10?4 :R@>W[1@h(.?HP?CGCCA4;R@ׁK$?CGCCAׁK$?vW6?c?u H˻?˚3Y?@4R@b=@^$2az?H}}?GCCAAzWslR@ ?GCCAA ?j*?փ@^O??ۜ u[?e;+R@?W[?@T4,@Mb?CCAAGC-אR@+\m?CCAAG+\m?)}?cp?0)?VDAQ?R@A@j?/n?CCAAGctWאR@0[XH?CCAAG0[XH?{I?&x?AGA+?aU?raJ2R@ґ\C@[۞ ?&S?CAAGG:|Mw#R@.i?CAAGG.i?4bZ@-?OO?1c}5?S(W?k@mR@H@-brn?I +?AAGGT]fQ@hh ?AAGGThh ?OK;yK?HpA?f"A?XU;q?77dKR@FxK@U ?a+e?AGGTTbQ@4mst?AGGTT4mst?#٧?.FY_?Ywl?nYe?7>6I@;NQ@n2Պ?eX?GGTTG"'[K@xSZ?GGTTGxSZ?1…z=3bا>fS.?vH2?"QEJ@?٬Z@;x?_L?GTTGT\$#J@)~%?GTTGT)~%?zק0>@W?, {K?MI?Dl٣L@M F@l@Mbp?GTTGT7}+J@ekZ?TTCTGGpE?fg++?7?]78?ݻ86?5M@|/L@RʷY?C?+$n?AJJ@$J{@[2?-C6z?TGTCTB{/I@gy'?TGTCTgy'?wف S{>* _l?W95? ߁?ɉxM@x&@'Id?vq -?GTCTC ԰M@I ?GTCTCI ?=z?vQ3?It?漜?21n"P@|a2@>)&?]K=?TCTCA/%FO@`?TCTCA`?T+i?S=?F|‹?n!k?P@B`Т@麉?UN@?CTCAT]_ijQ@'YW)?CTCAAn?Gt?پZ;n? ×?9&?U2R@l @06O?cX9ȶ?TCATA%/5R@C{R?TCAAARi"o?>?a* U?!BjbZ?rOw~?1?QQ@Bi@$/?tF_?CATAT߳?R@1@L#-~?+eX?TGAAC0S@"NOg?TGAAC"NOg?,)' ?fvV?K8?z]>L! P@ڊ@.@S㥫?GAACC P@OI?GAACCOI? ?`P^?O?zh? ףpQN@c] ½@{xd߈?HP?AACCADKO@.w?AACCA.w?a&]?;v.y?h2%U?0?~S >O@ŏ1½@uP ?q?AACCA{ZY O@LJ-?AACCALJ-?Iw?\?oJ8/??Aj7?e0Q@K7A½@%?w-!l?ACCAC*Q@Ә˅?ACCACӘ˅?,)'#1t?)?Nv?ctOz?Q@X[L½@f[V?_vO?CCACGdQQ@Kۦ?CACTAEʳ?\cn? n?z1~'? ,n`?e $Uӧ?C'J@Af½@(?gs?GTTAC! 3K@n_XJ?TTTTA)^?9呏Y>駰O?'}!?ݩ*E? }jR@ ½@?"u?ACAGC^>R@h"ؗB?ACAGCh"ؗB?y MA?F/l}?B?c53?SP@:M½@ ?d`T?CAGCT;.pP@?CAGCT?G?VTÅ6?o1?`?"2{R@ŏ1w½@ M?ݓZ?AGCTA~gPaR@7l?AGCTA7l?Gl?C?!j?r?1cvP@Y½@5?ZӼ?GCTAA薉4Q@?GCTAA?s>o?բ(?c)YC?C?V?%mH@W}ý@yB_y?b2U0*?ATTTCkhPI@iFİ?ATTTCiFİ?V=ճp{>G=>Q>U[?cI@a+ý@Bm).6?Q?TTTCCgGH@X"?TTTCCX"?>))=3>Ppz>y5d5D?osN(M@R!ý@jj"@I +?TTCCT<M@b@?TTCCTb@?L7/&>?ޯ?v X.?u5R?6oL=R@{ý@?vq -?TCCTAQ@n[3&i?TCCTAn[3&i?V:l?b?s4̭?PY?S@Q@Fý@7O?ZӼ?CCTATeuQ@rAW?CCTATrAW?VcY?ent?ⴰk?ה?qg1`Q@Pký@J>|?p= ף?CTATTIQ@ ?CTATT ?~]c?I?{b\c??x??MބO@ZB>(ý@0չw? ^)ˀ?TATTA|fpN@ n?TATTA n?<U?We[a?-f?'E+?[L@ÆW*ý@K$?HPsע?ATTAG K@C?ATTAA`I]ß?^RS>Է5R?j&5W?أaP?!/KJ@Aa3ý@0}kF@xzb?>""?:*c҅?F7KL@46ý@bmp?q?ATTAG K@Ie?ATTAAit?6Xi\?V1?d?d:?Q~Q@( >ý@m(F6S?/$?TTAGT61'Q@E(?TTAATir)?2qk{?`1?3f)?z!{?G R@ű.nCý@myZ?Mb?TAGTC0=JQ@{-?TAATC\O?Yɷh?l ͳ?x;?cn].s?9+K@&†Gý@?镲?AGTCGAQJ@ |$&?AATCGu?_y>kNlD?er*\;?BY?=J@2Zý@@/# @ZӼ?GTCGA(ԡN@tĽG?CGTAGP?CS6>D?]EFA?d ?GG]Q@#\ý@'Ҽ?H.?TCGAAHZR@"+$#lR@ F%uý@@81҂?JY8?GAATT"HnR@L=(eZ?GAATTL=(eZ?@8.?C5L7?ق4 D=?E%?Y VL@rhý@V@{Pk?AATTA_*\M@l?AATTAl?Bv>5G3?E&ڳ^?_;?]'ΣmK@<,ý@J-?i|?5?ATTAT]a]K@~)?ATTAT~)?!в{>{1ϋU?ڕ"R?Ku?Hར̕P@|aý@?~:?TTATC;{P@zC?TTATCzC?, 6 ?ܳdvr?F~?ـ?~W!{P@lwý@ΚTp?J4?TTATCPC|P@s;h?TTATCs;h?=Ұ?nSV y?yon?E? k ǹM@xý@??/n?TATCC{[M@N%V ?TATCCN%V ?`PE?gۆ?' ?; xF6?c?W4Ͷ?đ^I@|aý@Gz@ZӼ?GGTCTR*J@xi?GGTCTxi?lg@2> 8?Iz>,?-WBP@Fý@՗?NSt$?GTCTTQcM@Ń_?GTCTTŃ_?kW?^?FR?;m?KMޡN@*ý@^H,8?X9v?TCTTCON@H84A?TCTTCH84A?EHA?Ƕ? h?h u?1/GI@W}Ľ@W~? ףp= ?CTTCTjA\I@>ֿ?CTTCT>ֿ?~H]>o/*+?&m T?0e?M-TO@5;Ľ@-͸?F%u?TCTCTZoO@@?TCTCT@?[p?p:?}9? w?WFQ@FĽ@'*ŷ?Oec?CTCTCьMP@஼{+?CTCTC஼{+?Fh?Kv[?Hl熘?5X/?&'P@|a2Ľ@t F.?<,Ԛ?CTCTCKVP@G9=~?CTCTCG9=~?DBH?k %"n?%|t?8t7"?ѐsO@"9Ľ@2nҤ?Ǻ?TCTCTu:vO@T?TCTCTT?:8PB?ep?1?T 6? kP@#<Ľ@}S}?UN@?CTCTTwbnhP@Gq)|?CTCTTGq)|?] .P?? ?=e?ix O@K7AĽ@J\?5;Nё?TCTTT,g|O@]:77?TCTTT]:77?%>:DKe?Rle?X1fpy?_\Kՙ?)I@ڊEĽ@al0?6;Nё?CTTTC3H;I@KB?CTTTCKB?=0޴=7G,l>Sl͔5?Gy?€ ;I@(\bĽ@2i~7 ?(\µ?TTTCT I3I@Q7fW?TTTCTQ7fW?`"s=[>rH> ?:m8M@QxĽ@}Jp?ZӼ?TTCTAnON@<ĽV`?TTCTA<ĽV`?HcS?.b5?hv?9rϙ?H~P@czĽ@LYb? ^)ˀ?TCTAC9P@J?TCTACJ?9d,?{QZ?BbV\>?D?9k_Q@^K}Ľ@xz&#?y):?CTACA~wQP@nӔű?CCTAC(ى3?7K55?I -?X?SBtE?Q@=RĽ@]S?ZӼ?TACATQ@7ȷ?CTACAw+ʽ?P]v?hs?; s?ka?le!R@AφĽ@No,K?HPsׂ?ACATA JeR@~M?ACATA~M?WLw1?1jwK?Bd;?*˜BJe?1P@3U0*Ľ@n??߾?CATAGw#P@lŌ?CATAGlŌ?ïKM??oD?yEkU?_ 3Q@ŏ1Ľ@fQ?"u?ATAGTDr*-]Q@R粻?ATAGTR粻?x[_?AK,?D?zU?bjP@ǘĽ@S@Uد?TAGTC4aZJQ@qd?TAGTCqd?(G?Uα?/?-`?n`I@RĽ@,J9 @n?AGTCTPVfJ@;-?AGTCT;-?E@xa>D?0?wl !?0P@o_Ľ@cr>?q?GTCTGM@CvZߡ̳?GTAAC´ZѢ?#3^`{?l|?m.A?emw?p= hfP@uĽ@iJ?gj+?TCTGCUQI}1P@HG?TCTGCHG?x?lž ?Cr ?h:.?qP@/nĽ@ZNۭ?@ǘ?TCTGCȸa}1P@<#5Ǯ?TCTGC<#5Ǯ?Mތ?):?vk?ڴqwK?A}L@3Ľ@`@/nr?CTGCC`L@.ԝDn?CTGCC.ԝDn?4&?<&}?{dqr?=O?P@SĽ@f;@&u?TGCCG؝<Q@Gu?TGCCAiֻ?:4?;vw|?r &˒?/OV?v䖿%R@ZĽ@֌.^?+ h?GCCGTԨ/fR@6h`?GCCGT6h`?xX?d>?y?vcn?I}i R@ͪĽ@*ik?2%䃞?CCGTA4Ñ[: R@0O?CCGTA0O?wu>e?*JǺ?|9Fn? nr?YJ@KĽ@1y[ @_vO~?CGTACaSK@ v?CGTAC v?AtkB>;*7?j,>@D'?NUQdO@ 0Ľ@h H?I +?GTACC?I6O@.OI?AACCCcY?e'?x+?z?rRv?v2Q@?&Ž@rh?&1?TACCA &.Q@y۳=۷^S@/n<Ž@,M?q?CCATT NR@Y?CCATTY??R?8B}-?$*>؍S@>Ž@GJm?Zd;O?CCATT2R@ Ut?CCATT Ut?CwQw?yD/?t揫~?I0|>!j_M@%CŽ@g 7p4@{Pk?CATTCi8gM@ۇ;Y?CATTCۇ;Y??Ҋv9>?Qԥ?ëm|?v)I@#~JŽ@mh ?Ǻv?ATTCTk4^I@{z?ATTCT{z?`i>>{5?+J,n=?GV_?k(M@CKŽ@N8@+eX?TTCTTV%WN@][ nP?TTCTT][ nP?ՆG?q?J?.?ҥ&]PI@X2QŽ@x{ KR?6;Nё?CTTTC幛t;I@?CTTTC?Q@%̴=Ԣ#`>>5ӯ?C_I@vq `Ž@ `h>?HP?TTTCCJH@pb^?TTTCCpb^?,uji=Ah ?[>"6?{.O@yz,cŽ@/g??TTCCAk7 N@fS?TTCCAfS?x?[.?!\m?:-frk?juQ@/$fŽ@ǂs?HP?TCCAG$! 9Q@~0g6c?TCCAG~0g6c?@_u?I?HEJX?Xk?)R@!AclŽ@)l?@ǘ?CCAGG_"S@d!2?CCAGGd!2?H+|Pa? G ?!?k]2??sQ@rŽ@fi ? ^)ˀ?CAGGG%O~Q@-?CAGGG-?s>3?&LȜ?`)n?3j?QxjR@ OtŽ@}_@/n?AGGGAMmrWR@\x52ॵ?AGGATo}mO?T?uv}?H0?nfX?2N$ü'S@vŽ@QJ>@/n?GGGATBR@fZ?GGATCgd?$3i[?r?ʯ(_?ؚ?8w_oR@"uq{Ž@% @a+e?GGATCHuMS@ıY?GGATCıY?Κ2?ֳG2?0d*=7?b؛5?)AwN@~Ž@E?F%u?GATCANc+!M@&K.?GATCA&K.?x! P?=ɾu?*h?H(?-9P@H.Ž@|oB?2%䃞?ATCAGV-P@#'Y; ?ATCAG#'Y; ?.?@#y?0m? ]]?ߗXw>R@UR'Ž@Ô@y):?TCAGCSmR@#?TCAGC#?h[O?y?\, ?4;]˹2R?bLߤP@3ı.Ž@%?a+e?CTACAY jP@V ?ACTAA?m??gQP?enl?? S@RIŽ@pKr0?F%u?TACAT DQ@k17[?CTAAGI?f?#K?7?%ju?ik>q= 1R@Ž@t+y?-C6z?ACATGTg)YR@٘|D ?TAAGC}.}?^EG?ȺgY?y1 ? #Po>v?N/=P@RŽ@)Ks1?gs?CATGG0[SP@V?AAGCA?:?pZm̮?69?j?{HQ@5;Ž@{}7? ^)ˀ?TGGAT;[rQ@f}^?AGCATtB'ff?_?WM ?;OJ@BŽ@%*z?Mb?GTTTC>H@n"]?GTTTCn"]?Hg(x>|'oR?Pwf?o8[?lH@)~Ž@]?j+?TTTCTN3I@ =pK?TTTCT =pK?rͳ=~Bja8?f<>BC)?hkشN@ޓŽ@C8a9@UN@?TTCTTfnN@u%'?TTCTTu%'?F}=Q?Bp?A?,z?Qf$.5QJ@shŽ@~%׏?DJ?CTTCA\#|wI@?CTTCA?=wb>е~?q&U>wt{?mn!\N@ Ž@! $S?_vO?TTCAC͓SO@Ƨ3v?TTCACƧ3v?l7?OMY?#%[N?"F/?XQ@ڬ\Ž@?gs?TCACC% Q@9 ?TCACC9 ?+ղ?X?2:?>?3Q@1*Ž@x<?]K=?CACCC<AQ@wAe?CGCCC ? ڎ:?Fs|<?^W{?% I??>Q@V-Ž@er2'?_L?ACCCG8|+hQ@#?ACCCA(5?T?}E??k[VȢ?`,S@&Sƽ@w'-f? rh?CCCGG^ER@z?CCCGGz? ĠyP?vL_T?];<%?7n>0R@)~ ƽ@@d+?<,Ԛ?CCGGCwVRR@ sY?CCGGC sY?9KN?2](?ئ` ?iX?Gx O@_vƽ@v|9)?Q?CGGCC8,O@bY?CGGCCbY?T$EgL?R]z?+3?x(ef?4$9S@jMƽ@(1?Q|a2?GGCCA9Cq=R@jIF?GGCCAjIF?zÜ9?k?Cz?dF=?G %WR@-Ԛƽ@̃4g4?V-?GCCACXQ=[R@؞j?GCCAC؞j?7Ù8?gCP? ~?mOh?g#"Q@&S%ƽ@:.L? 0*?CCACAcQ@Vv ?CCACAVv ?ؠ$M?_?░!?K?o7lH,R@=yX(ƽ@26?Q?CACAC1+.:R@>?CACAC>?DxJ? eV?0"?X[[?\Q@K{/,ƽ@&ZT:h?ݓZ?ACACT y9Q@%6EѼ?CCACTʄ C?Yj?dy"p?2@N?@ ? KQ@?5ƽ@e?tF_?CACTGltQ@Lv?CACTGLv??r7Sn?D?'H2>>%8?y0OOP@ec]ƽ@:k?L7A`?GTACC*6O@G@S6?ATACC9-?&0MK?Ԡ\?e,"c?G,#x5?.fMQ@Z8eƽ@4i? o_Ω?TACCTP@])?TACCT])?7.?Y_?<&r?¡9r? 0]Q@6H[> (6?RM@QI}ƽ@(b?<,Ԛ?TTCCC,PU&M@HZ2?TTCCCHZ2?I+u [?xJ?]o? -Ո?|%\KN@ґ\ƽ@f,x?gs?TTCCCu]t'M@?TTCCC?0 ?J?PZ}Bʘ?R;? !ɑQ@( ƽ@q ?gs?TCCCT\t/Q@)dR?TCCCT)dR?qKd?b &a?BB?ظs?6>Wg/R@kƽ@ ?{Gz?CCCTTۄ}R@u6t??CCCTTu6t??#E\?W?ˈ?] P?nP O@tƽ@i+?F%u{?CCTTC8O@ m?CCTTC m? ?yR@O?@u;?άQ?֣p=I@Uƽ@޺@/nr?CTTCAիwI@ڣ?CTTCAڣ?Ym3=61#?G ?0d}1?lL;P@ˎƽ@y}@( 0?TTCAC,oO@`!mҟ?TTCAC`!mҟ?*i? >?C?2B?hoP@1*ƽ@ T'?~jt?TCACG9aEQ@'1ƨ?TCACG'1ƨ?mYo=l?V&扮?\EBJ?@?'aR@ѳYƽ@ad?+?CACGGO)R@q?CACGGq?丄r(?{pS?fBܔ?p=8?Ħ*R@\ Aƽ@;1Y^?Ǻv?ACGGGI5R@П2?TAAGG-ѧ?8(?Lc?"H5u?/<חYa?!oQ@8A`ƽ@}/l?Aǘ?CGGGTF4 P@#?]?AAGGT!Y0b@?HI?nX[?Qg6h?PA?i$;P@) ƽ@O:0@H}?GGGTG@sMQ@ h&,?AGGTG7Fv^?f'?HYE?+ ?m79C?UO@9mƽ@̍?_Le?GGTGTE|ľM@m?GGTGTm?[3?t!?W:dj?S&߻p?AL@1*ƽ@%??ψ ?GTGTTl6M@AHi?GTGTG =?ƹb>UGl?@ '?op҇?\LK@ƽ@c8?x&?TGTTAL:ueJ@&x?GTTATvN(?jp9>p2h?TϡuY??KK@oƽ@+}i5?Mb?GTTAT<VdK@a?TGTGGkޤ d?[:k?Hʁ?Dd?W*?dϗ)O@aTR'ƽ@ ,@ o_Ή?TTATCqܟP@Fa6?GTGGTĻq"{?{|?Sz'?EE^? ??9T)P@O@aƽ@?{Pk?TTATCڿP@s`?TTATCs`?Cz?d[?Ĥ~!?,]0*? CY.N@lƽ@Y[{_@gs?TATCA@8zcN@?TATCA?pX?e"?3I$E?q-$?%pO@镲ƽ@6} ?_vO~?ATCATwP$TP@{PsZ?ATCAT{PsZ?߶t?1+v[?@!V?ƴ?}wHR@Oƽ@BQ.?ŏ1w-!?TCATC&R@ۡt?TCATCۡt??~kڰ?HòJ-?@Ab?X`3N@S'ƽ@)1,T@Q?CATCCDXN@lR ?CATCClR ?L|kBm?i#q?ORG?2L?rE'P@d`ƽ@¹b?ŏ1w-!o?ATCCCW6˜vN@&G 0?ATCCAI+ ?`T?XJM?dҒ?Nh Ҽ?)9jM@}гYƽ@p?Q?ATCCCcƙvN@OύD?ATCCARZq'?h:?=HNc?ulױ? ٭?ijBQ@ 0ƽ@$?H}?TCCCT//Q@{/?TCCAAMx?H'+?Y\?;T?Zf6-?OmnR@-ǽ@Qf\!{?"u?CCCTG4:fR@n:j?CCAAT= A?Ffț_?}5T?1AJ?9}L?!S=7>i E?J?0,N?9vxNI@+ ǽ@bR?/n?GTTTAjZmI@h_?GTTTAh_?|=UU?WH1MX>k?} ? 9L@_L ǽ@t9?46{e?=\? @~?q= ׍L@mǽ@{Zb?Mb?TTTAAԧK@H,:D?TTTAAH,:D?`-I>$Y݅?V*Q@`8~ ?TTAAT`8~ ?vb?5$n?o}?K,癪P?l )Q@W}"ǽ@uG!?~jt?TAATCE'waQ@ys3g?TAATCys3g?[d? ?7?oof? EM@ݓ'ǽ@{rX[?<,Ԛ?AATCGL@y?AATCGy?A$dG?$3{Fl?1€n?Y ? /N@|P+ǽ@̒m?vq -?ATCGTOxvP@ލ7?ATCGTލ7?T?f B?XRX?CF٥?Yc4Q@ g3ǽ@#HhU ?#zHR^?v3?'a]L_?ɚK@ q;ǽ@n@mxz,C?CGTGG\\`J@_?CGTGG_?I>%W& Ą?q?G^;?8"O@BIǽ@ k@`Qڋ?GTGGT܁N@zJN&>?GTGGTzJN&>?,|? ?Eɽ?<>%Q@(Mǽ@S_@y&1|?TGGTT0]; Q@f1?TGGTTf1?D( J?_?PP?9FH?uJ@jMNǽ@?ʣ(@{Gz?GGTTC#K@?GGTTT6w?i6~=$ K -?{9}%?=?wʫH@ Qǽ@?M O?GTTCTzH@.R?GTTTAk?ilm=9?6+> 7؛?sKH,L@mV}Vǽ@a:?ŏ1w-!?TTCTA^N@(?TTCTA(?/g14?V2?\4=j?=V(ݎ?пP@TZǽ@_p?2%䃞?TCTACCkb*P@߃E?TCTAC߃E?1?P „`?h)8I?P?tTP@3bǽ@budj?j+ݓ?CTACAQ\P@٥?CTACA٥?vBڹ?#e?~۴?N=b?.Z٢Q@J +gǽ@Vkɿ?a+e?TACAAa R@KT<?TACGA`9S?tĹ+K?S?)f|?j>?!oR@;Mmǽ@֊ML?~jt?ACAAT"HfR@1#7?ACAAT1#7?y7#?=H?6 3?S?*Q@k ǽ@uz@L=U?CAATGEõ nQ@ xk^?CAATG xk^??>?_17]ʄ?ک?F3?_JBEtN@:pΈǽ@hb?+eX?AATGTj$cN@fy1F?AATGTfy1F?D5EuC?rvs?CL?DjLo?kN@)~ǽ@Fu?_L?ATGTG.٣(N@Y:?ATGTGY:?LHi?Pܲp?Dܡ@Q?1@[:?d<8yM@ cǽ@!8zP@Ǻ?TGTGTzu/L@=`B?TGTGT=`B?Wk23?jv?/9B ?H?5 Kh!N@[ Aǽ@ ڥ?tF_?GTGTG6M@UgR?GTGTALaO?ƪ??Qǫu?#/2h??R@M@fXǽ@h?ZӼ?TGTGT v/L@_Wg?TGTGT_Wg?iNS?Wl?@hg?~?J;\~M@ѳYǽ@EC? QI?GTGTAHYM@zX?GTGTAzX?|*t?;oÕ?91+?`?=k$L@{Gǽ@} ?ŏ1w-?TGTAA=NM@ĺ?TGTAAĺ?Ug?ͼ7n?#C?0O?C՟'P@wǽ@%5@mxz,C?GTAAA P@m?TGCCAk??jy?-?m*]-u`?b\R@J +ǽ@O.d?jM?TAAAA5UkY?AATATcF?? 5h?ryȝ?zh?,jP@?ǽ@[? F%u?AACTC= HP@/t3?CTCTCMqt?ළW?^Ă?_VR8? [!?(P)߭P@d]Fǽ@=?V-?CTCCC @P@'WK?TATAA<gS?ئ?~ ?`?{?rRQ@gǽ@#? 0*?TCCCTY/Q@?ACCCTHF-?)~c$?sU?Q۲_?tZ8m|?COR@Ǻǽ@Hys?_vO?CCCTG# NfR@.25?CCCTG.25?(۠u?/gq?"Dy?\l%? ;nX2Q@Aǽ@d.?ZӼ?CCTGG$X GP@r̍?CGACTy}q??Ykd؂? s ?Fq"?qbP@Zdǽ@$.?HPsג?CCTGG HP@F\?CCTGAmO=x?BW?=T>[?9s1E?a?YvO@6Ƚ@eד@{Gz?CTGGG2O@( t?CTGAT;O?Yn?&e?/<?X? GQ@ÆW Ƚ@}@:v?TGGGT\&~Q@ +y?TGGGT +y?c;Qw?ónN?i|=?x^?Ҋ[3R@U Ƚ@\ @fj+?GGGTAm6oYuQ@LJ?TGATCهY?ft?t$?63A^?=$NJ?c M@q= #Ƚ@Ig @ZӼ?GGTATb~f%N@3l4?GATCT41??Q\m?@5y?Aㅷ?5Jx5?ʜN@ׁs&Ƚ@̊m;@ψ ?GGTAT(Ʌf%N@-Z?GGTAT-Z?Y ?*%/?3Ŀ?,P)?֏O@FGr/Ƚ@X\?{Pk?GTATCEP@ݑػ?GTATCݑػ?\?sC ?7%1M?t?(![WN@/=Ƚ@zpes@J4?TATCT k;4N@uA?TATCAKШ?%ı?)ZSQ@?TCCGC3f+cqCS@}8gȽ@ P o@ ^)ː?GCGAA ^xS@E5-,?GCGAAE5-,?ޏ?&O?Ɍ?5L<"A>SS@gjkȽ@xԒn6? 0*?CGAACQHSS@@1q?CGAAC@1q?^Kj?]? ɃϾ?JR>*a1N@:pnȽ@Ш d@R@RȽ@[;7x_@Ǻv?CCGTG"Q@_?CCGTG_?b=?6?dCl?/l8?G<R@.!Ƚ@Tk@gs?CCGTGz;Q@`Me+7?CCGTG`Me+7?+?TMDx?0 ? LN?]nnH@ͪȽ@@H}m?CGTGGz]J@@N7-?CGTGG@N7-?C=MzQJ!?#>k[rB?FkĊ4O@ȘȽ@ʱ_Qɑ?/nr?GTGGG\>ǼTN@:Q:?GTGGG:Q:?a?XX?)#$?=HZO`?N@XȽ@RL?gs?GTGGGfgTN@Ҵlp?GTGGGҴlp?eȶd?8H\gB?**@?= O?cz7P@I.!Ƚ@n@/S@?^?|p?Gl؏?Hz`qQ@JYȽ@h;@Mb?GGGTCdRQ@F@?GGGTCF@? I܏?eě?V?5{FX?ōP@OeȽ@"֯?:v?GGGTCѫбRQ@ٜ>z?GGGTCٜ>z?hoV?o?}?2Ȋ?dQ@)~Ƚ@9 @H}?GGGTCfRQ@f֌F?GGGTCf֌F?m] 9?vaf{??=mW?L@9gDiȽ@!_@gs?GGTCAX'K@Kuq?GGTCAKuq?{E>mP? A?Y+M?Ny..L@Ƚ@uQ@_L?GGTCA 'K@+B|C?GGTCA+B|C?o`>MFI?(?4[o$?/@RN@QsȽ@<\Z}J?@ ^)ˀ?GTCAGfN@uQ?GTCAGuQ?{֦?Q(ڋ?*|#??0bR@$(~Ƚ@6_ ?_vO?TCAGAJR@tP?TCAGAtP?'sO?e?7"?QY>{G `5?镲 ?ATGAT~cCO@"UI?CTGAT(}G2?E]?[j?dy?}W7?$:ZR@QȽ@F5!@a+ey?TGATG+RR@/H[ے?TGATG/H[ے?ŒB Q?N?W)P8T?T6hl?=(P@¨Nɽ@or@F%u?GATGA7/O@>=H?GATGA>=H?:\i?ߖGԁ?(g?oX?broN@鷯ɽ@<)?Oё\C?ATGAC|%~%#R@+e9ɽ@t+@J4?GGGATۖR@\?GAGAT"Y?ՠն5?ނFTɺ?:480?~UZ0?0S@V-=ɽ@S6?_vO?GGATATDqS@*?AGATAqRd?&4I#?Or&?'q?ytOO>RP@9Cɽ@"?Ǻv?GATAA sO@I4?GATAAI4?oXd??B|Lp?M+aV?gQ@TDɽ@g:! ?~jt?ATAAAo,CQ@v\k*?ATAAAv\k*?tOߓ?D?9O׎?o/ڋ?"Q@W/Gɽ@ӏcF?Af?TAAAGĘQQ R@S"?TAAAGS"?(`H?푵pS?[ ?fx?|R@PnRɽ@kc??AAAGA ioQ@PQ?AAAGAPQ?[U8?&?SD?6o[2d?zQwQ@Xɽ@o?HPsג?AAGAG콬eQ@CGD ?AAGAGCGD ?0LU?O_ Q@-`ɽ@:P@q?GAGCG±P@3#Hy?GAGCG3#Hy?樻?غ}?2?IБ ?"[ P@qdɽ@^/1;@@Mb?GCGTGǒV,QQ@By?GCGTGBy?(I~?_bV?SK?Z4t?׀4H@hɽ@vXJm@L7A`?CGTGGyJ@=ٻ?CGTGG=ٻ?f>usl?KY?{,?Q@iqɽ@b:tUs@NSt$?TGGAT2ijQ@"?TCCGT[ڦ{e?y?-i?rne?wLBh?X#R@~:ɽ@SVy @b2U0*?GGATC fDZS@VOQ?GCGTAZI(?֩?$d3?t?*?FK*?=W,L@ ɽ@iF@ǘ?GATCTuL@ٜy?GATCTٜy?<l>4m}?VMR?orϲ?Ph8P@ΪՖɽ@ba?<,Ԛ?ATCTC 2O@Z@?ATCTCZ@?p?7젹?dL?wK?D#aO@_vOɽ@I?"u?TCTCG*O@JBW?TCTCC ?IV;ղ?,#C?-!h?08T?xZ P@՚ɽ@0`$~g?Mb?CTCGG:nfLQ@TY?TCTCA9ް޿?dfԧ(?`aP?v?y@H.g?+? PR@z6ɽ@xҬ)?j+ݣ?TCGGA%e6#R@ jƲ?CTCACˍ?H?<\W?(L?!?H+?DwQ@ F%ɽ@=ܪ(M@gj+?CGGACoD9P@2*v?CGGAC2*v? ñ?Y?y?x8{+?4A?r?eC?ֿqUB?U0*,P@,Cɽ@H}x@{Gzt?CAGCTdMP@L?AAGCTi_(?\4d~m?P/2?X?72-Ҏ?vSb7S@!Acɽ@{(?ψ ?AGCTGO&0R@ w%?AGCTG w%?84~?_a?K\A?΄4?SaPQ@x&ɽ@pC @y):?GCTGA]P@A(?GCTGT0&X=?f{?P?v X?RJ@?\LfmN@\Cɽ@j{?y&1?CTGACأgBON@z Q?CTGTAU?nkeS@sɽ@f?faִ?CCGAA.q_S@o \?CCGAAo \?-5*?o?cf ?m;P>Q^R@zʽ@"?Ǻ?CCGAA*US@L ʽ@?J4?CGAAC4yWS@+ʽ@\'_]?HP?CGAAC>OTS@m\M?CGAACm\M??kN ?ZxӠ?!>K7ylP@.ʽ@@s@Mb?GAACA' Q@| ?GAACA| ?<@?@: ѐ?Q ?Ēq?)H R@4ʽ@oH,?J4?ACAAC=.R@^{p?ACAAC^{p?5X_,?fg=ā?B""?P?5J#IP@}?5^ʽ@8{,?ψ ?CAACT=;sqP@}}?CAACT}}?|7't'z?IKAD>?DMK`S?eV?7F"P@%#ʽ@vT`)?q?AACTCB&n:HP@>8?AACTC>8?mTx?o?L/v?&:l?< MPP@S%ʽ@?S㥛?AACTCh8:HP@t?AACTCt?k8?L?쐷?0yz?Q~?'O@,ʽ@0\r?Mb?ACTCT,[OۉO@e?TCTCTCy2?uOߨ?5?0Mɠ?J$Gc?Mk1/SP@+.ʽ@P?HPsג?CTCTC:L@Xj?CTGCTXj?kW<>>W-uCl?uT#8}?I?j{YL@atʽ@((N*?=U?CTGCT#;L@P\U?CTGCTP\U?2>It?;?ҙ׮?>lS@1w-ʽ@rC@{?TGCTCyКQ@xyB?TGCTCxyB?- E?wص?jz?[mTLA?BAO@joʽ@ EC@HPsע?GCTCG P@}Ft?GCTCG}Ft?^E֔?q?U"?%j?b쾷 R@ʽ@ԕc̟?(?TCGGA]#R@:6c?TCGGA:6c?W@?K"?p?ad? OfQ@ h"lʽ@wĽ?/n?CGGAGt_VQ@h?CGGAGh?T id?"&DZ^?nu ݁?]Cσ?2ޟT@hoʽ@CxѰL@Ǻ?GGAGA.T@kHi?GGAGAkHi?!3?9C.?%>#?׆:LX>}vHS@:Mʽ@&/i@n?GAGAGZyZtR@Xu?GAGAGXu?>y?ZU`T@AϦʽ@'$@/nr?AGAGAMDS@=q?GGAGAܧ2.?*I"l?؅s?x׻id?%@ͣ=`DR@-ʽ@n@Ǻv?GAGAA=_WLR@^ωC_?GAGAA^ωC_?%,U?Cqs?GW? ~ˬ>R%T@ ^ʽ@u@P?Mb?AGAAAB{>T@x?AGAAAx?(?\e@?vB̚`?',4 =be?R@ŏ1wʽ@Im?J4q?GAAATmT*R@?GAAAT?~?4?6&Y=a?Ʒ?LL?#§P@jqʽ@b!?HPsע?AAATC,Q@#?AAATC#?S?eN{?:R?[h~k?HUTM@j+ʽ@𳴕=?`Qڛ?AATCT[N⅜L@@?ܟ?AATGGpe ?uڲu?c7o?M]|?7b?p= g tO@\ʽ@ץ2?-C6z?ATCTGBO@(޽?ATGGT?CwSE?jb?̛Ӻ? &?k^La-Q@-ʽ@!+l1-? 0*?TCTGCGo1P@KNRʾ?TGGTGvs?ACGAT^:R@qp#?CCGAT2wEA?L03v?}%?}C?ej>*ER@Bc]˽@G?HPsׂ?CGATAMscR@eSr?CGATAeSr?^"ʷ?sDj.?#?]_7?I2+P@aTR'`˽@/v@J4?GATAAʰ8O@%MƬ?GATAA%MƬ?}Ҧ?Rl[0?1?F%y?PާP@Mb˽@^8?~jt?ATAAT _Q@j?ATAATj?ȶl?R?'`^Ղ?WNiU?mz.Q@ rh˽@㣐k?0?0*?ATGAC3bӤN@L"?ATGACL"?9h,s?gǬ?wg1R?zFR?aAI0Q@z6~˽@uQZ?gj+?TGACCbP@>jN?TGACG,Hj?HI?jjT?al}?׼?i-P@T˽@`m?mxz,C?GACCG ~NP@?CTACC*o%?f]?U?JK͓?'E@K? >Q@)~˽@}6?`Qڛ?ACCGCbQ@?TACCGe|2$?>aѓ??b?Ot۰?M?HR@ ˽@TiQ[?/nr?CCGCTQ@'?CCGCT'?7Ϡ^m?T?8B|?=u^>RMS@|Г˽@V?:v?CGCTT(R@fv!?CGCTTfv!?A BuF?] 7S?A$?e c>ݍN@St$˽@@b2U0*?GCTTC3)O@1z?GCTTC1z?yc8>Gp]?PSW?%7&?vH@߾˽@ au@mxz,C?CTTCCkqH@ n?CTTCC n?7=9?G~x>?HP?TCCCGǢ!Q@VN?TCCCGVN?ret?Q ? .?Υ ?a]P@1*˽@rȶ?ׁsF?TCCCG5XP(!Q@IF?TCCCGIF?Z=?p?h0? ϊ?F=JR@y)˽@_Un?UN@?CCCGG*#R@GW?CCCGGGW?ZX?vA?o?}9>S@˽@Uh@J4?CCGGTd>R@I{?CCGGTI{? ?UG?3?HjI ?T2wO@!Ac˽@W/@Ǻ?CGGTGOI^cP@USu<4?CGGTGUSu<4?EY? F?Ms0 9?}FcM?Rq6VP@A˽@x7҆@~jt?GGTGCEN@B>W?CGGTC6?n仌?j?fgEM?T?ףp L@e`T˽@-7t@-C6j?GTGCG_wF5L@ +zri?GGTCGcL?}t_X >cbº?'0(?(9l?.qVO@&˽@Ά@+eX?TGCGGɋ@B R@~#?GTCGG,c?3+s ?G?G??a?\27R@HP˽@@/n?TGCGGiaSB R@'M+?TGCGG'M+?RFo?%bB?Q?U?eQ@L=˽@(=;@{Gz?TGCGGt||B R@ϰ?TGCGGϰ?A1ʓ? (S?$3? = `?LR@Bc˽@8Q@/$?TGCGG\6$C R@"M\?TGCGG"M\?O]&??6X{?؏5E?]tt?Q@˽@z=wJ~ @Mb?TGCGGJ D R@ ?TGCGG ?J~? u) ?=7u"J?2 f?zR@0˽@nQ`k?Mb?TGCGG5D R@Ua5ך?TGCGGUa5ך?٨?ZG?#&?^{.l?ߟQ@mxz˽@& @ZӼ?TGCGG ٢aD R@}}W]k?TGCGG}}W]k?V ?XB?r{-b?UM=L?X9 S@g˽@0?Mb?GCGGA`R@LI.n?GCGGALI.n?uy?+Z?hlH?N j?3E-P@^F˽@’_@ŏ1w-!o?CGGAC2+iP@QU?CGGACQU?<Y?y?&Ѽ$?+[G?TDER@HP˽@+ ?( 0?GGACG,Q@n ?GGACGn ?^?6?i>g?i|:?IATQ@H˽@k$?ǘ?GACGA_bQ@}7?GACGA}7?5)? ?7bod?\?LMR@ű.n̽@4xF? 0*?ACGAAWNNR@w:?ACGAAw:?K}?<`?ܷ?!?7]yT@ׁs̽@@?CGAAA"ўSS@m U?CGAAAm U?+ֲo?!ozwQ?GSVks?/7ZB>R@C> ̽@i@ŏ1w-!?GAAAA]S S@T?GAAAAT? ."?RBw?mή?Pf>;nA}Q@) ̽@#LW?`Qڛ?AAAATq?AAATC>q?@j?<ִ?.04?G?VhL@v̽@"è?X?AATCC]OL@Ly?AATCCLy?[Ŧ?L(.x?aq?)6?SN@UR')̽@r1?8d`?ATCCT? N@OV?ATCCTOV??*1?7=+? ?nTN@|3̽@.?J4?ATCCTUMN@ {V?ATCCT {V?"Ej?ur_?9J$?N\(1? &WR@I}8̽@S6e=g?UN@?TCCTG)xVQ@o?TCCTGo?>.k?[ĝ ?<Ϣ?H\ 7?)P@ޓ:̽@~^s@\ Ac̭?CCTGC/pP@tOװ?CCTGCtOװ?fs(E?H͙6?C? ? L@kI̽@:λːh?z6>W?CTGCT}-L@Z&_A?CTGCTZ&_A?K^9>نg?vnT ?@?X# R@XW̽@J5@Q?TGCTCTQ@CW?TGCTCCW?xZZ?P0i ]?Eb1?x\ c?PP@vq `̽@rr1N?( 0?GCTCG |k P@Sng?GCTCGSng? g3A?Z[?ǿ?[a? U R@JYf̽@iRc?=R!?TCGGTH/@R@xGN?TCGGTxGN?{e?U DI?vD?~?awzP@Dl{̽@/7@_vOv?CGGTGmcP@BmB!?CGGTGBmB!?E#ɠ?N'E?Vc?nl@N2?MLHO@QI}̽@Y8VvL@a+ey?GGTGGDM@-D;{?GGTGG-D;{?W V?u_‰?bd?U?oyPM@?~̽@ ? rh?GTGGGc%dUN@S ?GTGGGS ?h{ [w?شW?s6?h=k? |tQ@9̽@Oy:@Mb?TGGGTQȕ~Q@EJP߽?TGGGTEJP߽?a}M{?b??D?ɟ[s? 2-R@`TR̽@n5?Ǻ?TGGGT`X~Q@*˴>,?TAGGT[Y)??vLB4?dj!B6?&'x?nQ@V̽@dO|z(@?߾?GGGTCc@RQ@BpX5?AGGTCҗ?dp?b4픀i?߳?q|4Sv?=Cw?a8ob?j?X-o̎K@~b̽@0a:J?Ǻ?GGTCA=wYK@WoG-5?GGTCAWoG-5?]K> M?sifC?k?|G&+M@5@̽@N^?2%䃞?GTCAGB>7N@GjA3?GTCAGGjA3?ժ[ļ?Т&?_c?h^?WȫiR@̽@f<'@?L7A`?TCAGG2ҫR@hĐ]Z=?TCAGGhĐ]Z=?cee,?V?L~?oA? +zQ@e`T̽@N!J?Mb?CAGGCjQ@cװ4?CAGGCcװ4??\]\?Ewme?,:Z?YP>P@d`̽@js ț@?a+e?AGGCG!8=P@^?AGGCG^?J?Zs?._'?4c?fu'S@Y̽@[Z@{Pk?GGCGCAư}nS@|J?GGCGC|J?R?g?;ـ?M`>j5R@T̽@)+ ?Uد?GCGCTjQ@w;uz?GCGCTw;uz?!??rP?C5~WW?jوnS@[ A̽@졙7?H}}?CGCTAkFr?R@ w\?CGCTA w\?>Wo?v j?4_z?HwW8?(pxP@HP̽@ 5$?<,?GCTAGPʕAQ@sYWײ?GCTAAy$-?Qh?L`ҵ?1ߝ3?jvJ?G R@58E̽@C;?-C6j?CTAGCaqR@oV)D?CTATAw>?C{? $aB?3C ?+h?7.\jP@̽@r?l?TAGCT /P@i>|?TAGCTi>|?Mjj?p?Fa{}?=w@?+Q@v̽@b<ϤN?ZӼ?AGCTC E:-R@u?AGCTCu?фX?1s't?#?kf|?U؝]O@Mͽ@ת!u7?vq -?GCTCT6wO@D\ͽ?GCTCTD\ͽ?8R?8v?n ?'$? 6N@8d ͽ@Yb @ ^)ˀ?GCTCTQxўO@Z>e2?GCTCTZ>e2?pǐ?љtq?X xK?1$1?ЂW.'Q@ $(~ ͽ@! ?7[ A?CTCTTGp$P@؊0?CTCTT؊0?k:?VlA?!O?%?b/&M@Hͽ@}w)?b2U0*?CTTAT.ZL@5@8"?TATCTR9 ?LLD?fX*k?v:B?w??ԭH$yO@ "ͽ@nޖ? ^)ˀ?TTATT!ER?P@^?ATCTTu>"?5[?8? i>e%m?(0?\(?mcM@7$ͽ@* ue?C6?TATTTcN@X\(k?TATTTX\(k?U[D>]K鍪?ʡn? ?O H@eDͽ@\|Bh?q?ATTTTֱMI@C꿙?CTTTT7v2M?](R^=>= j@>0%V??}J@DTͽ@tⵆ?@Ǩ?TTTTAHZI@P?TTTGCSq*?P 4=dJO6?P]"SN??'?̾b|K@Taͽ@uu@n?3?TTTACǑpK@EѦ?TTTACEѦ?Uc>6?𾝣r?a>? `:P@k yͽ@>]K9@_vO?TTACGwWzO@+͹?TTACG+͹?YU?l s?t2$܋?l?<֖Q@Y5{ͽ@)>-}?_vO~?TACGG\Q@~,?TACGG~,?}?=UF?xR\M?av?/$wR@V-}ͽ@Y?y&1?ACGGC[7 R@iC*W?ACGGCiC*W?3PqH?r7?g5? ϟG?߫M@{Gͽ@4I?:v?CGGCGcO@G)K?CGGCGG)K?Gt?x ?jп|,E?^<[KTX?Y}%NS@-ͽ@ J@a+e?GGCGT<瑹}S@WC&?GGCGTWC&?"N=8Iʟ?]Pdr?y c0f?@>rߤQ@,Cͽ@u-@?GCGTGRQ@Dx?GCGTGDx?`iZv??y?Tz$[?Z1[H@ ͽ@!I@C?$>mJN@Yͽ@qќ:r?HPsׂ?GTGTAM@VӅ?GTGTAVӅ?XV\R?CQ ?D?HP'?DПL@Լͽ@?V-?TGTACizL@Jl?TGTACJl?&s'aP?af?Y^۱?hCy?ޞQN@ioͽ@p?B.? ?GTACT^*UO@\z?GTACT\z?$^?A?Ĵ_-?#6?o8#Q@Bͽ@{ʃ?/n?TACTTQ@bb^?TACTTbb^?未O??k?0[Rw? P@X2ıͽ@~eԘg?Mbp?ACTTAnqyO@ZE8+?ACTTAZE8+?cT~Vy?q?sbUM_?^<|e?uJcL@Wʲͽ@jIB2?^K=?CTTAChhL@wy?CTTACwy?A?RP ?D>?lZUY?&?v\aN@k+ͽ@ٚs?H}?TTACCG"O@sGf?TTACCsGf?#v?Z+he? U$?r?qVnO@{Gͽ@s$=?"u?TTACCd応O@&x"-?TTACC&x"-?q?*sZ?9IIih?u?tP@1ͽ@Ƨ#J?F%u?TACCC P@`0?TACCC`0?M$"?oΏ?寇R?Gd?YlQ@ qͽ@9g?&1?ACCCTn_2Q@~ P?ACCCACUj?`Ûm?(m{?6 Wto?.,(w?Pc!R@bͽ@i4? o_Ή?CCCTALٌR@;W?CCCTA;W?ZK NY?55?c?a~B?ڐ>CyR@#ͽ@ eQ@jo)ν@f2h??2%䃞?ACACTm\GQ@/V%?ACACT/V%?3c(?riF$?qP!O??QYQ@x&1ν@ & ?-C6?ACACT-rQ@Yzv?ACACTYzv?,? ڛ?dG??-?2#R@9m4ν@n#?gs?CACTTXM]Q@K1?CACTTK1?`j>?_?5 ?|}p?,N? }N@H?ν@]@ݓZ?ACTTT{x0!O@9 C?ACTTT9 C?Y?#_>@:?/_?_?RI@]Hν@*n? g?CTTTTI@'R?CTTTT'R?NF=:O$>$X@>Ahв?E;I@u\ν@? rh?TTTTAUw@I@O??TTTTAO??gnIW=;TzA>^_k^h>ٸ4?SK@Oeν@_?J4q?TTTAT*fK@Rj[?TTTATRj[?T!)&&>d6!?]i?z7tZ?8_*@P@fν@M?+eX?TTATG2ɞP@l}?TTATGl}?pY? VA?g?ؽ?@ӜzL@ iν@| u? F%u?ATGCTL@t!?ATGCTt!?j۔? t%i?}gs?'n*?m*Q@1*pν@~[@?TGCTCSQ@0?TGCTC0?Mq+?oB ?=E2 Q?M.|?5CSO@zvν@"zh@a+e?GCTCAl}P@u6\?GCTCAu6\?i_7w?@O0?g-?̓k? P@ yν@ݼ2ݦ?eX?CTCATz7kQ@@?CTCAT@?SI`?{/b?u:7??t dPR@@ν@ɸܪ?ZӼ?TCATT;SKR@cs?TCATTcs?f"QyE?äfY?Ud?PI 4?ݫcyN@.!ν@*l#.N@ݓ?CATTG $N@p>??CATTGp>??Df>kA#@?k^t??u!K@6ν@ޠ:9?Mb?ATTGC4-yK@V*3?ATTGCV*3?]>&lg!>.}Sy?~ۇ?K@{,Cν@k'??߾?TTGCCAK@hi3>)}-?$kg}?%SQ@d]Fν@ \(4?n?TGCCC ПP@ P?TGCCC P?`uɺ?l??7Ǚ?"(UQ@fXν@9)#@5;Nѡ?TGCCC }P@rE}J[?TGCCCrE}J[?N ?A*x?-&>4?w?hzGR@L7Aν@xg @/$?TGCCC?;P@a?TGCCCa?o']ۆ?`F ?RcE~?r/'?bgQ@ʡν@Z˘?J4?GCCCTsQ@ׄԶ?GCCCTׄԶ? Xf?z?f]6?+s?i"{MR@]Kν@xZ??ܵ|?CCCTT]o~R@Ns?CCCTTNs?$Eę?Tq?n? >;3?iP@ν@\ @a+ey?CCTTC:kO@K9> ?CCTTCK9> ?5V?S^se$D?,6H?b95?5ǴO@uν@͗Plur@Ǻ?CCTTCsO@,͘X?CCTTC,͘X?4r7?Yio?[?vXKܕ?l"WI@fXν@]?UN@?CTTCAm{xI@?CTTCA?̎pK =ZL??䖂a?qYGM?S]!P@0ν@$SM?C>٬?TTCAAO@q1?TTCAAq1?H?н?(+O@xϽ@l~?ŏ1w-!?AATAC㥅 N@Z"$P+?AATACZ"$P+?MJ?B5,?xg?N[Q(?6i1N@僞 Ͻ@F3o?J4?AATACN@x?AATACx?}]./[?-(*s[?1(o?"@(T@?īZP@wϽ@hJ2KW?gs?ATACTSJ1P@M!Ħ?ATACTM!Ħ?1 5?5ؾ.?7m?#3s?Ut6`Q@$Ͻ@1>hn?Aǘ?TACTT*?/Q@u ?TACTTu ?Ø#?3F?fBp?tn?-[lO@Ͻ@K`vq?vq -?ACTTCgSԋN@2O ?ACTTC2O ?S^ ,?ANi?9|u?8ɯO*q=ٽR?WM. ?SD?;7O@B-Ͻ@=Qm @ZӼ?TTCAA'8O@PFa?TTCAAPFa?}G;O?*ꏈm?uư9>>\µ->R@A`0Ͻ@\A?J4?TCAAT.R@i-H?TCAATi-H?5?C ?*Z_?q<> eBgQ@|a25Ͻ@u?<,?CAATT.ΓQ@rhr?CAATGPg? S5D?ߞ& ?*q?mr?W-rQ@H?Ͻ@D!P^@~jt?CAATTZϓQ@f /3?CAATG3.<(?>t?B'"?ަOi?XYm?aS.DN@ cZBϽ@}?{Gz?AATTCdBT8L@d4?AATTCd4?#sX?'^?y]ɚ?8L?E:L@|PkϽ@z[ @ͪզ?AATTC{+?L@RX?AATTCRX?(̪=>(J ׄ?t?Ia? &qH@ǘvϽ@g@:v?ATTCA?_āI@*y'?TGTCAdI?fP&\=1YW'?M??Z1.JO@zϽ@7{anj@(?TTCAA厩O@ ?TTCAA ?hrp?%Aw#?BS C?MןVxP?\WGQ@ Ͻ@E1g/i?Q|a2?TCAACI.Q@(Ѩ?TCAAC(Ѩ?0p)Q@X%?AAGAAX%?2h?\Ok?,n?.;p/?󆋛pT@Ͻ@3mw@d`T?AGAAT ;T@/ ?AGAAT/ ??#ܽ? l\x?i=>䪻8Q@/!Ͻ@1!@S㥛?GAATA>$!R@k?GAATAk?A1?'6{d?u?#G?eI+M@-ԚϽ@iܽ&>?mV}b?AATATU6O@ ˕Ý?AATAT ˕Ý?mYjw?U&-z?|5~?Rx8Wn?"h?$?x4TzI@Aaн@%<@@ǘ?GGTCT50J@x/?TGTCT ?o@>h?_4"?}m r?z:N@ѳYн@er8?H}m?GTCTTSޢM@!l?GTCTT!l?Ǟ;4џ?ĵ?t^!VnР?ؔ9ݰ?L\P@Gн@+t?@ǘ?TCTTAД@O@Sv?TCTTASv?g5;ߍ?b "?ySn?뇃.Ay?RVlL@N@!н@tn;?L=U?CTTATvӿQ[L@l4?CTTATl4??*n'b*z?/|?RY?GzO@) 0н@Ol8@-C6z?TATTA۰N@҅5?TATTA҅5?g)?J|{jn? 9?o7{?6*2L@|a2н@U?Ǻv?ATTATF?SxL@a?ATTATa?%[/"?@,P?5 [?ֲL? mpP@|3н@n5?n?TTATCBP@nOU?TTATCnOU?>k?f\E^g?5NK;}? )?NVaM@@Gн@ai?M O?TATCG!^MN@=fs?TATCA ?:r ^?Abƛη?Q̱ ? VV?7ubQ@VMн@c@{Gz?ATCGGh(P@(\[j?ATCAG3n?P ~? "Q?tԀ ?G 'c? `yR@V-Rн@.F[v??߾?TCGGG4)!R@L=|T?TCAGGD̫e?  ?KE)?'L?3|J >mUhQ@ 0Yн@^@?b=y?CGGGA@ VQ@yU?CGGAT֑Fd`? AeHt?cq\b|?5[,({bjS@z6kн@#t@F%u?GGATGm3S@!=!?GGATG!=!?|r=?*9Ѡ/??Ď?Q𠷅> A4P@?н@Xv @`Q{?GATGTڲ:EO@$(?GATGT$(?B ?upG?(<`?@=?k?shQVM@#н@H6?Mb?ATGTG"á$*N@7?ATGTG7?xk?̶9=x? Wt?&~x?[uSN@ н@el\sW?Ǻ?ATGTGcQ2_$*N@u b?ATGTGu b?VQH4?SWBs?? J@oŏн@%"?&S?TGTGCPK@\u^?TGTTG^4B+? iR`w>E9?1[9D?h9!N?r0?V¾NWL@4н@> d?HPs?GTGCT:Kf$j3?V!_x]c?z,ڍ?wER@7>Wн@MX)=@<,Ԫ?TGCTAFhbbR@?TGCACˏf!U? ^?3TH?گd?DTK{wyQ@!]0?ACCGGx?Nq<:?†g.?:1?7|ַtw?5S@Cн@$&7:?-C6z?CGCAC+141.S@ 8.?CCGGGf ?jA?!8^?N?1h>+HvQ@н@YYQ@_vOv?GCACAȽQ@"X?CCACA9Yq(?A 1?D?<כq8? SJ$5?NQ@Hн@nթ?@ZӼ?GCACAK{ȽQ@?cƌ?GCGCAMVˡ?Kn?o=?|L?U*˝?p.kR@A`н@`[? ?ŏ1w-!?CACAAcR@S!F?CACAAS!F? gj?K}B?\a#?aM[6?`,~R@Vн@E M@~jt?ACAAAaﭨR@t?ACAAAt?h[7G?`A?Gi?=;ɧ?TvbQ@6н@$ Dc?H}?CAAAC2DSQ@AX? ?CAAACAX? ?bw?s~z?Rb:?)5En?yO@ ѽ@x$h?Mb?AAACAc$P@5.?AAACA5.?Rt?<`V?i)?%y?!lP@}8ѽ@ZzM?{Gz?AACAA~P@&Q?AACAA&Q?m¿?qo?JP?4Ɉs/?aR@y ѽ@>i8?8d`?ACAAG:EdR@ѽ@@Y?y):?CAAGA<]QQR@!_?ACGACF2?Y3?=1?[?1Cb?NzFQ@Լѽ@E}? o_Ή?AAGACZ&emQ@{?AAGAC{?Cc?af@M ?E-?RY?) Q@¨N ѽ@.?"u?AGACA.Q@7?GACAC"qf?X7R?Zz[ ?TBY?3}?)<Q@@"ѽ@͍6? c?GACAA>_Q@ T?ACACAȸ?T}?Dq`?e-H?Uy?PMR@FGr/ѽ@;?`Qڋ?ACAAAЁLR@EAu0M?CACAC,,V?B5*?a4w?L@z?O Ot?r5ܮpQ@jt3ѽ@*iо)?/$?CAAAAdNQbR@㋣?CCTAAhѩa? ? u?N?^#vl(#?MI@R@8ѽ@B'?+eX?AAAAAPfrQ@θ?CTAAAy傼?`?g?pۦ]?Sp?ͱR@6;ѽ@)?)\(?AAAAAʰQ@|z-H?AAAAA|z-H?NZn?6M?lr?%8R?3Q@+Iѽ@p24?n?AAAAC3U0ttyQ@{9k?AAAAC{9k?}#?ó^?',?ӶW :?4=P@-Ԛ]ѽ@@n?N@aã?AAACAd$P@/PG?AAACA/PG?G~?Ǹ$>?+? nZT?VXIR@]Kgѽ@gb? 0*?ACATC"JIR@i.$?ACATCi.$?OG5?v$?<3t?V.D?!sҊO@僞jѽ@b}?46yѽ@9 ?gj+?TCTAGŭ슒P@8ө*?TCTAG8ө*?*?u[?qU?GC9?hR@ѽ@w&?F%u{?CTAGT,ZgjR@iP?CTAGTiP?E69?f?w/iU??*}/DQ@=Rѽ@#?JY?TAGTGk}Q@ny?TAGTGny?_^V9?8?L{3dV?\[pp?zD?2iq%? - K@xѽ@?|hW@Mb?AGTGC=/M@ -?AGTGC -?W8>%9SE?]2?̳J?|mqL@]ѽ@Р@q?GTGCG.L@B?GTGCGB?^$|>y?>g?{LHtT?(\K@Eѽ@6U&@?gs?GTGCGX /L@yq1?GTGCGyq1?}h4Ԯ> o9gX?5% ?g?|F/Q@Mbѽ@Ґ/s @ ?TGCGG' R@rZ?TGCGGrZ?r!9E?q?4k`ZM?phWM)??ͱ:R@NSѽ@aC?ʡE?GCGGGR@/?GCGGG/?Tca?ať?S/ ?b-V?a|>Q@0ѽ@H*!@ ^)ˀ?CGGGA',nuQ@?CGGGA??.""?J I3x?X1MYx?<\R@镲ѽ@mҾ@ZrR@8ѽ@k?46N!Q@͕?AGACTcդ*?Obp_?OŻu? Y]?;3\?"Q@]Kҽ@d~4?~jt?AAAAC@QyQ@kkfq?GACTT]?$d?{(0!?[vz??i0N@Z ҽ@[?aD?Dl?AAACCTO@;+?ACTTC^x?1? ɏ?nW?bτ݊?۸,P@ܵҽ@ɯu@ŏ1w-!?AAACC&O@Z"?AAACCZ"? ;`?f?_xw?ɲdd?C2 O@:vҽ@gS?@ǘ?AACCAU&ɦO@~!?AACCC}U2|??(?ZJ?N>>T? l Q@T$ҽ@5O?X9v?ACCAGQ@`K]O?TCTAG??l:0?y?OYI?/?\M ?y߅S@_,ҽ@ǰZc? rh?CCAGA;[HS@ 5 ?CTAGAi!?K uz2'?T|?$#?>2,>;R@>ҽ@/Y?V-?CAGATzT_Q@YT?CAGGT9r?}Vm?t!f?*??y1Nd?N1j81!R@\mEҽ@7&4@_vO?AGATT)H S@O+U?AGATTO+U?m'?a9?y|?KCR?1 [M@EJҽ@(uq@M O?GATTG]M@V;-?GATTGV;-?}oI>xʃc?V1݄?rWqW\?Cio L@ Pҽ@C-1 ?{Gz?ATTGC$*zK@tPM?ATTGCtPM?:>):~?z҅?/?YPL@ Rҽ@&@_L?TTGCTcZL@CXI?TTGCTCXI?zi3?J쬘`?8-X? iC?^RL@}гYUҽ@TSl?S!uq?TTGCTZL@S ?TTGCTS ?!y9>58"=?f5?k? L@46\ҽ@|;@ rh?GCTGCg6Q}P@JLFz?GCTTA&K')?][4>l$9c?sF?1/g?O}P@-`ҽ@~=O@w?GCTGCZw}P@V&?GCTGCV&?X'=%?,tG?Wܡ_?|; ?mKҶ!L@_I bҽ@6v2? ^)ˀ?CTGCCLcWM!L@9 ?CTGCC9 ?nmjk?d;?ɷ5?bt%'?|;Q@2%dҽ@0??TGCCC W P@6P?TGCCC6P?13??0-=?uH+|?K>VL@wOjҽ@`Յ"@b2U0*?TGCCCXP@AOd?CTGCCAzϨ?pD%?õۿ?LQ ?c?aQ@Clҽ@Ss?J4?GCCCC0.Q@z֓?GCCCCz֓?B5s?.?G4?e<3?9,lR@Dpҽ@=`С?Eioɤ?CCCCGbER@%&?CCCCG%&?xXf~?0?#a'? vE?8AR@L={ҽ@\o?Mb?CCCGC ttXR@!Y?CCCGC!Y??,Yϒ?|M?M1X,#?[ғkVR@QI}ҽ@)?y&1?CCGCAWDvQ@` K·?CCGCG:Р;A?V,?JaO?}F?F9+?%L$3S@Stҽ@ނ ?gj+?CGCAA8S@a%(#?CCCAABs~R?8?' ?Ifk?<^iQ?1UR@iqҽ@qi?HPs?GCAAG $R@ڪǸӱ?CCAAGFh)?@HUe?p-?=3c?Nr?5TR@j+ҽ@ЯH? ^)ˀ?CAAGA{:qQR@*k?CAAGA*k?J]?{˓g5?[:Q?M~i?ٞQ@Dҽ@uvD@ ^)ˀ?AAGAAGszQ@0?AAGAA0?rU{?!p?$&Ǜ?`K5YΉ?:/=S@}?5^ҽ@/'rwr?0*?AGAACs..S@ӈ>?AGAACӈ>?m'L? ?j J?e۟>&X#P@?ҽ@2>@H}?GAACC176P@#?GAACC#?bL?0}?@.ȢF?|`Y?O@Sҽ@?Zd;O?AACCTJO@Q6< ?AACCTQ6< ?"8, ?BM \?xSO?7h?r vR@aTR'ҽ@lA.@'†Wʲ?TGCACw'NþR@e3r^0?TGCACe3r^0?QEb?0>B?,|h?91ǧ ?Q@ҽ@?NSt$?GCACCSQ@• ?GCACC• ?S?~^5?Y!N?~S9?̽pQ@Ǻҽ@GZ?M O?CACCTGֿQ@?CACCT?`?sF3?pd?wT'?Z:?Q@Pjҽ@SU? o_Ι?ACCTAa Q@kB?ACCTAkB?p?kPjtC?;|3˥?$?T>Q@,ҽ@E9*_E:??߾?CCTAT8,/vQ@0!?CCTAT0!?w=6?DŽ> ?zjJu?l͝2N?=DQ@Gҽ@ft?"u?CCTAT;!ŹvQ@F(?CACCTVE? $m?<*[?:jF?7%KԬ?zuQ@Լҽ@>H1s??Ƭ?CTATGjdQ@x?CTATGx?"SU?xFi?c?1N?#-$寮?=1ʥP@Fx ӽ@pX?I +?TATGCogO@s?TATGCs?;+]?) rj?}>? 3?Ɍ^ɷL@Hӽ@u4?&†?ATGCGuY~L@T?CTGCG, 8? z|n>ڳL?4p#?s?l.$MP@2ӽ@SFڄ@~jth?TGCGT#=BR@<_(?TGCGT<_(?f13?F?{G(*E?$YЛ?U.vs?i$ۦR@Gӽ@_Ì2? o_Ω?GCGTG=0 Q@*(=|?GCGTG*(=|?Oq?*U`?ܒ{?%Bn]?uA/?#NJ@]K'ӽ@+VȐ @S㥛?CGTGCxdJ@~{`?CGTGC~{`?H󡿠Ǫ>.=? _?TZQ^?W ?HzQ@2ı.ӽ@ <@ZӼ?TGCCA])Q@pN=&?TGCCApN=&?@Q;?} k(B?XBN[? ԥ?a|R@6;N1ӽ@-d? o_Ι?GCCAT,XGvxR@?GCCAT?鐇Ҥ?V\?07?Hfw?~R@7ӽ@$G7?~jt?CCATC) ŁR@T_ͼ?CCATCT_ͼ?hK?8ܳ?i:?:ߡO=6?VN@<ӽ@D5I@I +?CATCT:hN@nx ̊?CATCTnx ̊?VWGN?bf{?B%˳??38M@o?ӽ@l7?ׁsF?ATCTTO O@&q/?ATCTT&q/?q]PR?zG?0Y?NF[?a1X P@ Iӽ@ŭ{?eX?TCTTAtnQO@vNE'?TCTTAvNE'??Ҫ?8p-]?S)~^?ۉL?mK@`vOVӽ@ ?J4?CTTACDJwL@%/?CTTAC%/?Ĉp컷>b9T??K??igU<\L@DXӽ@If?ʡE?CTTACo<L@0S?CTTAC0S?%tm?;"?6o?7dB?Pj?E|=Q@jqnӽ@Ky? 0*?TACAG8)Q@?TGCCG3?5S.?K?(|]h?T2n?מR@ŏqӽ@?"u?ACAGTUR@l/?ACAGTl/?7? i?IL4?_Vg>48PQ@Aasӽ@mG= @"u?CAGTT)^VQ@.zKd?CAGTT.zKd?U@?!͉*@?Bn?0ˢ=?d8BK@0*xӽ@d1=Z@ZӼ?AGTTC`?J@?GGTTCf\$?b%ü->\sa?75l+X?'B?d "J@Y5{ӽ@V6M]?_L?GTTCCVh|vH@e)j?GTTCCe)j?EߗTh>AM?Pw?uE?їPN@ׁsӽ@5z@HPsr?TTCCCaSM@;j?TTCCC;j?y v&?;7i'?#6t?j2%>a?yWP@l ӽ@Zթ?/n?TCCCC>0{Q@ ?TCCCC ?zckt_?A?Z.8?gsOX??2xR@ h"ӽ@>픤?46IS@?ߞӽ@8kV^ ?tF_?CCCGAfR@ޕoB?CCCGAޕoB?I|?΢m?A™?;Eӷ‰>@S@eӽ@1 _?Mb?CCGAA].S@idM?CCGAAidM??T?%0k?=pnz>즹n,%S@鷯ӽ@L.?( 0?CCGAA~Q /S@Ƚv?CCGAAȽv?;U/P??P˺?7]?&>ѢS@e;Oӽ@~? 0*?CCGAAr/S@h_[yu?CCGAAh_[yu?RP՚?4n~?CaR?0Mɀ>]nnS@Zӽ@*Y?rR@j+ӽ@\%JJp@gj+?GAACG5"^P@ۼ|U?GAACGۼ|U??)Y0?sCO7?\-?Q@Eӽ@@+?_L?AACGTDP@⫮:?AACGT⫮:?]ˌ?!C?S<?ڜ4?;Q@&uӽ@8Y:D?HPsׂ?ACGTG 1@Q@RX?ACGTGRX??R1?nh?9 P?/@J@Eӽ@4@?CGTGCfdJ@UX?CGTGCUX? #f>#k~+?r5?x8?$+NR@W}ӽ@:@^K=?TGCGT~,R@c-?TGCGTc-?|ק?@??uR!?:W 0?O G@;Mӽ@v m@=R!?CGTCG6ӲH@ޟU?CGTCAR?אƺ_=jA)>X>!A(?)^3P@nԽ@vYc@<,Ԛ?GTCGG6TN@N,q?GTCAT`c?c+?T^?v?\fp?Q R@AԽ@/8H?-C6z?TCGGA̬z$R@է8?TCATA*>!?zx妖?/M ?ל?4$:%;?O@ rԽ@õr? 0*?CGGACqplP@;Ff?CGGAC;Ff?S]8Z?k0!j?!V{s?ti?@5YR@Fx Խ@~] E? QI?GGACAyR@&<'ظ?TACAT' ?.?7?i+~?i {>F?gQ@WԽ@E?J4?GACATȩQ@B ?GACATB ?0Ȣ?}hp?!#=)?_?dA=sR@DԽ@ 1{? ?ACATTIR@9MXz(?ACATT9MXz(?.?t?V/?K? #D?g N@V-Խ@rӱ_@gs?CATTGlN@ z*?CATTG z*?: dyj>to ?pg?+ >?o<5?ATTGCQO>o<5?8mֻ=>>0,P`?s(?VZ-HL@&&Խ@hW:=? ףp= ?TTGCA2v,GL@2?TTGCA2?{@@@|>F6J>y0?xR?QxjR@8EG2Խ@ .)`@HPsג?TGCAGxu2R@Vo?TGCAGVo?j޻?hў_P?oE ?FMSb>>bS@/!6Խ@woT?Q|a2?GCAGC;S@1Op`(v?GCAGC1Op`(v?Fe?1oTCB??;4PB? ףP@=RAԽ@z?_Lu?CAGCG1aP@Bx=o>kt?%5tM@(MԽ@ծSd@ǘ?GTCGGɛTN@X?GTCGGX?(+M7+"?σ?}X?O?OVQ@6;NQԽ@?Ǻ?TCGGA $R@Yt?TCGGAYt?6f?KHy??q{O*H?-[sdQ@<,TԽ@!7?<,Ԛ?CGGAG7ٽ/WQ@!{|z?CGGAG!{|z?Y [?PLT?q$;?yW?Nbx?JT@ cԽ@a @Mb?GGAGC'KNhT@M?GGAGCM?zw*?&Tlۜ?߬dw?'EH(> S@a+eԽ@jRB?_vO?AGCGCĻR@컯I?AGCGC컯I?@?Ǜ d?ێͳ?0Z>X^>TQ@gjԽ@=-F?y):?GCGCGލgQ@zCvp?GCGCGzCvp?1?آ*;?v\-?WxK7H?.jS@AoԽ@MTْ? 0*?CGCGAQS@BFB1Ԥ?CGCGABFB1Ԥ?2|)?(hT^?\?P4>/?)S@8EGrԽ@)?H}?GCGAGBS@?GCGAA^k;?X" ?b&ǁ?3`=?&N5>;?uS@ yԽ@  ?,eX?CGAGC{@4S@P5F?CGAAATU?j?`m?ϠluhDz?GAAAAQ36?&+L?n"?B?5Y?Fn*S@&Խ@7S?&1?GCACT`;SR@)# ?GAAAA_Ki?+i? U9? ?zE?tL7R@Խ@S2?Mb?GAAATƯR@ DY?GAAAT DY?_Qz?Q+ȡ?Bk?>QP@F%uԽ@+@A]?8b?1?UeM@Zd;Խ@˹j?g?2%䃞?ATCCC RxN@AK?ATCCCAK? c?W?͸i?k&?7&%ϗ?o P@c]Խ@ٶ?HP?TCCCAȦ$K4Q@?TCCCCŢ)?|N:m?L?&*PӛXz?bG?R@ZԽ@7_$S?Q?CCCAT4GR@G$?GACAT̻ ?͔?EN?GVYW?2Xmt?oxR@HPԽ@/ c?&S?CCATCd?R@\83?CCATC\83?6c?+?GCGCCᷢQ@v|?GCGCCv|?Q!" ? F ?}%XE?[3?ɖcgR@8-ս@Ǡ?&1?CGCCAV/l~R@"V˹X?CGCCCp(?? f-?>#?jԻ?(3?y$Q@<,:ս@@` ?/$?CGCCA􈕝R@(u?CGCCA(u?8?HL$?5sb?^aj?PpR@m4@ս@F+?a+ey?GCCAG$gR@>g ?GCCAG>g ?;"Х?8LG?k^ 6?\4?q= WhfS@Aս@a*?/n?CCAGAHS@6b?!Q@Gx Dս@šY?mxz,C?CAGAG)LQ@?CAGAG?6Ѭeh?i??G%?ÊtC?n@`U@ݓGս@pu9@:v?AGAGAۮ5'T@?AGAGA?e?Bfei?@"؉?/j %=;u-S@5;Nս@J^ @?GAGAGkSuR@(7@!Ut?GAGAG(7@!Ut?%s&=?. v?9o?gYS>̏!T@K4Qս@:m|@@ZӼ?AGAGAa(T@jEȉ?AGAGAjEȉ?JH{Y?q???~5p??8>Xk#T@v_ս@m? o_Ι?GAGAGguR@ܟa?AGAGA?WYDSX?9D?9aJM?X:OWT>?>S@1fս@3'@o_?AGAGC۹BS@=?AGAGC=?ll?-uy?))_?K>t VQ@@߾nս@&8/.@:v?GAGCAk+|P@ax?GAGCAax?oW&ȵ?~`?5ϐXo?3{?[D] R@Afuս@%r@_vO?GCAATΓNR@z?GCAATz?Ixo8?~?Ps?XQ?2CvQ@ 0yս@??ZӼ?CAATCo@Q@=G5'?CAATC=G5'?'RZg?.f?nG?Oc? RunL@Z|ս@&' ?ܵ|г?AATCCZXQL@-8E`Ի?AATCAV1k?en$?Hv?f.Խ?gc6?XkntO@> ףս@<;D@b2U0*?ATCCC&L yN@BYe?ATCGC>}??妁?ta?:U?9I^?RJGQ@HPս@*]Wa֊?ψ ?TCCCG;rh"Q@Y0w?TCGCC9ᒧ|?\NF?e.?- ?p&6,\?MBzR@ۗս@ZB?y&1?CCCGCeR@&W?CCCGC&W?L4 ?r?<=m?z0)?nd4Q@"uqս@ վ OQ??ܵ|?CCGCGvΟQ@n\?CCGCGn\?FJ;Jt?+??A?oQar?r;wƶR@鷯ս@DT<? ^)ˠ?CGCGGս[S@TA?CGCGGTA??4N?A3?Y4\>WX S@_Lս@0 @@Q?GCGGTZRR@R!1?GCGGTR!1?|?Ba?Ι??351?xV4pO@Vս@`tT @$4* ?7AML@ۊeս@GGp@~jt?GTCCA;SNM@Ta;^?GTCCATa;^?oTs|>?! ?l A?.?dM@h"lxս@S?@ZӼ?GTCCA(nNM@LR8sC?GTCCALR8sC?UǴF?+Cq?RB6S\_?˪/Xab?5-mQ@ս@CA?_vOv?TCCAG[@qQ@|?TCCAG|?^KIwx?8.?#0?Sa=msE?E4_S@i|ս@vK5?:v?CCAGTyH@S@[`Db?CCAGT[`Db?Q?!џ>? ? ?>333so[Q@/$ս@^U(@b2U0*s?CAGTCP@Uoߞ?CAGTCUoߞ?W\S?*A^+?c 3R ?%H?+kL@ o_ս@TsZ@@ ^)ˀ?AGTCT1iJ@N5k?AGTCTN5k?H >(D 4?Bf?A F?ˈ2L@xս@:b?q?GTCTA}'N@g\ *?GTCTAg\ *?]?ڳ?SԌ? ő?8P@!uս@n;Vz?MbX9?TCTAGz]P@ -)?TCTAG -)?؄M?sD*? P_?vn?R@1ս@2??镲?CTAGG᛺:OR@CRI|?CTAGGCRI|?%?˝{D?:q?c?_~XQ@Dս@u> ? ^)ː?TAGGC+_pQ@ȔfU?TAGGCȔfU?DM\?$?pd??vsb?_9P@Qkwս@[ ~?ZӼ?AGGCG|@P@(v,\?AGGCG(v,\?F[D?HA@e?wt?d!P]ﷲ?TUS@ս@g&j@+eX?GGCGToFn~S@~CV?GGCGT~CV?)AHw ?l?j4?խqƼ>iS@H.ֽ@| +X @~jt?GGCGTx;n~S@+ύ0?GGCGT+ύ0?sx=?>t?ï:y?0Xn?_xu R@Hֽ@*f@H?GCGTGS\M_Q@?GCGTG?I9>.?}7&PR?O#Z?ԃH?fŒ2P@%ֽ@@@ o_Ή?GCGTGc+_>aQ@Hʴ?CGGTC(*?aCzy?y m?_ȃ?S_ޢ?K@!ֽ@~}j @`Qk?CGTGAP0D-K@viVJZ?CGTGC xI¼?%T>Z%ߧ_?ZC?)]]?Ce)vQ@ "ֽ@O' @H}m?TGATGRIkR@kx Y?TGCATu ?_=?ndp?no`?Gp?@l*,[R@%#ֽ@״z@Ǻ?TGATG )kR@'?TGATG'?2uÝ?H-g?~9z?)h?EQO@ׁs&ֽ@fY]3?~jt?GATGT`+FO@P s?GATGTP s?q*ɹ?CF&?TU?Qmg'?^YࡑM@|P+ֽ@ ?F%u{?ATGTCJjUSM@H6욱?ATGTCH6욱?׈Loi?Tķ4?|[4wm?o9?N@:-ֽ@A}> @Ǻv?GTCTGM@IVh?GTCTGIVh?օ`??3?c^?1?:W P@:p.ֽ@%3?_vO?TCTGAP@Qz?TCTGAQz?WIҀ?EA ?ZP@fX7ֽ@"o?ŏ1w-!?GACTAsP@=k.?GACTA=k.?O?yw?xD?C*?v̆2?Q@J9ֽ@Uׯ`B?HP?GACTA:P@L?GACTAL?p?(-Y?ZvΓ?"?;2ZP@~j<ֽ@k܁??ŏ1w-!o?ACTATT ITM?S?UVV?333sI@Rֽ@"V?-C6?ATTTAHI@:?ATTTA:?|B9U=y&#?e[/?b4i ?RK@KY8Vֽ@ ɝ?3U0*?TTTAT3 K@y'F?TTTAGc?kp}k*>D?P^s?>3?`60P@dZB^ֽ@YN?mxz,C?TTATGf~IP@>(Ϲ?TTATG>(Ϲ?%n#?4Fp?Wו?|uL:?D2NۺL@&Seֽ@Ck@/n?ATGCA*L@"-n?ATGCA"-n?T(C4M?Yj?H-? ؍lо?}!pa{S@+iֽ@ $?:pΈ?GCAAGXvR@ǢFs?GCAGGTq?n/;:(? r O?}k? ӁH>GQ@HPsֽ@A F?~jt?CAAGA dtQR@/?CAGAGaV?ݛ3?tp)Ԫ?%Zx?5 v?xVQ@c=yֽ@=nRO?Y5;N?AAGAG:Q@%i?AAGAAk-L:?j3b?BpZ?_E~Z?Qya?RES@eֽ@cj@_L?AGAGC+]jZS@C1!?AGAGCC1!?U$?+:?+lf0?*E_j>s cQ@qֽ@\Jd=@<,Ԛ?GAGCCjP@N ]D?GAGCCN ]D?W?eZ??;q?gBr+Q@d]Kֽ@֋?F%u?AGCCA,iQ@3ɾ?AGCCA3ɾ?q$é?Qcs ?̽ҦW?aS?\ZR@ qֽ@R}ԅ?<,Ԛ?GCCAAX;cnR@?GCCAA?r?\"?Zd?B<|8?{ӛ}rR@|aֽ@Z3?Zd;O?CCAAT*;R@RGvv?CCAATRGvv?t?$V+?t?+?clB?_~>;Q@Dֽ@5P_?&S?CAATC:,@Q@O?CAATCO?uLϱ?uTnv?a?ɠڸ?d,K@shֽ@0ws?y&1?AATCAKݹL@-3(?AATCA-3(?;?D1m?2հY? oZ?\E}CP@nֽ@&Nj{?J4?ATCATnLHVtUP@W%?ATCATW%?!ejM?!@?aG?}M|?pHR@ֽ@m?HP?TCATTILR@&>?Moz7I@d]Kֽ@#jnM?v?TTTCC1H@jke?TTTCCjke?i*Yؙ=l ?lUE;>Vww?(\BN@Pkֽ@U?J4?TTCCTmhPM@R?TTCCTR?9Vʐ?~dhD?[rvև?9tj?"ٟ_Q@m4ֽ@? ?TCCTALQ@^-l?TCCTA^-l?z2?~~?ſx?VJ?)aQ@2%ֽ@ ?a+e?CCTATPb wQ@1'94?CCTAT1'94?a?4^V?00(?4xq?bxP@`TRֽ@}>VY? ^)ː?CTATC0mSQ@fO#?CTATCfO#?YR'?)?1@a?1?GJM@Rֽ@2@_L?TATCCC( M@_?TATCA"%?ogTzP?i4Q?1Ɨ?5-KN? xP@3ı.ֽ@>N?~jtx?ATCCTـٹN@@,3a?/+5x? qӖO@V0*ֽ@!q9z1?J4?CCTCT1ePP@z?ACTCT;#?yo5ж?,n](? !)??@P@j+ֽ@7 x.?gs?CTCTGÁuP@>1B?ATATGI?0xs?݉$(?%G?& w\xE?ʡŲQ@?٬ֽ@!ўb/ @Mb?CTCTGtP@I>TGATGV?PZ?`~r?O~a?vm+op?;xB?{P2ogP@#ֽ@s?l?TCTGA,P@MLj?TATGAu~q?Mv?.?,)6?j?7 MʼN@1׽@`vɕ? o_Ή?CTGATy= 3O@P@Y.?GTATAY.?!W?R?o]4?Wշ?6TP@=yX(׽@6+`?b2U0*?TATAAwP@8j?TATAA8j?g-?U*5?0u\?9?bҪYQ@僞*׽@lqqo?/n?ATAACA^\5Q@TPVD?ATAACTPVD?mn3=?Be?;:7e??@&P@V-׽@~^?J4?TAACG"P@\@ ?TAACG\@ ?EH?[>uw?ZTtU?2r]?o?P@>W[1׽@ӃPg?Mb?TAACGBu ~P@BP?TAACGBP?KK?9I ?Ru-s?EgK?G橻P@ g3׽@WUα?-C6?TAACGbҩP@%J3?TAACG%J3?LӠ?cdE?U7Wt?!~ ?بaP@mV}6׽@˷Ex?"u?AACGT{ P@-cR?AACGT-cR? v?誣q_??i_?(Q@,e8׽@Gr?j+ݳ?ACGTCqqKQ@7}/?ACGTC7}/?5{?c8`?-w[?JJ5M?'H@X[L׽@bla_@-C6z?CGTCAμhH@K?\T?CGTCAK?\T?G!;hg=W>Sn> =L?C܍M@ cN׽@|Ό@<,Ԛ?GTCATpM!O@;I<?GTCAT;I<?as}?mXy?lOjĜ?ԷNF?,.MN@R׽@\qE@_vO?GTCATAnO@!D2?GTCAT!D2?I/H?0ft(?ں**?WLwǖ??TQ@/]׽@tY"i? QI?TCATCYgR@ CW?TCATC CW?J,?{ ?](?,+?kN@ak׽@(y4?mxz,C?CATCGg=N@]:?CATCG]:?U{?jaD?Nt?t\?p= hfP@(\o׽@3|q6?`Qk?ATCGGiMkP@+͹t?ATCGTdt?&g:?OwS`?}!|?7)FA?8ŭ Q@~:p׽@z@{Gz?CGGTCP'z P@ *ck?CCGTCͣIAr?VyC>zbV.>Ycۉ?i- 7>#F H@}гYu׽@4p@gs?GGTCG}vu%K@{ r?CGTCG|-?nAT|v=q} ?M> {P?(lL@Mbx׽@`X@y&1?GTCGTadp_N@? ?GTCGT? ?L{R> ?I~~? +? {E Q@S{׽@c@~jth?GTCGT Z `N@ɟ6?TCGTC?\W?P>5z?L|#9?(OK?QFWgM@~j|׽@bu@:pΈ?GTCGTew*`N@zd b?GTCAT*?50s?^N9?5?:' ?ԑWR@jM׽@2,?w?TCGTAnAQ@t?TCATT/ Q? "1?݅lx%?3`?(S?kWM@hDio׽@x~;@Ǻv?CGTAA&q8K@6P+?CATTCЗ`c?okxA?|?C?9ZUJ?H R@Ciޑ׽@gt?V_?TAATTV@Q@A.?TAATTA.?|?[?WѠ?9[m[y?D H@ZB>׽@)]g?@ǘ?ATTCC!I@U?ATTCCU?wT=ǎAPp>u+m7>1Qi?b9M@:p׽@K6?b2U0*?TTCCTS sM@m?TTCCTm?ʩTy?䂫KU?`q;?jD?'ݸQ@Z׽@rQxqG?~jt?TCCTTXIHQ@=?TCCTT=?d.+?)k?Ϳ?MO4?%BQ@47׽@֌@Mb?TCCTTEC Q@$?a IQ@'1ؽ@ʐ@F%u{?TGGGGLQ@}zץ?TCCGA9Q?7:H?I?4Q>O?iMB?Z>S7S@Oё\ؽ@`?S㥛?GGGGT-Z9R@qzJ/?CCGAT(?{?F2?Ya? DUR@M F%ؽ@ި?S!uq?GGGTG 0mOQ@L0x?CCGGTr~A9?,<{?,?)?t^ֲ+?5L@ h",ؽ@i$?0*?GGTGG/KM@.?AGTATp(C%?13?!mGQe?'2x?#?ەN@:Aؽ@Ǻs{@a+ey?GTGGTNWN@j?GGTAT+a߅??f7yV?;ö!p?>?+&b7P@B`Bؽ@^pf@I +?GTGGTeWN@ovmk~?GTATAyMQ̻?RF?0Y7?s"|~!?tI?# jP@ʡEؽ@ I;@Y5;N?TGGTG8$P@y?TGGTGy?؋|?p{Nݶ?`k!?bw?1P@HNؽ@Vy?ZӼ?TGGTGԜ3P@w ?TGGTGw ?T2?,8?}&ʤ?-?,d! M@S!Uؽ@%+] @?ܵ|?GGTGG6M@Uu?GGTGGUu?=g}4?%0؂{?t۸aϣ?X[?8*/N@Bc]ؽ@t4?<,Ԛ?GTGGAǫN@: `?GTGGA: `?G0?XŌ?շG?Sum?`U\Q@K7aؽ@p2?gs?TGGAAc iQ@z!?TGGAAz!?lL?ֵgy?$4+?K5FR?]VT@?dؽ@ 0@?GGAAAH=U@Kr?GGAAAKr?4?pa?p퇛z?vh>8cS@}8gؽ@p?/n?GAAAAh S@PM?GAAAAPM?$!?gSm?m5j-?qiqһ>`8*Q@xiؽ@<?ψ ?AAAAT .Q@*bf!%?AAAAT*bf!%?)iW?yӶu?gCy?b ?0y70>Q@5;nؽ@}c? F%u?AAATC:Q@.;S?AAATC.;S?ܢmf?hp?ݽ/B?z]>`l?\@9M@~jtؽ@%(?0*?AATCAO2L@.p,?AATCA.p,?>+Au?G!?\ &|?!ܺ@?M>TO@Hؽ@yB?tF_?ATCAAw55OP@?ATCAA?,H?\?H(?5~BE?Q@8A`ؽ@?w?TCAAC6snQ@HC?TCAACHC?"!?Y 5?T}?5VY?C/BZP@c]܆ؽ@_gW"?q?CAACAD:ebP@]?CCTCC@+?>(AZ?2u ?0?r?O@Zڊؽ@*`h?-C6?AACACQO_P@;k?AACCTռO? HA?L!(c?:?}>ADS@:Mؽ@.{?]K=?CCCGGJ9R@ֹ?CCCGGֹ?[tƓq?ܳ'?DO?7Į>٠R@,Cؽ@2Se?:v?CCGGC۳pR@P?CCGGCP?S&;?&pO?`g?՗ >-R@:pؽ@)xwwwyR@m4ؽ@/cS?F%u?GCAAAB R@У?GCAAAУ?V_? `-?z2?/܋?4Q@Gؽ@$B?o?CAAAT­Q@Mr?CAAATMr?Ivm ?`~{?2ŧ?pJ!?3nP@0ؽ@±p_?_vO?AAATC5#Q@ O?AAATC O??6bL|w?A%NG?C?5>M@ cؽ@W?{Gz?AATCG)WyL@2b%?AATCG2b%?'Dk?' ?akhn?n$?N@-ؽ@*4? o_Ή?ATCGCe_P@i?ATCGCi? nг???d< ?jD?GQ@Qؽ@F?-C6j?TCGCA&zMMQ@3*M?TCGCA3*M?+.k?-R?#UԑD;? hH?Ӗ%S@'1ؽ@ho@V@D?CGCAAu+fS@QK?CGCAAQK?MI{)?+u,?̮?}7>ިR@uؽ@žaC@Y5;N?GCAAT1R@^=?GCAAT^=?a>1d?wQY?B?&'%"?ΛjQ@\Cؽ@߳?UN@?CAATA&&MzQ@ v?CAATCrN4?#6F?ZHblBQ@mMnn?GTAAGT"0߻?G?4?&Q?V*?I?>s`- R@J +ٽ@Ī?( ?TAAGCY)MMR@;FQ?TAAGC;FQ?ˮO\?BP=m?gyA?yiZ?_X1P@sٽ@_26?"u?AAGCC G]%P@쪶?AAGCC쪶??A*?]k?6YU?Hm?C@Q@2w-!ٽ@-?S!uq?AGCCAr>S Q@ Na?AGCCA Na?eh~?@.9?S}S?3RD?ov@R@(\"ٽ@?ŏ1w-!?GCCAGLhR@'?GCCAG'?{ad?)? ?JTL6?oR@ׁs&ٽ@07x?<,Ԫ?CCAGC7P7vR@~v-?CCAGC~v-?Az(?JBط?Q ؤj?za?u<=dP@,3ٽ@8<.@_vOv?CAGCCmcP@aa9ʻ?CAGCCaa9ʻ?Kx?;??%?O>KQ@|?5ٽ@!1?Z8m?AGCCC4VQQ@ KR?AGCCC KR?(6֠?"?Mg?Zo%.`?At'R@BIٽ@n/Hl"?ZӼ?GCCCT= dQ@?GCCCT? /T?"J?ښ.q?3_liE?Q@1Nٽ@@7m??ܵ|?GCCCT&A.eQ@CoYj?GCCCTCoYj?2ޝ?4?/?ǜ2?ֳ̍R@~b_ٽ@Oܦ?/$?CCCTTE1RR@ ?CCCTT ?\%?w?\dfZ?!4g5>?O@7dٽ@/|Q.@ ^)ː?CCTTA?Ǻ?AAGCTJhV^P@ꡦ?AAGCTꡦ?:OCL?3??C ~H3?4x ?*;L$R@L={ٽ@x?H}?AGCTTEZR@4?AGCTT4?>أb'?tia?_"?EB'>nBP@lwٽ@oIp @vq -?GCTTTO@eAk1?GCTTTeAk1?Z[OQ>V*>n(s?޳+v?&T0H@阮ٽ@ ?M O?CTTTC{>I@ ӿ!?CTTTC ӿ!?ks<Ї>@״d>Q O?Kwr%H@u$ٽ@?Ǻ?CTTTC@؛>I@ԍW?CTTTCԍW?{:l8>TŸE>0`4+?kiI@ǘٽ@5Ve?/$?TTTCAP`RI@+?TTTCA+?sX22j`=QK-}'?ԁ6n>Ur?j #P@Qٽ@&#c@Ǻ?TTCAAhZO@}RKr?TTCAA}RKr?$\?:4+?U->U"jO^M?MSQ@סٽ@G?Q?TCAAC=ӅQ@i?TCAACi?&MΘ2?Y/Ph?i=8?>e)q?F\P@1殥ٽ@,V?+eX?CAACGCC]QP@L7?CAACGL7?vv? 9?Oj?zD?9pQ@Nq}?ACGCAb?j/?{4??Θ0Ib?R1w?@ Hb=S@ Oٽ@GD/ke?HPsr?CGCGC kS@;I?CGCACű~?7:0?A|NU?S4?X??kHQ@?ܵٽ@A?HPsג?GCGCC7XQ@*fwI?GCGCC*fwI?[3!;-?uVQ?gY?]?8г?Ku|Q@Tٽ@l&-+?CGCCT>&-+?.F4?zк?/ a?=?9R@QIٽ@=P2?ψ ?CGCCTc3'R@\c5 ?MbX9?CTTCC7 H@6"dC\?ATTCC\Jl?Gè=X9>X>Svd0?5E2N@Bcٽ@b?M O?TTCCAӄg N@??TTCCA??S׉ ~?#ju?{s's?ׂ%G?یn7_Q@7ٽ@zO?n?TCCAGGQ@5'?TCCAG5'?4J1?슡r?`{L?zoA>\?^R@:ٽ@+O|?gs?CCAGG G8$S@Dqt1?CCAGGDqt1???GLP?R@>[TxQ@Pnٽ@z?J4?CAGGC;۽Q@rUN?CAGGCrUN?ąڈ?"Q}Ʉ?6F?v^z?*xP@*ٽ@ҥU6@Mb?AGGCTE82P@7C͙?AGGCT7C͙?(oHI^?}n?Z-Vs?@Yљ_q? ўDS@aٽ@?\m?GGCTTy¥S@r='?GGCTTr='?w:?J:F?c1֏J? ̾>q봦P@ڽ@ SR@S!uq?GCTTAipP@?u[1?GCTTA?u[1?ʚ$|?)lRH?1#a-?`?UL@:#J{#ڽ@!If?<,Ԛ?CTTACWML@"?CTTAC"?019Y?'l'h?(&6o?h?gEmP@b2U0*ڽ@YˍNׁ?H}?TTACC9gXO@])d?TTACC])d?rXN? Wf?<؏?Dij%?P?P@r -ڽ@=T?q?TACCC+$P@|?TACCC|?ff?7YO y?'}?1xF?Q@Ci1ڽ@j{?S!uq?ACCCG\S=Q@_?CCCCG)cr?Ewq?݇|'K#?8Ǟ5?`kx>I@S@Ǻ8ڽ@XBA??ܵ|?CCCGAE@R@1B?CCCGA1B?@??-mg.?ŌʃC> ?S@K7Iڽ@}J>Ae?ZӼ?CCGATLS@<5?CCGAT<5?("`O??n^?גnے>+zsS@aKڽ@:v-?"u?CCGATQS@D :&?CCGATD :&?#u?(2ͤ?2o?aՙ>C)Q@~:Pڽ@ ?i|?5?CGATGʥbR@H9?CGATGH9?|d/?#/׭?H?U( ua?*P@=U_ڽ@x@j+?GATGT$FO@ڠf?GATGTڠf?a٨{?MazH?cvaj?UiK?|^N@R!nڽ@#a?UN@?ATGTCbw( M@Z ?ATGTCZ ?)Ekce? R?(?|3=?bkI@rڽ@7k@_vO?TGTCA)I@QE{?TGTCAQE{?Oi"q>2P*/ˏ? YEb?y.:??Q@ޓzڽ@YT?o_?TCATT^gSLR@2|?TCATT2|?A?x:? Qr?뼩ɝ?EO{jK@nڽ@-WE5@ QI?CATTC5 M@#| ?CATTC#| ?}F>jJ?5$a ?@4 m?.s?CATTC>s? Y?@?}~P?p?bƊXI@e;Oڽ@7X?S!uq?ATTCT6>aI@ h@?ATTCCkK?:<ȴ=Ē@0?eR"=?~{0?wWYӺL@) ڽ@Tj@46&????I9?0cP@6ڽ@'?? ^)ˀ?TCTGCg*:Q3P@L誩~?TTATG^l?TX?0w?9;?Y?d^L@S㥛ڽ@K?&4?~jtx?CTGCAQ<|L@>q?CTGCCx?.WR?N ״?ε®?\6]?1eR@/ڽ@6\iG? rh?TGCACfR@Ys?GCCAC*=?A(? DJ?Un6G?b?SQ@K7ڽ@cO(;@_vOv?GCACGZQ@&hh?CCACGj݋B?Pyl?R/De5?(~&ӹ??B`PR@-Cڽ@py7?Mb?CACGGHPk+R@a]?CACGGa]?2Qe??D]W ?a3h?*d4--?Qa=Q@eڽ@ K ?H}?ACGGGμ;27R@ ?ACGGG ?,L?Pۦ?DԨ?ڋp?X9tFP@ڽ@z>TQ@#ŗL?GGGTC#ŗL?^c?ïb?9xi?=^x?6`+K@~ڽ@q@S!uq?GGTCTɡHJ@ǘ8?GGTCTǘ8?'|>n?;ALSI@tڽ@ PT?_vO?CTTTCY:9 ?I@Ƒ?CTTTCƑ?E=I^t'?j4QWR"? (}?bH@ yڽ@`U?_vO?TTTCGQGI@ke&?TTTCGke&?}2U=e?5lM.>_0'?!c*N@;pΈڽ@I6@UN@?TTCGGf-O@ږ}?TTCGGږ}?${Y>tU4?y>YJ>W>NrQ@Dڽ@Wu?ZӼ?TCGGCM،'R@Qav?TCGGCQav?4A_? 8?uk9c?~N~?m ~O@ 0XR@zڽ@k?Mb?GCGAAk;!S@l b?GCGAAl b?yz ?v!?)gY?Y>~AS@@5^ڽ@=?"u?CGAACO&xUS@×L?CGAAC×L?iՎ^?.='|7PP@Cڽ@sq@ŏ1w-!?GAACC0QP@jd>Z?GAACCjd>Z?cp3?*"l?ز1?9쒝?LFEP@ڽ@ G?_vO?AACCGqO@6ʥK?AACCG6ʥK?u?XdH?׭? 昵?. Q@ڽ@y!?Ǻv?ACCGT6 Q@qؒiJ?ACCGTqؒiJ?X8%?w?4mH_?{KbA?8aR@' ڽ@H@"u@vq -?CCGTGWF R@p?CCGTGp?|2~f?<t?JX?//R?j߰7K@+ڽ@V_=@/nr?CGTGArq.K@*ə?CGTGA*ə?hA{>`K5p?=-|? `%hL?%P{ZR@6ڽ@MVP9@HPsג?TGATA|l$R@lГ<?TGATCWȸ?U?s9?B] ?F^ ^m?.oQN@\ڽ@ny0? o_Ή?GATACn5O@c$N?CATCC[7D?{Z?_uY?;Vy?nc?FO@J&۽@}?\ Ac̭?ATACGVzP@A?ATCCC˭}?P?< ?nz#w1?ʪ?_JB֘Q@ꕲ ۽@Ӥ?ŏ1w-!?TACGAbB+-Q@KL`?TCCCAFB$?P(&?GՀ.:?uR B?y{C?~SR@]m۽@xf?_Lu?ACGAAM>GR@7dGK?CCCGAn?F M*ޱ?6r;?m?bd>Υ"d,S@NS۽@1??<,Ԛ?CGAAA(:S@g3逫?CCGAA6?K[=?%G%c?Y?l~>WIS@Mb۽@jAE1?Mb?GAAAG+MMR@t7H?GAAAGt7H?"?2@C?)Sۨ?"9? pOQ@L7A ۽@LN@??AAAGGPȉQ@cds(?AAAGGcds(?c?~?pk?t=a?:E[JQ@9#۽@+7/?HPsׂ?AAGGG;[Q@?AAGGG?=?1?QK?d䅳w?Q@O%۽@/6HM?{Gzt?AAGGG4[Q@jq-?AAGGGjq-?0դ?v,!S?"QU?$B?ЏR@c]&۽@S1@?a?< 7?u-\R@ ףp=۽@}8`?"u?GGCCG+b +R@Z?GGCCGZ?Ψ7?Fg?O߫?Y>l?G R@?F۽@kd+a,H?_vO?GCCGGsMR@#ʴ ?GCCGG#ʴ ?.т.?Zwa?Pj??@i+B?GfR@I۽@3?ǘ?CCGGCabRaLR@v?CCGGCv?&-? t U?3?w`K?^@6O@(M۽@XD?&u?CGGCGs cgO@^k?CGGCG^k?hƃj?]95???h_\??>R@ OT۽@xg{@ 0*?GCGGGݲR@>sv?GCGGG>sv?F~?,A'?X?ի2?L0P@YZ۽@t+MLm@HPsׂ?CGGGGXP@%L/N?CGGGG%L/N?5㾾X?t<nz?}>?V=VXd?R@Լ]۽@(󍨕@<,Ԛ?GGGGCڂR@;wx.?GGGGC;wx.?K9ဵ?٨?l'E? 4ZX#6?gs?GTGCT`VL@1?GTGCT1?OP?ZH?Mb?PzY?ŎS@l ۽@C@H.?TGCTG7<bQ@N凪?TGCTGN凪?xI?4ڷ?T#?!5}qk?{!~HɯL@A۽@X^@ o_Ι?CTGCAqٽL@%SW?CTGCG'ȃ?0,uo> Ϗʍ/? T?e?TvR@B۽@63.@H}?TGCAG/V3R@?TGCGAO:?tV?q?ΕbI)?Yc]YR?.uR@{۽@ca@UN@?TGCAG%3R@y~vu?TGCGA%*3 ?Km?с?nǽ?m02?BS@T۽@Eq$@vq -?TGCAG3R@XJ0?GCGAGns??3A??F&?xe+?oBS@۽@qa+@q?TGCAG#e@3R@M3ҙ?GCAGCC?Ifg?Hj(?U89^?i7> IR@=,Ԛܽ@샋]@ ^)ˀ?TGCAGcl%3R@9M\g?TGCAG9M\g?-X}?ô21m?>CeU>_S@X9ܽ@(D?y&1?GCAGA2i\S@>6/e\6?GCAGCvAtT?wȶc y?ؑt*?:n}?g䤢>e1 Q@[d;ܽ@d{?Ǻ?CAGACNAqQ@>7j?CAGAC>7j?{?m/1PK޹?R?쏠Y?4vR@6<ܽ@#b?{Gzt?AGACAM*Q@?AGACA?vq?q4?VG?cIZ?SxQ@Jܽ@QV?Mb?GACAC_w-]Q@:4?GACAC:4?Y?d?B G8?g 5?pQ@4ܽ@L(?Mb?ACACG?JeQ@N:_?ACACGN:_?G#M?Ec}??:B?&R@dZBܽ@^L{@ 0*?CACGTzSWR@PLS\4?CACGTPLS\4?A/?yHv]?e?x? 4g?.!5R@"l6ܽ@OŃa?+eX?ACGTA(r>Q@ۜ?ACGTAۜ?}E!?@e0?.},~?)o!?44L@NbX9ܽ@ @ ?CGTACqVK@Si??CGTACSi??Ԯg>nX:g? h@?-Qltf?\# ,B O@QI=ܽ@9 lg?gs?GTACA(RO@v^^q?GTACAv^^q?Zl{? ?c?/|9F?F{Q@W}Bܽ@;?_L?TACAGZ+f?CAAGT?.?Gg6M??ngmg?|;Ϻ='?svQ@8Mܽ@0ZAa?:v?CAGTGSQ@~3?AAGTGBP?^-C?עs?R%?7M<_?S5<{P@9mTܽ@t޻??W[?AGTGCl1M@wz?AAGTCBv?Θ;U?4C\M?$a?A~f?_;K@(\ܽ@Z K/?MJ?GTGCG5L@J?GTGCGJ?_5jF>Sw?&o?i2?E3?R@ -pܽ@ls^@~jt?TGCGTuQR@Uu3?TGCGTUu3?#G?{<?>fiuo?2(ZC?.GRJ@N@sܽ@3#قe@HP?CGTCT|GH@KO/?CGTCTKO/?LxOOk>VL򣰶l?q#?B?6JצN@byܽ@Gք?y):?GTCTG[ WM@z?GTCTGz?{52??'+0?W?G˄ј?LnUP@( ~ܽ@ʓ?y&1|?TCTGA1~P@i?TCTGAi?>ť?YI? _ET?~?pN@ܽ@޺}?{Gz?CTGACXs`RN@2?CTGAC2?W?4ŏ?`9??h_-?RQ@eܽ@G\5?JY8?TGACG/3P@zX+?TGACGzX+?B^w?,\4F?0(uA? JDg?Q@1*ܽ@ .?{Pk?GACGCA8Q@f=?GACGCf=?﷚<O?r?:1??jK"i?̈Y7Q@mV}ܽ@=?y=EmQ@oůܽ@L{@J4q?CGGGCnBAP@?CAGGCwfQ?gMLvYu??C?G?fgU?Q4sP@Dذܽ@LJ@b2U0*?GGGCC՗n+P@"Z6T?AGGCCI~D?nP%?fQ?E!α?t(H?Cp&,?|P@jMܽ@oiJ?Q?GGGCCɆ(+P@tK$?AGGCCyM?_:[?C"?{f#?9$?ͪ$Q@X'c7?CCGCTX'c7?/q?r1G?ou?K\k?y崉R@ŏܽ@S;@HPsׂ?CGCTT٨P$R@t?hؙ?CGCTTt?hؙ?:pX#?+œw?K?wDJp ?wb'vv5O@gܽ@WY@_Le?GCTTC`,O@o$?GCTTCo$?ĭjO>H㊷?環ː?*2^?{w?I@*ܽ@׸?-C6z?CTTCC.H@?CTTCC?) > "?נq>?E_%O@KY8ܽ@ܟ?:pΈ?TTCCGYM@bzt~?TTCCGbzt~??[u?(ׅ?5c?oiU?@@jFQ@i|ܽ@|3%?<,?TCCGG..Q@gՒg?TCCGGgՒg??4d_P?wXKF?F:HA#?~j\ڔR@ ܽ@'O ?Mb?CCGGG`;R@e'?CCGGGe'?Rm?+yy?>? ?wP@=Uܽ@??Ǻ?CGGGTncP@@Ζ[?CGGGT@Ζ[?f#5%?h/n\?f?H+ɼ?ׁNiQ@lV}ܽ@cy@gs?GGGTGOQ@*G?GGGTG*G?+3 f<ǧ?Pٱg=?bV?Xx4?<L@K4ܽ@^@n?GGTGTύuM@ vtiU?GGTGT vtiU?%!@N~>ޛ^l?a]kG??CvTN@KY8ܽ@MU?ZӼ?GTGTGi{~M@R| ?GTGTGR| ?,B?̀a v?Fˀ?*R?<,M@ܽ@1f??{Gz?TGTGT# 3L@Son?TGTGTSon?di>:)?t?*Y?4?-.N@Zdܽ@ K}?q?GTGTAMFM@c ?GTGTAc ?Xz?`)^?ڐ a ?wѴ?H_M@ecܽ@EJ?<,Ԛ?GTGTAM@Yc/P?GTGTAYc/P?ԠἘ3?Z1u?с)?"i?ljM@tݽ@Oi;?q?GTGTA8M@WOEh?GTGTAWOEh?3$f?x?6~?1n?Nc%L@ݽ@@"u?TGTAGB~E\L@js?TGTAGjs?L1]s? ?k@J?b _?shzP@ʡEݽ@zڣ?Mbp?TAGCC%sqP@o?TAGCCo?u˚b?TL?/m[]r??gg C.Q@Kݽ@z? ףp= ?AGCCG^\Q@($)?AGCCG($)?( hvi0?&f?yBBR$?yI?p=R@B`"ݽ@4?Mb?GCCGG\MR@T?GCCGGT?e'$G??OEf?W(֨?2*j:A??R@x&ݽ@K?HP?GCCGG_w,MR@Tκ?GCCGGTκ?c?u"?^?B r?q1`R@(-ݽ@ZM?y&1?GCCGGMR@͵?GCCGG͵? T?< ?Bvdx?nM 2? MR@NS4ݽ@[xQ{pL?ǟ!Po??ϟWH@JYXݽ@s {?Qs?GTTCGe`H@/ :ݦ?GTTTA2ol?P}n8z=ȭ)>^rC{?ȗ&?LL@0jݽ@b@q?TTCGTZ#G.O@gݽ?TTTAG_?g?C725?Z lI?80G&y?NB֒?ayQ@_lݽ@%3 ?HPsג?TCGTA1?Q@p9񫙸?TAGTA! 7?%d?8S~#*?N?:Y^֔?X/FN@6;Nqݽ@uGr?mxz,C?CGTATiơK@>=D?AGTAT萾?_?t$?c ?Q R>?S`896P@atݽ@41@?&S?GTATA>P@cr?GTAAC>MWO?*d?n2X?e v|.?G@7?W47P@x $(~ݽ@:c?H}?TATACtgNP@~3<H?TATAC~3<H?h#sA܁?3s?Hoy?Xjq4?ONNNhO@ׁݽ@[ar? rh?ATACG\P@ Ue?ATACG Ue?̝u??G9f?{%}Ҽ?}",Q@1ݽ@ p?333333?TACGCߡ-]Q@fN0I?TACGCfN0I?]'_?kT?Db?%~?yKsR@+eݽ@FSP ?_vO?TACGCz^Q@7 ?CACGCF.>?g%?!~?͉?.G Y?C#[Q@\ݽ@~?J4?ACGCGpQ@Jًh?ACGCGJًh?y" ?X"FD)?յ@.?]?N^sЂS@Fݽ@LVj?"u?CGCGAQRS@FC ?CGCGAFC ?&&5?Z $?9y&?;m>y~8R@ŏ1ݽ@u!@~jtx?GCGATcQS@?GCGAT?̖mB???#]ec?Vb*?nןY:R@Ǻݽ@D~?/$?CGATT7R@s;3Q?CGATTs;3Q?zU?*fO/=?P?;@4y?&о!E?L6kL@ݽ@ʗC@S!uq?GATTCL@<: ?CATTC&)Z?.8/>Yޯޕo?^_s*?${?ٸl#-?~X/I@&uݽ@hLP\?gs?ATTCTj,bI@'̸)#?ATTCT'̸)#?zD=Å&?@Pc>=?5? cL@o_ݽ@f@_Le?TTCTCBYD~N@+D?TTCTC+D?2 _?X#?4ưHS?w8?c/BO@2ıݽ@ 4?ݓZ?TCTCTꭖO@;; ! ?TCTCT;; ! ? .г?:?4Zh?f4?%4P@_ݽ@KwG?o_?CTCTC6]#P@?TCTCApD?=G?s?3?VєnU?-EO@xݽ@:=7?N:>?$_5?.)?,I@ڊݽ@ ?"u?GTTTC=H@,?GTTTC,?KÀ=Hj Ԩ> ^L?_r?-nI@t޽@HߤxY?_vO?TTTCTXD:?ٰ5քO@?ܵ޽@mc)?_vO?TTCTCLSM~N@n}Gk?TTCTCn}Gk?jC`?ͤ?*9Az? m %a?X攡#P@;޽@F+o? rh?CTCCC ClBP@Wa?TCTCAH-j?x+?2wM? gCdC?\'Tq?k+%Q@C> ޽@l=?{Gz?TCCCC%u\Q@|d?TCGCCp{?u3*?K'[?Cg?%3?vQ@9gDi޽@zBQ@:-޽@uR@y&1?GAGGT/ ^R@(?6?GCGCT2Z?G4C??rʐ?Ix?qmEP?(G?KR@Ș0޽@d}`?gj+?AGGTT^x Q@erH?AGGTTerH?a2\׵?G_* ??3$?QWO@sF6޽@b]tu@Ǻ?GGTTTb0L@QH?GGTTTQH?(?~,ozT?eR? ]a?zI@9EGr9޽@3dp? rh?GTTTC~H@1{ ?GTTTC1{ ?]GCrT=2K'>~&[?ܢ'O?ףphfG@Bc=޽@)?Mb?GTTTCKH@iY8?GTTTCiY8?+եڮ =ib>>玹v>e%?H@?޽@6jk?b2U0*s?TTTCT֡q8I@F ?TTTCTF ??нx״=<4 ?>cֿs۰>u.?5h+K@N@A޽@f-8@H}m?TTCTTxZ=N@TH4?TTCTTTH4?Q9^)|>pe6?){,?_ٗ?GzDϬH@H.A޽@K?-C6z?CTTCC+![H@6H?CTTCC6H?h;=~1!+ŕ?Sv˦>?~~TM@wC޽@6aU@wOjM?TTCCCPM@/z?TTCCGz?y?6ޱG?=e?D6W?U>QL?GuQ@V޽@|ju?ͪզ?TCCCCPbQ@A!9?TCCGC$^?|x&cyb?@"J?] ?ޝ0,?8 R@ cZb޽@YfK?~jtx?CCCCA_w`R@c ɿ?CCCCAc ɿ?;a)??jz?ܐ?|":?KI_9}R@%c޽@vAVY?H?CCCAT5ERR@s?CCCATs?Fcy??=p?X2f ?>Yؘ3?k. R@<,t޽@ {i@Q?CCATCbTR@"_sq?CCATC"_sq?G? `?Â-?#T,3?aR@^Fx޽@gl?ǘ?CCATCwR@bfq?CCATCbfq? i?h?}C?Ql?N@(|޽@)˻m?q?CATCA(*?=N@l) f?CATCAl) f?2~? u?Շl?I -? 1|HP@x $(~޽@^of-?ŏ1w-!?ATCAGC 1/P@:#F?ATACAdYi?4T ?V$?NKKR}?%DF6?: 3%R@6޽@: xL?ZӼ?TCAGGJ#)R@d/Q@A޽@ڮ @b2U0*?GCTTGۊұhP@A5V?GCTTAd譶?~=?пgc?a|.?͐J?^AL@X޽@?DԤ&?/n?CTTGG7 K@3n?AGTGGrҊz?K#?csSWj?IOi?i?C25O@޽@mG? 0*?TTGGT&QN@]a)?GTGGT4o?a1?G_,?oAQ@L7A޽@UMݚ@^K=?TGGTT^Z Q@n?TGGTTn?zj ?FCqz?F7oJ?:ߩ?ͯ"Q@0'޽@CCI@M O?TGGTTa @ Q@?TGGTT?.8?-s?H?Մ99?9u#HM@Af޽@PHNLӁ@x&?GGTTC0\K@an?GGTTCan?hmӑ>&7\?/]?3S2j?t7H@Ǻ޽@d?a+e?GTTCT>X kH@u%I?GTTCTu%I?fyh3e=aU"^ ?J0Я ?ٹ-?Vx ,AN@޽@1` @2%䃞?TTCTC4Lxt~N@0pY?TTCTGCH-?U-$_?k>؆?PSYM?ܣ;gu?C:&,M@$޽@5{4U??TTCTC%u~N@@c?TTCTG?;2A?4?h?~1?(XF^P@m4޽@?HPsע?TCTCT*O@;Ot\&?TCTGGK~?'zZ-?bc? #v?G?3nO@D߽@rq?J4?TCTCT*O@)2!VAY?\F?)?GzuJ@J$߽@-Q?-C6z?TGTCG;ߣI@i ?TGTCGi ?/wFwĎ>M{i?b_?\*? O@Ǻ&߽@HG;t?S!uq?GTCGC4N@C2?GTCGCC2?Vvr?@{b?I?@Gf޶?XQ@Pj-߽@gyк??ܵ?TCGCAaqNQ@͈ ?TGGGG?w63?[d?(oY?Uq?'8HQ@I߽@2;B@ZӼ?TCGCA+sNQ@fxhi?TCGCAfxhi?~~X@?:w? \?ToU?C\R@K4Q߽@w{@ŏ1w-!?CGCACjqe/S@)p?CGCAC)p?au)?Z+?&]kO?k7!?K7!S@}a2Up߽@[{7@Mb?CGCAC&Dsg/S@w??CGCACw??(?I?ZV[`R?P7?jqR@|ar߽@SjLM @Q?GCACTl< R@n?GCACTn?p?;ܱ?7#k?-/N?}Q@KY8v߽@;2@?CACTT-AQ9κQ@}?CACTT}?2?Ux߮?şr?U}?/AP@ 0y߽@GE_? ^)ˀ?ACTTGS3jG\O@y ?ACTTGy ?]Ḽ??C`'a?h8q?oXL@9#J{߽@1 2?/n?CTTGGN!C-K@!?CTTGG!?.? e?\[[#?bzN@e[d?CATCTe[d?  ?5My?v2:;Ӥ? Y?jN@3߽@c߆G?vq -?ATCTAGYC wO@#?ATCTA#?=Th ?Y닜?̜?km?8 P@?߽@(Ov?y&1|?TCTATWP@hPh?TCTAThPh?l%?gE3?=WIf?=Nc?˺wQ@ ߽@a[ƽ?w?CTATA۹ Q@4?CTATA4?A?[?t!?4Ƹ+?KTЏP@jo߽@8?@Ǩ?TATAT9?azP@?]?TATAT?]?NLge?=E?V ?1D\?rP@߽@č,͝~?/n?ATATAJRP@㛕o?ATATA㛕o?,J?z4?0t?-w"$?0l\P@0*߽@u z?HPsג?TATATDxbzP@E"V=?TATATE"V=?[?fb;?Kl?;aQ{{?2P@u߽@N'Z?Mb?ATATASwUP@:KJ?ATATA:KJ?ۥ?af޲?Jɼj?-Su?6+S fP@\߽@L#m? ^)ː?TATAT czP@}yڼJk?TATAT}yڼJk?K?b1?~_hk ?_K?X9P@ ߽@SG?Mb?ATATAIP@F?ATATAF?OԢ?d?eʁ?5?svP@a+߽@L9<|?X9v?TATATq՘czP@'fF?TATAT'fF?s:W Ɵ?2fP?&z~?lwh?'_2P@uq߽@=S?a+e?ATATAhP@4Y?ATATA4Y?+G?$'J? qE|?'%[?PvP@H߽@Fwag?vq -?TATAT|dzP@9 K?ATATA%[;??K$(?fC?7lM?WW?$5 QP@> ף߽@rQj?/n?ATATADYP@zl!?ATATAzl!?8j1?v?v7_?*ϫ#?mfP@r߽@8m?䥛 ?TATAAfmhP@ g[?TATAA g[?He?z`^3?,]?O2?!>;MQ@O@K*E?{?ATAAG|`CQ@?ATAAG?R?)|7B?GK?Y]d(?&1qR@ʡE@.#?Mb?TAAGG>2XR@t)9?TAAGGt)9?Kl?zVF?W ?xkC*?EԵ=R@Q@G!?_vO~?AAGGT9͠Q@,o6?AAGGT,o6?_zP?wُw?@.N?׷bMQ?݃R@6@|?n?AGGTTe[4Q@.I?AGGTT.I? 6c?f?OP?HU>Zd;M@?$@$Yq!VR @{Gzt?GGTTCIK@}?GGTTC}?0!j>+݄qI?NqL?xǮ ?OāVG@ݓ%@;y5?I +?GTTCG5H@!?GTTCG!? fV=~ ?.K𹆬>YO:?BfuN)N@^)0@#?ZӼ?TTCGGd{{.O@Fk?TTCGGFk?Dr?#?Ux-;I?>hq? Q@Mb8@(|=?_L?TCGGG›V R@$??TCGGG$??JDG?",?#?? ^h?V'P@ec=@ ?ŏ1w-!?CGGGG0sP@@k??CGGGG@k??&s?&Lz?lD҂P?oU?`2@?MbXK@&f@vd?;?GTTACV>;?A >hu?-q;?F:&?Xt1>I@c]k@Ȭ~eP?UN@?GTTACT.8K@m_#ud?GTTACm_#ud?]I >* G?Cze?T?%N@Ft@.ũ?_L?TTACCٮ4`O@u t?TTACCu t?ZuB?yAp? ?yh&e?|r[>Q@Qz@KX?HP?TACCC`>ҪP@?TACCA8B/ ?|"$w?um"?L~n?yQ}?CMSٗQ@-@rX?$ۧ?ACCCA@!;Q@iW?ACACAbs!A?q?=Ϥ??c?M=s?VqR@ $(~@"UH?"u?CCCAGoTZR@?CACAGKC? f?%j?pP;?n8 ;Z?k(S@2ı@}ؐ?ŏ1w-!?CCAGAIS@.^?CCAGA.^?QtI?$Ws`?Zk?r?**fER@> ף@?q?CAGAA*l UR@" U?CAGAA" U? j0?W%E@B?C`?nQ};TN@ү@s/@J4?CGGTT5zqP@H"?w?GCTTC?0x\>Wz/lG?W=?$)?:7{yDH@x-!@3lR@HP?GGTTCmPٽK@y.b?CTTCCeEr?i!a=Uʚ>v`>]Uhj?G [H@QI@-?5;Nѡ?GTTCC~+xH@$Se?CTTCCj J?Z=bAÌg?h7>RSҜ?sΝ-UN@jo@-Ua@<,Ԛ?TTCCT0V>M@ #?TTCCT #?b܍U?SC?H-3z?gVO?JǧsQ@B@.$\ ?_L?TCCTCa]ZQ@~?TCCTC~?!jUjy2?`WZ9(b?N?+?@P@V@VȪw?_vO?CCTCT1{QP@ݏ7?CCTCTݏ7?- ?A\|?ldo?T>? P@~@ݗ?I +?CTCTC@lcP@w*?CTCTCw*?u[|q?6ǛT?8hUap?UJ ?8$g=O@Bc@gz?y):?TCTCG O@ڪ?TCTCA ?~LF˛?I aԻ?\j|?#"?͢Q@ cZ@kA_Bo? 0*?CTCGCaOˑUQ@|C?CTCGAc ?4 3q?_2? B?8]7*C?qgR@8A`@q{?j+ݳ?CTCGC. UQ@5wU:?TCGACJ`T?iu:?$]X?5 43Q@S'P@]š@"u?GCTGGaP@?A(?GCTGG?A(?OPc"?a?Fz!?9?6HN@6@?z6>?TGGGGłLQ@6ѫ9?TGGGG6ѫ9?n?wk?ZV?n0k?މNc?,T@?d@ ɐT?Q?GGGGGѕCR@1?u?GGGGG1?u?E~?^cvLnR@zX5m@gR@{r@S@Ǻ?GGGGG.DR@CgB?GGGGGCgB?D6? sH?Ȁʮ?:kY?;|R@}гYu@[ z@"u?GGGGTY":R@xN$)?GGGGTxN$)?6$K?Y?]8cT?{q>xP@x $(~@7Ɩ@J4q?GGGTCڀTQ@\C?GGGTC\C?ϩښ?>!5H?l?1]ޟ?zQK@Zd;@7;a@/$?GGTCAvFK@rzG>>׼"?p 8{ď?#Q?y 5PP@T㥛@Pąr2@ŏ1w-!o?GTCAA?5A'O@G ?GTCAAG ??M\&?t2?H?*?ONR@O@c\µ@J4?TCAAGF78"R@R?TCATA rE?:?3i z}S@(@őж@HP?GAATTP*pR@"o˯?GAATT"o˯?&3x?Tau?*^?m 4>-aL@H@l5@ZӼ?AATTTg>< M@9 I\?AATTT9 I\?Ƥ 8]> *?`hBǗT>sFݎ?ΠEҢK@1*@֕ԟ?_vO?TTTAT K@ wv?TTTAT wv?\!0/>/q?#(9&Y?w.?WP@@r?mxz,C?TTATAK{ԌxP@?TTATA??8/w?38aZ`?f?}?5vcP@Zd@4?Mb?TATACސ_NP@i%X?TATACi%X?fS?:$j?^XY?n;i?6aO@ @^S?y):?ATACC1P@rI?ATACCrI?wIQ(?i ~?2QC?+dfc?[psP@}a2U@:N?H}}?TACCCZSP@Y?TACCCY? E?MV?YMx?f'->?Q@V-@I>L?ŏ1w-!?ACCCGݴ*Q@zg4k?ACCCGzg4k?* cg?8b?f94?>r?uw}R@ѳY@@Uj@?Pkw?CCCGGl\taR@k8 ?CCCGGk8 ? T8Ü?_W?QB}?=nJ>X9FS@N@!@xFN|@I +?CCGGTҽYR@?CCGGT?kKd?CÕ[a?M;i?Δ׭>3XP@%#@[y @gs?CGGTC9 ^ P@jŜ}*?CGGTCjŜ}*?:!?>%?0a5?1x9Xv?v]_H@Q)@>0?S㥫?GGTCTߦU5J@,fR?GGTCT,fR?"Wo=jGVӧ"?@@c>{߆~I?7F0FK@St$7@MZz@Ǻf?GTCTGe M@#F/ ?GTCTG#F/ ?`>8?(gvH?Ōz?2+P@7@.?5;Nё?TCTGAP@_?TCTGA_? C7?1,?{w"B?#u?rÆfM@HP<@ ?ǘ?CTGACIaUSN@[9!?CTGAC[9!?ZRg?PM.b?;3h?ͪnO@b@[Cx@?TATTG1 ŧN@)?TATTG)?pidqC?#?L<4,??6 \N@@_,;?b2U0*?TATTGdƧN@x[YQMR?TATTGx[YQMR?tO#?UL?YIB?2?tcO@ cZ@Յ@&S?TATTGBIǧN@|^p?TATTG|^p?q˟n?w&n?w;r??`RK@鷯@+oX?J4?ATTGTsdK@iʽ?ATTGTiʽ?(xN>8Sfć?J_>N?'?7E#N@3U0*@!ny?q?TTGTT>N@N?TTGTTN?nf#?] C>F?אXxF?8K@(@n9_H`?gs?TGTTGPMJ@@gC?TGTTG@gC?EA`4<>>|76?7ɚĐZ?>?EE~i?,"7k?(bM@ǘ@N!?b2U0*s?TTGAGzF2蔤N@r?TTGAGr?vU8-?EB)a?ܚ.?[?,{#@R@ZӼ@jwݺ@"u?TGAGGM>S@$ N?TGCTGIu&ۡ?H}3 ?*{V?юj?B,U5?V_ ^P@G@pAl?D?GAGGCB;'R@9j)?GCTGA֖ՇE?I׀'?3'?78?QkK?[TyP@@4?+eX?AGGCGzP@ߡ,@?AGGCGߡ,@?S# Z;?3vƒ? IJ?x?O贽S@?@|;o@~jt?GGCGCv,`WpS@5S?22?GGCGC5S?22?@˘?lH?V?rhH>ۙ[Q@W}@*X1?3?GCGCGiշQ@?GCGCG?Trx? H ?uTK?}q?w$nGonQ@fX@ k_? ^)ˀ?GCGCGApQ@sd ?GCGCGsd ? f7?kL{?2 2?GEO Sd?q2WS@9EGr@tZ@~jt?CGCGGkxS@?O?GM?CGCGG?O?GM?-D]?2vK?c (?=>D S@ܵ@d ?UN@?CGCGG`xS@92_T}?CGCGG92_T}??N_.? 16q?(ĮoPM> B)S@\@@^?{Gz?GCGGA'Y@MR@@ 7?GCGGA@ 7?#*q?#cc:+?;]?n> _nR@R|@ Ω@o_?GCGGAvMR@dX?GCGGAdX?0?yQ@fX@8zg@J4?GAGTAJHQ@y; ?GAGTAy; ?!Wf?o|I?iDy?p9Ы?N@b@*?tF_?AGTATrM@2 wq?AGTAT2 wq? I?w?tF?K%{?%P@1%@)W?ˡE?GTATT 1hP@f?TCTTA=Mې?lq?fp3?ѡXN'}?RP? K@ -0@4U?ׁsF?ATTAC]_ȵK@ U?CTTAC/?c )_?#qI?˸F?@F?VP@|?5@]m@]K=?TTACTV#P@z?TTACTz?4B?$?ne?Dv^h?4 h?1CQ@B@gngo?`Qk?TACTG뇂orQ@vdґ?TACTGvdґ? ?3 \ ?.]R?/lN?ZtnP@ZӼC@|":`???ACTGA+P@D?ACTGAD?A?yg?j[?G{?@O@jMS@\-6`?{Gz?CTGAGlRvmO@5 ?CTGAG5 ?kRQ?JG?]?d?GR@`vOV@ z*@+eX?TGAGCÓR@S?TGAGCS?Y4 ?ӄJD?w?rZI7?)Q@k Y@lI{(@UN@?GAGCAMjP@{pm?GAGCA{pm?Sa~?h/c ?U)=?%*ކ?ޘT{HR@"uq[@x?L=U?AGCAC?R@!.>?AGCAC!.>?c@B?7|i?'? TKd?NZQ@d]Fc@ y?UN@?GCACGMQ@l \?CGACGL{Y.?iI\2?ɟV?sq^I?צ?Q@1e@W2k?J4?CACGCUR@=X?GACGC6 7B?I\2?kAEO?c?7?_9Jy2EQ@6{@^]??ܵ|?ACGCTxQ@ ]?ACGCT ]?kw9?½!G?DnFNL?W쭼j?4nZR@ґ\@ylU_?J4?CGCTG +NR@iV?CGCTGiV?$ ?m޿? eB݊?1J̆>pΈVP@_@  @{Gzt?GCTGC10#[P@W?GCTGCW?W;^sd?+tĨT4?[|oI?=W?q|kZR@r @@H}?TGCAA ͪR@)6?TGCAA)6?q<]?NJ?qבo?>>?cXMS@ŏ@IQd@Mb?TGCAAR@_X?TGCAA_X?R HD?V?W)?uwl`> ~R@@OvŶ?a+e?GCAAGRv;R@?I?GCAAG?I?8J_Ή??Aμ?CmM?j x?n+CR@X9Ȗ@.ˣm?"u?CAAGTVqP?AR@2X,?CAAGT2X,?Ȭ? N? S?pJ?QAVQ@V/@?s?F%u?AAGTGaIP@0w?AAGTG0w?3?x|?r1,?`:m?36M@t@DjN?{Gz?AGTGC^`2M@IIkU?AGTGCIIkU?i>NfZ?2yX.%?k?YK@_)@)-? Zd;?GTGCA-G:L@J%EH?GTGCAJ%EH?A*>n{KY?Gs+?b?1S@mV}@\|@ F%u?TGCAG8D3R@zYZ?TGCAGzYZ?{.(?R9= ?:s?`@> vS@/@*(?5;Nё?GCAGTy8̠gS@XQ8?GCAGTXQ8?^o?]\?Ck]?ik%>KMoQ@.n@Sv&Y@a+e?CAGTA-{XQ@8++?CAGTA8++?\ ?qi??X Cr?7gL@+@?Q?AGTAA#TM@(ȀdC?AGTAA(ȀdC?+]xb?˕L:!?q?f-=?w{OP@<,@n!?w?GTAACQ P@,hX˂&?GTAAC,hX˂&? X?#X?rfe(??M҅O@>yX@"v-?`Q{?AACCG`wxO@`%j?AACCC`ٶع?F1j8?ACCGCW2 >8?殜?CH%&+? ?óy}?E!CQ@/@<^?~jt?CCGCAQ@6Yȵ?CCCCAaM˼?1LE?ȍ[?Jm??? i2R@-@&S4ѡ@ F%u?GCAGC+{%=S@EjSn=TGCAG :ie>rLDu<>@mFi>"%>{LŠ|=-R@:p@ԉg.?F%u?GCAGC?s&=S@ꚽ??CCAGCΦ?AK?F?^5ePW8?C5[?][]$P@|a2@a{_"? ?CAGCC{dP@cV?CAGCCcV?,eС?(^? ?&?Wv Q@x#@O?Eioɴ?AGCCGF|Q@z%w?AGCCGz%w?{9?q .? ?y/#V?LScR@( @Y?ŏ1w-!?GCCGA̷,sR@ 4H?GCCGA 4H?pZ? MǗ?2ޑx0?%p?SiyS@s@|r/?Ǻ?CCGATVS@)Ͼ}h?CCGAT)Ͼ}h?Dz!V?}8e)ݴ?@mQ"I?}m_]?u ?лpS@9gDi/@`F @`Qڋ?TGCTTJR@??TGCTT??*Q?W?܏/!o?K,D7>j3`Q@r2@nrL@UN@?TGCTTz]R@py?TGCTTpy?^?`?V?=T~]?3ߒ? Q@ܵ<@Tt$H@a+e?GCTTTG2[O@Q ?GCTTTQ ?^_{z?̃?X>St?9C\?ˢDI@B@4, ? F%u?CTTTCȌ@I@6i!?CTTTC6i!?A=pK9>&'?.eB?J`KI@ ^I@` ?HPsׂ?TTTCCH@߬m?TTTCC߬m?GD`=!>j ?A8S? "L@)~K@ n??.iG/?rwK@}гYU@RӢk?HPsׂ?TTCCCHY"M@*ڢ%?TTCCC*ڢ%?K e?\IS?{e0ʺ?7k?bՏZQ@3W@n>?eX?TCCCC$Q@UJq`?TCCCCUJq`?Qܹ??ih^C?c6ޭw? Q@-`@Ka?NSt$?CCCCCjbQ@]`D?CCCCC]`D?վ?_ V?t\ʊ]V? {1?QAaQ@JYf@{ל?q?CCCCGR@@A%!?CCCCG@A%!?H?^6d?KEif?xUt)? ףPQ@=yXh@/Њ?ŏ1w-!?CCCGA ڂR@e77z?CCCGAe77z?i0O?w"?yǗ?3?02R@ p@gk~j?ZӼ?CCGAC+bR@ u?CCGAC u?kLA?!.^:?Zt?Ҩ~Q?:OWz]Q@ۊew@Jf?8?ŏ1w-!?CGACTOknQ@?CGACT?0o?j9?]wlͱ?ڏy2?hs5P@9#J{@أQ)?{Gz?GACTG eP@cf?GACTGcf?"fnDD?3ᨫ?>p%? KVU?ss(,P@b}@< c ?I +?ACTGGk4CnP@#75?ACTGG#75?٧ ?nu?ˀk?S?UK"ѺO@d@ ? o_Ή?CTGGAѶ%O@Z"?CTGGAZ"?~@Llm?Cs?9UZ? a?)lQ@%@Ɂc?Zd;O?TGGAA9lQ@?TGGAA?6X?zs?n8?ʍj?U{%gU@ylj@ nuS?Eio?GGAAG:U@hH|~>?GGAAA#_{3I?B< (o?rrD4w?"3vMd?`wz=s'S@Z@0x|6F@_vOv?GAAGT)4S@ |?GAAATFFjb?|T?i?B?~wRQ@~j@pa*?H}}?AAGTA>'%P@_Af]f?AAATC͞P?s1?45j?[?bOn?MM-L@sF@M)>?_L?AGTACAn+M@ ;*?AGTAC ;*?ٛZ"?'*݅t?t`4ܑ?gva'?)JO@:@P" ?F%u{?GTACA>O@9 ?GTACA9 ?6"(?jj?M@t?\??HzR@-C@ug?a+e?TACAA-R@~8/Ĉ?TACAA~8/Ĉ?QD?ٿ ө?z$S?M_ ?> gR@8gD@ݐ}R?Mb?ACAAA5HPR@c?ACAAAc?Kb??=?3\?~0<?mQ@ @6t8?_Lu?CAAAGsrzQ@aX ?CAAAGaX ?,C?v)ń?Ɇj ]c?3cE`?Vj%Q@~@Cn#S?_L?AAAGA*Q@-9G6?AAAGA-9G6?ai?-3v[?K,g?f=C?ԛQ@ʡ@ȱ)[?mxz,C?AAGATRZQ@Jk[?AAGATJk[?L ԰?#?pa0P?gIYJO?c^ԝ{-R@镲@mt^@HPsג?AGATCa@R@~n|?AGATC~n|?Jݨ?؞w?)? z`?>K@!rh@w@ QI?GATCCāeoL@ z?GATCC z?_(7͈>TE\? #?X? N@Ǻ@Ok?<,Ԛ?ATCCG5N@[&Y?ATCCCXHk?*%#fK@-@jHf?_vOv?GTTAGZfK@97eJ^?GTTAG97eJ^? n>]??2E?T"?XQ@u$@ySP? ^)ˀ?TTAGC\Og+Q@VR7 ?TTAGCVR7 ?,?\]ea?go*?x)Ao?tXP@HP@!N,?Mb?TAGCC삯qP@c7?AGGCCwx?T8?p `u?*3?BtQF?@_R@ F%@,O?_L?AGCCG4XQ@s?GGCCGu\P?\:?nkI?Za=;?\L)iWT?8[ꡉR@h"lx@+7Aq?{?GCCGTij5hhR@N,?GCCGTN,?M}Xd? L3v?"R?E)P$y`\?o3;H?b,(?uFP@A@1E5'?S!uq?GTACT:tlGO@ϼ?GTACTϼ?a6?m:?g?P?O?,?ryQ@48E@u&u?HP?TACTGqc3rQ@!=?TACTG!=?$ c5?-Vȟ?Xq_?`p3r?ߏP@=yXH@3]8?@ǘ?ACTGA*P@Nm?ACTGANm?=)81?!lu?%}4z?[?%ˢO@jqN@q|?( ?CTGAAm4O@Lw:$?CTGAALw:$?lH{?0P b?)O?0{c[?&1LCS@_l@J^:?޲eR@K4q@/>t-@ ?GAATGQ%R@)ޘU?CGATG"&?*e3X?~̏?K7Z ?+Jb?O@ F%u@ G@Ǻ?AATGTI N@3q,?GATGT]w?W(?~?Jb~?I?)N@Gz@-UI?~jt?ATGTG]xz-N@+ ?ATGTG+ ?:'#Bl?IWW?ATGTG ꩩ-N@It?GTGTA>K.??^F\ ?j0~? $? &dc?D>N@$@KW6?{Gz?GTGAT׃'N@!(?TGTAAV:?¡.?2A?1lU$?R?v_RR@\mž@ϑ?46 ]5?"{qo??/2J@ˡE@G{V@?\m?ATTGC6}K@O=By?ATTGCO=By?aB=ˋ1U?a?ݶǓ? ?L@( @"B`?ZӼ?TTGCGHHL@Aά?TTGCGAά? >fϿ3?|ɹ?k0S5?@@R@Q@:?@vq -?TGCGGao"R@( O?TGCGG( O?O2?}8VcT?Q4!?tyCi?/8yRG`Q@@I0܌?_vO~?CGGAG XQ@W?CGGAGW?.,h?hX?K%?vΎI,Q@Z@ps@_vO?GAGCG"TP@so ?GAGCAPjO?3-N>?X˻?@Ĩ?\>r?^I R@QI@_;?y&1|?AGCGAWh5R@l?AGCAG8??!1=?Zs?Z7vk?u?;?b_XɎS@ h@u I#?<,Ԛ?GCGAC_nS@eRsG?GCGACeRsG?GKͳ?%}#߭?:*?69?FxCQ@/$@!?ZӼ?CGACG["ZQ@7?CGACG7?fR4̂8?$>Kt?yS?$?S 5?7lhP@T@6}?ǘ?GACGG^nDQ@0-?GACGG0-?@zXc?5-3R@SC@oW@q?GCACC(彥Q@-Yx?GCACC-Yx?a' ??;s?D02?eLa]Q@`TRG@2?JY?CACCA\Q@{p[D?CGCCAsh?zPO?TZ?Oz3ę?oNs~@ZӼ?CCATTIR@f?CCATTf?x_? -$?h^mK?@>*;2N@l g@!;C @_vO?CATTCY}S M@^@VZV?Ϥ㘛?ʀA?ױI@8dj@=>Sq?ͪն?ATTCG BɎ{I@ps?ATTCGps?!H3:=S]A?POy??^ R@:@`p@<,Ԛ?TCGGCE!R@/;4?TCGGC/;4?4u1?Fn?p=?@IW?a;b-P@e@8[t?8d`?CGGCGTGO@V1?CGGCA_Y|?/ I?2 xB??R*_ ?E!yT@/'@߻=?Pkw?GGCGCcpS@tSn?TGAGC?έ! r??13?#L>hѵP@ec@<@y&1|?GCGCC57 Q@aB?GAGCC;k ?[a{C?qD˓?r?\ʬ?X1L@r@-#'?{Gz?GTCTTVm(kM@j,LI?GTCTTj,LI?SOSN?סX?NJQb?=Q|r6?"O@hs@[H?gs?TCTTC)x-xN@bI|?TCTTCbI|?O{OT?!=}a?-Sfŵ?vNAj? ףp O@0*@@˓ ?j+ݣ?TCTTC>~xN@(G?TCTTC(G?6n#?P t@Œ?,GJ?e?D?{oII@+e@9~? ?CTTCC6 ePH@]?CTTCC]?V:~<>mbGG? IiS@U@4u?ׁsF?CCAGT T׷AS@lqҖ?CCAGTlqҖ?RwӖ?JNj^??̮/?,!>ȐQ@ˡE@[?Zd;O?CAGTGb>TQ@̽ &~?CAGTG̽ &~?%?+cW@?b?/X?~/L@߾@^ꅍ5=?HPsׂ?GTGCT}XL@/?TTGCTVμ'? t>I;h#k?wZ2i?.s??a~LR@Bi@4L@Q?TGCTGf;RQ@U q?TGCTCp;3?lHdj ?}?E??WNO@ o_@_*Y??߾?GCTGASP@~0?CAACC:27j?3njI?8A_? ?~@?=fN@ c@̯6?_vO?CTGACS}#TN@/_$?TCTCC$Cg?  V?E?4d4f?c40ȝ?o0:&O@g@05? o_Ι?TGACC@A7P@'!@?TCTCCt֤f?dɹG?hԉ߸?L?A ?uc1WP@}?5^@Ɂ?faִ?GACCA}_eP@ف[,/?CTCCA Md?ڮ?H\6?&6O9Bn?0g?ReENR@b4/@E?b=?ACCATϦVQ@@k?ACCAGB?gt?{Pk?CCATAiĿR@с_%c?CCAGCp?E0?i ? &?)J?P@M O@.9hTs?<,Ԛ?CATAAr6SP@r0.?CAGCCe?8 B?9{)?m2B"?8࢕?YQ@WR@'hr?UN@?ATAATjaQ@ ܴg?AGCCTu$?*;Ա?:Y?#?Oq?_U R@|a2U@?M O?TAATTɸ;Q@0~?GCCTTJG?l8ZRU? ?eS?tJ v?䏎mG@}?5^Z@'@? ?AATTT b#!M@2uF"?CGTCTK?(?/=aؔf@>a8.7>pōa?az0N@5@b@[g@0*?AATTTT%!M@b< ?CCTTTG+$?$ ?[Wo ?ߙ?+ ?SA˰I@&†g@X,P?A`"?ATTTGP[I@c:Q1?CTTTGԿ R'?f(cq= w2 ?q³>&N ?NK@1*u@ !?r?TTTGGMP^K@È^SV?TTTGGÈ^SV?&lT> ƛT`?)?H ?RI[O@x $(~@kWp?Q?TTGGG ? wN@D?TTGGGD?"t?.\%#??fU?k2>%pi?3Q@H.@V@J4?TGGGTǀQ@b5(M?TGGGTb5(M?B,&.?9mE?'p?ac?6P@0@hӎ@vq -?GGGTC?;A2UQ@ v?GGGTC v?{zLH?MtA?D?sƹ]?$L@ @H&,P=@b2U0*s?GGTCATJK@l.?GGTCAl.? Đ>Bˌ?dssxQ?xK-nR?bKJP@g@[@UN@?GTCAGj<N@)?GTCAG)?K 1ި? 8?nR?>'} l?ٜhR@Ǻ@-13? ^)ˀ?TCAGCj ,pR@]?TCAGC]?U+L? y ^ȟ? +:?sǵ>"P@<,Ԛ@w?_vO?CAGCTo%aP@b1?CAGCTb1?@e?(f`H#?>?5dS@/@ͧ7?{Gz?CCAGC*R@ `Eq?CCAGC `Eq??Cg?@/r.?tF_?GCTTGU/ P@rY ?GCTTGrY ?uDL?ȶo??qKb?^?RzqL@ lV@C?I +?CTTGCֽK@$ PJ?CTTGC$ PJ? X>YV;? +9?#¨? eL@7@h~#?q?TTGCGVIL@y ?TTGCGy ?ԏ{}-(?VtI?9q?R. ?F=eR@@ҕ@tF_?TGCGTېR@q?TGCGTq?:Hg?s7=?iP ?`#?OQ@2w-!@sWg@{Œ\>'?,v$H@ڬ\-@j?eX?GTTCT4دH@F6]#?GTTCTF6]#?֑J-~?{sꗿN@KY86@?St$?TTCTG*GeqWrN@M!?TTCTGM!?hSc9W?0 =+?d[&?ZT??Hz\P@Q>@݋.R?ݵ|г?TCTGTkkeP@kui?TCTGTkui?⵹&?q"o*t?KO?؀?QN@):K@N&?^K=?CTGTTj=QN@F"c?CTGTTF"c?^>jw#a'>_OX?TjV?"?J@_V@Id?JY8?TGTTC]^I@e@?TGTTCe@?v4ZO@= 'g>!4|C?d?\ʥLH@R|a@瀋4? o_Ή?GTTCG U8H@CR?GTTCGCR?TaߛQ=%ߐ>5>[?p=JiL@?ܵd@J攁G @-C6j?TTCGTϜO@pV}h?TTCGTpV}h?AwA?zp??vG?h?' W?T׹@?\5K@ŏ1wm@Pv9@( 0?CGTTT{#H@\HS?CGTTT\HS?/}xcg>:C A>?Q̠>?3g?I@Aas@Dv?S!uq?GTTTAyrI@@?GTTTA@?JW=胒i?CY g?+w?8AL@R|@Cj76?H}m?TTTACOIK@9p?TTTAC9p?)66a?#r6?x|?sQ?xX]O@ h@2@HP?TTACAvO@ X?TTACA X?? ڬ?Mp9%?v)P?y+?s#7Q@@mO5UW?_L?TACAAES}R@X,W?TACGGxᴕ?Ct?{?lL=¿?DV=Md?'zR@]C@B?Mb?ACAAG]ЄFlR@Z!~Z?ACGGG( ?Q{*?˪Ê?v[h?,qk0?&K^Q@@ YD?+?CAAGC4ZQ@2T?AAGGAXI$?1-\??B#+p?e]Һ?S&R@F%u@$ 6?Y5;N?CAAGC8/Q@PP?AGGACK?-,?$B?Yn?Nެ?M |?a;b/R@ @~@/n?CAAGC1Q@+ӗ`i?GGACC1Ͱ?n?݅?k[Hc_?6?i*K'P@J +@׶?NSt$?AAGCAtmRP@-)?AAGCA-)?B ?VƼ$?k ?&-t?dfR@6<@[z?n?AGCATR@ iiQ?AGCAT iiQ? j?(u?M_?5#?Ÿ+R@?Ƽ@|@( 0?GCATC^3R@ ڐ?CGATC'QG?MG ?y* ?W?|Ld|? pitM@n@_fu?y&1?ATCCGJyN@d_1?ATCCGd_1? z?i)^N?0's?E?ڪ/kQ@@45? F%u?TCCGTUQ@>o?TCCGT>o? ?c?;ߜ?z!Kn?IR@d@~:VE@ ?CCGTCi.ڠQ@ :JU?CGCGT|?z&l~?e[?O?-wpc?@5^hR@@$? @Mb?CCGTC &ڠQ@:x/?GCGTCZ!?2 03?`l?QU|8?7E ? 'CG@mxz@[pa?~jt?CGTCCmLH@Cl?CGTCCCl?K`Q<Q>ݗ1>@]}?KIG@ @!$@ŏ1w-!?CGTCCH \LH@'(?CGTCC'(?8%-8<<9?@ R>j{V?<M@Af@tʑ?DJ?GTCCAJQM@Z?GTCCAZ?fb6?R- ?Xyr?"_jr?QnQ@_I @AH &?_vO?TCCAGL2Q@*.J/?TCCAG*.J/?Miֳ?[?L ֽ?Gَm?\S@Z8@ܜ~[?~jt?CCAGAoJS@3?CCAGA3?[Ù? ?i?^GLx?^X*r>&3\R@@2&~]?&?CAGAA)afR@.?CAGAA.?b3?q?e?HY !? >S@߾@c[.N@ o_Ι?AGAAA AT@(?AGAAA(?ߟ/DG?] _ǻ?_/-/?<>K7lYS@@"@]@c1@Mb?GAAATO!jR@L]V?GAAATL]V?WC\JZ?pocĹ?((WF?G.ϡ>>'S@=,Ԛ&@Uo_@gs?GAAATݥxjR@.,?GAAAT.,?, ?xna0?'t/?T>SgQQ@Q)@DZ2?HPsׂ?AAATT z_Q@E=?AAATTE=?"M-|?2g^} ?qb<?2Hh?Z\N@ q+@X oQ?V-?AATTGpz)M@S-3\?AATTGS-3\?Ck"?{?JV?5?'L@HP3@JL??ATTGGugl:K@M^M ?ATTGGM^M ? ƺd>})`N8h0?9G?op2?iBJN@k 9@BT5 ?y&1?TTGGC{W N@?TTGGC?L?3eɰ+l?Av+?>I5?XkiP@<@{$:8R?A`"?TGGCGQJ#O@}"?TGGCG}"?7]ل?<³i?3,W}?.s\O?0yyS@b2U0J@$@y):?GGCGG,[S@5xg6?GGCGG5xg6? }?GjNX?A?!o>'R@@߾N@!HP@o_?GCGGC=ӮR@B9?GCGGCB9?$?)=n?vwx?KzZ?@($+O@_@6?V-?CGGCG=O@~;/O?CGGCG~;/O? 6p?̧?z鱞?i}>l* 9Q@Ej@ W@Ǻ?CGGGT2P@i.kv[?CGGGTi.kv[?^?LjW?vm.q?Cg*z?[P@{p@k!m@Cl?CGGGT(` P@V?CAGTTćϴ?%hw+?PŎ?g{?0AA?#R@_@-l@M O?GGGTTv R@G3T ?GGGTTG3T ?_?9 L0?0 SC?L@'?QK@X2đ@6s@S㥛?GGTTAy8L@Ԧ?GATCChj?qMf^s>@]?' ?z?%}?f]Q@ O@;R{?( 0?ACGCGGN>qQ@C?E2le?ACCGA@.z?tq?Y?ŸG?2IHY2? In.S@{G@<]@n?CGCGT+]6;S@9?CCGAGƿ?1i?e5[? c?j[><_S@@@C$S@O@Ǻ(@Q@2ı@{r@a+e?GCGTAܫR@N?GCGTAN?+4Z?=_Ď8?q?}Wo?XqGR@Zd@"*E@HPsג?GCGTAs2 R@8 2?GCGTA8 2?e u?jz!?#--)?&$$P@JY@VCO?Zd;O?GTATC-HP@꼜7?GTATC꼜7?ގۀu?'MQ?iӴ=?we?tyN@<@XI?<,?TATCG]AQN@GF?TATCGGF?-Xi?w?`9P$?94ϸ?fffN@6W?AATAGO4O@@FN?AATAG@FN?6u?`?\Mi?y?/%٧P@ F%u"@$?ŏ1w-!?TAGCAxqP@! ?TAGCA! ?vV$6?J7r?% ?ݻ#?ґ" S@JY&@Eީt@]K=?AGCAGsowR@۽?GGCAGoQQ?5ӕ? ?;Ay;?Y*J>S@(-@@(?~jt?GCAGCV1=S@E?GCAGCE?ϊN?InG?Bu^H?>L G4?bGeQ@D6@Q}D??߾?CAGCAL"XP@tu?CAGCAtu? /ô?4Z?M k?2M3U?S@-Ԛ=@yiL?I +?AGCAGyR@?AGCAG?c=?A7l?c@&%"Y?9dF/ӱ>)ݜAS@eC@Zy?<,Ԛ?GCAGTI,hS@ei?GCAGTei? ?Cٲ?[qm?C?>/dѮP@ףp=J@ݠLb@Mbp?CAGTT*GXQ@-}Fx?CAGTT-}Fx?@W1?!Ғc>f,?3:Jj?"uJ@CK@K? ?AGTTG¢=K@fw%?AGTTGfw%?sf>ή?s<~\2O??*59?z_K@&S@jxJ?H}}?GTTGCsXJ@ ]5?GTTGC ]5?{C=>x/y?TI:|?<6)r?sJ@FT@Od?q?GTTGC'+J@_c?GTTGC_c?[#q. =uC?Ndf?^$l?1w-qK@/!V@f?{Gz?TTGCCWxK@U*N?TTGCCU*N?Wna>NPV\?`;4U?P?UQ@$(~Y@h@Pkw?TGCCA_I+Q@tTbA?TGCCAtTbA?9Ƈ^?V?ON?!x|O? ӳ0IPR@d`@#X8? ^)ˀ?GCCAG oiR@\`+A?GCCAG\`+A?׭?*@l?֙V-??/B?TjS@b@b3p%?"u?CCAGAth7JS@?CCAGA?# #?8|m?ޕηo?ÈJX>lQ@ed@@C?gs?CAGATVQ@&i?CAGAT&i?֡?U&H?)g?@z?eLR@zg@3-?46[}[+>- :Ge?G?\tX$P@?|@H(~? o_Ι?TTCAT3MO@ӈ`?TTCATӈ`?z>?PԯH?'R?KY?w? 2rR@9@Xw?S!uq?TCATAa8R@"??TACATeW?]? ?T;?/RU>tڰ=R@阮@4=z?b2U0*?TCATAR?O8R@ܚV?TCATAܚV?@0Do?'RTʧ?kJS\E?âY}&?/ 6$P@):@3`X@J4?CATACT tP@z?H?CATACz?H? ?2ߐ6?#'θ?3Xt?Z` bJP@Ǻ@kBU'Ь?St$?ATACC`P@on>D?ATACCon>D?(D8?#6%y?S'?4?Us#Q@.@VA?&S?TACCGlk=P@[%ftb?TACCG[%ftb?xװ|B?\ъq?1?Ñ?|``M@2ı@о>q@Mb?TTGGTWN@k80?TTGGTk80?fϸ^'?l?pEC?mu&?1G`JQ@D@'V1???TGGTT6O Q@J@y?TGGTTJ@y?i{?h`?3S\?)3ez?(vb'J@QI@ѫ@_Lu?GGTTC]QK@Yr?GGTTCYr?[#7>:zU?t4??#G@@:?St$?GTTCC azH@$Y?GTTCC$Y?Pޕm0=k,.?J`s>!2?sM@՚@Aa{ \ @ŏ1w-!o?TTCCA ,?N@'r?TTCCA'r?~t>C@p?,BTM:?~A^?5lVQ@@&E?"u?TCCAC`Q@v?TCCACv?j?_QJw?\b?ny?|?կQ@ +@}6?Mb?CCACTFFZQ@Ma92S?CCACTMa92S?27?0v?>9?[x?sRP@uq @Sz2hk@HPsr?GAGCCaqfP@2+?GAGCC2+?PV?bR(*?~?GgD?Q@H@y? ?AGCCC SQ@'\ ?AGCCC'\ ?Ch?=~y? j8ž? 1e]?z`Q@j+@s xH?-C6?GCCCAKּQ@|'?AGCCA9 ?+?sky?XSb1?qy/?gR@9EGr@rsP,ɡ?x&?CCCAC/+'R@JW?GCCAC=?⽴A?m?Pm?ѳb : 3?S>Q@0*@!q!{p?Aǘ?CCACG]SQ@?CCACAt ?!k?&ڶ&?& "?z7?`jR@"5@oNjIG?46DR@@SC?CTAGC@SC??U֫??6wD?cL/P@QI`@K?J4?TAGCAgP@e$̽?TAGCAe$̽?_P? sF{? iP?o2Ŀ?P0QS@Jd@Wٮ@w?AGCATMYR@ɠ?GGGGTej? ,??- A?U c>~Q@gffff@c! v?N6?بШ?\<ӉJ@ h@Rv?ŏ1w-!?ATTTA+|I@.F?ATTTA.F?$QZ-6>(-[d?fv?( p?rL@li@eB0?#?TTTACRttK@*tf?TTTAC*tf?5&yD*?AE>? (?-x3?5nO@%~@5? 0*?TTACAG4O@rrA#?TTACArrA#?ڤ9X?_| ] ?w?ca?Q@q@t<,5?I +?TACAGKRQ@#?TACAG#?2?e ?i W??jyjF?)\R@ o_@01?-C6?ACAGCb֟R@10?ACAGC10? EZҙ!?5?Ku喵?7<%>ceP@/L@:q7?2%䃞?CAGCCP UeP@?N?CAGCC?N?U;ca?S 孾?B?;a?x9qQ@8EG@ 3,?{Pk?AGCCCSQ@wY?AGCCCwY?Ըѵ?Bf?}EL:?"_5!W?U@Q@,e@e(?HP?GCCCC4U Q@$W?AGCCG/܎?">)?Mџ\EA?dv?oG?]•kR@/n@7W~?-C6?CCCCG D_ R@|@kZ?GCCGA^~?e%r?%*?(?z&^>3a`KS@H@??HPsׂ?CCCGA,R@3Wt?CCGATIEO?[դ ? ?}$?e>b'vR@.n@ޢ ?q?CCGATXS@sf?CCGATsf?ɩlI\?0(l?=(4?eϿ>#oɝR@UR'@]l"@y&1?CGATCR@A?CGATCA?T ?6JV}?ab?v?.Q@zX5@ov@8d`?CGATCF5R@[`R?CGATC[`R?/]?I r?#?d3(?C N@=R@*b {@Mb?GATCC7ЈpL@X`k3?GATCCX`k3?4d~?D\Zqɓ?4EBu?>w[?SoO@w@ `seX?3U0*?ATCCC6[s|N@H e?ATCCCH e?0i d? ? P?Lj?s~`N?ЯDQ@ q@""?:v?TCCCA>76Q@?TCACA3g!?-?;? ջ?#?+R@h@GJ?Q?CCCATX*b.3R@l?CCCAAkoFu*?ND?utױ??wqݤ?] ?'t;hR@Oё\@TtL?/$?CCATGPFOGR@'HW߾?ACATGmR ? a?Q?W?tNdbVU@v@@mxz,C?GGAAC2mT@S(e?GGAGA)R?w??yF?Y)}b?NZ#q=8S@%@oMLa?_Le?GGAAC븸T@)x?GGAAC)x?  ?7Lo?QbW?|1IJ>u@Q@Zd;@ ]@~jth?GAACG$b(eP@\̪˷(?GAACG\̪˷(?"e?h>kҐ?MD*? V%?]El .P@@?ǚ?Q?AACGTK P@/G?AACGT/G?x?K \?Мښ?dAS?d/Q@q= @Z ?+eX?ACGTCnQ@DL?ACGTCDL?c ܨ?.,>?+?Wa^kv?Y' H@&@5 3? Zd;?CGTCArޛH@b(0f?CGTCAb(0f?hK=O>5ݳ> 9L? V[O@_@_t`@y&1?GTCAT=+Ub"O@lS'?GTCATlS'?[?Nҵ??"?̙W;O?Tg4R@ڊ@.bS?/n?TCATC#R@`FdL@?j+ݓ?CAATTIx;Q@'?AAATT"(?3Y: ?+t{?,nZ?=.‹?l9vL@<@U@`Q{?AATTTw6!M@Wg?AATTTWg? h>Y[^?$ĔN_?a?,J@Oё\>@xԅ ?X9v?ATTTG*I@+Dt?ATTTG+Dt?> ~=$]t>"k^3 ? 6?U K@|/LF@2&k~?<,Ԛ?TTTGCOZGVK@tז;?TTTGCtז;?/֚=nu>rY?s)#?fK@ J@A%?Q|?TTGCGK*IL@%q?TTGCG%q?ǬW>F&w>{/?L3 ?~?5^OR@:m@:@Q?TGCGALMwR@?TGCGA?&5o? ? w?2TQP?}DZS@Dp@`+~sB@&†?GCGACS@z_ ?GCGACz_ ?Ŷۤ?h;?#:p?̖kD>):!S@'1|@^?{Gz?GCGACS@?GCGAC?r}nw?M0?0,?e>.Q@Zd;@e̯?gj+?CGACTQ@۸ ~?``?y+?YX?I@X2đ@#ހt?"u?CTTCT=tcI@ю2 ?CTTCTю2 ?XM=JS>3xۛ> H?p|e?N@@r>,@1*D?TTCTG sN@vp?TTCTGvp?)q.?VYľ?IZ?{5Ub?ErP@6@9XYd?-C6?TCTGC#4P@Rw%?TCTGCRw%?,V?(1~_?/r)?l3k?_KM@O@a@T?HP?CTGCTfL@ W?CTGCT W?j'5?Cz?!jA?7?IuP@RI@O5??GCTTA;WP@q7R?GCTTAq7R?O.?X<3?6p?)?GzL@x@?I?Ǻv?CTTAT.`L@GHD_D?CTTATGHD_D?m[z@?FUn?D?=Y֮GCTTT^FI?>.>rȾ? U?v Gނ?(\vXQ@X[@~ۀB@b2U0*?TGCTT)}BR@E~?TGCTTE~?"/ ?z??x"?/FP@sF@\rK@y):?GCTTTy)NʞO@??GCTTT??r?lj\{?= aп?͐N?|I@a"@9?Mb?CTTTG;/PI@+?CTTTG+?$:p=< ?7>"?4pK@/@Ⱥ%d?Q|a2?TTTGT_ vqK@z̹I?TTTGAx/B?$^oO>6"?l3bs?\?M@]K@#Q??߾?TTGTAVkM@yM?TTGACmP?|Ѭw^?CޭN_?*x?< 9?$8)N@@'8\{P??TGTAA:M@"ZjfP@X2@yc?e? M?kK?vs?QM@@xH@b2U0*?AATCG_L@[4+?AATCG[4+?ep?q?c-?<*?^I dO@6@Y+?Mb?ATCGC5ޑ,P@d$Ӧ?ATCGCd$Ӧ?'b? ?_ؑ\?}+?czҏQ@ h@=Ѵ??W[?TCGCAIOQ@0@v~?TCGCA0@v~?(wզ?Ȗ?B5ѸPT?HȾMH?h?S@9# @#H`?n?CGCACcl^0S@L\?CGCACL\?XB?SǓ?U{i7F?y+9}>v˴Q@mxz @'@mxz,C?GCACG"Q@%?GCACG%?_f?\33>?v???G8^RR@ -@ ,?2%䃞?ACGGChLR@o+NFZ?ACGGCo+NFZ?Bhy?=dOu ?As?kD:#?7.O@@.?mxz,C?CGGCG"}`O@ ??CGGCG ??hi?K ?X'?sB)Ļ?1:%S@?@ B@y&1?GGCGC '2qS@6;?GGCGC6;?^x?Ń4 ?|g+@U?:J><$0R@ F%u"@_Y?gj+?GCGCA/Q@_'?GCGCA_'?I0,7?Yؿ?f?Wn.#D?FR6S@ r(@9?S!uq?CGCAGhB S@+@5תDB?Q|a2?GCAGG-LV(?S@!u`?GCAGG!u`?묲y?38Uo˧?Ol?γrD>\;Q@z6@f`$? 0*?CAGGC#mYQ@%?CAGGC%?&~n?f?,Ø.c?bdF`?-P@UN@pt?_L?AGGCGdwP@ !?AGGCG !?_^j?VC ?=w?!) G?S@6;NQ@I*V? ^)ˀ?GGCGG7>\S@u?GGCGGu?)r6?2?vڭ?-dޒ?}̹s>[d;2S@ gS@Ȳ ?Mb?GCGGCn)R@M&؞?GCGGCM&؞?f>K?ǀ?d38?7Cj>ϔ7S@hsU@ @0*?GCGGC˲)R@x?GCGGCx?Yh?.⋦?-U?2>mƐN@v_@vq@6;Nё?CGGCG<2lO@5?CGGCG5?жYV6?^ 7U?_?w?=[T@o_n@K_U@HP?GGCGTGecS@9?GGCGT9?&}h#?qSrV?Ŋ?fsƽq>P@x&q@I2 @J4q?GCGTC2Q@DP?GCGTCDP?`?2M?aA?>p1?l)*J@z):r@ss @Mb?CGTCGSH@ƾ2?CGTCGƾ2??jv>܉Ic?H=4?>p:?8M@؁sFt@r?46q+Q@9@B@I +?GCGTAR@,Y?GCGTA,Y?~ 0BN?im?mP?/x?ʹOeK@0L @j/@L=U?CGTAGޮK@{ O?CGTAG{ O?;>D ۹?s?~Zj?R5eQ@r @7?u?TAGTGuQ@}9j?TCGTG/{E?a;t7?,_7?ǻ?G 0R?NڔlK@R@^3@ ^)ː?AGTGCv+n4M@E$J?AGTGCE$J?<8>kՔX?]b?z*?Z4S9L@@=8g?+?AGTGC{n4M@)(3*?GTGCGqyɦ? M\>%O ?'.F?Oub ?`ǖK@|г@s0hu?ZӼ?GTGCA;L@ը/y8?GTGCG}q?U:>$ި?:U?/ͥ?Q\RQ@\@1>@-C6?TGCAT*LR@p|?TGCGGٝi ?g M?f,z? }?/18aV?w3S@#lxz@S?1*D?GCATA@lR@i[,f?GCGGAE?Nm??Vu?OHM?Wm=P@u@]lkq@/$?CATATKSP@jVϾ?GCTCTTg"?~"?4Kȑ?})?+>R?)LQ@fc]@6-c0?9m4?ATATTvP@}?ATATT}?-?{'#?vXI? X9s{?!4BO@,@Ebf@/n?TATTT+Aڅ:N@-?TATTT-?jOAF?AS?mSHJ?9 ?@I@`vO@0?镲?ATTTT+01I@@6z?CTTTThwn'?%Lb=wq!ĥ>. >ɣ?򇙛-I@X9(@HDnJ?Bi?TTTTGn)I@#Kl?TTTTG#Kl?GS==N>*>C?9ȖL@s7@ Oux'?Mb?TTTGAN'K@b?TTTGAb?Ii!>{\Dd?.aw?w?HPL@/n<@?q?Q?TTTGA֬K@OİBI?TTTGAOİBI?c#?{K{YK?2?\-:?ؔN@c]K@@/4 ?46T=> ;?G?zG=K@D@]B?{Gz?TTTATN]hK@[V?TTTAT[V?>%V6>RJ ?kLjq?|m@G?ƹP@:#J{@Ө?NSt$?TTATG^>KMP@jl?TTATGjl?N'6~?قN?t@﫶?3z[˯?N P@8gD@ 6?mxz,C?TTATGrMP@nPd?TTATGnPd?To o?KmC, ?Ar3?3Ip?to$}^P@}a2U@SU@"u?TATGC"-2gO@B9?TATGCB9?Ѿd3?Dj?#L?~R?7dM@~j@L @Mb?ATGCG&8L@>y?CTGCG_!S ? F>]o?T{:?!,]? {+lpS@X9Ȗ@@:v?TGCGTQfR@?TGCGT?LFg?-S[R@2@*G>@F%u?GCGTT$U R@,D@?GCGTT,D@?C,!y?v# 4?j?ڣ#? H@H}@ B@Zd;O?CGTTT`+H@p0}?CGTTTp0}?&~=# >_>?Q};G@O@a@?J4?GTTTC2fڻH@Au?GTTTCAu?T,q]K>1+?Y)H@ݓ@idj`?eX?TTTCAbMVI@EKs$?TTTCAEKs$?/'GU=Fp>?Bp !#?́??+Q@ c@|6 @vq -?TTCAAIEO@BG?TTCAABG?EK q?ij?q2{5?D˅h>?链:R@Pn@48?H}?TCAAA|KR@!J \?TCAAA!J \?u$Ff? ?R?zKZR>3vD‡R@`vO@TJ@y&1|?TCAAAꐶ`KR@ *?TCAAA *?E?Fz|{?]#? hx\?qR@s@{xD?Pkw?TCAAA'KR@ڎ a?TCAAAڎ a?KXG?p?9[?%ݠ\P?gIM Q@/$@Bs?J4?CAAAC:B}UQ@!?CAAAC!?D4?fA^?60c^?ID?u]OQ@iq@+?QȂP?Xc8R@4333@i")v?b2U0*?ACATC{:LR@Ax*?ACATCAx*?~R ?-d?#Yޡ?nr^}X?i}z7N@^K@|O!@b2U0*?CATCTr:(N@o;n?CATCTo;n?C`4 p?im.?]_Am}?IM`?gffJRP@i|@:r"?-C6j?TCTGTXJ,fP@My{?TCTGTMy{? ?<dR? J[ʅ?B7u?֣p}iN@¨N@/в?b2U0*s?CTGTARKN@W?CTGTAW?zVv?rW((׸?0!?@?JpN@K7@f'?y&1?TGTATgL@lj?CTGTA I?ޤ?:}ڿ?Zl`?no?4O@[d;@}?5;Nѡ?GTATTssP@;?GTATT;?ЙE{?m7Ɣ?^Ѭ? +?QEˍL@A@j(o?_Le?TATTTd`N@(*-y?TATTT(*-y?+>&f̱}?H>׽?=/?O冹I@9EGr@v3?/n?ATTTChuWI@7/&?ATTTC7/&?h>"=z7L?%QR?n[l?bSƴH@n@l:?Ǻ?TTTCC:hJH@Oة ?TTTCCOة ?K9=͉>+? ,fM>G?CDDgN@%@جq@b2U0*?TTCCC}v,M@wQV?TTCCCwQV?rhU?eQ¾'?%#D?:,9 ?}6);Q@:#J{@mQ( !?ǘ?TCCCCgNQ@ ✓?6?TCCCC ✓?6?S ȚA?A?#z5?3ڐ?V Q@l @8?ŏ1w-!?CCCCCQ@"?CGCCCO?Mp\/d?S@鷯'@Gſ?Mb?CCGAT:.CS@zzg S@Hr)@h>2?Ǻ?CGATCo]cbR@"ͽ?CGATC"ͽ?e7t?aꬦf?+t@?V&?o ?T?kL@>?AATTC>?x>!1?܆ |g*_?ʟR3 ?ɋ?_,O@ÆWj@DOx"?b2U0*?TCTCA ZO@Hxq?TCTCAHxq?/i?C|*?BYT]? u?+w?Q@~@d>a?*̈?R.? LM@|P@ wDv@-C6j?TTGACN@K$c[?GTCCT;?(?<0s?x)?lT?{qlRQ@ h"@EdK?HP?TGACT }PKQ@("±?TGGAC`t?,tl?o?mL?SWk]Ӟ?leQ@A@?ǘ?GACTAFP@&_?TCCTC%NI R?&%?KPA ?;S?D#;?X&P@ g@ V?y&1?ACTACZ"WP@ɚ?ACTACɚ?Z9=??6(wS??1;?d.t[P@T@ Y0@St$?CTACA:4P@[1?CTACA[1?Hn~?%%?G?`? R@qΈҾ@?ZӼ?TACAGsQ@/e\?TACAG/e\?lG"?+6?p #d?xAՂ?gffS@Gx @szC?/n?ACAGANR@?ACAGA?Wi? ?҃? z4E?pR@|/L@bq#ǫ?_vO?ACAGAi-R@!_?ACAGA!_?cSU?yt?Q@wO@?ŏ1w-!?CAGAAGR@"??CAGAA"??V6g?lQ!h?`평?1'XkQ@9EGr@C z@jM?GAACGޓ9P@&Y??GAACG&Y??ddE?7c~y?u݈#5?E~?d/㢧0P@9@p?"u?AACGCXP'0P@6 ?AACGC6 ?=zga?{Lw?~Yv?54%?ΓQ@\m@yܦ?ׁsF?ACGCT$?̑Q@KB@?ACGCTKB@??mK+k?N?M^ .pbN?WpS@#~@D=I@HP?CGCTTK;N@) @" @+eX?GCTTT OO@?GCTTT?DQm4>d˺Om>s?֞e?5^X J@V0*@Vt|)?Mb?CTTTAI@`>f?CTTTA`>f?<ܹ=˜/?Ya>*q?>L@@x??UN@?TTTATK@Si>?TTTATSi>?NzD?s>%(?pYp?.g=?% P@0g@>??=q I@ @̕%7? ?TTTCG\""KI@B淐?TTTCGB淐?GI5l=Ui-I\'?[5>g?:L@/!@?ea?TTCGG'E1O@F{*?TTCGGF{*?θ@S2?B?Uyd?g`?HZ{R@M"@S@/n?TCGGCTZR@JL'?TCGGCJL'?8O3:5?(sS?jA?[,t?OWO@A&@Bܧf? ?CGGCG2ɦO@/'o?CGGCG/'o?v[?߬_?H?ts? ѻ!S@o*@DѲ@ ^)ˀ?GGCGTS@^?GGCGT^?c‰?O ?ʕ"@?sg:>] Q@C>,@-ɏ@~jt?GCGTT xv R@iR?GCGTTiR?bZKxt?j}kQ?5/:@?7FO?9WQ@]m2@JP @gs?GCGTTnMIw R@!8H?GCGTT!8H?;W=?rіF?w-?i[nUa?rG@ h"l8@x K?S!uq?CGTTCMԠ(lH@hYg?CGTTChYg?Z3KU'C>N ?D H@Q;@"h~?NSt$?GTTCC!w{H@В;6?GTTCCВ;6?b}$=K?R?2?= ÍK@.nA@g=c?Mb?TTCCA~s$N@+n?TTCCA+n?*+>YZ?omw?L D߷?#=Q@oE@@`Q{?TCCAGdSQ@҅/ ?TCCAG҅/ ?oڟ?[;F?<?,&,?;S@ yG@"kh? ?CCAGT[BS@Zs.?CCAGTZs.?ڶ?}?yI<?>I>߷VQ@HPX@'(j@HPsג?CAGTT|XQ@'z?CAGTT'z?+'5an?'u?m> ? $:b? 3J'J@V-]@J(?oŏ?AGTTGe|K@ ?AGTTG ?~=Xb!?.'](mD?T?ןNJI@Ao@5o ?5;Nё?GTTGC^J@Q/f?GTTGCQ/f? \=ZU9?U6Z?f'G?TUL@ˡEs@oWP@y&1?TTGCGqނJL@ٮLA?TTTAGᘑ?0n6?˜E?d4V?2 [?hmR@Kw@ @ŏ1w-!?TGCGAj?TGCGA E>j?O?.f?k?F/2>?Xlw ?Ԡm0S@c=y@2? rh?GCGAT_qTf"SS@m&~t?GCGATm&~t?6^Ϥ?Էi?kKN>A?)T@>d:NyR@k+}@a|F@?߾?CGATAIy^fR@"?CGATA"?Ǩh?0jߒ?rey?%q_k?;NUO@T㥛@GDi@jq?GATAGivO@ x?GATAG x?*Aո?ڴ?1ᥥ?w?!Q@m4@_#ͽTk?L=U?ATAGC4 ]NQ@>k?ATAGC>k?6|7??7i?כ1"M??O?AGCCAL>?O?z]?4B-?o׷9?*]Y0?OBR@KY8@疜?j+ݓ?GCCAG{DjR@o?GCCAGo?Z3?ﴟ?b*?+x`?քj S@V/@S]?d`T?CCAGGs|6 &S@n1kL7?CCAGGn1kL7?͉l?0?ż}&~? >$R@;M@v?]K=?CAGGT~R@ -Y?CAGGT -Y?S?\9?R??cd?#쿱Q@NS@`,@F%u?AGGTTLS\Q@n"~m?AGGTTn"~m?Δ&?&c?Sp?,v3^b?6N@3@H~@mxz,C?GGTTC5[K@SAsH?8 P?1?$H@L=@NVY?:v?GTTCA(KH@0ͩcR?GTTCA0ͩcR?⺟b=!qzۨ>pAC &?t?yQDP@e@ْS@&S?TTCAG˜}O@n?TTCAA'?Ex? }?2Ue?TQԖ$?;@Y>eR@Ǻ@L?/n?TCAGGFR@H?S?TCAGGH?S?Xj?4ԫ?-E?y!?*c{dQ@0'@!?ŏ1w-!o?CAGGC9OQ@_Yl?CAGGC_Yl?wMȣ?1p9?b}c?KQ?2P@&1@q?I +?AGGCG DP@Z`ċd?AGGCGZ`ċd?MTJ?wƷ?xw>?ط{?Qkw??02J? @>yoQ@Q@d4@b2U0*s?GCGTTWJć R@{z.yg?GCGTT{z.yg?'6?Uk?sO돰?1R4?{OJuP@$(~@mF@46I3X9?[#f?ل(,?JY G@?ܵ@y7?{Gz?CGTTC0B4KlH@9_?CGTTC9_?"<(FI>9Wl>ں "?G@58E@w }K?U?8 6[O@ݵ|@pU[@vq -?TTCCG~tM@U?TTCCGU?V3U[%?wB?rU?"N %?^.PS@$@ЄlcdR@z6>@3J\?~jt?CCGAGKt S@QEB?CCGAGQEB?wV.?0 7?1`/?w? >TR@Q@ȧ'?_vO?CCGAGU!2 S@BDV`?CCGAGBDV`?=?j?) M?f[>7{S@e!@Aѕ@<,Ԛ?CGAGT .S@]#J?CGAGT]#J?ւ?ts4-)?5?>{KQ@&u(@eiLH?:pΈҮ?GAGTG?j2έQ@4OT?GAGTG4OT?C,?fZLJ?8 &X;?WV[?[;CM@^F8@#**?ea?AGTGCz5M@# Yy?AGTGC# Yy?aFBg{>q h?wۂn?R-?RI1#2J@UN@S1:>?Q?GTGCC[-K@^ݫ~?GTGCC^ݫ~?r[z>>5jr2e?漕Yr`?df?E.€-K@{R@1yȹ?_vO?GTGCCӊ.K@pp?GTGCCpp?N؁>eIj3?[?qGn??Տ P@^FX@kr??W[?TGCCAFN,Q@Rs ?TGCCARs ?֓(?ӱ'T??Ӥ?#zd?to$RR@v_@`ey?"u?GCCAT^zR@"o?GCCGA?-?*oqǰ?vά2? ?1>,Q$S@ta@Ƴ?0*?CCATA8RR@IKX?CCATAIKX?+n?J?U,h?kQ>(|R@ $(~l@cciY?-C6?CCATA~3R@Xm ?CCATAXm ?6op8O,?? -xP@&†@W'\??ܵ|?CTCCTm-xP@P|?CTCCTP|?6|Pg?7 =?GSq?MTW?:mQ@^F@eUug?b2U0*?TCCTT`-Q@6/q_?TCCTG8{?doH?O8?!? ?|?'KP@h"lx@3?{Gz?CCTTG): P@y~?CCTGT!m?ZFڒ?TzzJnE?k'/?Z?WSIK@]m@nF?H}?TTGCC!K@d[0? $ї? ?v[?~:pfO@mV}@3{?{Gzt?TGCCC P@~I?TGCCC~I?O%(?C ?:?;*?,+~Q@j+@&H.??Ƭ?GCCCC33Q@όVz?GCCCCόVz?,Z?uk0?*?aw?PG|Q@JY@P\f$?Aǘ?CCCCGo7 R@U5B0"o?CCCCGU5B0"o?D@kT?sQ2i?u?黵͌?VK"bR@&1@F]4? o_Ή?CCCGC;7R@7!?CCCGC7!?%]?/g?_w^?3M?\R@A@2 ??CCCGC*E,1R@Xf?CCCGCXf?✯yF4?p?e?E Ѫ*q?v0 R@|a2@f(?Mb?CCGCTyQ@k?CCGCTk?U= ?ó?+?F-l?Y6rS@z6>@ͥCe@q?CGCTAeuVR@hq;?CGCTAhq;?3LA?Zj ?TEgcs?{]R&? `=R@c=@8 `?_vO?CGCTA%WR@Ia?CGCTAIa? ?T?L?>?vB&%Q@^K@]QX?&1?GCTAGyDQ@5dW?GCTAG5dW?ՃIR5?KD="›?3?5o7?6hR@wO@"*)? rh?CTAGCTR@v ?CTAGCv ?kJ6[?l`??`c?/nX6 x?^gP@:p@K4? -?TAGCC'']rP@G?TAGCCG?N#?~}?$ ?5^?Q@h@#?"u?AGCCA1TcQ@K?AGCCAK?]^?9*A&?ht?Փy?`gܫR@+@>·?J4?GCCAA0~6pR@G,V?GCCAAG,V?)?cL\l?=Əҷ?Jcs<:/?L R@tF@nk?&†?CCAAGק}R@ˋ?CCAAGˋ?Q?%Xk ?Cd?Ͽ2?*jQ@@SJv>?n?CAAGC0ȭQ@OPj?CAAGCOPj?= ?tc?"cY?}sz\m?O@(@ _I ?46!u'P@?AAGCC?5r?xo?:-_XZ?A?'vQ@5;.@DeBM?q?AGCCGZQ@֒ˌ^?AGCCG֒ˌ^? ")?+x c&?2wH?RK8]?@5^:, R@KY86@]c?:v?GCCGA 8tR@Rͷ.!?CCGCA#Z??>?voyL?^5+ !?mLS@u<@UMpn@F%u?CCGAG*u S@^y?CGCAG?h#:K-?p|R?r:Je?ꔢ ?<;>N8S@L7A@@ɹ[?ZӼ?CGAGTfFS@2 ?CGAGT2 ?E_@M?6 ?gd? n̂x>ϲhP@B@p@_L?GAGTCFN}Q@g?GAGTCg?%'`?sFR)>G?|Cjb?zәJ@ݓE@W׆?b=y?AGTCG%+J@`p?AGTCC0j^c?{@p>f᣽g?DOO3T?L&Z?M@X2Q@O~mb?_vO?GTCGC#bhN@>=@?GTCCAHp -?DzEz? D ?k#782Ϳ?7Y7? šQ@S!U@l i?Eioɤ?TCGCG;pLQ@i`%)O@ű.nc@ ,@46 WP@f/I?CAGATг U??3X?Us5Q0SO@n4@wg=?"u?GCTCCD7O@ʮ9?GATACCa[q?iLc?/ ?&8̃?Q!ڶ?'WP@-C@vґ?ZӼ?CTCCC5ZDP@k߲?TACCCR:C?e?Z?7H?Lte?++Q@x $@l Q?`Qڋ?TCCCA 6Q@B?ATAAGgs?࣪?'j?$?v}EY?×N#qR@=U@86 ?~:?CCCACHUTR@af?ACGAC*߹?Yfk-?H?gtO?_W ?X Q@Qڛ@ل|?8d`?CCACG.lxQ@jg?CCACGjg?Mw ?Bgӿ?TlW}?L0細?~f hQ@0L @a>?Aǘ?CACGT28R@)g?AAGGT\?xr:Z>?~#?5>b?I0%7"?E#R@)~@I1C+?y):?ACGTTd Q@]5?AGGTT/?b)?I>? hHj?{> TʥJ@H@U @?CGTTTcH@Aa?CGTTTAa?/=wI>⥌ui>㺾?Nb? H@N@@!>D ?Mb?GTTTCpX\iH@Yg1}?GTTTCYg1}?ep<7>>6TW8W>a~pg?o"I@_L@_bh?gs?TTTCA"cVI@`i?TTTCA`i?Ě$ 0=Na`->>dɈ.?qM@Y@<@H}}?TTCAAl/ӌO@"n?TTCAA"n?UǕ?Ku?k4>@D>[7b#Q@P@^?GCTGA^?QG?*f??75_?ƥ}N@V@[B?_vO?CTGACVzVN@}ܐ(?CTGAC}ܐ(?\&w?^v8??\b# ?6Ie?Wb"P@ˡE@]t-?Ǻ?TGACCB5P@4xհe?TGACC4xհe?-a2?^d?*\??ϐ?uG'P@ZӼ@@?Eioɤ?GACCCP/P@u?GACCCu?Ǿ{?d?A}49? g ?YΤ7kP@R!@W?gs?GACCC./P@c4njo?GACCCc4njo?kR2? 81?4u!?I_u?Vh>Q@jM@-Yj?a+e?ACCCCvVT Q@#?ACCCTL?9?k,?L??)92x?7܂Q@ǘ@o-?C>٬?CCCCT~R@dJu͵?ACCAT,3U?V/|p?\BD?į ph??廉x?rS@48%@û/?Ǻ?CCCTTvq*yR@ؐ5?CCATTҒ?-?J? %ӷ?7l>}uRe\N@(<@ w@ŏ1w-!o?CCTTT?}fRO@oaL?CATTT3?A>cGN>?*4?c n͕?rU#>T8v+4?+K@¨N@@ ԼD?HP?TTTAC/èK@|*ZZ?TTTAC|*ZZ?iuݧ> 9 ?\l?{?뭁zO@ű.nC@ IXK$h??TTACTzP@hɁ3?TTACThɁ3?6Jʑ(?) D?C3?{H? Q@+I@46?_Lu?TACTTy0.5Q@o}3?TACTTo}3? _A'?/S?g U?|ۿv&?ePP@^)K@^h.@{Gzt?ACTTC*%ޑN@/裝?ACTTC/裝? Ls?, \l?:S?|=h?g<(oI@ qL@xW?ׁsF?CTTCA>I@j?CTTCAj?fa> Y?7vW[?k-t?GᩃP@ Q@W*Vڧ?_vOv?TTCAGr~O@qڐ?TTCAGqڐ?$??Tg?c?M<+R@rR@)g_?)'Q@|a2U@˞@kt?CAGCTuP@ ^?CAGCT ^? ?Kg?Rט?+t?h(P@m4`@P:q@y):?GCTTCfg/O@a?GCTTCa?؍F)?{*A?U^=?7X!?$ X!I@7d@R5?b=y?CTTCCugH@ey{P?CTTCCey{P?Wjp=sB+?I3 =+-?7??V{RO@u$p@Lgf?DJ?TTCCTpPrN@_}˶?TTCGAw*UO?'G?q=4?N+T>?'@? uTR@}@W_v?:v?TCCTAρQ@T?TCGACi?ѭ?s->? R`$?g? Q@k @B(?Eioɤ?CCTACm4Q@j?CGACGD;?pS?,?6ޛU??rD| Q@c]@< Z?X9v?CTACG-$&ӃP@UB ?CTACGUB ?2#U?*r&a?ftX??ϯ?:GQQ@jM@rDM?NSt$?TACGC3B4Q@>nH?TACGC>nH?-r>G,?Wv?v?ps:?-FQ@iq@Qfw?-C6?ACGCGP+jrQ@PP?ACGCGPP?дe}?4E4?6u+Fc?޵oN? 1S@ ףCQ@lw@1~_k @b2U0*?GCGTTyj R@K]?GCGTTK]?zނ -?2j%)?h3?0%D>(dY2H@v@c@$ۧ?CGTTA^_I@na=?CGTTAna=?5F8/SR=} >O-nz=>G?Jo8J@u$@C#^?J4q?GTTAC%4D;K@hS?GTTAChS?Ib:q>gxa?Q|}?z۴?y$O@s@ͤ8k?MbX9?TTACCJO@r%t?TTACCr%t?'q w?^l?0l/N?r?g?RQ@|/L@$ﻗ?`Qڛ?TACCAd)Q@Z7|?TACCAZ7|? FlȔ?0@D\?ᴬpO?d?":3R@B@ugI|? -?ACCAG/~Q@>?ACCAG>? mL?m&? s[??l.Dm @?_z9S@Zd;@R@@J4?CCAGCf*R@dI?CCAGCdI?"(C?ne? ٔ?Ო?l iP@fa@8"D?NSt$?CAGCChj fP@/i@?CAGCC/i@?Vt{?y}B?Ra(>?U.޳?~3pQ@J +@.Vy/?y&1?AGCCA t@Q@?AGCCA??k?s\G?*PME?~ma?- qQ@o @"M-?z?AGCCAQ@(X?AGCCA(X?C?d˟?\ ?ឃ?:./R@:!@dI0?0*?GCCAG!T|jR@>s%?GCCAG>s%?}h? E=?$? ]S?,ɕ*S@RI&@e=x?UN@?CCAGGfOi&S@Tہ?CCAGGTہ?}?4"4?r)|?9a9$>һQ@ 0@%)x? 0*?CAGGG Q@"D!?CAGGG"D!?P~WYu?O57?r_0ι?(?%HQ@&3@EPs?3U0*?AGGGC3q Q@c;c?CAGGG5]}?Fz#zͧ?hL ?5(R?qQ?Q>ǗQ@V/;@1h) %@-C6?GGGCGh~P@H "?AGGGG3`y{?9lE?ni?1SO?W7r?ۈ΁R@:v>@n@ o_Ή?GGCGG0\S@^⻿?GGGGGjqI? u~?b_7o?&I?S*5,#$?lR@(A@$:@?߾?GCGGGr׺R@݄?GCGGG݄?o?[8O-C?%Fx?m:a?>P@X9H@|w8@a+e?CGGGC3D CP@lҕV*8?CGGGClҕV*8?)b'?>V? ?5Zm?vF{P@K@/?Q?GGGCTe)~P@W(?GGGCTW(?z .Z?ٲŘ?n r?zɀ?.U?c]#?5?$UMR@zV@-@/$?GGCTAx~~-S@] 2?TGCTAPu?VWB=?~3x?+*?i?;"P@:a@\7a@?ܵ|?GCTAGEEChDQ@]E?GCTAG]E?:?$ 7?K؈? ? WR@xi@+ &?"u?CTAGC_R@6`+X{?CTAGC6`+X{?=`6?d^pI?  ?%?P@{p@p\8?HPsׂ?TAGCCurP@rʡc8?TAGCCrʡc8??C?n?jV?U@k/?!Q@ s@}nd?/$?AGCCGLOQ@rh ?AGCCGrh ?(Dlě?:,X?悯?=!`(?mR@Bc}@t5+?l?GCCGC ejR@k {h?GCCGCk {h?;jZ5?>l؂?"͝r?*ȍU?`& R@58E@d|J=?Mb?GCCGC|RHfjR@)1[?GCCGC)1[?;GK?,Ø ?٧?J?']R@Q@iHޡ?Ǻ?GCCGCfjR@y4o?GCCGCy4o?AV-[?3?Q??%"Qm-?+XQ@L7A@]?I +?CCGCG96Q@mAk?CCGCGmAk?  $?55?n%?hQ-LO?X{xS@S@ 6@䃞ͪϥ?CGCGG][qS@f.?CGCGGf.?t?zQ?A??bN2>7iS@^)˰@ O@b2U0*?CGCGGHrZS@ ??CGCGG ??G??3#ͲV?nܮ}?ij5>T㥛ԐS@N@@ XMQ@ rh?GCGGTR@+(?GCGGT+(?[x?O+? 8?*>[`P@Pk@4@ 0*?CGGTGS3fP@ ?CGGTG ?D*Ӈ?GJ1u?"a63?ϦP@7@8H?_vOv?CATGGgJWP@H).{?CATGGH).{?܉a\ab?%~un?\ 6BD?~ ?nsIO@/$@Y?/n?ATGGA`2(O@A)[?AATGGk)?pVg?r?c^4?y.y?QIN@/L@?ZӼ?ATGGA;(O@o -Z?ATGGAo -Z? H]n1?SSW0g?c@^?(k΀?cQ@B@dV`@+eX?TGGAAt?*"Q@XGE[?TGGAAXGE[?53?@Ï*5?NJ{U@ -@S @ZӼ?GGAAC-@T@U6?GGAAGvSpSf?\$vAE"? YWzC?p?I!2=d- U@Af@9އuP@_vO@9f8?S!uq?AACAAm#P@&v?AAGGGȀ?[`Ī?^v?V+R6?'bb?/"R@a+@筤@Mb?ACAATĒ~jR@ ?ACAAT ?;sJo? ?9E!?ak?IQ@}8@z? ?CAATC=xڴBQ@(Z?CAATC(Z?34?vs?i?B_Q?$M@^)@?M.X@I +?AATCGeQ+L@Kt&|Q?AATCGKt&|Q?2Z+e?#'β ?NÏZ?Q?DQ@^)@|u??߾?ATCGAWM /P@~2 ?TCGCG\!'V?7J?m?/?agB?qlz?t6G\xR@@% ?F%u?TCGATWR@]c3?CGCGG~]^?";?v4?ZbH?CQgo"?2=R@V/@{M?Mb?TCGATGWR@ ΠJ?CCGGGE#g?3c??\и?@L"?IQ@46<@{d@HPsׂ?CGATC2KR@m~?CGATCm~?e%$z d?Bf8?;:M@?\*?g?t26'%NR@Tt$@ SE @ ^)ː?CGATC}R@^?CGATC^?">7?-;\-zq?醱?Ŀct?=K@@+@y):?GATCG M@?Z?GATCG?Z? q=n>B?%Q?T ~J;?ԵKP@=yX@.h@z6>W?ATCGCpaP@G(((?ATCGCG(((?] ?H7?vi?y5)?qxQ@u@<c?jM?TCGCTbFWfQ@Tg8 U?TCGCTTg8 U?ru'M?{u?r!?I_ w?hhvsiR@*:@1?J +?CGCTT &+R@6N?CGCTT6N?b?$W"?:p5?  ?]uP@V,@ k@F%u{?GCTTA.CP@|bX?CGGTT ?]GX?֐9-XH?<|W? a?]8^L@o_.@㪙m?"u?CTTAT4FaL@I?CTTATI?&5Xt>:f”b?fhF? ^??K@~:0@{?HPs?CTTAThBaL@,l?CTTAT,l?D#ߕ> hQ?{A?@13?67(L@;@VF?St$?CTTATȶ7aL@G?TTGCT镌6.?Ҷ?X^??S֣C?bP@m4@@?HP?TTATG퍉R݋P@lC?TTATGlC?Y)׀?<S?!ᝰ?~ ?t`O@ׁsF@KH;.@gs?TATGC&'O@kgV?TATGCkgV?@DWn?:_M?e?T6kA?`ТmyL@3U0*I@<8(?~jt?ATGCCnj!SL@X2?ATGCCX2?(P>1D??> e?'O@L?ʱQO@FT@Jb%t5? W^?]M1?h TP@Un@2b @_vO?TGCCTI Q@cƠ?TGCCTcƠ?^E 0??:~*ڬ5p?(k?HRGR@KY8v@]JJy?-C6j?GCCTT 9)R@N{B'?GCCTTN{B'?6pj?( ?̖j?b3 ?'8zP@p= w@?o]@a+ey?CCTTC9P ZO@5U?CCTTC5U?UYA? :?WLNc?,[?uPGP@-x@AK@J4?CCTTC4-PZO@gsӧ2?CCTTCgsӧ2?ݜHk?lr?&w?:4X?.xI@:@ |m?M O?CTTCA'qI@cw?CTTCG8d?,&)=E%?tʯ4O?LoVb?uBP@gfff@] @q?TTCACuQOGO@<%?TTCAC<%? S{ߜ?h;?8]e?TyxYib?uQ@Oe@scJ?(?TCACAz^ZQ@sQ?TCACAsQ?(L?D؟O?D EL5?@S?E.bwR@r @G n??߾?CACACKk#>R@*?CACAC*?ʷm7?k.?X? <(?8V<Q@[Ӽ@\ ? QI?ACACAMbdEQ@@#D%?ACACGFG!(?̏'? LӠt?E9P?H (?&j} R@46@$@M O?CACAC/$>R@nCb?CACACnCb?su⛷?Łm?1+>{?YN}$f3?n:Q@fa@a|? 0*?ACACAvFQ@Tw<J?ACACATw<J?1H?d8o?$&?CPY y?Hz`R@~8g@W? ^)˰?CACAG4/WR@>+I?CACAG>+I?G*KT?rW?.ˍ;? P+?!R@|a2@*;&@ψ ?ACAGCcc;R@m?O?CCAGCB.eQ?9+˽?76]ǧ?O?~'?WJ!jP@Q@b ?CAGCGH>?ی9+?Њjm?1[YhsQ?!rK?"vJS@ Z@@?q?AGCGTѸ߯R@?AGCGT?:!?LRxk?o.y?ސt?QH@JY@^ @Mb?CGTTT^(a]H@p&?CGTTTp&?[Y_W="x >hx>s]?T G@iq@'rF?/$?GTTTC8ȫH@͊?GTTTC͊?B,I=<$Ny >C>R{?_I@@aFr*?{Gz?TTTCGqLI@ĥMs?TTTCGĥMs?̕yR="ھI?{HF??4puO@D@slnR@vq -?TTCGC.oO@_C?TTCGC_C?ET? |?ֽ@QU9'?jt?:i~2Q@^K@i4n??TCGCT&fQ@ǶD ?TCGCTǶD ?6?1@ř?/44?ϋ{?ZdgR@@Tq?Mb?CGCTGX װR@2f?CGCTG2f?Iҝt?O%? ^/o?UG?(\-P@y&1@,d ?:v?GCTGGjsP@ ?GCTGG ? .? 3PsK?Aʱ?6nIX ?s?P@R@j|?a+e?CTGGA}njO@џ"?CTGGAџ"?G\Wv?z(i-?5Uf?pLw &?/$S@47@]|Y: @Mb?GGATTecS@N6?GGATTN6?o v|?Ki?lieԘ?p_>"z>Ս)N@HP@mI:3@UN@?GATTTM@u_/?GATTTu_/?` ?'&?Gg ?Baj?hݷnI@Q@g^vY?E3>[o?[B1K@x&@̈́[?Ӧ?l??WW?㥛n*I@jt@o ZO?/$?TTTTGdYlI@k?TTTTGk?o&D-=kL+>X #Vח>Lְ?333K@@f$k?-C6j?TTTGAK,K@0?TTTGA0?J2!և>U9?2}3?»?zbaM@ @jR?-C6?TTGACON@)O\(+?TTGAC)O\(+?a9?jfw{?u_?spǙҫ?aQ@sh@O*?+eX?TGACATQ@`UX?TGACA`UX?W.,?-s?+?y.2?2Q@@uPB?HzG?GACACZ_Q@n/>?GACACn/>?Bx?0WY ?Xo?e'm?"@Q@ hB@Gu{{?w-!l?ACACA[FTQ@?^j`3?}?8j8XW?]Y?l~R@XQ@N}w?cZB>?ACAAANJR@H"0a=?ACAAAH"0a=?QB2,?yg_?"j?<@y" ?TkQ@z6^@~B?S㥛?CAAAC~ VQ@)&?CAAAC)&?KZs?#eBNN?w5e?Ю?>MO@Oe@Nɿ?J +?AAACT[Q4P@$N*F?AAACT$N*F?eeYt$?EC?L̶?se?e_3P@r@;_B?N@aã?AACTGQLAP@fN(?AACTGfN(?R ? ?\i`?g) =? P@/n|@?rN?_L?AACTGBNMAP@i?AACTGi?mH?nWZka(?Mv<"P? ??R4SP@阮@Ao?Mb?ACTGT;A^P@Byw?ACTGTByw?Lf?6?xS?FĔD?3O@o@˻?^K=?CTGTT( N@S5?CTGTTS5?57?{8~?eo?JW?έI@7[@t ?2%䃞?TGTTCI@:frfk?TGTTC:frfk?>KV=7 >N)'?ī-?ڤH@#@qc@Mb?GTTCGUCH@pi\I#?GTTCGpi\I#?(i=XYܵ;?`b>@(N?兀יpN@ @]ڄz@0*?TTCGGV'^2O@(w|\ ?TTCGG(w|\ ??6J?p81O?OC +m?-O@@Z,h-E @q?TTCGG-Ω2O@ @?TTCGG @?zRqH?Du?TTm#?IBP@\C@`5 @H}m?CGGCTsBO@.$?CGGCT.$?,T?ua:G?#K?zTn|?R@V/@d-ʁv"??ܵ|?GGCTGi-R@l?GGCTGl?,.~?WAڀ}?LtB?UP?JݸfP@ű.n@S?Pkw?GCTGAл@ P@ gi9?GCTGA gi9?*EV?vu??[~ZӖ?*?%˟P@L@ۖi7?a+e?CTGAG,pO@[:}3?CTGAG[:}3?JRBg?9c Ɂ?v??$K?бjS@z6>@U/@_vO?TGAGC.2MQR@# ?TGAGC# ?݊B4?PԞ?EA?쎬>)FTP@v@Gɽ@_vOv?GAGCA\IP@?GAGCA? ?o:#fͤ?G?F! R?t,R@~j@2P?? ^)ː?AGCAT( R@AU\?AGCATAU\?E)_U?Be*?F9?_?ũ5?A,S@QI@m~?:pΈ?GCATTR@ܰQ?GCATTܰQ?qnc?Ԯ'?ߥi?u >5!(zL@ @6#hf@_vO?CATTGZVAN@=6?CATTG=6?X=b>Îam?w42??)?!o>K@U @2?ŏ1w-!?ATTGC K@ݘd?ATTGCݘd? ->؈$) >Fd?<2?#xL@ŏ@U??W[?TTGCG\ĝKL@ a?TTGCG a?r M>mG*?>?To?׿8R@0$!@э3@ QI?TGCGT\rR@5_?TGCGT5_?Dmj(2X?/3?BY?hA> ӛH@=yX(@o.@46]ԥ]>x}K?n1 I@(-@ Q@"u?CGTTC3yRmH@ .?CGTCG(?uވ=KEr;?$yfIH@ǘ6@IS@ 0*?GTTCAH@<2?CGTCG5? ܊N=Oܶ^k? >) 9?XO@9@[f~?:pΈ?TTCAG~O@s0d?GTCGAҾzW?kHɤ?R ?R6?5~@?@ "S@&SC@sp?r?TCAGCzqR@@" ?TCAGC@" ?XōS?x?A.8l?cm>0;AQ@_LL@JuC0@_vOv?CAGCT~!ӾP@ž|DG?GAGCA268?*)?? r?S- ?;RRet? l9R@ŏ1wM@n-?o_?AGCTG4R@ϳw?AGCTGϳw?QlA?#?N{?v_06?DwMpQ@uV@F=@L@`Qk?GCTGC/-P@nO?CAATCϹB? ?M?܄I?dZ _?mNܹL@DV@OQ6 ?/n?CTGCG/zICL@@?AATCGkD?xCZ?j??}?gffJQ@Zd[@?oٯ?Mbp?TGCGTGOR"R@A S?TCGCG ˎl?uH"?ܙW?$m?jvXt2?xXmS@~j\@z@"u?GCGTG@'Q@=)%?CGCGTI?%;6?%9^%?]y?5Ó>}I@Y`@q%b)@J4?CGTGC*yjJ@VW?CGTGCVW? ?;AV?gͳML@Dv@:U?`Qڋ?GTGCT>[L@?GTGCT?s >fbË?~J2=? Ų?-Œ7ZS@}?5^z@,# @J4?TGCTT<".'R@ ¬?TGCTT ¬?[‰M?9溯?ClJ?Iq|> %O@ܵ|@yAx@Af?GCTTG"z P@ *?GCTTG *?i0 ;?,$S?Jgdiu?h}?n$L@}8@p?n?CTTGGg1K@_#?CTTGG_#?|Q >VbP1p?Uc a?<?]fM@YѠ@(@M?=,Ԛ?GTCCArdTM@ (?GTCCA (?Bi'?m [w?yHg?pL?YվTQ@M @qV? ^)ː?TCCAG7ynQ@u?TCCAGu??-?9"?*x?x?fKxS@N@@f>Ly?ߝtQ@@t+:?0*?CAGGThT-R@l;+?CAGGTl;+?Uy?Ts??8r?D7t$P@I.!@} #Htu@ψ ?AGGTG`Q@rm?AGGTGrm?ַ?nPw?TY?6FgL?a^N@@٦?{Pk?GGTGGf)M@F9@ ?GGTGGF9@ ?}t?yvN?0_%z?!?%IkO@B@:NA@~jt?GTGGAY?N@_g(g?GTGGA_g(g? ء?w6 f?5$ዬ?'r?GN[N@}a2U@ ju~? 0*?GTGGA4?N@JzN?GTGGAJzN?T?b7EK?H-3uL@Z@53@ǗQ@ZP@48@w@^@Q?AAGTGQ^P@C۸?AAGTGC۸?ߋ? ^l?̐?f?%L@Hr @Q1?~jt?GTGCCoMK@B~P?ATGCC5) ?6t2?s?yR?QO?k{*R@W@[=b@ŏ1w-!o?TGCCGC…Q@Vg?TGCCGVg?V=?u \I? g\?F=)P?7 MPP@Aa@/DM@J4?TGCCG1Q@C??TGCCGC??f1 ?LR?}-y?RXrC?@CR@Mb@숇2?S㥛?GCCGGim$#PR@#:ϧ?GCCGG#:ϧ?KH_K[n?*?-3??I?Mxn S@"@ s$2;??W[?CCGGThfI~R@g?CCGGTg?\wL? 6S?}?h>ֹopO@( &@}W}u@_vO?CGGTC}5 P@mԉ?CGGTCmԉ?F>jr][$?G?5U$ ?X%IkH@x)@:T,@H}}?GGTCA|ǞK@v|Li?GGTCAv|Li?D]Ef=X# ?p$Y>dRw?VgRM@|P+@BP@Q?GTCAG`zM}N@.X_4?GTCAG.X_4??|h]M?wI1?18j?R@؁sF4@M?]K=?TCAGCGZqR@c; ?TCAGCc; ?OR?I2I?wy?=0t>@P@s;@gC`?&1?CAGCA2SiP@PH㔱?CAGCTPWe]?yUl ?.t?S%?wb?ˡE6R@|a2U@1@.?Mb?AGCAT+'R@s* ?GACAT݅D!?.'?`?GgU? ?!_ir? ӇR@z6>W@C@:pΈ?GCATC"lR@T?ACATC*\?y[?ύ6?R?Y=Y?*;lN@yi@leJ?H}}?CATCAs֑N@\-b?CATCA\-b?$!d?oLe?\?qL^7?}uxP@=Uk@BzdkoR@?@$?q?CCGATWTS@Y;?CCGATY;?VŅ?Vm?[aюz?/' >3R@w@&?Aǘ?CGATA*>WgR@p>?CCATAQ,E:?d?P++~???=?u,P@h@$&x?kt?GATAAyUO@T?CATAA+a]?U9d?+16?0aT?4<9?~1ܦQ@o@x\[Ȟ?gj+?ATAAG $EQ@~%X?ATAAG~%X?3m? u? U 6#?7t?3 R@I @!(~[?gj+?TAAGGVpEZR@,lTv?TAAGG,lTv?Nez?!Rʚ?Sea3D?Mqvq?”2Q@u$@;!HX?&S?AAGGAeNn>Q@i_X?AGGAT>X?o?gLuT?v ?sQP?*PJVT@Q@w7@y&1|?GGATGLvS@7 ,?GGAACl(?,xQZ?Kx^?Ϥ*?zi>؆lWP@n@a/?St$?GATGCEO@O?GAACT+?^X?J^?D?!s?-OFRO@7@nre@? F%u?GATGCO@kɂ \?TATGC"e?!A?=1! ?VⳆ?g?zGyM@C @: m?ZӼ?ATGCT ML@SlM?CTGCT{?h1A?˅]C?1@u?0?|9Q@ݵ|@J} @+eX?TGCTCZ,~Q@2=k?TGCTC2=k?tΰ?Q;S"q?F<:r?7s8?3:O@ g@ݳQ"?vq -?GCTCTbӘO@Mh?GCTCTMh?E=O?[F΍?_Bs}?3ռ?l? Q@~@z~?C>٬?CTCTTP@Cp==?CTCTTCp==?$4N?SfU?Qאkh?>-p?EiTN@l)@FP?ZӼ?TCTTTOلO@ /v??TCTTT /v??,.>װ%@g$s?Pkw?CTTTA٭)I@$?CTTTA$?cFgE=1D>f}>v{N?tsK@7>W[@JC)[?mxz,C?TTTACdȩK@=s?TTTAC=s?{>^sX?]b?TTACC0Q>]b?|_r?4Uj?+奘v^?;8ѕn?H΅P@Oe@h=?kt?TACCCޮYP@oT?TACCCoT?yyO?^1'?ژ\Wa?&0?qQ@ǘ{@<~I ?ψ ?ACCCGș4Q@}?ACCCC˾?$ؾ,?"~?hP49p?M \?cfR@7[@W\dj?Ǻ?CCCGG,UR@/Զ)?CCCCGɱ8?vUwX?T|Q7?Oh.?DO0?cqɺR@9@Ѽ # ?j+?CCGGC•ҶR@d`/?CCCGC،?ϷL?k?C=ؙ?B->Q63O@YѠ@ @_Lu?CGGCG; xO@9Jd?CGGCCV5?6g?` a?;?N8?.oQ@J&@ %?J4?GCGCGİQ@Aqtн ?CCGCG"bU?z(??U`H?Q`S@ׁs@Z(?Ǻ?CGCGC TU"S@}k?CGCGC}k?.h?RN?tjlR? }:>%S@K{/@ВfKh?tF_?CGCGCίU"S@ww/W?CGCAClGɬI?D:-?1*W?Ei ?uZ qQ@8EG@Z'@ ?GCGCG^Q@n2Og?GCGCGn2Og?ꚨ0wI?R`5y?tM ?iX q?R@KY8@DBT@UN@?CGCGCh^8V"S@Y`1x5?GGACG5Jp?/r?Ο'?}^H?g]i(?/9"]Q@-@?5@?y):?GCGCG0RQ@^w?GCGCG^w?fB?Yj;$??ovǭb?={KS@@0_ZQ?ׁsF?CGCGTQ.t)g?O@A@)/SF@~jt?GCGTC0.Q@gn?CGGTCE.?|\R?FE?oAF9?ݶ?`o:>Q@.!@Kd@<,Ԛ?GCGTCQ@xF?GCGTCxF?5i*P>T*>ɩEp Q?#>4շH@9m@+ݟI @gs?CGTCTOfpߑH@$QeX?CGTCT$QeX?Axe =-gT |8?`QjP>_ՔB?p= 'aN@St$@BP6@-C6z?GTCTT'+q"?<^EF?c/H?p2"N@Y@R&7@~jt?GTCTT՘M@8z?GTCTT8z?hǝ?k?+/Lj?X+?BNO@Bc@3;?_vO?TCTTG5O@ GГ ?TCTTG GГ ?6n??ڧ\?{3-m?@l* K@-@ W~?J4?CTTGTHnK@N(F~i?CTTGTN(F~i? %H>Q9 ?#$?O?t KN@/@ a?y):?TTGTTmN@^rK?TTGTT^rK?ؑhQ?Jp>\:Qu?8=?ԑWJ@]C@zf??TGTTC/D$yI@ç\?TGTTCç\?/9w=%g^M?>>f?,1i?7щ!GH@{@+\{?46ֽr?|?#M@ +@SiVN@Mbp?TTCGA?:x,tO@og?TTCGAog?/_??"q~W?40J?<)^?%R@؂-؃ R@HP3@ n?S㥛?CCAACFSR@)9?CCAAC)9?5k?6?E?R?HUP@F%u:@[c`?@Ǩ?AACGA~]P@u(27?AACGAu(27?ϯq?sLڲ ?!&?!i?c_R@gfffF@S*?~:?ACGAA}J+R@Խ?ACGAAԽ?3:?}@7?Q=??1?S@aV@K?a+e?CGAACsXS@aH?0?CGAACaH?0?P'?ZN䊾?Q&qR?>3>-߲-AP@p_Y@I\@q?GAACA=Q@Fn?GAACAFn?q; {?sЀ?Դ욳?, $?.'XʨP@a@s?HPsע?AACAAa[P@0?AACAA0?Ùf?]?!I?nXб?MbQ@z6k@w:I?~jtx?ACAACt:qХR@Zj?ACAACZj?Ҽ>X?-V[?xUi5?m!=_?O@X[l@yiF?gj+?CAACAveP@#QPo?CAACC*Y?nG? ?}і)?#?Ik"Q@Ǻx@`r>?d`T?AACAG@~?P@&H?ACCAGH??4?"ĩ5?+X[r`?uPS@0'@W܆_m?HPsr?ACAGT 2z5VR@t ?CCAGTL??'_?n?[ MV?a'>ٓYQ@<@~V`9@<,Ԛ?CAGTT>YQ@u~?CAGTTu~?+V?<D??gy?)YBJ@FGr@Ե 1@}?T"? J@8EG@1?&S?GTTAGeE}BBjK@rlV?GTTAGrlV?:O>/P?ȇ1?09??!Q@ǘ@p|~@mxz,C?TTAGAEc Q@y}G?TTAGAy}G?<#&7'?of??NM\x`?OkOQ@2w-!@ rŬC?j+ݣ?AGACGQ@!)?AGACG!)?{xU?$WY[?z?/򞹟?y#$PQ@Hr@U??߾?GACGT_}OQ@ 81?GACGT 81?2oӹ?;.?i ?&;2?T/5R@X@DrjҒ@46 JzvI@Pj@LT@_L?CGTTCqamH@ݴk1?CGTTCݴk1?V/[z=>A@t?ks4o?lG@6<@˓@?GTTCG%+MH@eeA,O?GTTCGeeA,O?g7ّ0=_!>'@:>vr?мO@s@?'֮@X9v?TTCGG]ίX3O@#*l?TTCGG#*l?G{t?N?au׺;?%Xs2?ΛeR@@k?C>٬?TCGGAV(R@/b?TCGGA/b?11O+P?3uJr?*!?4>c.EQ@ h"@18=|*??W[?CGGATncQ@0MY?CGGAT0MY?<ŷ?JeoZ?Ɔ]s?p?3ԠQ@ǘ@4*V|&?vq -?CGGAT}j1cQ@eo?CGGATeo?3w:?du((?1!AJp?(|Kc?ї eS@?@}EZ@Mb?GGATG< ˡS@?GGATG?]&?AWM?3t? Dن2?~KUM@ q @(,@`Q{?GATGCkMeU O@:E(.?GATGC:E(.?ɜ2?D&?_a_(?2O;?,žS@Pj @f@@@b2U0*?TGCGG_3$R@pV?GGCGGC-?D%ˡ?=:QF?8m?T>uBԺZqR@z6>@ ټ@oŏ1?GCGGT%C5R@9?GCGGT9?:+G̛??s ,9?{2)?mxid?g5Q@:p.@Ci @St$?CGGTG&SgP@'l yq?CGGTG'l yq?W3c4?ih:u7?Pºt?k?BP@ 2@V-<8@ rh?GGTGCSLN@G mYw?GGTGCG mYw?GHC\?UHg?ư?/?a$&.K@Zd;@jX ?faִ?GTGCTy[L@o ?GTGCTo ?`&>RZĒ?JA?r(*?z'.Q@~:P@[p_@mxz,C?TGCTTѼf,yR@jB e?TGCTTjB e??"YE?3 [V? rj깪?|M@AaS@ߜ|U?H}?GCTTAiP@NP?GCTTANP?x6[6?_Wvv?9(?s~J?!aNL@QsW@bs?0*?CTTAG:AfL@\]?TGTAG6 o ?:5?^d2?)(?5&~m?^>iP@#\@^4Q@F%u@_'A?/nr?GCTTTHnV4BO@D6-?GCGTT%? ׃V?Dz!ϙ?p<ϭ?X?Gz:H@a"@xv?S㥛?CTTTC<#DI@ԕ?GTTTCb!?~2=ч^%> > *f?I@_I @'Hj?n?TTTCAK9HxXI@_}?TTTCA_}?q-mE>žS?OUGj?[R?cP@q@ܨS0 ?'†Wʲ?TTCATt$O@#?TTCAT#?q?hf'a?g3?c5c?mh.R@fX@9,?ψ ?TCATAvc:R@X"d?TCATAX"d??t#[`?a? uR_?6AH\?V:aP@Q@l ?UN@?CATAAR?P@iV`P?CATAAiV`P?4㿅?-?nTZ?Wn?p38@oR@D@"e4e?{Pk?ATAAT@n,cQ@wOy?CTAGTFxG ?fBs?‰N?D "']j?hYZ?`/DQ@R!@s v?Ǻ?TAATCXUqǪQ@(p?CAATCBo?È?v?Lp?ӥ?Q L@u$@77k?S㥛?AATCAo@fL@g@:?AATCAg@:?,߆>mg*f?:?Wv?&1p P@s@nkF?Mbp?ATCAGLĦm2P@|?8?ATCGGx/4}?)$P??Eg?|#?cGR@4@J %I?eX?TCAGCԤqR@n ӷ?TAAGCUi^?ٴ?tix?$?D:5?j^X!P@@|?4@_vOv?CAGCGΰP@E2Ѓ?AAGCG9'??F?w1?fCVl?^ ïLR@yz,@^?&S?AGCGT2R@SS?AGCGTSS?}? _b4?ǐ?.g]I?'TP@Bf@@?GCGTC EQ@Z.h?CGGGT۳B?#y`?1Jy?<?NΘ?O R@8@dP7@C?GCGTCf EQ@iJ鵺?GGGTCR?EH?d<ج ?'q?KOϐ?8wK@&†@pCZ@?W[?GTCGGLýF[N@Zfߒɡ?CGTGGxNN?c#H>#y(?K|?W*%?!fYQ@A@9rZZ?_)Ǻ?TCGGT2sDR@+bڬ?TCGGT+bڬ?Ykf?NZ?5O?$h?öO@#'@Jq, @vq -?CGGTC 1 P@[-+?CGGTC[-+?fA`~?(y?)ꩮ?(i?w K@&1,@Ĝ%?)\(?GGTCCVP&SJ@[rl?GGTCC[rl?`Œ>D??;4^ɰ?.p4?}+H@2:@ ̹@`Qڋ?GTCCCeQM@rz?GGTCC $?>[=WD5?c.g\v?TB|?6_%KQ@k+=@Q{X?<,?TCCCTu\A<4Q@hӀ?TCCCThӀ?(L9?3b7?Zrإ?p!b[?)zR@zG@6.L?ZӼ?CCCTAq;BR@Xcُ?CCCTAXcُ?x_ng?<}?̞(p^?#V[<$?a[Q@MJJ@j9Ӻ?ͪզ?CCTACt4Q@ m?CCTAC m?HV?.Ռ?miz?-o?duQ@sU@C'5Mj?ݓZ?CTACG3-?P@i?CTACAI\1?O^÷?-S?*9O?% ܘ?&_X2R@~b_@wԡ:?tF_?ACGGABm"IR@˩y?AGCTG I]?j0"? *\V?`c}6?;M?K*[T@w@9-! @HPsׂ?GGATGY64S@\s9?GGATG\s9?w?rp?B?"+j>pH O@2z@jD]?C>٬?ATGGA=nh)O@ 2?CTGGA^#?EFM?j]?W ^f?8(?ׁNiQ@&u@ߢ@gs?TGGACq} 6Q@/t9_?TGGAC/t9_?!ݯ?P 5?:3?fQ?_Q@o_@h@&S?TGGAC! 6Q@qR?TGGACqR?L0?3!?i?x?]'$P@fX@s ?"S6?O:t}?]? ?L[4I@q@s6?jM?CTTCAPI@ٌ'?CTTCAٌ'? ,=?a> ?LP\?{H *O@V@u8h m?_vO~?TTCAAAQ6O@ؗ?TTCAAؗ?W`Ix?301?k-ecV?6Of ?df!R@~:@E7?V-?TCAAGP^Y$R@ K?TCAAG K?s?? 4K?A$0m? tR@@BhE,d?HP?CAAGG͆n(R@y5?TCAGGsָ?Bn?L~F?y7y3? 26Y?~3c>R@3@6F?ZӼ?AAGGT Pf^Q@ԂeJ?CAGGT߾?rsx?w"?+ޞ? fUi?mkR@x@& @I +?AGGTT6єQ@J& p?AGGTTJ& p? E{?Xtڰ?" ?K?75L@6^I@HZ@0*?GGTTT)-aLL@RY?GGTTTRY?IjIa>/J(|2?Óg?[?{y H@ŏ@BbΗ?/n?GTTTTB޶%hI@ߴR?ATTTTd l?ƃm=>؝o?U>|׬k?7]I@|@C3z?*Dذ?TTTTGRSI@ǷF?TTTTGǷF?w!=Z-BL#I?d)M@T@H&?UN@?TTGTC39M@MOE8?TTGTT>(?qLw$?\#?x4.?]L?_VK@_)@'V;a?G(̮? x?[QJ@)~@ߝ?&S?TGTCGθI@*T!?TGTCG*T!?ؠt}>7z?z4(? #"?&^N@Mb@ncC9@?W[?GTCGGsݡm[N@~(?GTCGG~(?Xl%DE?7+*p|5?mNY?8?ljcKR@I}@/8iS?(?TCGGCLW R@pZv?TCGGCpZv?"'?oA?~%?fȞC?i E/O@n@0ι@"u?CGGCA,գO@r}n?CGGCAr}n?G6:6%?@& Q&Y?*3L?g8#?]S@MJ @^$@HPsׂ?GGCAAS@}*?GGCAA}*?Tj|c?=:3&?;2j?Ķk>Gq3S@mxz @I?W}b?GCAAAlvR@}1!6?GCAAA}1!6?X?>f?G7.g6?L(z4?mV{`+?kSo?%af?mΜԻ?&B%?>ym'R@+.@#՘?䃞ͪϥ?CAGGC#Q@xZ?ACGGC2-[?9n??tO,A?-=?sQ?K:>3P@9@VR?_L?AGGCGގKP@4P?AAGCG"`?^E? ոu?6?4a<|?5ST@?@s?/n?GGCGTɗ[S@,8FH?GGCGT,8FH?{&er? Y?-:v]? \.c>略Q@TA@J^JK@n?GCGTC4aQ@+?GCGTC+?L?1bvQ@SE@Aw @<,Ԛ?GCGTCMbQ@?GCGTC?|J>Pw)?._?qKC ?U]G@ڬ\M@?@_Lu?CGTCC>APH@ ?CGTCC ?5Oq?S- M@2ıN@v ?4?I +?GTCCCŋM@WE_?/%"?aF~o2?QzQ@ Q@`!? rh?TCCCGV%Q@??TCCCG??^=wF?o:~d?F?V% ˶\?KyS@?U@`f?48EG?CCCGA]×R@:P?CCCGA:P?$'ܛ??9D{?=?5CŰ>Mbr=S@x $h@y(?Mb?CCGAT) sS@}N;?CCGAT}N;?c)z?ZIrӽ?w:]?{Bg> &kR@b2U0j@2S@HP?CGATC_jR@H3?CGATCH3?a-?bZEy۔?IK?Y_e>YBxM@e;Om@8@+eX?GATCCpY|sL@H?GATCCH?v?Xn?˄?CCN^l?*H?]\O@&s@<?46 ?@*:?؅R@V@As?5;N?CCCTTG WR@(.?CCCTT(.?VMW%ի?»?k?Xh>DyO@{@Dn@ݓZ?CCTTCO@77N0?CCTTC77N0?^J?yAA@?J:{%Z? ?> ףAI@}?5^@J@+eX?CTTCCtQ!I@r>e}?CTTCCr>e}?$Ӯ">_/ =?T Ly)?l ?nEO@QI@Zk ? ^)ˀ?TTCCGWdM@?TTCCG? ?އ?cYAZ?=g9?ZhcR@~b@>Twe?I +?TCCGGO`Q@\?TCCGG\?hXh?*w«?ي?dM?8R@3@M?St$?CCGGC [-R@Z:kS%?CCGGCZ:kS%?e?9@]Ѱ?(A?b>SH1O@ׁs@SW^@$ۧ?CGGCTNO@ǂ@?CGGCTǂ@?ԚA|D?MQ%V_? $jP/?Rqh?ƎH7S@a"@ō@y&1?TGCTGG/:R@(y5?TGCTG(y5?E?М??Jw?.yP@Q@z!m@q?GCTGA*ڵP@C?GCTGAC?J@b?~ 5?1Wg?|d?|?O@W}@!Oۓ @Mb?GCTGAvx/P@4b?GCTGA4b?\^Im3?d$^6?1)?c6':4?x $P@7@fD.@{Gz?GCTGA9A[P@?GCTGA?yi63?V94?]?r%1?U(VO@h@?,C?CTGAT!۟9O@em o ?CTGATem o ?W~F[q?.QV?Th?gc?gfff&IR@S@'P4@_Lu?TGATA;E'R@"ǿ!t?TGATA"ǿ!t?1?:L?a? CT?[NpO@}8@)䱣o??ܵ|?GATAA;WO@˼?GATAGZp?xx8ɳ?4 Rȿ??٦_? oP@_v@x-_?Zd;O?ATAAApHQ@!zڭ?ATAAA!zڭ?8oSM?_?5C??23Q@}гY@B@{?M O?TAAAC-Q@)\uE?TAAAC)\uE?"G?g?G?`=i?ŕ{hEP@ޓ@9! ? Zd;?AAACGrP@,dJݿ?CCTCGuR?t?"(hu?ߝ?UJ?}㔘IQ@9#*@N@䃞ͪϵ?AACGG0(P@whd ?ACCGG 7`5?g)D?H򴀷?z!mE ?v6oE?]}#S@?@AO?Y5;N?ACGGT2ZR@ ?CCGGT_PG?V)g@?ډ?iDZ?Q]YO> Cm2P@&uH@q9L7@UN@?CGGTT4tP@\Y?CGGTT\Y?w>">5_[1t>lE?`"|?-^H@I K@QlS}a?gs?GGTTG XL@Y?GGTTGY?=+=K,?/-e>I?vK@ǺM@>8h?ZӼ?GTTGALeK@b3uG?TTTGAHo?swt>V)?;T?&Z?Wg>P@}a2UP@LDk?S㥛?TTGAGX*0N@ S?TTGAG S?Nȡ[?]?tW@tp\@gs?TGAGAYtgoS@Ų>?TGAGAŲ>?)-(?7a*i>R@Q^@}j@ 0*?AGATCU`R@AW?GCGTA08H?CEUt?K?*a?l"2P?ͫsK@a@ץS@_vOv?GATCGXU3ZM@N+RM)?CGTACz(C?LׄW?N? +3?İƙ?'YP@ c@>.?j+?ATCGCO\P@%m?TACCC/,=~"S@N@@!|q)?{Pk?CGCTGoR@6T0-?CGCTG6T0-?J?Q"?!!w*?l`A?B`]P@"ۙ@X@{Gzt?GCTGC㝁P@~ ?GCTGC~ ?c2?g?2g>+\?w?Ls"L@a"@1N?=yX?CTGCTw΢L@?CTGCT?8Pl>}TOn?wN?v5?y/S@^)˰@Ju|@I +?TGCTG:yLR@+ڄD?TGCTG+ڄD?P??LYYv?>YVR8?mO@"l@c? ^)ˠ?GCTGA>xP@f=?GCTGAf=? R?s62x?FX?KW?5O@qΈҾ@sU ?HP?CTGAT9O@~ g9?CTGAT~ g9?O?I ??A[͆?OTS@v@oý@?TGATTifxR@שb?TGATTשb?ظ?[Ru?^]>?\ˣ>IU/O@Ci@H*5,@ QI?GATTG~hͨM@un~N?GATTGun~N?2ځ? x%?k N?E6I ?Y5K@ 0@"}?6?ATTGCaTK@AB?ATTGCAB?Aj'>j >e=?H(?Ƒl,L@_)@Oflni??ܵ|?TTGCCRK@jp&C?TTGCCjp&C?hD[>v ?5%|5?~1bL?} KQ@M O@{M)?_vO?TGCCG4Q@?TGCCG?Y?)U?PC?Wa-j?sfaUR@s@S;e?HP?GCCGAuR@:nB?GCCGA:nB?NȻ|?l` Y?ggϚ?:O(?klZ S@|a2@Ԣ?J/8? F%u?CCGAA%eS@9?CCGAA9?8Ƈ?~?},[?э̲>#S@n@C2DVH?8m4?CGAAGKAS@/?CGAAG/? A],?{]d?/ű i? _>5^T@ܵ<@C=(`@ZӼ?CGAAGEJTS@J?CGAAGJ?-W?h@9b?́**?`5 >^An.R@aTR'@@[1?<,Ԛ?GAAGT#ɳ 7S@u6?GAAGTu6?i ?k!˩?̻?sh>t;"EUP@%C@>H-@y&1?AAGTCP@2?AAGTC2?ꍚ4? +sI\?(U0??i!o-J@ yG@ + =?ŏ1w-!o?AGTCG ᆮJ@m]?AGTCAӎ%?&4O>ԌxA?y4?%,?\^N@ rH@k ??GTCGGP[N@-6`"?GTCAG?"?;P?5? x:"x?nR@NST@ڙM?"u?TCGGAb_c(R@j?TCGGAj?КЩ?tMI ?|?`z ?q?-T*R@ +V@8gU?镲?CGGAA\.vQ@?CAGAAoG\?p̾?oC.M?(6?^H0?(}ҧ(U@i@pA7@H}m?GGAATDL}(@U@w#U?GGAATw#U?"z?%IҲv?V oJ? k8 =IτR@ j@1*֯@F%u?GAATAw%R@r'?GAATAr'?"/Mx?D?A}H?B.>R_N@Pjm@6oyI?^K=?AATATPO@m1gЩ?AATATm1gЩ?|Ĉ?R?Dw~??]NP@47x@k!S?~jt?ATATCgGGkP@Ng?ATATCNg?y߳(?[I?N/7@?ͧ?YEdIN@t@}Ma?M O?TATCGճD#dUN@&?TATCG&?opE?o?cҡȭ?$gϮ?hSQ@6^I@p44u9?mxz,C?TCGTG~ WQ@p6#?TCGTGp6#?=pBw?p?Sh#?*V?axhyJ@ҏ@g@ ^)˰?CGTGC_*lJ@1?CGTGC1?#s>z6?:GZW?Un,8?>iĉJ@QI@!V?St$?GTGCCN6K@Nl?GTGCCNl? Wo8P>q$?_#?? =/P@@d)HI?0*?TGCCG^'Q@?TGCCG?t5Q? *y?ˬW w?7J>幼b?Ϙ&M@G@PŨJO@_L?GTCCT`і0M@!|f?GTCCT!|f??e5m>yq?GhAJ? `Ϗ?_^L@(@R P!@_Lu?GTCCT5C0M@Jt3?GTCCTJt3?O㻝 >0?Jx[?BIo?He \L@&S@1@I +?GTCCThZ |0M@c21?GTCCTc21?o` ?Қ0d?|?0?* }gQ@Z8@E7?ŏ1w-!?TCCTG5Q@V=(?TCCTT:M?h!?TI?^?^?qCQ@@5^@_uCX?X9v?TCCTGTBegQ@|Ӆ?TCCTTDS{?|0?.'*?)Rƛ?J:?o8O@m@z?Ǻv?CCTGCyitP@^1D?AATGCof?S?J{_֔i?ڈ?=7g?auK@HP@G]r? ?CTGCGBL@RΐY?ATGCC %??\=, ?oɨ+?ѓa@a? I^xFR@~@:w&{@gs?TGCGTHؒR@zah?TGCCGURg?nY#??yJ?H6?NۿP@V-@0@HP?GCGTTG67!R@0U?GCGTCo՚T?Y龗 ?h#C?WB1K?5P'++?^mR@Y@λ?V_?GCGTTy!R@\1j?GCCGT?gI?jF?Rf?WnlԼo:?kYG@ŏ1@:M> @H}?CGTTC$nH@M;#?CGTTCM;#?bJh<=_Z>F*> <;?\=H@G@yc@ ?GTTCG~[)H@25e̅?GTTCC ^0?=J=ǤP?tؿ+>(?ဇN@qΈ@Ѝ1!@?TTCGA^d.uO@{)f~?TTCCT3i? `܎U?w:l0?9"(̈́?,{gV?mvQ@g @˦@HPsׂ?TCGACJ7R@7k?TCCTGG.T? a\?% ?zL?k Nl?"ªQ@V @?%?UN@?CGACT^ Q@WBZ?CGACTWBZ?凪 ?S !w?єz??P@Ci@`0);?V-?GACTG ekSP@kn|?GACTGkn|?ۮ|?/L\?l)?2G ?C>P@n4 @1f?^K=?ACTGA`UhP@ 襽2?ACTGA 襽2?6; }?SOh?YWs?]tbO?(\/O@R+@‘s?-C6?CTGATAy9O@ݬ:?CTGATݬ:?3=F0n?+$?^Q?iB±?#Q@.@t d]f@n?TGATCuPR@ZGo ?TGATCZGo ?=e? <?Vah?Ӛg]>? EM@6;N1@MO @<,Ԛ?GATCAzD*M@$?GATCA$?4+&?Ro|?V? > *? P@A8@߃i@X9v?ATCAGD@2P@T2y?ATCAGT2y?֣?] ?jm?TN?1eO@n4@@@DL?Mb?ATCAGBX2P@'P?ATCAG'P?n{hD|?~V?ݲ,b?Zw ?P@H@'t?0*?ATCAGt2P@ ?ATCAG ?C;گ?{?k1-?hj[?\r.P@3ı.N@M`@( 0?ATCAG] 2P@/=?ATCAG/=?"@p~?*]?G  ?A/6}?iR@*Z@>*#/?<,Ԛ?TCAGCaS=rR@;rnߝ*?TCAGC;rnߝ*?&?"? v ??\l?'LQ@R|a@M ?S!uq?CAGCA`8pP@A9?CAGCAA9?zaYCW$?y?f Gd>?|+!?đR@Jd@$pGZ?`Qڋ?AGCAC+rAR@[-ک?AGCAC[-ک?`?c-?2M>r?)M/?@R@Oeh@ @-C6z?GCACAt9Q@%?GCACA%?u3`78?SS?uX8?[**}:t?AR@ j@s-?gs?CACAGQxXR@q ?CACAGq ?=̟A?Q2R?>ת?^m9?1u}R@X[l@~[oX?H}?ACAGC—LWfR@#I%?ACAGC#I%?j~}?#{=?֢89??&>VP@x-!t@V"x@ ^)ː?CAGCGp]P@P?CAGCGP?BI?|j#8?Qe/?r4 Ɵ?7,{R@Qx@zz @F%u?GCGTTc0 !R@`_Y?GCGTT`_Y?) '?6@?F?kS~0?*ŴH@n{@X 5@lV}?CGTTG>`a5I@/%C?CGTTG/%C?A=$=g>ɭ>ZG? I@|a@t'$? ?GTTGGp J@:<*u-?GTTGG:<*u-?:{=42?Iy>N#?{eO@\C@H#=?-C6z?TTGGTaN@/Sؓ?TTGGT/Sؓ?sj?6?}No)?ȥ>E?eNaQ@Dl@VR\M@p= ף?TGGTTIC+Q@D?TGGTTD?P?36ٟ?0?{bo2I?<>K@C@B?"u?GGTTGl &yL@YW,Sf?GGTTGYW,Sf?3*+fg> ]9^?ؖQ?_X@?5mM@{@G>?_vO?GGTTG=PyL@z:O?GGTTGz:O?D;4?H^?+?YC??%m,K@ˡE@y?mxz,C?GTTGA8hK@i1K=?GTTGAi1K=?6h> 3?s ? `?unN@z6>@Wa0?Y5;N?TTGAT8zN@\uix?TTGAT\uix? ?f4YG?HMQ?=?UM@@w@ ^)ˀ?GATCC#mN@H.@U ?5;Nё?ATCCCgAN@bC*?ATCCCbC*?A.0?oq ?Dgx;?7hҰ?KhQ@ׁs@n4?5;Nё?TCCCA;07Q@P]M?TCCCAP]M?hԸ_?¯n?Z֬f?A(co?u R@f@Nq?F%u?CCCACJ鄯R@5/=\?CCCAC5/=\?w? w?%?ZO]>&1ާQ@m@$vf?Mb?CCACAiQ@`?CCACA`?`?CnC?4/P?n1ӈ?L[R@ˡE@!{ "C?y&1|?CACATJ*BUR@&?CACAT&?#9 Y!?{O; ?hگ?" jt'>#ݝR@$@ /8l?镲?ACATTKR@>C?ACATT>C?N?lG?kv?x)>:. O@@~9|@n?CATTT~dN@"Bt?CATTT"Bt?&~Gi><΂V>MXC?q27?3H@uq@ }X?Biޱ?ATTTAzזeI@3H[R?ATTTA3H[R?W|=İB]>_C~]>#6?x]K@"@JE?q?TTTACi eK@m)9?TTTACm)9?RLS/]>IRk,?&5?fkbj?fO@7@6MA{\?St$?TTACC!OI,O@ Mfa?TTACC Mfa?ȧOq~?WGx?%+??܃?԰ġ?{?ˡEkR@-Ԛ@(JS1?Mb?CCGTApx@R@ߚ?CCGTAߚ?Yf}Fx?2+=&?+L?PH?h]JJ@@o*? ^)?CGTACƟ-#]K@?CGTAC?>`P?tNe?+iR?rƖ O@K7A@~q)?5;Nѡ?GTACAj*5ـO@jB~?GTACAjB~?i?qYv??|66?/'QR@iqJ@^x?0*?ACATG`vk^R@=v?TGATGw/?Tr?9?&?VDY4?(`P@G_@HQ?<,?CATGG;}WXP@K?CATGGK?'?8$?_{i?iV.?(\BN@4333s@cj(?/n?ATGGC&eO@TK5|?ATGGCTK5|?CPw3?@2)?}OvQ4??A M@hsu@hTʼ?n?TGGCC(?@"~O@yEPZ?TGGCCyEPZ?xvg0?$ړN?E)?ڀs??q9Q@j+w@MW? g?GGCCG tK.R@L|Bk?GGCCGL|Bk?X88q,?6?O7?1m1*_?*R@@ _?{Gz?GCCGA$L&vR@ ,U?GCCGA ,U?( ڻNB?q8?['p'=jS@?٬@㱢 ?J4?CGAGC0 a8S@|f?CGAGC|f?&VL??T а?*[c#>z~P@ZӜ@^ҥ@-C6j?GAGCGfTP@X@sJ?GAGCGX@sJ?XQx8?ե}?AѦ?*Z}Q}?fR@@H鑑Y?S!uq?AGCGG_ޢ"R@BPZ?AGCGC.?'[,?'?ȅk?v?6hH#R@N@@S@ @JYF@Q?GCGGT3R@dD?GCGGTdD?<}r͟??RN'?a'=|?x=P@]m@ b @n?CGGTCUP@˃-"?CGGTC˃-"?oFh^?)D4?v6?CI?yQSQ@$@6g?@ ^)ˀ?CGGTCC?P@\?CGGTTKN?p2*?N ?ϯ?BhJ(ל?&t[P@Pk@J^@Q?CGGTC^cP@[Yg"?CGGTC[Yg"?no՘>T< ?4~ ?){?;6[ P@-@_\w6@_vO?CGGTCP@^?CGGTC^?>#>ge?<8P?`?*?l֘H@S@A{@H}?GGTCTK}J@ 'a?GGTCT 'a?= ]Jc?kr%>Rn~?K7TN@鷯@͐?{Gz?GTCTGZD:M@&LJ&ʗ?GTCTG&LJ&ʗ?e 8A?VsZw?΀(u?H?ZYg_M@ @Ӊgt1?j+ݓ?CTGCTSqyL@3?CTGCT3?e 2?IbJv?W{j2^?G/?*F R@jq@?䖪@ǘ?TGCTA.{"R@o.!{?TGCTAo.!{?Y%:,?73L?:D0?j4w?k+%Q@ @Tg4?{Gz?GCTAGZFQ@T7?GCTAGT7??8Ӏ?M3? PO?%S@|?@ >h ?䃞ͪϥ?CTAGAJR@!5L?CTAGA!5L?I~\?ƺ0?IJV? Ic2?5PPR@aTR'@^]@/n?TAGAAajAR@OL?TAGAAOL?V?\v ǫ?yx?(=TS3?]Fe%>?eQ@gfff@N|NG@M O?GAACGgg9P@?U?GAGCC?]Rt?$c?y"lo?4y?y q?o`*Q@) @!0xZ?Ǻ?AACGGF03P@-w?AGCCG(Y*W?z!?OQ9Ƀ?Cw?q䆑yz?_"4R@@ht?ZӼ?ACGGTU5[R@*V?ACGGT*V?|ۗ+?Y ?yL?Yхa?'aR@z6>@`X?q?ACGGTϤ5[R@a?ACGGTa?*(?ZMW?A[@?>%.r"?DP@L=@aN(@~jtx?CGGTCMP@T*!D)"&c?[U?ǪB? mN@@Kb#7?+eX?GTCCGis5M@2Ā?GTCCG2Ā? Tcu@y?\QM?g,vw?d 2C?0R@( @U7g-N?y&1?TCCGGw> IQ@w3:?TCCGGw3:?bp?9@2 ?'̹?~q>ElQ@ @d,@Ǻ?TCCGG7YIQ@'^4j?TCCGG'^4j?[6?; ?n`nvbS?^!Bm{a?@R@K7!@2^?5;Nё?CCGGGDR@B?CCGGGB??~NT? 2Yp?Y(<?6qU]Z>H4P@ڊ%@/@_vO?CGGGC>DP@ֽ1$?CGGGCֽ1$?-q~?LR?C>1_?Y-?+p38XcP@y)@smQT@"u?GGGCCiD.P@"T^]?GGGCC"T^]?*FQ?+?^-?"k?n0"??|=?BoBf>z5jS@On@|K.I?H}?CGAGGNS@U?Ux?CGAGGU?Ux? M5-?e|=?? K>/mQ@ lV}@#H^??HP?GAGGC)R@.N?GAGGC.N?M?[;z?n"Yc?id~`?.3P@"u@":@@5;Nё?AGGCC/`J0oP@+U*@?AGGCC+U*@?#H9O?f |H?u[K3?ff?B7R@J@}̥ˮ??GGCCGnE.R@/M?GGCCG/M?l?6/?xNL?"?; (R@Zڊ@20?+eX?GCCGA|2;vR@ ?GCCGA ?ZMت?!X?FUf6#?VZw?&0S@8ō@2?vq -?CCGATPS@f~?CCGATf~??xSE?Y}? 5>[KOR@?ܕ@y&?q?CGATCJ^R@J޴$((?CGATCJ޴$((?_j0? ׊ʉ??tC^|r?L@"ۙ@o&\?/$?GATCC#YtL@)?GATCC)?2qH`?/_l?bOc?(,'?gKu#OO@T㥛@ZЬ|_?/nr?ATCCC-N@"a?ATCCC"a?'߈[?;p? c'9?9?M2[Q@o@漾?`Q{?TCCCAWd6 8Q@ܭ?TCCCAܭ?zhʣ?gE|v?W b¤?Sa݀?>M1TqR@ y@ K?@߾?CCCAGavR@"v'?CCCAG"v'?"i?0? ?x> mgDS@s@4 i\?_vO?CCAGC0R@vrH?CCAGCvrH?VV?B?-x?VnUI>!BA؁P@?߾@v1U"? 0*?CAGCG CP@"?CAGCG"?4PI'b?^]С? [(??!+U&?ҲR@e@Gi?r?AGCGTGR@Pa?AGCGTPa?'T? v%N?? LN;?Q@E@]n@&S?GCGTAѤR@?GCGTA?N%)/? hɐ?+u?2`kiy?ZYRK@k+@žwR@ 0*?CGTATjaK@'DJT?CGTAT'DJT?YUI>MڽIe?cir?efPë?VKP@QI@v?~jt?GTATTbnP@E?GTATTE?5?#G?_<}?8Y?p\O@鷯@R80@ψ ?TATTC.N@Vc?TATTCVc?kal?A2]?m=C/2V?;SE2?{o%I@ r@ń ?gs?ATTCCE^c*SI@^ۢL2j?ATTCC^ۢL2j?~N0=x>SAU>E+?J 8M@^)@ofu?K46?TTCCCG#w>M@Ig?TTCCCIg?g?<7{?w _?IL^p2Z?.5P@ o_@U?Q?TCCCCfTrQ@w?TCCCCw? e{?)?"m9^?x˥?=PQ@z6 @.'2?HP?CCCCAN*vp!R@M?CCCCAM?˄|?/Z(?{{˳?t`?PXR@!u@ѯi?S!uq?CCCAGOR@nzw?CCCAGnzw?\˔?JCtQ?Z9?{ֈ+>vvS@[Ӽ@W(g?L=U?CCAGG4)h'S@jP?CCAGGjP?f3?"9aݩ?q V?6:> +癨Q@#@d (?Mb?CAGGCI-Q@HQ?ħ;B1?z6+P@a+%@Kc'@Q?GCTCA}P@Lsn?GCTCALsn?&O,?7'v?U`Fd?^39x?aݟQ@C>,@_^@Q?CTCAG-zOQ@zM?CTCAGzM?C?=?SRD?°u?nz&R@ͪ5@ڸL?)\(?TCAGC'_zrR@0p??TCAGC0p??{?t:?$O;?u)??۪=|R?Uuk[P@%C@fJ^"?St$?CAGCT1ӿP@.*?CAGCT.*?3Gfh?#?G#xy5? _?Ɛ[:P@x $H@=I@5;Nё?GCTTC۩2O@Lݹ.?GCTTCLݹ.? &?K?ڥ{hp?<f?;Y(#?2/I@_L@o@gj+?CTTCGٛxiniI@&?CTTCG&?kNÄ=.L*3??}?{q?>޶M@ktX@LEx @ǘ?TTCGGSܗ4O@̣?TTCGG̣?&m_J# ?I?}e?ͯrU?RLR@#\@a3Ԣe?gj+?TCGGG|KF#R@/ޯ?TCGGA$p?hM?W,‡?"!u?& H?|ozwQ@X9h@߽@gs?CGGGA(Q@n j`r?CGGAGt.:?t |?3vW?$?M?*l?x T@gjk@k@a+e?GGGAGdR,R@(jNO?AGAGTp;-?[]e?O5͗?""'?FXe0P>$ϴ7T@On@ap@y&1?GGAGTA`/T@ԁ֩3?AGAGT8? <ض?$en?_? >[Bw2T@V-r@x @Q|a2?GGAGT{T@A`H?AGAGTr? ?Io?^unM? biQ@?|@/H3@+eX?GAGTA#>Q@*ů@?GAGTA*ů@?`ap?Ԯ?gA?vU?y͐Q@?W[@&X0 @S㥛?GAGTA}Q@5P ?GAGTA5P ?(0M?8$6?!A'?ޣƶ?}*~ߊK@=,Ԛ@J?S!uq?AGTATtgWM@CA?AGTATCA?E{)ݴ> ς?w\d?j #?IP@NS@%ō;?_vO?GTATC3JP@>?GTATC>?L?7?AB^? @_x?L=U?TCGCTkMgQ@^y/?TCGCT^y/?|8̧??,#?#gȲm?3HR@1*@ %?p_Q?CGCTTACcR@rE?CGCTTrE?r?!P?DŰ1N?44\>:KM@46<@w@M O?GCTTC^82O@Qb1?GCTTCQb1? P QT>Pw>%ff?ɉځ? G@ h@?Ǻv?CTTCC2C2#I@y'\ ?CTTCCy'\ ?ֲr 9=־ r?}!;y+> qS?-΂K@q= @`PTy@a+ey?TTCCTZN@?TTCCT?q>-¤>D?u5zP?lek?3HQ@\m@:~>?HP?TCCTCEUFQ@&8?TCCTC&8?\?q[h?hv?&?fP@@O?NSt$?CCTCA5w~jP@?CCTCA?R`v?8 ,?PU ;m?x?z 1Q@V@:? ף@zEug?0*?TCAGTR@ܜ*X?TCATC9%+?nI? k+(D?Bh91?g`? jR@@];8?ψ ?CAGTA})[Q@›?CCATC-xKm?U f"? ?KKd?t9?rBM@?٬@?UN@?AGTAT+reM@~?CATCT$~?Pl~Sd?RGb ?9ZPA?o?Yo[P@Լ@ ? rh?GTATTղҿP@[`HK?TCTGGYo?[d?zt?\gIe?@W?i) P@lV}@ح?Pkw?GTATT2FP@uGֹ?CTGGTi!#?k 0u?s1?)GNf?RN?żL@=@Wup@HPsג?TATTGo%XN@0|r?GGTTTb@?R>7#Qr?@?O#??;;sK@Q@;?gj+?ATTGCx͂K@m3?ATTGCm3?TS?>_@>?Ҡޙ?qF(B?2K@¨N@f( 3? F%u?ATTGC7΂K@|j?TTTGCI ]5?,(W[>/,.@?bvj<"?#?f L@A@φ?(?TTGCCͰ-K@Ld?TTGCCLd?r18?Z_s?.5/-A?N@?AʹrQ@6^I @⤷?d`T?TGCCT7 )Z!Q@Q>l?TGCCA>qrq?{~?oDș?G:}?l%'?ER@hs@xmo? ^)ː?GCCTGDq&R@Yu?GCCTGYu?! L?ސ?B!?m ig?1O@ @[A??CCTGCztP@sw?CATGC ?h9E5?OQRH?#|? -?T}L@!rh1@?8?TGCGG#C>8?@i?h60 ?|{uH֛?NR2> fR@A8@yA?2%䃞?GCGGG R@:?GCGGG:?!b==?GH/?j]+? UG)/?B`]P@h@@ѭL@{Gz?CGGGT36EP@xy(Y?CGGGTxy(Y?D N-U?;ׄq?9?e' e?ƒ_P@7B@uRl@b2U0*?GGGTC -MWS@ta@9Щ?]K=?CCAGC-%R@nS?CCAGCnS?1- ݼ?ثv?xbm!k?8&JY ?:XP@o@i ?i|?5?CAGCT'sP@y ?CAGCTy ?`7?p̀?#f?fB?#R@z6~@Ȍ\?n?AGCTA1%fR@w[LB?AGCTAw[LB?۞L?*DM]?/+w?N~?|D8P@鷯@Ɣ?_L?GCTACړQ@ m?GCTAC m? 7?z'?bg]?gBlڮ?VQ@HP@k q?gs?CTACCO%|wP@mw㝎?CTACCmw㝎?d?>"\??nƀ?q/??DAQ@n@>%c}??TACCAzQ@yoN?TACCAyoN?b?*A?L?\i鐋?uޛCR@ݓ@Nl O?F%u?ACCAG2cDQ@{' ?ACCAG{' ?φ"Dޙ??&h ?ڢ|?HǢRS@E@ SKL?5;Nѡ?CCAGT]3DS@B?CCAGTB?jXe&B}P@,ݳ@s7@NSt$?CAGTGN:A#WQ@ M&X?CAGTG M&X?t@?dmG?6 ?k?PK@ @2X?Q?AGTGT³ M@p?AGTGTp?]L>Ilb?bW8g?p5L?QM@lw@=|]?ׁsF?GTGTA1C *M@% +?GTGTA% +?GZTP?gh?Rz4?up?`-L@z@E( ?0*?TGTACʳ+L@-k?TGTAGLQ>?1 ]?R@:p@P??߾?ACAAT$[kR@‘?GCCAAz ?&‰?E!=?cez?1nb|?R@@zv1?"u?ACAAT~kR@? (?ACAAT? (?r?z" ?|c?%'A?"I?~ Is@-?NrM@A@C?+eX?ATCCCVA;N@FN?ATCCCFN?݂XV?1FC+=? k?v;1R?ˈosQ@n@OT1 %?gs?TCCCGVٚ]&Q@qf}?TCCCAi̡?o"?  iR?O1?[e *A[?ޅo>S@Bi@ֵ6?L7A`?CCCGCINPR@?CCCAC#??7v/q?:%x?f>䩤Q@c]@n?/n?CCGCCvQ@=?CCGCC=?X%'? W ?% D? i^~?{OR@ @-C?_Lu?CGCCCJ4R@E('^?CGCCCE('^?xk?yK? *ϐ?!M`qs*?oQ@iq @b- D ?/$?GCCCAQ@gPk?GCCCAgPk?bsX0?,J??y?2GH?<)hS@@;?_vO?CCCAA>/3S@¹2|?CCCAA¹2|? m)?!~ԉ?ɦ|?V2P>{R@ۊe@n0H?j+?CCAAG R@G9(1v?CCAAGG9(1v?Lʬ?hY@ʴ? ?ܟo$b?R@1&@?`Qګ?CAAGAj4ͪUR@1?CAAGA1?NK`g3?`m?fqӷ?RGS&?:Q@x-!4@gg?q?AAGAA,gQ_Q@\?AAGAA\?!Dg?q2!lw?kia?XM6 J?bφgT@I}8@<]E@0*?AGAAAt_CT@*坖q?AGAAG?n}?U2{Q?w_a?Ս\=ƫ7bjS@ec=@ۗ#^?ZӼ?GAAAGS0MR@4R:k?GAAGAq.UKm? z4?e ևk?ɀ۔?-,>?^Q@0$A@dkÜ?"u?AAAGAUhpQ@mdz?AAGAT, Q??g6w?gi/?sPA?6\Q@\mE@KB?Q?AAGAT8Q@ ?AAGAT ?(?ݝ?T}Wp?(NM @HPsג?AGATGX\1 R@]?AGATG]?͇4?!J^Kg? F ?D}?gZL@;NQ@j>Q?3U0*?ATGCT))L@}f?ATGCG3?K'C)?V쥜?*?e&?N<+Z}8R@"Y@س;@H}?TGCTTOR@}5q?TGCTT}5q?F_?ۘ/?74?Ic;?4WxR@ڊ]@@Uد?TGCTT5PR@,"}nw?TGCTT,"}nw?}F?]:?A5u?w^:L?9(N@ŏ1wm@Sy@St$?GCTTCh2O@#?GGTTTz4b?t^`??xu ?A:b?uH@Xq@ɤ?q@Q?CTTCC/a;kI@deb?GTTTG9 C?)շ=,j?]X>{$rS?#ù*J@S!u@M/^?ZӼ?TTCCCЮM@Zj?TTTGGb˳?_D>@?BGA?9 h6?؃TfN@ 0y@&6u??ܵ|?TTCCC1>JM@jb?TTGAC2 [?4aJ?EBA?|?a/?&XlP@y)@ 34?+eX?TCCCCQ@vTǺ?TGGGG^mk?ž?PXX?FZ+a? 7*?HOpR@Լ@%?a+ey?CCCCG%lȋ R@s٘o?GACAG͑κ??N+?U#ւ? ]0\?tp%R@_@SD}_?{?TCATC-FR@p}1\?TCATCp}1\??,-h.? F?y3T*3Q?RBF?h0&KO@n4@i聯.?/n?CATCAj)0N@ҬL?CATCAҬL?w 1?`?ՒV?6o2?45>#P@@5^@^:??߾?ATCAC'u P@Es R?ATCACEs R?#w@ ?sƖϕ?Bϣ?E%å?8 9oQ@) @UJ?I +?TCACGwJQ@<>?TCACG<>?OdY?c.k?uϐuK?;s-?oq#R@/n@9]޺?{Pk?CACGClxR@hc?CACGChc?S\?lO& ?6[?^a?\5RQ@K7@.?ŏ1w-!?ACGCGDx7sQ@H?ACGCGH?0޲?vD?A5?V?ϪR@uq@3y?"u?CGCGA^U?US@?]?CCGAGBcy"?j޴?bU? s?j>QY|S@ @Z/?:v?CGAGA5S@X#"?CGAGAX#"?Jg s\?]?Zi`?yS>myR@a@TWU1G@ o_Ή?GAGAG cyR@_6?GAGAG_6?G,l?=?+%RG?̉QO?ݏeS@Mb@}[]@ ^)ˀ?AGAGA%8T@ ?AGAGA ?%? ? 3bh?w;KjE>ƱR@y)@sSw@HPsג?GAGATAR@iٛKCi?GAGATiٛKCi?=F?zO&?!(?݌$?.#'S@?@E{lx-?Mb?AGATGXR@LL*?AGATGLL*?et@oMR@D@4s0@b2U0*?AGATG'HR@$YG?AGATG$YG?F%|G??}Oռ?=Y??kV_N@Z8@sJ?_L?GATGCL**"O@Ѱ,?GATGCѰ,?k 0?ˢrl?=q?<Վ^?L@;@jR?L=U?ATGCGL@oc^?ATGCGoc^?|6vhN?awv?K[ՑO?# Ѡ;?mSªQ@}a2U@|DɂX@]C?TGCGA!dR@]?TGCGA]? ?Zބ0??``}O?[R@V-2@E.'+?_vO?GCGAG#xS@W?GCGAGW?ӰT>?(j?.?dW?zS@D4@6K @N@aã?CGAGCg8S@@L?GCAAGt?Ƣ2f?{?x.?מ;2?W6QWR@qΈ>@k̿?ͪզ?CGAGCph8S@"?CAAGCּ?5?/?Jpb? CZod?s)oP@ףp=J@D&Q@a+e?GAGCTd8P@Ki5=?AAGCT{o?2?)' ?)?a2-?&R@PjM@gaY?Ǻ?AGCTAÇfR@#6?AGCTA#6?8HPJ?C4M`?LP5?q~/j?[i;Q@&S@X` F? ^)ˀ?GCTAA睾9Q@~?GCTAA~?a #+?jӧ{?ғ!?_&S?A0GQ@|?U@ ! *j??CTAAC.:DQ@-a?CTAAC-a?]kS?!7H??M?@i3IP@S[@E)fp?j+ݓ?TAACA %P@ X̯?TAACA X̯?9?XM?|įõ?usif?BOCEQ@QI`@&?b=y?AACATJP@`8?AACAGM?W?#9Y?e?7[?nӋ?wͿR@C>l@\T?H}m?ACATA`jR@}G?ACAGCm?o#=??l?L7E>~P@8m@?ݓZ?CATACU@`vP@ C7b?y&1?ATACAI.P@hhxN?ATACAhhxN??TJ?3+8?Ttkا?՘:R@?ܵ@{oF?eX?TACAA#KR@n"?AGCAC2??h m?a؄E?YWݾ ?oFR@rh@xz?_L?TACAA]`hR@싳ݫ?GCCAA~Y?e.P?x?E;ݠ ?Il?!CeGl'R@~:@`H}?H}?ACAACOqR@ ˕"?E3,50J?S˂?P@I.!@Zl?gs?AACTCW>GMP@*?AACTC*?*adT? K{1??N?҉EO@(\@|zV?UC?10f?̴Q@ +@fU @-C6z?TGGTT`A_ Q@rw?TGGTTrw?g?)舽n?eWL?h.?F@VO@0*@nh@:v?GGTTCf-2K@(/̡?ACTTC90?"5Dt\?l_?p?aB35?AI@qΈҾ@?"u?GTTCTH@Xy:?CTTCTqC|?"O>mQW?ȨM*C?>>%?~jmN@9@ƜS?Mb?TTCTTxp9FN@mӒ?TTCTC_[!??muǫ?rn?Nq,?3Sr10?`HP@gj@#:?~jt?TCTTCN@J~?TCTCGz?S`?E#n?.MM@?zp?h+N@ŏ@7@~jt?TTCGC[rO@N?TTCGCN?/m ?x ?io?l3nK?߇[Q@3@}?Zd;O?TCGCTAǯgQ@?TCGCT?)9w3?2f?mB?b#{8?~R@ޓ@П]ؼ@?CGCTGXBR@rw-?CGCTGrw-?&&?.?$;?m?n;?)%{2Q@`TR@)?M O?GCTGA$vP@f?GCTGAf?Fzf?B? #X3?Sʱ?#N@ $(~@/I>?J4?CTGACXvYN@W?CTGACW?)܆Җ?d? ~7?q80?*z,Q@U@ h[?Zd;O?TGACA tOo\Q@uSu(?TGACAuSu(?[yj~?7կ?:)?_Iǚ?nQ@Pk@G ?St$?GACAG02h}Q@x?GACAGx?XAY^?dd?LԺ7K?j(1m ??Hoq'v?4d 0?^~jP@H@=?/n?CAGCCG~igP@?CAGCC?y\?ФS?@! ?VQ?.7Q@;pΈ@rS1X ?H}}?AGCCA}bwQ@>}Lf?AGCCA>}Lf?Mಳs?AP?J-R>?1qU?NȅR@d`@ ?ŏ1w-!?GCCAC;`R@?GCCAC?҉]\??Y ^ŝ?7琑RN?7iϝQ@D@ i?b2U0*?CCACGI lQ@}Xa?CCACG}Xa? n?1(OLG?syB?!cr?xR@+e"@ ARt? QI?CACGAYDR@qO:?CACGAqO:?˛qb?kp?r+??f”>aݢ+YR@k)@(?J4?ACGATN7~R@"CޕO?GCCATwf?N? .'?`ߒ? Ļ0?U\ѡR@):+@4/Oq?tF_?CGATG(fR@oʓ?CCATTS@?ZpZ?-}@?\2SuO?L>K~"M@7@3`f@H}}?GATGCN#]"O@9g?CATTA?'?p{f9?q+Gl=|?!\`?0L@9@ݿt?J4?ATGCCQ%VL@h'a?ATTAGfHI?=(a?MW? .q9?X7?gv($P@3B@Ad?DJ?TGCCGy2'Q@#:?TTAGA`E?o##ߝ?du?") ?p;n}?uR@+N@Ia?Bi?GCCGTB;ޢkR@X?TAGAA14c?=k?jϵX'N?Sç?eC2?{'H@( ^@mCr@-C6j?CGTGA~5K@d"h@?CGTCA$5 3r?M%=cjm> F>ΰ .?ыO@?^@!s@/$?GTGAAJ̽HN@܎Z޻s?GAACG=wֳ? o?wڨ? eI?IQC1?> Q@?d@H-@Mb?GAACGfͮP@@?GAACG@?όg<9?yu?R??T1f6.ƕ?XȽP@|/Lf@/WJG?_vO~?AACGCUo)'P@G¨h?AACGCG¨h?[þ?p*?R?X?3333ݶQ@y&1h@H`?y):?ACGCA2g~Q@Te+dv8?GCCCA?B O?V9?3yuF?f0SR@z6>w@z:?vq -?GCATC8R@. :t?CCATC"nd?FL(l?pDz?+?@&t ?M@9#J{@-%@3U0*?CATCT"N@4[ȳ?CATCT4[ȳ?= P'Z?O2{?56?-x?)$O@S@ ؚ?UN@?ATCTT\ĨO@{T?ATCTT{T?@34!?tc?G^i?g쭸?>B%O@o@3)g?:v?TCTTCPGN@dtV?TCTTCdtV?!`]?. @?7{؜?,n \?yGZI@!Ac@k؂e?n?CTTCCb3I@q)Xn(g?qzN?['K@1@:&(?ZӼ?TTCCATBA N@5g?TTCCA5g? 2>H%^?Rq?W.x?))Q@x-!@᥵#?M O?TCCAG*O׿Q@A?TCCAGA?u ? ?'~?@#u?u4S@J@Џy?Mb?CCAGCWR@(tk?CCAGC(tk?ZW$?U??]!B?9H>P@R|@Rb?q?CAGCGP@qe?CAGCA C?s??;no?C, WS@#lxz@EC0?Mb?AGCGCĥ R@.?AGCGC.?hz?FM~?UƬ?=>iG"R@&†@ y⌷?:v?AGCGC R@x?AGCGCx? g?㣆"?' ?kOE/P@b@0Ou@@ǘ?GCTTT2HO@^?GCTTT^?5T|?#U!? 6?nk?c/ȔmJ@?W[@ӆ?7?ZӼ?CTTTAnyI@3o"`?CTTTA3o"`?eb!'[>9?{ôr?kQ?K~Q@9#@@L؜ ?ݓZ?TTAACW"Q@ڰ؃?TTAACڰ؃?E,z?HR?{gzQ@NbX@_Zg?Ǻ?AACGT$?Z7P@G}T?TACGT!6xb?GB=?pAR?P5[?6g?zFp?R@46@Fc@tF_?ACGTTy$ bQ@ =?ACGTT =?¾A}?r?<*?REvG ?|~H@M@@G3@I +?CGTTG{sqI@'?CGTTG'?7M)=8>UhQg>D r?SVJ@Q@4~?vq -?GTTGT=`B??;v0%l?yh ?!@PN@zX5@KV?{Pk?TTGTCCbM@@S?TTGTT||?}Ȥ|v?( !%";?&+U?-m?LÃ`H@Pk@:_ ?W}b?TGTCT9I@C?GTTCTOmi?}~="9c>;>Iob?aЙ:N@J +@v!? QI?GTCTGEM@\ ?TTCTGǛ3? hO?,;?@;E?nە?2YO@lV}@2?v?TCTGCY7P@Mͮ-s?TCTGCMͮ-s?P0r?rޚ`?Ts?&|S?nHRs?變#?4fKI?B?":SQ@tF&@v@@s4-@<,Ԛ?CCCTGWkkR@5Z?CCCTG5Z?1yF/?KBV,J?P23?b &t?|?GP@A@#?Mb`?CCTGCyuP@۩w?CCTGC۩w?-y_3D?SЗ?11s?ʷw?䶺LL@5@B@UNp?0*?CTGCTYVZL@b4 >W?CTGCTb4 >W?K` ?W|H?m?9M?'M@ΪV@8!`g @gj+?GCTTCrX3O@rv}?GCTTCrv}?"}3?(?P ?T?d^I@Z\@?I +?CTTCGWFjI@;?CTTCG;?,E1=S>+һ/l?3T+?5J@h@Psɞ?L=U?CTTCGz+HjI@a)|y?CTTCGa)|y?x1'>QYh?tUr?$?f6SP@Vo@Iu@ZӼ?TTCGT0]O@i}?TTCACS$?n+Ur?.Y>%?.]?6Lv؝5?]oQ@jMs@?:v?TCGTC4yµQ@MF?TCGTCMF?S4?cRD?7"* ?Vś\?+M@Dv@%b @ ?GTCAG6N@Ho?GTCAGHo?u%p?k\9?Đ?2&ͩ?(w@tR@\m~@/oA??/n?TCAGTZ #R@wNyk?TCAGTwNyk?M[?%?Uok??3?a .R@0$@!n~z?H}?TCAGT(܃<#R@Ru?TCAGTRu?)_?:(H?aZ5?i$ ?<R@Oe@>}@a+e?CAGTGt #uWQ@-6?CAGTG-6?l?M("h?tK0?Rt?Y]M@):@De?( 0?AGTGTri M@v` 4?AGTGTv` 4?1힒T>E2Z??S?8kL@Ciޑ@Yґ# ct??J5\?@DbaK@ףp=@B}?+eX?TGTGC@'KK@ >?TGTGC >? 1/>%Z@?K ?)Y?7,{L@(@zea\?/n?GTGCAuv@L@䊟t?GTGCG6 ?v>6?z#{?`&]+?k(G?&&iR@9gDi@IM@{Pk?TGCATr)R@根?TGCGCO?L?(?1޺[)?\7c?PԼI^S@잼@vx!S?465h20S@3@w(!?ZӼ?GCATT8R@yT?CCATTD?ӿ '? _>(??e'T>)_M@Cl@Zm`@ψ ?CATTCS- M@@f?CATTC@f?y%$?I ?B?Uz? ף0N@K{/@Zk @H}?CATTCDM@ls?CATTCls?~oR?AT?7?Z?u1?<ŅH@jM@ي&p?0L F%?ATTCG ҍNI@=8k?ATTCG=8k?Q^X==eUW1?AY8?$ ?W]?Od{P@X9@UK?H}}?TTCGT, qO@T?TTCGTT?d7a=M?oȩ?Mtw?3m;A?9>fR@L@5_ AX?j}3E?i++?'7? TR@1*@Nx@?TGAGCiX{R@R?TGAGCR?Hc>?2 ?'i:?wl@F?,| P@k @K]?mxz,C?GAGCT hrP@ֺ~?GAGCTֺ~?KhbŤ?G^n3? 8w? ?5 (~R@io @A•Q?DJ?AGCTG}'6R@DžB?AGCTGDžB?FQ?!p?dC?{x? L@x& @wdž?/n?CTGCTIL@<?CTGCT<?ұO> /B?Q,+H?LI?HT8rQ@y) @,mG @q?TGCTTlR@@@}?TGCTT@@}?-Pt?Гux?Fww?6M??q?s@O@( @i")v@b2U0*?GCTTGa5 P@Rdc?GCTTGRdc? G?X?_I\@?An?<?W@GK@ @&;f??W[?CTTGT@#K@rJ[BbBT?dۅP?eթ?:&M@JY& @z D?+eX?TTGTAÏ M@1ިf?TTGTA1ިf?k^?Hi?t ?L ?|P@8gD) @x2}?`Qk?GTAGT 4WP@i{j?GTAGTi{j?ϓ.%d?|b?#_4ӷ?G5?/m=Q@9#* @iQ>T?Pkw?TAGTT9hwQ@dr/?TAGTTdr/?ԥ??Hf{?]7>l?aPK@[ A1 @ld߾?J4?AGTTTWK@F^_:?AGTTTF^_:?P0:>,Q$?lV.f?`O]?i[Q I@"9 @UMD? ^)ˀ?GTTTAhxI@& +?GTTGCIuu?%E F='0"?x9M+ws?*~?<VLsL@; @U爏?J4?TTTAAefK@'.K?TTGCG5 ikJ?D ɦ'> ))}? Q?InS ?8dkQ@L7A@ @s|7 @/n?TTAAG^d&Q@n?TTAAGn?{g?ܦ?#_y? z6K?rR@@B @UF? F%u?TAAGG?*[R@PAd&?TAAGGPAd&?t0P?0? ??e?$9Q@I @fEv?mxz,C?AAGGGIЎ_Q@p: ?AAGGGp: ?'r? Ֆ?\ J?yGՍ?2MؚR@CL @q.&M?_L?AGGGC-Q@HQ?ACGGCSk?'m?Eoo?/yP?2SN?o= iO@b4O @`0)?ŏ1w-!?GGGCT- @P@] ?GGGCT] ?)I ?WJ!M?F5)=?KF?hN݈R@/!V @{M$@S!uq?GGCTCR@Ac?GGCTCAc?(?@@KAK?C.~p?-=A?8(vO@b] @4ӝd?j+ݓ?GCTCT$!O@Y\~J?GCTCTY\~J?-ھ?fo?@ Ѫ?ae j?MH V)P@B`b @}?St$?CTCTT`.P@uF $?TCTGTt@\?;#y?ϊ?TOy?s=p?8!WN@|Pk @ʈ?N@1-}?TCTTC1-}?y*c,?C܄?Kk9?(H?~eJ@$t @-զ@-C6z?CTTCArƂI@6S&?CTTCA6S&??C>nIxb?c4dp?^9Û?X<9O@j+v @8@`Q{?TTCAA#bXO@4a ?TTCAA4a ?*?KGq?nMCS?Џ}g??`zu6R@sw @VZ?¨N@?TCAAGZ*%R@K0?TCAAGK0?:?f8?W|?Qu E=? R@ @h;@a+e?TCAAG2i%R@?TCAAG?o{?|*0{?yǴ?CqE?G jR@46< @P/p2?}гY?TCAAGr%R@洓Y?TCAAG洓Y?qe ?_t?QE,?ZSb?p?lGR@0 @NA1m?+eX?CAAGCa]j }Q@:X/?CAAGC:X/?#`/?X-@?rbE?v:{O?AJj8P@;M @IC?d`T?AAGCT$bP@톏?AAGCT톏?.—?Kxi?7KZ?ly?ga{R@mV} @b@Pkw?AGCTA=tT?ڃ?= ףP@Bc̽ @ #~[?Ǻv?GCTAGFQ@~c?GCTAG~c?Gc8?R.S?RC&?Ѣ ?("R@Zd; @5N ~?b2U0*?CTAGT toR@}.?TACAGEXE^^?3G "AlM?z?*K >?RohM@ŏ @jjO@a+ey?GTCGCVTN@|?GTCTA &/?w+O5E?i?=݄?A?äjP@& @!?5p?Aǘ?TCGCC<-Q@4j?y?TCGCC4j?y?JWUe[?o2ˀ?`X5.?? Q@ @4cz?a+e?CGCCCeDR@Q+?CGCCCQ+?ɨk#r?;?S7?BT?K s?9x?n4L@ @ˤK-?~jth?TTTAClJ0K@?TTTAC?7aLQ?,3/z?L7/|?<Ir\?MP@ˡE @nID?r?TTACA O@f?TTACAf?ܯK{? <+?1Hr?u?IpQ@? @<<ڸ?&†?TACACX(Q@ᤚ?TACACᤚ?1a?zݜ?xHč?[xupR?N^=^Q@&u @-c?"u?ACACTվ7Q@ۛJ?ACACTۛJ?V?zn?^$&+?`G`t?sRQR@: @?6?CACTT_ \Q@8v1,;?CACTT8v1,;?;i??W?g?P?tc?O@G @@DJ?ACTTCf"C>s*?]R0:O@o* @+s-Q@S'0 @ @ o_Ή?CGGTA0gdP@h?CGGTAh?Y)G!?E?^ʌ?}xh?cP@Aa3 @`QE@a+e?GGTAA!b?CN@)ٹԿ?GGTAA)ٹԿ?$I[??:'!}?X(O?SYgP@2: @7lS@D?y):?GTAACPP@VLuWw?GTAACVLuWw?΁֦?(TF?-OJdE?M>?%P@z6> @ w!?_vO?TAACTgBXLP@rY?TAACTrY??Q? {?Ph?q9O7P@W2D @RI? ^)ˀ?AACTGJBP@k^MX?AACTGk^MX?'?_?lҁ?#?_вP@|/LF @ہgaP?0*?ACTGGTkqP@7툗{"?ACTGG7툗{"?͢F ?2HO?^UĂΊ?n_2q? P@):K @n|0?"u?CTGGTc𕲒?4,a=O@x-!t @m0P3@"u?GTACT+}O@Wٺ@?GGTAA Lm2?킛y?X??(?ӉS,?WQ@7>W{ @ G"҇?b2U0*s?TACTC}~CqQ@Z,@g?TACTCZ,@g?V&kB#?r=e?/(E8P?~=>i?]+0O@O?>j?pxR@<, @M?ZӼ?AGACCƕ!NP@U ?AGACCU ?K?vW| ?#-?! a?XYHP@Η @ʪ\O?@ǘ?GACCAhP@{v3m?GACCA{v3m??& 2?Y1?I[?CP@ @l'y?+eX?GACCA%^hP@D?GACCAD?W@W2?lqշ?XDZ ?q:r?\9P@D @@&S?GACCAhP@G{?GACCAG{?i;D?JM?)3E?w+w2#?7WQ@O @[f1?^K=?ACCAG|TcQ@Q`9?ACCAGQ`9?uh?fk?~X?Y(rb?> ףS@Mb @9V?w?CCAGAҌ>MS@0*Y?CCAGA0*Y?+??[I??`*>qkQ@Ciޱ @9nX?<,Ԛ?CAGAG!Q@eY27?CAGAGeY27?\4s_?-$?/n?NsxS?j%# T@kt @7@Aǘ?AGAGADT@ǹ?AGAGAǹ?}Ugͮ?X [n3?c9?ϙ4d>LtQS@dZB @qn>@J4?GAGAGJI6zR@ċON?GAGAGċON?R ?Bf?j?Quֱ>YS@h @o?&S?AGAGT>z:dS@bH?AGAGTbH?ۋ4 ?PT $T?ƝQ?Ư>#Q@@5^ @w@&S?GAGTG=NQ@hƾ?GAGTA:M ?G%sݬ?P9Tz?oy9?Všg?G(;N@ c @|?L7A`?GTGATݎBĶN@?GTCATT#?C6$?Î;?a.?'?> Q@H @V ?-C6j?TGATGƬ R@oe$?TGATGoe$?OUS?Q??vC%?(d?ȿ"P@6 @Dl@b2U0*s?GATGGH*H2*O@vNB?GATGGvNB??y?i{;?_? {?,O@T @I=?_Lu?GATGG7|2*O@K4,?GATGGK4,?̉I?#x+-%?l?r?YN@ @38{??W[?ATGGGLO@xb?ATGGGxb?2>\?Lt^?mC8X?q]Q1?]1P@ @)01?d`T?TGGGCtfP@enΏ?TGGGCenΏ?絖g0?}?1b?ș?J:>}3O@9#J @[?:v?GGGCT7tcP@y?GGGCTy?(D&?b|?؎ ??1Q@ @Xh3?]K=?GGGCT'dP@@ٽ?TGGGAdK?i 'Ʊ?}?JZLK? r?ʔR@\m @ila@Zd;O?GGCTC R@XgR?GGCTCXgR?H# e"? vp?ډHdx? E? ^ R:S@|P @G@46 l?GGCTC&> l?~P@z @[.)?J4?CTCCCWgFP@j?CTCCCj?8c\?'; ??AD)? ?/$0 Q@- @d̼u?{Gz?TCCCGJ&Q@W ?TCCCGW ?"??P`?k-Og?Ƙ'?FRR@V/ @FUVo? ^)ˀ?CCCGCvl3R@ $;?CCCGC $;?]??+?.} c> CQ@QI @;b?j+ݓ?CCGCA'1Q@ /?CCGCA /?<[B? [?1K?EM"{?"xtR@5@" @P9qL? ^)ˠ?CGCAGZl < ?S@ TRA?CGCAG TRA?Yu?DG??3B̏u?b`Ͽ?\4S@/L* @wW!62@F%u?GCAGGɓAS@-`\;?GCAGG-`\;?{Km?*ړ? I.?bD 5?A^k2R@o_. @ Jz?:v?CAGGAQS=Q@z:G7r?CAGTA<_?˶ Y?I`?&/S$)?-?)\+T@ O4 @s@/n?GGATACS@ ?GGATTrJ0?0$NC?CiV>5 yw>E%=PPP@6 @ I?`Qk?ATATT؀P@a+?GTATTPjBu?K??/-⋬?~3u?MzZM@7 @ V@y):?TATTCvȑ0N@~?TATTC~?Zφ>'>/i?tVa?]?A.I@D@ @Ynr?eX?ATTCAJ4I@7ƛ?ATTCA7ƛ?~ǜ>>2?MSZ?F_=?> ۓN@&SR @(5Z4@ ^)ː?TTCACs'MO@i 's?TTCACi 's?Sϝ? 9GC?.'B]?&ˑMY?J^WQ@ΪV @c J? ?TCACA^0\Q@0k?TCACA0k?74?eE ?_??:R@Q^ @oɜ?/nr?CACACTY?R@x$Y?CACACx$Y?q:?N >>(?$/PO@ h"lx @UKz@?߾?GTCGT 5N@Nn@O?GTCGTNn@O?^ѡBv??c}b?nb?ZH@Q@o @+qj?H}m?TCGTTUQ@lCn?TCGTTlCn? Q't?;BE*?Ցt:O?:WJ?sI@7[ @; ZJ5?#l?>J@gfff @ '?_vO?GTTAC:5$9?K@Qs|E+?GTTACQs|E+?.' >^dx?o+?g@T?TIO@C @>VF?`Qk?TTACAo+PO@ՂG?TTACAՂG??r?<)hM?8|?#*fQ@̌ @]s?5;Nѡ?TACAGtFQ@Yy\'K?TACAGYy\'K?[5L?9޹?!fy*?Q? 7? ^S@s @6>?~jtx?ACAGAvNyR@z6> @.2 ^h?kt?CAGAT`QQ@.5?CAGAT.5?=u@?WO??cr }/6?R@5@ @=^Ԍ@{Gz?AGATCYZ|R@l3?AGATCl3?`І?^- ?4?q-?a#?u}+J@ o_ @\E@ǘ?GATCG*9M@O[񷤾?CGTAG X;?TP>[$~?yϟ\S?""dM?.$M%Q@ͪ @g??iiR@[ @&S@q?TCGGC l= R@BP?AGGGC7S%Q?H n?ud?^؟?E/l\?65N@Q @#BϨ?HP?CGGCG5)O@= ֻ?CGGCG= ֻ?t˱Y?4Gʙ?3;^?#44jz?6 ˷S@ZB> @ZS?I +?GGCGCsS@OLK?GGCGCOLK?a`Yl?ݴ3?Ym)t?`>\Q@ׁ @mR)=?z6>?GCGCG T8aQ@<キ?GCGCG<キ?L(k'?;wE? 2 H?U2>8?eHaS@2w-! @?/nr?CGCGT>S@R?CGCGTR?Ymq?+,k2/P@L7A @Vx')! @<,Ԛ?GCGTC,|Q@X?GCGTCX?>*9? ?!??!j?Gd"%G@W/ @~p?(\µ?CGTCAu1H@ܥJN?CGTCAܥJN?Lq$=.+*I>;P^w>l?^N@H} @α@"u?GTCAAWY.O@\,J?GTCAA\,J?lig?? z+J?,Ao?$]Q@?W[ @QNY?y):?TCAAT_+[3R@3样?TCAAT3样?:[fTz? lgY?:) 2?NLփ?U)b1Q@? @T ?I +?CAATA{C~Q@4i;/?CAATA4i;/?6?sgϒ`?\nTU?tdFe?I!N@_) @?/n?AATATJ O@޹|'?AATAT޹|'?1y?0V3?ڰ? ?ףp=P@Q @dɀA?&S?ATATAZP@m SI@t?CTTCC{3Xr?dn "=;pvI?#}ɷ'?<8Y?N?Eu?ޣ~?@A{n/?r 4S@ S @-j?mxz,C?CCAGT7DS@,?CCAGT,?~ p?!q?@ϻ~?'}$>MQ@sFV @LKt@ rh?CAGTAScM[Q@f$[?CAGTAf$[?;q?_8 ~?x2?#ڹr?EP0K@H_ @%_?2%䃞?AGTAGkM@߲Q?AGTAG߲Q? yM> Rb?J/?-W/?^]]]5XQ@xf @P@ZӼ?GTAGAisYP@F?GTAGAF? ?JU>?/ؗ?c1V?brQ@joi @UB5E/@L7A`?TAGATĵ;Q@ WB?TAGAT WB?N&}?s}VW?@s?oR[ɸw?=>R@.q @o ?_vO?AGATGx9R@y:?AGATGy:?1*g?[b?eF? xd?P@~jt @G?J4?GATGCK=#O@`$Wn?GATGC`$Wn?[,^?6Fϙ<\?F% {j?+&Y9?ݘ ML@Dv @[h:?ͪզ?ATGCAVL@]"?ATGCA]"?x >k܍ ?~ǀ|?WVǐ?jR@M @?p@/n?TGCAG,se)7R@'p2R@q @lQjg@#?TGCAG6ŕ)7R@1n?TGCAG1n?Y:U?;d?;w?F}/?_Yj P@+ @o+ @St$?TGCAGvL+7R@[0?TGCAG[0?H`c?0Mˊ?%Ũ?{gCc?,ДWS@ lV @tT#?Aǘ?GCAGCK@S@/O?GCAGC/O?Dm,?I o?C =?Jq>:vP@&S @gR5?~jtx?CAGCA4;vP@UT?CAGCAUT?я?Qׅ3?1<?v?rujS@q @=J?H?AGCAGfr YR@p&<~?AGCAGp&<~?'H?0S?L_~L?9;fr>QcR@镲 @Eێ?y&1|?GCAGG`AS@Iy%?GCAGGIy%?;V9?^ ?-?{d?)0VQ@lV} @??HPsׂ?CAGGC ڞwQ@8&'L?CAGGC8&'L?r T?|Ȑ??z5y?.lQ@Dذ @\l#@Mb?CAGGC _Q@JN̂?CAGGCJN̂?N v?0@UԷ?U?]0?qtVeP@r @( C2?y&1?AGGCGt)畦P@Fԣ?AGGCC)wP?pj֘?%,S??|/!`?ҏ3S@z @!?X9v?GGCGG|kI^S@"7?AGCGG\_?u̲?%?tQB?qH[y(>LzR@Bi @0͓u?gs?GCGGAB8R@d ?GCGGAd ?;xj? SF?V?^6??pXiS@[ @@ ?/n?GCGGA:;R@V4h?GCGGAV4h?=/ ?@ z?Xזٸ?hې >ǓJrQ@ʡ @ "@46ZV<W?Blzv:?wzK?e@1P@( @Kr2?1*D?GTCGA+N@>S?TCCCC84?Ωո?kf(?ӒT)4?΋?R@9m @ޅ %?HPsr?TCGAG#Y#DR@=eh>xw?TCGAG=eh>xw?QT?G?e ??<A>gYS@= @t?~jtx?CGAGTckāS@~Ͼ?CCGATuD|d?ҏq?Alr?Ee?5z>J$AYR@St$ @Z@+eX?GAGTGç Q@ G?CCATC6_6?3?sԋ?*b?XQ?3PM@lV} @W?`Qڛ?GTGGAoƏN@dž?AGTAG ?ֈ{Py?H޺? /?6-}+? /R@hs @cR@<,?TGGAThQ@?TCGAA~?Rj90?uv}?0=A ? ew"?KS@  @h{ @o_?GGATG1C%S@«̣]?CGAAT|q?ym7?ua?%4?i?=B2Q@( @$@gs?GATGAGӑO@-9?GAATG?iFow?*FP.e?U?+&?b!|N@僞* @5q?ψ ?ATGAT*9 O@A9w?ATGATA9w?GXs?E~ ?+"'o?Uxu?{~FxQ@/ @HPQ@~jt?TGATA)R@O/C?TGATAO/C?(?|xf?ݞ?lݵ?C7d _?Xb)9O@9m4 @l?:? 0*?GATAT^v>O@[\ ?GATAT[\ ?8qÙ?8A ۟?sKCz{v?PD ?ϜCdP@Qs7 @=/?St$?ATATTpAP@Du?ATATTDu?x:?MI#k? 'u?0nϙ?:MO@? @D|>?Q?TATTC&tN@\P?TATTC\P? B}?z|^`?ϴTLF?&Td?XYI@C @Ff>? ^)˰?ATTCTUjI@g~j{j?ATTCTg~j{j?Jh%>BM-? x-B?TCAGA7??+I?y:F?jˌk?SK ?QoQ@Std @B- e@ψ ?CCACAvQ@F=1}.?CCACAF=1}.?!?7"?`?û|mM?ͻ)S@K7i @ !j8l?L=U?CACAGᶎYR@(lt?CACAG(lt?Avp>?\?j ?^vBz V??=u?EN@{ @B=?~jt?GTGAA-QN@a?GTGAGU?vC?60?vLć?Ul?JQ@- @lχ@-C6j?TGAAG_՘S@M͖j?TGAGA2ɇ?豔?+U?2?]&jMF?,iNS@9EGr @~z`@Mb?TGAAG/՘S@5?TGAGAoaN?y֜?X@o(?>?ç?>| nR@ڊ @MK? ^)ː?GAAGG93cR@CmM?GAAGGCmM?ތ*?h?B?5[ dM? R@ @W͒@/n?GAAGG"2cR@@yd?GAAGG@yd?v.?RY0^?ר?/ Q;?0P@ґ\ @A~d4?a4?AAGGCYQ@#i?AAGGC#i?̾?1?09V3a?BϏ`?WuP@sh @:bX\?_vO?AGGCT<,6P@XY=0?AGGCTXY=0?{oç?dGԳ?'I?Wf6?hG`S@io @]+?wOjM?GGCTAz#HQ@ @q@Aǘ?GCTACoSQ@gU$?GCTACgU$?ڕ>+7?g?ιg@b?ej ;?`t .P@H} @% ?:pΈ?CTACADsrP@<(NP?CTACA<(NP?Q??A2?[Zuc?`R%?tŇQ@ @fWFHW?Pkw?TACAGOJyQ@BG?TACAGBG?Ri'p?jZ??k%?kn Mۧ? t(pR@St$ @ݯ`zR@x $@%,4@y):?GAGAT3erZR@Z̅?GAGATZ̅?d9_dZf?Q?N?]( ?h-2%R@[ A@Xb@St$?AGATAR@@fO^?AGATA@fO^?B/K?UWwc?&?UnVW?Svz$O@@Y@H}?GATAA:l$]O@߀G?GATAA߀G?8fAvb?L?&\E?4zZ?ھ;Q@ ףp@zZB?Q|a2?ATAAAJbvIQ@3i?ATAAA3i?g?{Ú_?M HΛ?#я?(vbg4Q@ (@( [?_L?AAAGTgom R@3Nd?TAAAChI?{?d}Ұ ?i޺?Nı'?dZbP@ڬ\-@χɒu??AAGTCq8 P@WPHl˿?ACTGT`h?ŰN?rݤ?ҜB?[(6?ףpM*J@}a2U0@}U@-C6?AGTCG(J@늁i捳?TGTCA6~B?ЪJ/mb>. N?mv&0gQ?tB?E'P@3@}^ ?n?GTCGArpTN@x?GTCGAx?yé?)˺??R ?뛲t?闤ĀE)R@7[@@d<]? F%u?CGATT&R@C?7?CGATTC?7?h7u?&kà?8FĿ?>8+?WK@c]F@T @_vO?GATTC̐hL@q?GATTCq?sJ5@>R2E*?ܐL?]@'?mݞI@UR'I@}c;@gj+?ATTCT7CFjI@Lje?ATTCTLje?t/>1wU(Mb?@@p ?t? }eM@-O@bI?7[ A?TTCTGebkxN@gW?TTCTGgW?ͤXob?Mf?h*)-?;e?1o P@ψ`@<4%?q?TCTGAVrP@$6I2l?TCTGA$6I2l?NǑY?XJds?L$dĀ? uQ ?< P@/d@M*?ZӼ?CTGAAcO@ :?CTGAA :?dJ44?*iQ@`;?T2?'.`?jqg/T@wOj@ @Q?TGAATKjS@?TGAAT?}Q ?;D[?9˪i?e>^8LR@(m@yV@ǘ?GAATAg&R@T_u?GAATAT_u?*hs?76B:^?ڇ?^bk"yE?ŷN@sr@+)?<,Ԫ?AATAGA:O@y?AATAGy? *?l|?&Nr_?0! "?$gP@i|@RC?H?ATAGA 0 >Q@Ӱ?ATAGAӰ?h\?Jί?Axs1?@j9?İQ@l @`@H}}?TAGACrPQ@Cȫ-?TAGACCȫ-?~gIn?ۨd5?c,P'?yOp?gKuFR@x@7~?/n?AGACAt? ˓OQ@]C@Q̐2?F%u?GACAA7)#Q@^?GACAA^?l?{%%v?GR?5+m??kWR@~@ di? ^)ː?ACAAGtoR@sΩX m?ACAAGsΩX m?Txljn?Xal?!f\?] G.T?{oR@?W[@L?eu vR@o@\@ QI?GCGGT62}R@k9sA?GCGGTk9sA?EC!V? ?%}?p!?csP@&@ofWv@ψ ?CGGTCz,P@b?CGGTCb?H` r4?ܚ!$?|5?,;̥?P@H@ @Zd;O?CGGTCBP@op?CGGTCop?\1'P?+7ߤ?z5[?cbڍ?P@j+@8 #@Y5;N?CGGTC"vP@p ?CGGTCp ?#͵j?]"?j?ƻ"?XrQ@qΈ@@ ^)ː?CGGTCo/P@?CGGTC?*N?Ƌ$4? .a?4%?R}%M-L@&S@e>oa@b=y?GGTCA8ҍK@b 4?GGTCAb 4?E:=}T>hK?e ?j1?dM2aP@A@`@ Zd;?GTCATrD4(O@ɣ?GTCATɣ?qH?=[?&j԰? H?N@rP@?@ T@S!uq?GTCATL 6(O@@ ?GTCAT@ ?3H?HF?EeЪ?˭?EU P@_ @GV@`Q{?CATCG uN@?CATCG?KΪ6?qh?\]EX?\aP?[FP@V@C?y&1?ATCGGv!P@{H³?ATCGG{H³?ΰO#?)+?lc5U?dXu?QY|R@@ަ<5?-C6j?TCGGA)R@Fer(N?TCGGAFer(N?s>xA?Ęu?~?yW0?QP@6<@.X`7˔@-C6j?CGGAC',P@{x,T?CGGAC{x,T?Wt#?GFm 3?y*(ς/?7'?maÏR@jM@B?]K=?GGACA~}Er R@;e?>yJ ~?+$So!I@:pH@.5@46YqH@ǧa?CGTTCǧa? W={~ ?$?ts?]gxH@ cN@?gs?GTTCGu޸H@o]nQ?GTTCGo]nQ?ZM-A =]^>MuN_>ja?D5O@|S@4C@o_?TTCGAgwO@iկJ?TTCGAiկJ?챂{:?bEk{?ɹ)o?X[?e;O4P@fc]\@_@:v?TTCGA%[wO@t?TTCGAt?}Qu4#?|H7?" n?m4?OevR@?W[_@2?"u?TCGACp.9R@T?TCGACT?FXR@ea@:$T?( 0?CGACTΊQ@[?CGACT[?GmW?@+?hp?H.RE?Ut0R@ cZ@MMs@46 xC?2sR?o?n{I@a+@4A_?Aǘ?ATTCT")$jI@,`?ATTCT,`?,-b,=eB`?G} ?t?GnN@Z@@-/o?p_Q?TTCTG,+xN@/Zi?TTCTG/Zi?vP8?f?pUNn?E4^?ͱ[P@^F@4q,x?/n?TCTGCЭ{7P@]q?TCTGC]q?JrD?IτX?qS?t ?L@ܵ@s?k g?CTGCCz^+L@Ğ?CTGCCĞ?PWE{%?iNGy?nRһ?Vs?\ӄj3R@V@df ?/$?TGCCA/.Q@&?TGCCA&?Ͱ?R~^=?N-`]̵?vLb"a?cyQ@_L@>bu@p_Q?TGCCA< H.Q@\#?TGCCA\#?G? 7?pے?NjO-ͦ?7jR@ F%u@}t\s?Ǻv?GCCAGelR@gzXp?GCCAGgzXp?,p?{/*?`鉄K?X)Y?(1 RS@%@$4v?S!uq?CCAGAĺHMS@[8 –?CCAGA[8 –?7m ?F RO?'zw?{P| >[Q@u@+K?H}}?CAGAGe6Q@6a?CAGAG6a?ABچ?<?SA?y8k*I?aܯjS@jt@sc@HPsׂ?AGAGGGYS@8D?AGAAAo[B?ћ?hb?t-(Bm?GZ%>jR@ͪ@9z!?y):?GAGGG͝ţAR@#K?GAAAA>-?bj?pqN?7?$HRw?/Q@\@IP7@0*?AGGGCC=Q@9`_?GGACCAG?N3A?HOw?{(? J?mP@W2$@.WI?+eX?GGGCGhP@s8?AAACGn(Y?lTGCGA -?P@ >Iv0?d->)tv>:m^S@ʡE@^W|dB@+eX?GCGAT^4[0US@;pw?CCCATH?>(, ?UD\?t?rD谙>_pYR@H@7fgG?Y5;N?CGATT!2R@@ ~?GCATTD"?[tz?@%@?=l/l?DzX> ze[M@K4Q@x T\W@HP?GATTTkM@Fsb?CATTTE~DB+?،D?,g?^M@NST@`]@/n?GATTTQCM@ (?CATTT˭6$?AE>$[s?;j?kde?jMQI@JYf@Э&z?o?ATTTTbLI@V?Sb?ATTTC3?^/Ob=k}>H >9v?3eSH@4v@﬿n? ?TTTTC EC)9I@j?TTTTCj?{": =:C >WAdKR>x? =CH@E}@'[ ?mxz,C?TTTCC7H@<- ?TTTCC<- ? +ƙS=;m!0?]II+>i?j7DO@_L@)=%?`Qګ?TTCCTkGN@@I"?TTCCT@I"?*f^Z?D[b~(?5!&?04?.H9ZR@F%u@lu&?L7A`?TCCTTvQ@uU`?TCCTTuU`?Utۂ?l?K" ?lf^4?@ 8{|P@ F%u@iZ^?ec]?CCTTC}r!O@1i?CCTGTWx-)?h%?@kO?u6??Y?ijH@> ף@ Jמ`?H}?CTTCC}:LI@qN?CTTCCqN?$,=/?%Y>s~Q? " BO@NS@t -L?_vO?TTCCCcM|M@FR@T?CCCGGT?;&??8+m?*Q?IR@\ A@ڿ6 ?I +?CCGGCSøR@aJ?CCGGCaJ? a%?jH B?>)B{?c8 ?^wO@ @ƈO:?Zd;O?CGGCC5З})O@M,)X?CGGCCM,)X?g0B?:b?5CwP?=U7?5R@_v@a?A`"?GCCTTzl0,R@zC`.?GCCTTzC`.?*L?|?sn$? ^L?֘}"N@^K@`'cm@&u?CCTTT' 2EO@>iJ@/L@Vbt.=2?j+ݣ?TTTAC-vNK@bk?CTTTAT?w%m^>BPҳ?KVY?f @%?U$!P@*@ |?HPsג?TTACA"m7O@&?TTACA&?cJi?9$w?5]΍?^"?\U(R@J@B?a+e?TACAT,/Q@̫@H?TACAT̫@H?u)?-3)7?TKک?'z~B?&ҩR@?@5e?NSt$?ACATC^NR@3?ACATC3?N$?m?ͨ?V?xi+O@\m@k?2%䃞?CATCTo'N@O?CATCTO?nvm?X/O?9G?i?K~hM@V @ArC-|?F%u?ATCTCi{u>O@Iko ?ATCTCIko ?uAfR?:?J?|qBB?2O̽O@hDio@ǾwfX? o_Ή?ATCTCͺn v>O@־Y?ATCTC־Y?x&?v;?CTCTCvjP@'eP?CTCTC'eP?i5D?T ,? 8OgU?1͈ޠ?KkBfTO@d]F#@uG?S!uq?TCTCGvc]O@|+>?TCTCCq^?$Ű|I???s?)x9ON@9#*@ANJ?n?TCTCGٴO@hw?TCTCCt?+ds?#19Ƅ?XV?_}q?Q@q= C@ Dj|,=?ZӼ?TCGCTi phQ@ Ie?TCGCT Ie?溧O?" ?`?KV'?:i~2@R@ׁsF@*cz@?CGCTG R@?CGCTG?X^?S0+?%ϑ?Ias?k߰N@e`TR@qa}? ?CTGTA N@$yn?CTGTA$yn?Gni??4?S4՚?2EL@6Z@2uF?ŏ1w-!?TGTACm(L@0+sH?TGTAC0+sH?}`٣?!?/rT?;ob?h'_!Q@^@8\Б?/$?TACTCKpFx)rQ@)h{q?TACTC)h{q?f ?հM3-?xŻ?Isc/T?ULZO@:#J{c@jQ >?/nr?ACTCT@!O@M7?ACTCTM7?^'!ڳ?`?gU?@A*?XO2Q@T㥛d@_q9A0?}гY?CTCTTZP@OY?CTCTTOY?ɠ??L+?#l_JԼ? Z? rdO@.q@4'_>?C>٬?TCTTCHO@k:i_(?TCTTCk:i_(?No?I? ?tP? J@"u@ +@M O?CTTCAꐪ*I@X?CTTCAX?tccB>[E`Jw?w1?KLt?aQO@ʡ@x/ b?ŏ1w-!?TTCAGeWO@fN ?TTCAGfN ?IQ{i?6?J@F??zN?>[ݟ"P?- ?)+>?V&L@*ǚ@ۜ' ?T㥛 ?CTTGA (L@zS?CTTAG+*s?5NqH?UZ&?[p?P'LX?IP@f@%8?_Le?TTGAGkN@zº?TGGGG Wc?0N٤?_? ?Bơ?pQ zR@):@pz 0@ŏ1w-!?TGAGC0R@wGj?TGAGCwGj?Gs7?N"]?7%?x)Y? IP@_v@GTo?r?GAGCT,P@#IJ?GAGCGco/γ?zŴ?č2`T?(f?I Xv?5]kR@=R@˨io@q?AGCTG*x6R@nҺ@?AGCTGnҺ@?DbS?+My}?jg@?-7r?>"ڡQ@%@'j?I +?GCTGAڹ%_P@Bc\?GCTGABc\? ժNӰ?A4xi0p?8Xۢ?AAe?6i P@K7@f@_vOv?GCTGAt}8_P@g?GCTGAg?D\<'?f1r?q?@s?y&1?TGAAA$&\S@ Qe?TGAAA Qe?(y?u??Ϡь?P#K>9Q@V/@@ ^)ˀ?GAAAC|R@Ӗ[p?GAATA>}[ ,?y?)' ?Q/3{?G?fCnR@QI@8T ?_vO?GAAACc|R@Ӊς?GAAACӉς?o=^s?1x?z"d?dz~:? 0GR@vq @s!@_L?GAAAC|R@r}?GAAACr}?ųf?~?|C;R?X?[P`[O@W}@L? 0*?AAACC%DP@4im?AAACC4im?5EJ.?-Z?Ͼ?H0+?,dO@o@zw/?ׁsF?AACCA2pO@It(?AACCAIt(?!Qό}?LA?sD?-d?+t !O@僞@IC0??AACCA+YqO@?ŋw?AACCA?ŋw?vم-?5\v?$v?? Z0?HQ@8@$U;?HPsׂ?ACCAC\jOQ@;Keͻ?ACCAC;Keͻ?3?:X?<4D?t:-JHb?iLhOQ@ @  ?_L?CCACG\ѝ:Q@k{r?ACGCC9ϱlf?Md@? (w? *?? R@*@Z%>?"u?CACGGr 0R@xD?CACACMK?hLm? [H?w?e/)$R@ÆW @c`` ?y&1?GCCTTK{4,R@B:?GCCTTB:? |F?hȓ?cEܠ?y0?U&O@( @:IV@q?CCTTTJxO@(f$?CCTTT(f$?,d?u )LR?!Ti|?꫘q?tEY~J@@U7?@Ǩ?CTTTTTKI@<p?CTTTT<p?r=pV>/E??+?NMM0J@_vO@ kB?w-!l?TTTTT˥aI@j?TTTTTj?>=By3>ī>x?aqWJ@jo)@ke?"u?TTTTGUӅI@a3);6?TTTTGa3);6?u~6T=G9>I[T[a>[y(?ƒ_,5L@(-@4?~jt?TTTGTZKwK@_K]S?TTTGT_K]S?ou>\(i>W $`?>z?CN@4@1qc?I +?TTGTT+aN@{A?TTGTT{A?)+?bܠG˰>3Yp?bo?ZK@D6@a$Ӧ?/$?TGTTT@Ms|J@ZeI@?TGTTTZeI@?uN S>.v@?u1H?JJv?k dK@{,C<@ˁLti?_L?GTTTTa?jkI@V ?GTTTTV ? aw0>ޛg1?SW??P8?4 I@\>@G9_?HPs?TTTTTBgI@߇?TTTTT߇?G1RMp=.T7:>^>>ȿ՘?J@/LJ@ x?S!uq?TTTTGi/#I@mά?TTTTGmά?Իhi=BV>TھfHc>I"F?#!rEFK@ Q@œW?I +?TTTGTIx(R> C>4B?,d! M@St$W@$+U?mxz,C?TTGTTG<N@A?TTGTTA?m?>!?ADh^c?tK@|?5^@Av^@_vO?TGTTTy|J@xya?R"/lГ?pjU?sR6J@k `@1鯞?/$?TGTTTaFUz|J@QAHw?TGTTTQAHw?^4>NtNuUK?ʅ?n?T[I@)~k@6'l#?Mb?GTTTAMyI@Xa?GTTTAXa?mDTv=#nH}?;1y?Ψ.?6PJ@8m@:=Q@gs?TTTAGdZK@ѝ{J?TTTAGѝ{J?ԹUfo>R$?7aF?(:?LP@ݵ|p@Oa>@`Qk?TTAGAd0 Q@F A?TTAGAF A?1!}?vNq;?Qff?$7M? R@>W[q@*t?_vO~?TTAGA.̤ Q@H'?AGATABB8t2?hR@d]F@ߛW@J4?GAAGGLR@8ml?GAAGG8ml?N2T?  ?x^#?UG?g8rQ@\m@9vNz?r?AAGGGOI`Q@U¹?AAGGGU¹?_H?q/??f$r$?v_{R@lV}@46&d@Mb?AGGGG49R@>l=?AGGGCI]?)$+?!?D}K?f%IU/?Q@S'@P?0*?GGGGC)VR@iL?AGGGCQ6U?T"_?OH?C"\ֳ?v݂?h%A$Q@ͪϕ@*`J@NSt$?GGGCT vmP@ Ig?GGGCT Ig?+k%?sؖ?\T9?YD2?*&WR@fa@(e{@F%u?GGCTGn&R@æ?GGCTGæ?oZ?, ?G]?nIgRb?AAO@7¤@H=U?Ǻ?GCTGGoQuP@,?GCTGG,?(xJ$?漵:?tl?(z?Q\zWFP@l @Qon\?ׁsF?CTGGG lO@x>{?CTGGGx>{?փ&?AI @?wh"?2*?!Q@镲@2RM%?@ 0*?TGGGT σbQ@z{þ?TGGGTz{þ?o(XN?iL\ƣ ?(?>LGj?jWQgQ@H}@R.?r?GTCAAMF~/O@~u<>?TCCCT`?ٙUR(?i?CW{L?+Tep?N~|iZR@Ǻ@ ?Uد?TCAAC\NQ@0Π?CCCTCV^Q?iTl?L?8ҩ?h/W?ͱ(EP@z@d_;? ?CAACG}+H'VP@?CCTCG?ox?׳?~jt?CGCTGx>lER@Pt?CGCTGPt?Ěׅ?Y&?hP?w^$f?5GјP@+e@"@:v?GCTGGز@P@#C?GCTGG#C?fu?hp#?az.ե?Ӧ' ?_CP@\m@#W ?j+ݣ?GCTGG=L؇P@A(~:?GCTGGA(~:?Kt?@qxWQ? ?W?gO@(\@XʯG@Q?GCTGGr0\P@"s4 ?GCTGG"s4 ? @?-?Bþ?Cv:?-/4iO@p= @/d?aTR'?CTGGCބbO@(ew?CTGGC(ew?MtV?8)6?n|j?L :?s4WeO@ݓ'@>܊C?a+e?TGGCG`bO@"?TGGCG"?+Bi?{PGr?V19R@W2@GKNqA?{Gzt?GCGCGɐQ@A?GCGCGA?e*?(ń[??*^e?JS@4@8 ?Zd;O?CGCGCnKqw$S@-7R܂?CGCGC-7R܂?㾧?P-?RA(B+?op)w>qI9Q@ѳY9@tkI?ψ ?GCGCA*vK>Q@] ?GCGCA] ?ְ;?u}{?;.'?ij h?p=T@Q>@J0?-C6?CGCAA=ÄkS@AIg?AGAAA@?a+,?a`<?$?g;}S>>s+R@M FE@݇ r?ׁsF?GCAATPR@?GAAAT1Z4?ZJ?km>?G@do?୬T"S?7&# Q@ÆWJ@?Ǻ?CAATA(+Q@?AAATA6,?}_`'?Ovr?) ?Co?gnqO@zX5M@!>?I +?AATAA~UO@1"s?AATAA1"s?5L ?7HI֓?>q}?0'_v?igCQ@P@6{?faִ?ATAACğW':Q@zF6&?ATAACzF6&?կC>??ޒF?s1r?L kO@/d@BCx?_L?AACCC\aO@*`?AACCC*`?s?t4?|t5?jۦ?gfffoP@&†g@ꯇ?~jt?ACCCT*(/8Q@"<&a?ACCCT"<&a?}B/ÿ?B};Ȝ?P*~?1x׎?=R@!Acl@HS?:v?CCCTG [tlR@ ?CCCTG ?B?K:?dP&j?듅>ףp=P@o@"?{Gz?CCTGAceQ@+ۋ+?CCTGA+ۋ+?*u NG?)8Ö?i&?3!?FkM@8EGr@zab?J4?CTGACr[N@]q ?CTGAC]q ?9;lp?U9O?m7|3?Fʡ9?Uk8ibQ@Gz@G } ?_vO?TGACTNQ@`Ej?TGACGa2m?w"5?pM6p?/vh?)STp?P@Eio@i`I?-C6?GACTTnQ@gץ?GACGGZY?)sl>?'?F?O?x&aO@ $(~@^r0@_vO~?ACTTTB,O@y~uk?CGGTC%|i?]r8\?XEc?b "#=?|B] ?wJ@ c@~uc@ rh?TTTAGqK@p4\ot?TTTAGp4\ot?7E>en?C\'?AyC?.C0+Q@6<@&C#@b=y?TTAGT_Aa.Q@+')?TTAGT+')?I?A?U?S?IRL@"@sʙ.?gj+?AGTCCNO J@[?CTGTC==?n>\3H?H?n#x?4 ?WkuI@e@M8@w?GTCCAP۸YM@,:?TGTCG މ?r&P>Eަ?Bv጑? ?DK`R@ׁs@Xd?<,Ԛ?TCCAA$Q@2o?TCGATaL?)?U?b_)? 7?}@R@(@kso?0*?CCAAC R@L?1x/?CCAACL?1x/?1?I R?oR$*η? o1Ga?Gz_O@4333@&"i?H}?CAACC0/*P@˽??CAACC˽??]}{6?͢0?֠? @0?`8O@D@ ԡ?ψ ?AACCAg1O@Zt?AACCAZt?AB?B7?jRe=.?n?O-Q@S㥻@AzW!?:pΈ?ACCATQ@5?TACAT7D?4c9??vl?OC-=xi? @NɑR@J@?eX?CCATC)R@z ?CCATCz ?Dx?(?N of?x ^}1?mާeN@8@Nf?HP?CATCTU1N@*/?CATCT*/?̫?g遼?lQ]ծ?JՖ]?P@J@UÄ?_Lu?TCTAG.P@VG T?TCTAGVG T?5Q?,$?Z? Nͦ?0R@}гY@x vSu@H}m?CTAGC t] R@jS{?CTAGCjS{?7?ajy6?q\?ҙxo?:*P@ʡE@ E?vq -?TAGCTP@3<ӛ?TAGCT3<ӛ??} ͻ?7Cp??;&x02R@ׁs@+L?S㥛?AGCTGDYEN7R@V8?AGCTGV8?PL?ǍXy?x͖Ԡ?%s3C^?,#ftP@ڬ\@J;e` ?HPsׂ?GCTGT}ԵP@^^Y?CCTGT$'V?M M ?VD.?'o?'o0 ?>N@@P6?y):?CTGTCԄM@Xxpa?CTGTCXxpa?OPE>v8|a?V RnL?´?XJ@؁sF@^׸n?Q?TGTCTI@?TGTCT?ѸYƍE>75#O?Z6I?4 )?@iM@1@Eo8c?ŏ1w-!?GTCTG nFM@ؚV?GTCTGؚV?C$>?$Sϱ?M U? 2Lx?q~@SM@wO @{)a?HPsׂ?CTGCAp:L@UYx^?CTGCAUYx^?"?[?Yv^?R1?7Do.?r&S@ q @0V@F%u?TGCAA6fτR@\GD?TGCAA\GD?,?^˥?s?x>&eQ@@ 6?gs?CAATAYA<Q@YW?CAATAYW?KbU5?,v{ ?Ox?1"/+?$N@;pΈ@)Ed?j+?AATAC ['IN@xNʄ?AATACxNʄ?T\?㗽?6k\cZ?I>k ?rOdQ@T!@n`?3U0*?TACTTGFQ@al2?TACTTal2?VśDD?ey:?f?J_0@Mf?%^EO@ ^)@k&Ϻ}?a+e?ACTTGkUveO@ T!9?ACTTG T!9?bQ^?]Sm?^]=\?݀|ػ?;NL@46@h$?{Pk?CTTGAeJ4L@9L?CTTGA9L?BZB>ELxA?^뢧|?fN?FݾN@'1<@/=A?]K=?TTGAT#iڑN@u=P?TTGATu=P?& ?+.y@p?֩g\`?{W0? hQ@:#J{C@"LTK@]K=?TGATG;=D!R@E3P@`Q@BW4?+eX?GATGG+O@C-9?GATGGC-9?Kڰ?jsh?NH? x?9hN@?\@e?/n?ATGGTsKB^qO@O?ATGGTO?i܍pی?"#?IӞ_?ɉݝw?n)Q@{Ga@g?\ Ac̭?TGGTCP@Q,|?TGGTCQ,|?O#J?,*M?︽-? ոFi?H@ -p@@5;Nё?GGTCGu#0K@eb9?GGTCGeb9?Y2N=X/?i>6C~?]tEN@3t@X6I?8tO@NbXy@гe?ׁsF?GTGGT P fN@ܗl?GTCGT#Du:? RSv?nX?La?ًȶ?P@Bi~@ @/nr?TGGTAr0Q@@wN?CGGTASmT?GO=D?E|?By˺b?&?uL@ @r3 @+eX?GGTAG'AN@%ɳ?CGTAGE|*u6?>/>G0?;"U?=±E?'p_Q@ F%u@[ڨ3>@ o_Ή?GTAGThP@wJ?GTAGTwJ?"G?lP?(?ߧo1f?oQ@1殅@ 7d?ŏ1w-!?TAGTG SQ@|-?TAGTG|-?sl2N?S6?0?#0\g?!tP?产%VL@ @5?d`T?AGTGGi M@4Z?AGTGG4Z? q>~wTPO??t?w?'&M@6<@oBW?J4?GTGGTfJjN@Me?GTGGTMe?Ypl?x/d?!E??xD.P@p= @(؟?ͪզ?TGGTC_@ P@} jJ?TGGTC} jJ?v`)?_}?|'{?PjԱ@~?0<ׁJ@ F%u@oG@n?GGTCC.XJ@MFh]?GGTCCMFh]?b>bz>?Bxai?X$;i?`]K@ $(~@?`Qڋ?GGTCCXJ@I?:8io?w/R^?I$=EJ@FGr@T 5Q<]? p?i?^ ?kL@ޓ@ ,? 0*?GTCCAAYM@n[?GTCAG8*;?KZ{dy?U?@?DUw)?8EGR@-@u,H?Q?TCCAAHr-&?\9P@ۊe@b\-?&S?CATGAa~P@! ?CATGA! ?|VL`?SW+?J? ;?+XCb'P@n4@[h}?H?ATGAA|gTO@,zIƃ?ATGAA,zIƃ?'[vS:?gLK}?b$2?u?R@q@f@&S?TGAAGm0tS@b(?TGAAGb(??8)?e ?Oa?DW99R@;M @/)?HPsג?GAAGCe"PwS@Iq?GAAGCIq?cG$ P@?$@(i@y&1|?CGGTCI@P@^? ?CGGTC^? ?a"E?aSJLu?n#? ?sdzYzXI@0L &@Ɩ7@J4?GGTCAdHK@Yv?AGTCAx?ʈͣ9> W`Xr?Mu=j#?P@Z?lsR@U.@N (?H}}?TCATA(?NSt$?ATAGCnQQ@rn?ATAACh?o\?[d>pع?O }? W?Hz_P@kt8@*`=!?-C6?TAGCCG]'ʴuP@G~?TAGCCG~?W39@?U$Y?\q0? yKN?{;Q@Q;@h@v?Mb?AGCCG Q@su?AGCCCGڱW?ؑ|?j?Rek75?`t?FeQ@\@V|?wy&? 6S@:a@sc<@v?CCGTT*,R@9P?CCGTT9P?j%?GF>^N?1LtFf?1?AR?H@S'p@IeT#?HP?CGTTGvheI@]7?!?CGTTG]7?!?M=!Aa>a>BǢ&?~ǗJ@V0*s@Vo?_L?GTTGTP~y/K@c>?GTTGTc>?i=(K61?\ٸ@?p:#?(N@HPx@zY?-C6j?TTGTTT>y(fN@uJ?TTGTTuJ?EE/?[qYd ?Rh?nx;?XKYK@p_y@Ь&@b2U0*s?TGTTC|I@4`?TGTTC4`?Dݓ|_>'Ldƽ6??Is?h?(SK@v{@Z@/n?TGTTCk I@׈eY?TGTTC׈eY?'5>," WQg?@?*??[2Q)H@QI}@ɲC?ZӼ?GTTCTTH@c] A?GTTCTc] A?݁z=>u>ê?G_M@D@2==\@ψ ?TTCTC;N@9?TTCTC9?H%,f]2?u?R;##?86#[:?ktcO@1殅@N'-)?Mb?TCTCT= O@me?TCTCTme?L\m?*{^Yt?xSpe4?ncy?B݈P@r @ND ?(?CTCTTdg2P@mFft_?CTCTTmFft_?S<,F[h?CX]W?,žeW?Qv $?H P@Z@ "QC"?( 0?TCTTCu­FO@W ?TCTTCW ?q3x)?I`NAq?#灹Hl?.՘ Y?,!I@ @A?T㥛 ?CTTCT؃iI@{ϺĄ?CTTCT{ϺĄ?͛?P=[>wPw">Me?ؒsΏM@y)@+e @l?TTCTGD8yN@Q?TTCTGQ?j?enT?'\ĝ ?2D/?@Oh_P@w@h?faִ?TCTGCL D8P@]\?TCTGC]\?g?4m~{?^L;4?6#?ԂʍM@=y@ ? rh?CTGCGֆw`L@?CTGCG?Hm`>aZ^$?psd?,&?c hQ@Z@Yj&q@ˡE?TGCGCּVnR@ ?TGCGC ?,?:G-?;ʈ?6Z `?qýQ@`TR@pzU?( 0?GCGCGM2S@&䃞 @` ?/$?CGCGGS@|K~?CGCGG|K~?*?eF?LPڅ?ƒ^a#>WXQ@]m@_?gs?GCGGC 1R@I?GCGGCI?z,戵?Ɩ[3?ec?מ :J?^oR@s@')@F%u?GCGGC(R@I?GCGGCI?E?/v?*}2? ?E?bY O@+@, F?`Qڋ?CGGCAJq`O@;42?CGGCA;42?|&Q?R/]N?:?+c?l!hT@lטm#T@!@>;5@_vO?GGCATS@9|^?GGCAT9|^?6?(B5h?]]?B>\R@s7@vh=6e@?W[?GCATC-R@=!}1?GCATC=!}1?P|ʭ?j?V,x˴?}[?@ֲN@??@|L9?n?CATCG?N@vV?ATGAC?)j?C)?8m6? ơ\?Y~?NޣQ@TD@l?]m{?ATCGC!P@.L/F?TCGCC!ҳ?Y>X?fG)?uS?z ?FpQ@St$W@U2? F%u?TCGCC4.Q@qI?ACGCCfjm`?^ ^]?ݽ?qm?3r0&?3+{6R@2%d@#br?/$?CGCCAkQR@xN?CGCCAxN?q<?(Ƥ?iK?\ŹOH? R@joi@gE6?,?IK?LR@{@XBE[?ʡE?CCATAZ{R@?CCATA?&<3?tJȷ?Qy?7[ʊNA?0b{P@ͪ@/v?ZӼ?CATAG jP@{ʔ4U?CATAG{ʔ4U?SI?3b ?>?_Bؐ?GqQ@8EG@y/N?0*?TAGAA8CR@im?TAGAAim?Is*?eO?A͠?_?dMk7T@<]0vS@잜@QϜ@ŏ1w-!o?GAAGAƙS@pO?GAAGApO?K?nL?NsIϿ? >]v"Q@2%@;%D@?<,Ԛ?AAGAT${Q@+C?AAGAT+C?h;?-Zm?0<E?Ǭ2?6wDS@@@Q e?Pkw?AGATTԭ>S@?<.?AGATT?<.?I?zx??Lj?ع?׊>(oXeS@h@õF\D@mxz,C?AGATTq?S@a?AGATTa?6s?Bc.?+~7?iVV>ZBO@4@->?+eX?GATTC\tnL@Z3kM?GATTCZ3kM?qM?g?kyڮ?6YZ?uկL~I@HP@m7?:pΈ?ATTCAw1I@fdq3?ATTCAfdq3?=[>Ұr?,C`P?,N@( @):Ef?{?TTCAT )O@@yS׶?TTCAT@yS׶?^5c?eb??o__?Wj?KA1R@gfff@Y=BI? ?TCATCr'DR@|Ĝs?TCATC|Ĝs?s\Ȫ?qYdb?lVB,?O\EL?E%O@ÆW@q#?jM?CATCGӛ.N@ၘe?CATCGၘe?7M$7?I?L?,ɢ? $?>|P@x-!@>?ŏ1w-!?ATCGG{b!P@w?ATCGGw?|Ξ׾?|do`?m(>o2??R@^F@l/?:v?TCGGC&!*- R@C?TCGGCC?+ey?)e"?l8? 姼P?*%?P@z6@~:H+?_Lu?CGGCAU,O@Uܾ?CGGCAUܾ? "#u?(K]sp?B v?mͯ?G]:êR@@{@I +?GGCAC‡S@Nd?GGCACNd?s%?7?&F?[~/@?O~Q@B`@Zk4#? F%u?GCACG!*Q@y0ճ?GCACGy0ճ?\*P? H?5i5?lں?L,MP@Z@ygP@"u?CACGA04FR@+'ܠ?CTCGA`t?4? %?E?Hd)M ?:m,OR@G@ "-u? rh?ACGAAR@7 ?TCGAA0?7_IQ?A'?:t?G5?3cVS@O@a#@'l_y?$J{/L?CGAAG3NS@jN ?CGAAGjN ?xCb?.E?iH?SY' >'uR@FGrO@q^5?z6>W?GAAGA։S@Q'?GAAGAQ'?<jq?q[?#s.Z-?45?e S@]@ad\Ŏ?St$?GAAGAS@/6?GAAGA/6?P?̍\???ҍ>M?T$Q@ea@&?/n?AAGATfQ@SǼ /(?AAGAA=7x?|0ه? Q8*9?}>?_G?C0t>0S@gffff@Rw?M O?AGATG(kR@tW?AGAACGo?(w'ݳ?Q ͸?_i ֧??-6S>P@):k@?&^?"u?GATGTFQO@}\?GATGT}\?Ei? O?~X%?}) ?'gHN@d`t@5e{?gj+?ATGTC&T;M@(ms_?ATGTC(ms_?-%?mu?Y?ո?^I@}?5^z@)!@/n?TGTCAϵ2yI@Nb v?CTTCAX:6 ??AC> @?BѴQ?n)R?XwM1P@|@HPP?<,Ԛ?GTCAA}D0O@"'n?TTCAA }c?[-X*ˏ?p,/+?:z?4&su?S%R@7[@4 ?Mb?TCAATAʍ4R@(.8?TCAAT(.8?2w? #?.x?"|P$"?#lCHQ@ h@}r2@&S?CAATAQ@FL?CAATAFL?ф,?,bZ>W?Y&?QlK?2fN@_)@S{?<,?AATAGF;?f?,2?Q&`b&/?;WRK@ͪ@Jl#?ǘ?GTTGC(]ZWxJ@'Q?GTTGC'Q?~70>=>c?†# ǻ?j?N(2HL@j+@$TV?!rh?TTGCCAwK@q?TTGCCq?6Ses;>BC?a4?@||?rZQ@[Ӽ@>!d@/$?TGCCAL†/Q@ aY?TGCCA aY?t"o9%e?ҏH?"=T?~`0K?shM,R@\C@"x?Mb?GCCAGノmR@UC\Ҽ?GCCAGUC\Ҽ?K?0}D?5Һ?xEg>vnS@HP@a?L7A`?CCAGTEGES@==SWk?CCAGT==SWk?|C?tP?Cڰb?iM)>>^MP@zX5@ Ax@ǘ?CAGTAA \Q@W?CAGTAW?OjV?9VP?iAӃ?gW̰?OK@>W[@^?ŏ1w-!?AGTAA'8M@ʾv?AGTAAʾv?ATf?Sx=,Pq?֍??*F~? biP@x#@j ?_vO?GTAAT9 Q@zf°?GTAATzf°?Y"!K?= ?:{h1?P?LQ@Dl@v&?J4?TAATTTM%Q@XD}?TAATTXD}?m A?ݢ??mG?~ϴOL@io@)@b2U0*?AATTCkm3_L@Bem?AATTCBem?!+X>^56?) o;b?ɢ?ՒI@V@7?Ǻ?ATTCA I@hU]k?ATTCT=;{?0PDfI>ƃ ? `?N=?N4FM@@b?a+ey?TTCACV4 O@|?TTCTA%4q?)CO?m&??}/♲?"-Q@>yX@qOi?8d`?TCACC"0Q@`?TGACG9D;??{C%?S'?n2?;P@@s0Qi?gs?CACCTƫQ@s}8R?TCTAG(P3?AԛWo?l8p?R/&D?m3?Q@g*@pj?a+e?ACCTG7WD܎Q@*t?ACCTG*t?A?gx)?6M(?gQ?;}Q@r -@~߱@(?CCTGAP$Q@3ַ?CCTGA3ַ?,н?8]g襸?b?O:Km?:mͥN@Z3@z,@J4?CTGATˠ>O@< {p?CTGAT< {p?{?9@Ǽ?RA???;Uz$Q@$5@OM@Y5;N?TGATCYfR@ǜv0?TGATCǜv0?S?(Ő4?-L?R)~?# %O@x $(>@31& @_vO~?GATCA{i.M@V?GATCAV?jyy?y8?W?/?:uSL@vq @@G@?GATCA޹#.M@sוv?GGTCA~ON? f ?*Ir?w=d ?I>8?hk^ O@&SC@C@+?ATCAT{ZP@Gwņ?GTCAT G?RWyC׶?Fn ?x ?FS?R@:M@.erGf?:v?TCATACyk`q?_P@fa@L@J4?GTCGC܋rȱN@i*<(?GTCGCi*<(?hc5#?KGl\?`M;p?_o?|)fvQ@l@(^d? 0*?TCGCTݫ*B iQ@R N?TCGCTR N?"aU?¼b\?jK?t/6? MS@:@L#a?y&1?CGCTT;F!R@ǯZ?CGCTTǯZ?<]w?gz&B?~?p>;}cP@Ș@=??ܵ|?GCTTTߞxO@M>dj]?GCTTTM>dj]?m\`? WgTr?TX.R?gg]?9D^@I@Ԙ@A;e?6;Nё?CTTTCg]II@\??CTTTC\??w6a=j>|ڻ>8!8?&yȎ$I@՚@+k?ZӼ?TTTCG۾QI@]?TTTCG]?єAJ=QO>J<>A?%/O8P@ c@6-"?Pkw?TTCGG@qT8O@~:?TTCGG~:?[3P?Z ?PSO?1{Nn?T*ξz(R@잼@H?~jtx?TCGGGn=%R@(3?TCGGG(3?8"/S?88o?^?pǷ?yF{P@x $(@ 4 @`Qk?CGGGGߋ axP@|HAe?CGGGG|HAe?`hӪ?%R& #?o%?e[ָ?47Q@G@E,qq?HPsׂ?GGGGCsR@`Zi?GGGGC`Zi??b?"N?P.AmWc?Q~5Q@fa@ɿQ@-C6z?GGGCTUP@XZ5ُy?GGGCTXZ5ُy?"ѲƤ?2y?yQ?5]ղ,?KlR@&S@{@I +?GGCTT ES@I`?GGCTTI`?T&c7?8Vl?V6+?> S *H?}pDYN@Z8@mӠ @mxz,C?GCTTT}'t!O@h_?GCTTTh_?Ǟi?rWNiU??}5 hD?_-I@ ^@يļ?58EGr?CTTTCeשeII@|T?CTTTC|T?t8">Z/? 6? KWh?y;8=K@B`@9 9@ŏ1w-!?CTTTCziII@Kb~&?GGTTC$?/XV?a>"rb^?;W?#sp?woH@7@^g? qh?TTTCAޡ \]I@Lc?TTTCALc?GN|`=V5)?V >Y?@LO@O@(BR@H}?TTCATcFoO@o%z-k?TTCATo%z-k?TZ?e?Fjd? VމW^)?Kb3&Q@8gD @`]d?o_?TCATT! QR@/?TCATT/?{#?#?a"I?&)F?abM@;N@c:@<,Ԫ?CATTCHNM@:rj=?CATTC:rj=? Χ>g$лL[?un}Q?Y"aQ?;OH@Zd;@x?Mbp?ATTCCs[I@mʨ?ATTCCmʨ?Ϣ[YCV=\:3>!> XJ?E%u"O@L7A @~ @{Gzt?TTCCGkVkM@?TTCCG?3meJ?jXt?CwE?]I)?4J8R@K7!@2y> ?^K=?TCCGC9Q@p[?TCCGCp[?16ka?SQx?hCq?0LwC2?EQ@V,@dR)?Y5;N?CCGCT\L/Q@8pew?CCGCT8pew?$8?I}o?R?:w?þWR@F4@ݘ@o_?CGCTCδ]̣R@ktx?CGCTCktx?+:FP(?ܚa??n~!AxQ?& N@ڊ=@.k8?S!uq?GCTCAP@e?GATAAlefG?,#ޙ?tzm?J'?U?m/?~Q@k @@q5*?a+e?CTCAAƤg1gQ@l#Ф$?TACAAJR݅*A?g=wV?'K?>+? An?c`R@`TRG@o?ׁsF?TCAAA!$bCOR@:dr?ACAAAB:Ƶ?<27?S!?_Vx?iu7?M4Q@!AcL@z-:B?UN@?CAAATΠQ@va\?CAAATva\? JZ?"xHd?m8?Oؗ?Ap"P@K4Q@!b?jM?AAATGyh2Q@;>Ɇt?AAATG;>Ɇt?f?c?e?wcWa?s-SL@~Z@%]?+eX?ATGCAk/L@q?ATGCAq?Q7?:w??-?t1:‘S@-Ԛ]@d.s@ ^)ˀ?TGCAAM66)R@@?TGCAA@?)Ahz?-?fjȸ?$v"H>T2φS@`@t؃?UN@?GCAATR@??GCAAT??50֏/? ?l$a?7*?Q@ hb@b..?a+e?CAATCo|EQ@|=m ?CAATC|=m ?(?ڥˌ?@'Zw?nI?̬-L@wo@I/R2@-C6j?AATCG*DL@Sm?AATCGSm?ek:$?U`?bzwT?LF? ף4P@Vo@B(?b2U0*?ATCGGV!P@?ATCGG??n[Qi?7/?Gɒ?0NiQ@|ar@fA?r?TCGGC#b R@T69?TCGGCT69?9?? ?Svw?/$nP@io@.Z[ ? QI?CGGCT>yO@9?CGGCT9?x^?ysc?q^?_R5?? Q@aӋ@+Ie @a+ey?GGCTT S@f3B?GGCTTf3B?t18? ?V ?$m.G~?W N@Pj@,gT@a+ey?GCTTTdkTBO@>:?GCTTT>:?wx>و R?QRV?]ߥz?7H)I@h@3 C?Ǻ?CTTTT)RnzHI@|8y?CTTTT|8y?՛<>\xo>8?;HwEaI@h"lx@z*>?镲 ?TTTTCdt%:I@k?TTTTTx_?&pM= >9 f[>o=?bL/!XI@R@Dw?J4?TTTCT3& BI@Kb?TTTCTKb?EX4d=Iw> :Ə=G?䒉L@U@|Q(??TTCTG+p6rzN@/&<=?TTCTG/&<=?r9\ 1?2r? TIw?N?lBP@> ף@YLu?H}?TCTGAP1{ȡP@?TCTGA? [?N# ?3hc?*o?_lN@NS@o?gs?CTGAC-\N@ lE=.?CTGAC lE=.?X?#ÐU?N(?bg~?mee#P@p= @J#?mxz,C?TGACG !gVP@0?TGACG0?Z ?C:?s?T?#N@<,Ԛ?GCAGCAS@C~\?GCAGCC~\?J@M|v?U|?jQf?>K9P@~j@•9?R!u?CAGCGt31P@G ̌?CAGCGG ̌? \ ?m.lѸ?Ay[?X\5?bVR@1@֫^1?"u?AGCGTOR@֤,?AGCGT֤,?`+Ɉ?}#???E혾4>xe}FR@0@+ߔr@I +?GCGTC2ƽQ@/ 3?GCGTC/ 3?\ze?{Tliu?p?T?$?ʡE}H@Pj@5pj@*jZw>?.aN@@sٯ@ˡE?GTCGGEE`N@peO?GTCGGpeO?%L?]?n>?؄8%$?U"ﻖO@ܵ@SnaO@$@BJ9m@q?GCTCTh|O@co?GCTCTco?aC4?ix-?)e ?H!4?oc"i?Z&Q? R P@- @A}?gj+?TCTCG0O@%o*?TCTCG%o*?c0xT3?(,?*??G7?1RQ@Ǻ&@(_6ZL?QI&?GGCTG,R@=}m*?GGCTG=}m*?(?l,m?ލ^w?0?0)xQ@Qkw\@-@Ǻ?GCTGAP@6pܶ?GCTGA6pܶ?sV,{?R?M4C?]3j?pƎ[O@=U_@M\=s?w-!l?CTGAA-O@ʏV?CTGAAʏV?iD3?JdT?l?k,?(\S@Lj@\\g @w?TGAATʍ1kS@nB%Q~Q@&1l@^=7K@H}m?GAATAt'R@dz?GAATAdz?}S@V-@1&?:v?CGCGA&!)IR@$@dH}?&u?GCGAG]7xS@tm?GCGAGtm?\ HO?,Jd2??I>6;S@^K@b?L=U?CGAGCҾ:S@ F?CGAGC F?.$X$?|?OS F?|v>d^*Q@/ݤ@tr@X?GAGCG3L lP@%F?GAGCAM٬? ѵ (?7HP?1-W?9Qb?S@,ݳ@n!Zr? ^)ː?AGCGCbR@hK?AGCACVm?]?[1?yֳ?pkf4?>{^bQ@Mb@O)t@gs?GCGCC3dQ@ↀ?GCGCCↀ?p"x?ky㦓?:?LB?|nZxR@H}@+P&?A??c`R@?@ n?Zd;O?CTAAGTg]R@GV/?CTAAGGV/?It?oKb?eQ ?`?а+hR@ݓ@>(?~jt?TAAGT ,R@ qq?TAAGT qq?%~?a ?y;?,{ ?޻P@&u@#H@Q?AAGTG<:P@ >W?AAGTG >W?` e6?v0q6?0?(q=?fGK@H@>,kQ?ZӼ?AGTGGGqM@?AGTGG?OYb>Z_w.p?V??K?JVM@g@6C?/n?GTGGGSq`bN@a?GTGGGa?6/]i?U2$b?q̅]?E?~Q@j+@?{Gz?TGGGTլQ@/re?TGGGT/re?YنLf?gZ?׃,?kme?-_˙Q@9#J@EW@q?TGGGTJQ@P[?TGGGTP[?{L? ?N^z?DR?֪@TQ@H@0՜R@Pkw?TGGGToQ@qM?TGGGTqM? ?y4?vef?pέ?Q@;M @[@T㥛 ?GGGTCgxYQ@ɲI?GGGTCɲI? *H?>nZ~?tǨy?8=?Md~PnH@@XK^??ܵ|?GGTCCME0YJ@if?GGTCCif?̲ W >D#@@?^K?@x?贁,N@R!.@^?b2U0*c?GTCCGpU9M@]p"?GTCCG]p"?OZe#ܰ?#͈?>?L H?FR@@߾.@`? o_Ι?TCCGC+Q@C1%?TCCGCC1%??ey?>d ?u?9hى"R@|a25@*s?&u?CCGCC;Q@)Jh?CCGCC)Jh?q׮ ?F!? Ƴk?"#?QtBؑQ@#<@xD?oŏ?CGCCT#jR@v?CGCCTv?W?Ѷ]D?#Iι?KV9O? -4R@HN@k5? 0*?GCCTGpR@rU?GCCTGrU?_:F'?T\Q?[/+?Nm?4QQ@6;NQ@u+@$y?_L?CCTGAQgQ@ոϖy?CCTGAոϖy?E?:b+̳?'?N >?%P@S@"m?y):?CTGAA 'eO@E>?CTGAAE>?EQ?rdA?3k8^@?c?%?mS@JYX@2a@~jt?TGAAT`p(S@IB [?TGAATIB [?dTsiݵ??lч?#+md?"BɪB>9xa_Q@ǘ[@06@_vOv?GAATGv#)R@l?GAATGl?DŽ^?-4xICP?n)9?]?c O@٬\@.BE@&u?AATGTILN@ΫL-?AATGTΫL-?s09GR?$luu?S'HS?'[?)DM@iod@0+ӯ? q?ATGTTvZ}N@\]&"?ATGTT\]&"?F2;E>$$??R}?ؙ?` K@8EGr@E^?n?TGTTGJVJ@]j?TGTTG]j?L0)>zL>=?Ȱa}?0W?* 3J@pt@˦ڡk?UN@?GTTGG)J@R?GTTGGR? p<>Z?%^+q?^ܟ2? YM@y@)%)?aTR'?TTGGA}еN@xH?TTGGAxH?6! pb?q˙?ᦒ l?*y ?ؔBQ@9#@|D+m?Ǻ?TGGAG̀!5Q@Ζ?TGGAGΖ?gJf{$?i>I? ?i":?ų1erT@:@º@c@H}?GGAGT {T@,?GGAGT,??1?R{iX?L֥V>:@4R@{@C,@Ǻf?GAGTAT)lQ@ݰ?GAGTAݰ?`?C5ϬMI?;}U?)?['?鐜SN@!rh@)z@V-?AGTATr[[M@dN?AGTATdN?D"K?8LՀ?+&$?-,{7? MM@Ԙ@_{&sm?/n?AGTATkޘ\M@]?AGTAT]?AY\Q?%?.K?S(?eJ/:?LF_P@ lV@ .kw?y):?GTATA DP@hr ?GTATAhr ?E3K?Bq?d'?uX᾵?gO@e@h? 0*?TATAC+SP@l.v?TCTCCEV5?#I1g7? ^)ˠ?TACGA5ЍQ@\`X¡?CCGCAs?J%]?~FJ?Ng2?l5?ȃ(MR@fX@uB.:2?HPsג?ACGAACu3R@W ?ACGAGFmb?G.?C^|?S?Ou04?gE#S@߾@u b? o_Ή?CGAAAV\S@m+t?CGCAA3h? \>5?7A?M?m,>nJ&MR@H@v? ^)ː?GAAAT=|7 R@a~m?GAGGTש"?-?Y?/d ?H{e.?J%Q@:#J{@Yٸ}?y&1|?AAATCy\Q@ݾ3?CAATC hֻ?3_y?ly?͏ЭR?30?ۨ*L@M F@T?@n?AATCCzf\L@ipȉ?AATCCipȉ? E?)?-6 ?kc?Cr=P@M O@ r?Mb`?ATCCGʮjN@C@?TCTCAD?q޾?gy0?e:O3?+/|I?×R@@nQM@q?TCCGT*XQ@AͲȫ?CTCAGvα?nsI?5Z?c??n:?.? R@|@Ӗ@? ?uoc?mXNK*?Jp@R@`vO@&f@<,Ԛ?CCGTCVQ@n?CCGTCn?= ?TN??S&zAWC?aS@k+@^>M@gj+?CCGTCM5Q@QF?CCGTCQF?6(?YV"\?ᇟ}i ?2>Dw%G@%@XIkx!@L=U?CGTCG 4H@!vs?CGTCG!vs?zj^= 8Z>_Aw>`?( O@gj@0W({@_vO?GTCGCZN@KW?GTCGCKW?z?8Ȧ?# ?B7A~?wM.rQ@]m@R?HPsג?TCGCCRS/Q@$H?TCGCC$H?h 6?o\@?)z*J?a^qs?BʎQ@3@8s?}? ?CGCCGuR@,e",?CGCCG,e",?ʆ4 ??(@?V |?P;R@K7 @xɸ?HP?GCCGCt(1mR@)v?GCCGC)v?tf?칁?f۝?*ќ?΅6Q@V @ ~?~jt?CCGCC?Q@R?CCGCCR?/88?Xk?,?<-Zύ?y@̀Q@9gDi@Htc?ZӼ?CGCCGj=R@U(?CGCCGU(?\?ہPR?L? ?; ?βgR@mV}@v>?q?GCCGCsQmR@9BIȴ?CACGCWqC??nP?nZ.?il? ?t Q@V@WX?S㥛?CCGCCƥQ@=˗1?CCGCC=˗1?1D?hF?@/ ?g,$m?+)OQ@Tt$@Y?Zg׼?ACGCCĊټm?,ƒ?գH?@`-e?*ֽ?#R@e!@-D?UN@?CGCCG`;R@`?CGCCG`?!>A?6?-ɰ?IT4pA?.J2&Q@( &@K?P@,CK@U;?ׁsF?ACCGG͞UnQ@$g?ACCGG$g?ӗ#?k>?O$(7?|?grm&>S@|?U@ J2?ψ ?CCGGT R@Zo?CGCTG{ln$?Ko?7++?ۅY3? ֎?@qP@F%uZ@'@b2U0*?CGGTGujP@.n?CATGT?fv=y?ihg1?Ye]Y?d0 ?&N@\^@ #x?ZӼ?GGTGC1sRN@Ÿ?ATGTCnr+?E gN?x?eBF?,?bɯJ@(\b@#B/?L=U?GTGCC_K@a8ZC?GTGCCa8ZC?Kc?a?ps, ?s*?0[?\tYlP@z):r@k _??TGCCC/G<5P@ZR?TGCCCZR?gL?}`#a?NXof?)?+RlQ@G@Ϩ>?q?GCCCG 0[Q@41FGƊ?GCCCG41FGƊ? $I*??n?H|[?zTS@&S@D?tF_?CCCGAlPA2R@=Ʈ?CCCGA=Ʈ?;)\-R@Zd@3-??D>?gKusR@&S@*?/nr?AGCGGTo|dR@V*c?AGCGGV*c?L-Y3?5G??!.;?򻙺R@ׁs@l?HPs?GCGGAkR@P:Z?CCAGC7/$?"H0|?,8/?ɶo?ɧpvq?MTS@V-@B8rc?0*?GCGGAl{JR@TbIf?CCAGCV\?<~s?=?cV?;@@y?P@Qkw@sG?_Lu?CGGACB(P@?CGGAC?b?P=(%;z?'1?N?2LR@Bc̽@2,@`Q{?GGACC7_Q@>!3?GGACC>!3?d]?S? o5v|?UhW?TW[P@ @1z8u.?N@aã?GACCC2P@[*~?CAACG]\?TFy?ӗ2?_5~?Lv?)7HP@k@RW8?UN@?ACCCAkR@Q@g?CTGAASj?w;F;?U%t?A?:b6? ZQS@a@O6+ @vq -?CCCAA<.S@7|1?CCCAA7|1?`?tj[?^~'G?As*>^z3R@[d;@+pآ@ǘ?CCAACFqeFoR@ t?CCAAC t?Ədro?h?Ѥ?b/?C'i?P@J@8ŋ?5ۛjP@@ H iQ#? 0*?AACTGkUDP@e뎾?AACTGe뎾?B?Ce&?!' [?v܇GpnGy??vh#A?JWh?4z.L@6@HES?@Ǩ?GTTAC)$BK@exH?GTTAG 3?eXx ?c%+?(t?m#L? XP@x $@)f? G {?Sÿ?u+|XO@Qs7@CՒ"?<,Ԛ?TCTCAե0O@6f K?TCTCCxE?ĊW?H~ֻW?~ ? _-?xr:P@V/;@1U?M O?CTCAG`QQ@aV?CTCAGaV?#B ?BP?I&?< T?\6R@ݓE@54?ʡE?TCAGCutR@ov_?CCCTCREe'?Y#о?FH.9?;R./?X?'?YLP@c=Y@3o?UN@?CAGCTRyRP@yBc1q?CCTCG!$?s_?[69?g+ב?n?#,yQ@S[@rvx1@F%u{?AGCTC`y4R@q?AGCTCq?ar?) \?g?\?̭N@ lV]@I?<,Ԛ?GCTCG6P@@'3?GCTCG@'3? l?l-,)?zȣ ? d?QֻR@+d@n/&Z?aTR'?TCGGTGR@m,o?TCGGTm,o?F_%?G , ?7'}?/;?atP@}гYu@Qq?@_L?CGGTTi3vP@=̽?CGGTG0v3?{#H?X:݉{?>]Z+d?L3?MbbO@^Fx@u$ ?Q?CGGTT,vP@#{'ż?CGGTT#{'ż?UC)q?Zk ?D?޼+x?P@Q{@O@d`T?CGGTT54vP@b>cYN?TGGTT/{U"?d. ?[9ߣ?cК? ƀ?4 N@o@ॶ@y&1?GGTTT1nüL@9j}?GGTTT9j}?E]ZR?R)r?-jy?Mh7?VzgJ@&u@qYk?ŏ1w-!o?GTTTC\H@2ݯA?TGTTC}np?{YTd.">9I?Э?xh?gqH@ @ַ @\?(?TTTCT/fBI@S)?TTTCTS)? =I$?\{L>`?Gb1N@i|@O1j?Mb?TTCTG)C{N@~p`[?TTCTG~p`[?݀Q?)?%j ~?U%P?y5˘P@%@kx? o_Ή?TCTGCe8P@ '?TCTGC '?s3]PV?;yL?F|? ?=M@AϦ@ž|?/n?CTGCA=ДL@Er#̭?CTGCGW{_?g?}[9оio?3ֈ+.?MF Β?L-lFR@Hr@yk@Aǘ?TGCAG8R@BPh?TGCAGBPh?W.%9?gWQ?Zj?Cwo;?JS@@߾@t~?0*?GCAGCZAS@r?GCAGCr?&;'?\zW?[ ??2.fT?+uY:Q@J@rȻ?"u?CAGCGV׃P@y?GCGCCe?eԥT'?r\o?L?+*zt ?V/R@KY8@>#{?Aǘ?AGCGC]R@?GCGCGE\(?e8l?쳨?w*@Y?cjO?WRJS@Dl@ ;G$?@ǘ?AGCGCHR@Hu?CGCGCgG?l?ɋ=+?t?CN?433Q@+e@I"?-C6?GCGCA6}qQ@nJϰ?AGCCAd`$?K [^?)B?*8?& +a?2R@8A`@bA?b2U0*?CGCAG&卩@S@"N%|?GCCAG%U?j?7x?e7?Q >ԒS@MJ@Lه? ^)ˀ?GCAGTsylS@ - r?CCAGTqGo:?]?iɢ?e@Nt>?eIܡ>!CeQ@!Ac@uj?H}}?CAGTG4R;YQ@×'?CAGTG×'?զ8?VdeZng?#SS?Z|Jq?OL@5;@Gt?HP?AGTGCr!| dO?ܣu??|W[@ jѕF?"u?GTGCT>]aL@?GTGCT?lmKф>ie|hw7y?b|?t6?]M@jM@ d{@?߾?GTGCTڿ`aL@s"?GTGCTs"?-DoY`M?6Λ?if? h}?P@T@BOd@Aǘ?TGCTG|R@j&?TGCTGj&?@y?fgf?-HBŨ? ]F-?32NQ@L7A@Is@n?GCTGC|:P@X(s ^d=M?:?a?vRR@>W[@ %@n?TGCGTP+]6[R@aO*A?TGCGTaO*A?ϐSkK? Z@_K?974?/>}vH@_@ ߘ@Ǻv?CGTCGCH@?CGTCG? J=slk?5+> v?x R@@.zl@_L?TCGTGh,]Q@Y ?GCGTTeB?2Fc?b?װ?i R?p= G@h"lx@ձ?H}?CGTGCX>qJ@$?CGTTG;i/?6?K=">'׭[O??fgK@x $(@bq#ǫ?_vO~?GTGCG~k'L@?9Π?GTGCG?9Π?*p0ć>hX??g%R@vq @@ @# @ZӼ?TGCGC7OoR@ZxM?TGCAC4d/d?JĽ?ZOP;?DHc?Ja>OS@鷯@fa?ZӼ?TGCGC*OXOoR@;4 ?TGCACpcV?E{w?[g&\?lE4-?*?uQ@@wz'@_vO?GCGCC;Q@"5|a?TGCAC!~6?ܶ ?`? 'ŽY?].`u?S(Q@镲 @}O?ǘ?CGCCCk<R@LN-?GGCCC^l#?`r?gX?I͋'? p? iQ@D@i57?kt?GCCCArQ@|AP?GCCCA|AP?[ڃS?9%;?F{ޞN?&߅~?C8(D1S@Q@& ?St$?CCCAG{fcR@Xm?CCCAGXm?z+pJ?m"S?Kx;?y J> R@ Z$@M}?|гY?CCAGC49R@C`?ACAGCHQHq?j?ؾ󅧳? ?xI?q= O:P@|г9@# 1?b2U0*?CAGCG 8;P@us?CAGCGus?pl(?^7?y KdQ?:OWq?JYR@>@|S?Q?AGCGCR@Q!4?AGCGCQ!4?OD?ڑk?>??mp?RPŨQ@ F%uB@G+?( ?GCGCGaQ@.?GCGCG.?;!`? ?עj?x}?V?s],S@4333S@9@Ǻv?CGCGTT6?S@bO?CGCGTbO?JX?r?ϔp?:`}>[gQ@3T@B4@N@aã?GCGTAKR@X_8w?GCGTAX_8w?#?EXaV2?xO֕?"n:?Z[7MI@%^@Q|{'|@ V*`?0bW?LS? O@ c@>O%s?HP?GTACGJNo~O@/#F?GTACG/#F? ـN?Cw5R?G>ś?g)?RQ@ ^i@ߑ:?y&1?TACGGV"kQ@4q5?TACGG4q5?`u2?e$?v,#?PVv?R@.!l@>?Mb?ACGGAJhKR@-}f?ACGGA-}f?b&2?RFm ?q>?QG?Q@ho@ 8?镲 ?CGGAAm:FQ@?CGGAA?ɤFY?pj[Y?O=X@?nej?Se͛T@vq @X/w @Mb?GGAAAKUBU@:S@+e@]rqL@a+e?GAAAT`&R@([?GAAGT9?F?orp_?32?)dѧ>Z?.6Q@M F@B~_B?&S?AAATG2Q@H-R_?AAATGH-R_?m2W?tF!X3?y0?@<$\\|?/g@^6O@O@J?Mb?AATGTp9N$N@S`Z?AATGTS`Z?ݫDb?Uu9?HJ?Je&?I@v@:@H}?TGTTGOKWJ@&x#?TGTTG&x#?L=> ,瘇?za?i?A׍K@_vO@8 ?S㥛?GTTGTGhCK@L ?GTTGTL ?![j>H֙,?Iit?dT?9OaN@48@VZl?46 ˿?>Aq?9Y?|P@4333@E@/nr?TGCGAR@^9?TGCGA^9?>ESf?H~ʎ?޷֮k/?"1?zCfR@NS@ h4h@q?TGCGA)R@@b$?TGCGA@b$?jv?O /ڀ6?#gjI?Cjj7??!HS@6VQ>AլQ@h"lx@;3@/$?CGATCh'[R@x Ѻ&7?CGATCx Ѻ&7?JpSd?^2!O?-'Ǐ?"VkO@? 5J@ؿ@?b=y?GATCC! yL@ ?GATCC ?);x >X%Qr?cep?!?zBA9O@_L@ ? o_Ω?ATCCAt{YN@]Io?ATCCA]Io?\JrZ?j?[_^?>A6?a/R@HP@\G4?ZӼ?TCCAGSMIQ@*v?TCCAG*v?:̲?4r{?ޖ? i\??IS@@ 忩?J4?CCAGT|dcFS@o?CCAGTo?SOs?e {4?e!:?Y% >K7lyQ@\m@Ms@Mb?CAGTG:RYQ@F;?CAGTGF;?O"?͙5d?? _0S~?mHM@@ k? ^)ˀ?AGTGCWNXR D a?AVë?,X?RI3L@e@.?j+ݓ?GTGCGQ(L@.%?GTGCG.%?oz>։"c?,F?߂1ɱ?C"tyFS@@ d@ ^)ː?TGCGC boR@sNU?TGCGCsNU?+eb?()oP?NoR@R!@$HR@@{O9[@6;Nё?GAAGC53N S@`?GAAGC`?}$?О;@ ? )@?-?ʞvP@5;.@ţ? ?AAGCG BMP@ju?AAGCA+`?U9E*?hؼ?H-?V±?z5,R@`vO6@פq5? o_Ω?AGCGGnUR@ 5|?AGCAGX ?J ͒?R4?zH?̭z> qS@&SC@Dts?/n?GCGGGY_R@W6?GCAGCJnT?+54?"h]o?W3n? jL:?"`P@M FE@JGw@`Qڋ?CGGGCBGP@J?CAGCAS`2g?m?~?w%+i?]8#?dd?GᩃP@TH@&F4?NSt$?GGGCTT*rP@B|?CAGCAFQU?eݰQ@ŏQ@!?{Gz?GCTATs^B%Q@\?GCTAT\?v?i)?w3J?!Na$>? Q@mV}V@I['2?UN@?CTATTQ@ha?CTATTha?6#?9TF^?L?N #%p?Q863N@+Y@E%g@-C6z?TATTCY,yN@$Ϻ?TATTC$Ϻ?1spkWߺ>n$%?#j]?ן?E#I@YZ@%:?H}?ATTCGEI@tRk?ATTCGtRk?=ĬV >.ie?+?ANz3P@Bi^@mH{t@S!uq?TTCGA^kzO@uؖ.?TTCGC<@՝R?"w(?qA?DEpF?7w+3?aRQ@ h"l@n?HPsׂ?TCGACit&:R@#?TCGAC#?Nt*^?#?Ut9?4K78v?BH\Q@lV}n@3wF?ZӼ?CGACGOf%Q@OZ>?CGCCCbE|??8NQ?0? h-A?;.1"&fq?pTTQ@r@V0@:v?GACGCBԙ=Q@OXV?%h?N/Q@o_@0?J4?CCGCTwQ@ H??CCGCT H??_?QFʟ?4ګ?c3?k?iYC$R@a@5yW?cZB>?CGCTTyṷR@sq?CCCTTu<#dA?G?jSR?jV?|u"?~OP@%@} @V-?GCTTT_eGO@^?CCTTCNs?=\i? '=>;Sxfc?f*?lVI@I @?&S?CTTTCJI@G~?CTTTCG~?ف=sR>l + ?I,]?KI@ͪ@|?8y?S!uq?TTTCGASI@>m8?CTTCGSEy+?A:_= A)?XF>-2뗊?c B,O@ec@\It@mxz,C?TTCGG'9O@s.U-?TTCGGs.U-?t~f6h?tJ?9H'?u=?ONR@D@*wc?ZӼ?TCGGAt+R@? ?TCGGA? ?\XǛH?Zʌ?c?YYO>+Q@e@?b2U0*?CGGAA!VbQ@kh"?CGGAAkh"? e?`f~?0 ? Պ";?8We7mU@ r@QF! @w?GGAAG`~U@V0?GGAAGV0?x%?6=Yk?~4@?ց5!9H=RXS@@2? QI?GGAAG<U@b(?GAAGTƃN?ꅑ5~?Ne?̺u⠼?:c>!rgT@[ A@ @Mb?GGAAGU@Iy/?GGAAGIy/?iԿ?2 6+?p;>8ų 9=}d_S@jM@2܈@ŏ1w-!?GAAGTn9S@`&xUA?GAAGT`&xUA?}+p? W^u?\NV@?pqЇ>vsP@ŏ1@`5nA?w?AAGTATQ@[`?AAGTA[`?3or ?&T'y?b[?a,?A` N@V@V›GE@ ?AGTAG M@ԣ;??AGTAGԣ;??ZOR?є?52֍?Ɂ#?HzQ@@6?-C6j?GTAGC6zP@%z?GTAGC%z?a?OEF ??#f]V?ſFP@ ףp@sWhy?/nr?TAGCGTwP@vuz?TAGCGvuz?/?B_D?6(?S ?l(arP@%@]5/N?ŏ1w-!?TAGCGxP@k~A?TAGCGk~A?F~y?J SaP?kU?d⚯?w/ďR@ F%u@BN¾@ o_Ι?AGCGT D4R@9ϰgX?AGCTTC8r?I?p"#1? n̬׾?v#?]z#Q@@|~PP@&1?GCGTT @s$R@ F~?GCTTT4C?91@?}-AXo?.q??u@h8J@"@TpV(u@+eX?CGTTTgeiH@/Ac%?GGTTT6'/ݰ?g=T,>rI><.?^Y3J@e;O @w(1?I +?GTTTA"8|I@ʂ䉻O?GTTTAʂ䉻O?iN>khp?B"&8?ە"*?1C'QfL@  @'sG8?&?TTTAClU?K@fZ?TTTACfZ?A@?'?i[|?k۸ΐ"?>{ƋLO@|г @5.?}гY?TTACC*`]O@aYtj>?TTACCaYtj>?܆?8g?<1?5ncݬ?~P@_)' @=h#?M O?TACCG7CP@r5?TACCGr5?"?3i?s8u?L? JDKR@6; @U?@Ǩ?ACCGGtQ@>$f?ACCGG>$f?={1?[w?TO?Gc?4fNS@x $H @y?ͪզ?CCGGT R@PO?CCGGTPO?K ^v?|?^?xfݝN@m4W @Xi?L=U?GTGGT@xaN@0j{?GTGGT0j{?=-7*3?jOa ? ҀӅz?b07?rE]Q@=U_ @U>?_vOv?TGGTAB.Q@Q?TGGTAQ?ɺ?T$ڴ?yS3?}K$?v/N@n4` @2*+@Mb?GGTAGi N@>9?GGTAG>9?4?>v?/?VO? y$&Q@h @xX?y):?GTAGC?1P@?TCGCG,?r?IuБ?YЉ?뤟ǂ? LfzR@r @ R@~jtx?AGCGA# R@< ?AGCGA< ?6?3' ?K01\?>ؖhpS@jMs @.HA?V-?GCGAA,&S@i?CGCGAN|?׀8?Lp?:TQ?ϢY>}>p= AS@~z @?UN@?GCGAAq.&S@rҺ?GCGAArҺ?a Q?j{?に1 ?> 6S@ec} @o@F%u?CGAATr*` S@=͹?CGAAT=͹?E?uk?dl? >#4Q@䥛Ā @Y{@<,Ԛ?GAATT4 vR@:?GAATT:?1=?|Vv5?*{):?I@|=)?x?!?]5P@J + @[Gݹ?Mb?TTCAGHO@Buc?TTCAGBuc?2&? H{?D ?XG?xVt:R@K7 @6c?_vO?TCAGCtR@~֚m?TCAGC~֚m?Qf?Fo:?P?RTbA?RP@@߾ @BM?N@aó?CAGCA("P@BXG?CAGCABXG?g@~BF?7? ?eAo?5R@@ @ 8Y?"u?AGCACH^R@<6?AGCAC<6?)[ \?N?H0Ę4?6P(WP?_%R@?ܵ @Mj?"u?GCACGPWYmQ@{RU]?CAGGT6y?YdH?XM>ӡ?zjQD?彁?DSQ@;M @IԐ??ܵ|?ACGTCANׅQ@d.2?AGGTCET?t3;?\:?P(?KEF?-,^I@)\ @ @y&1?CGTCCnL?1VH@x̝_?CGTCCx̝_?ɽG>m"U?E&?ERBBj%?"e3Q@sh @|s?/$?TCCGGpԧQ@1ƃ ?TCCGG1ƃ ?gx??Ial?%QҤ?z 7?yclRS@M @F?Ǻ?CCGGC[ER@f%o?CCGGCf%o?1J?@:8?"%<'>?Mp ?9x2P@ @cH@_vO?CGGCGfnO@pMRp?CGGCGpMRp?1nk?^Ȍ7C?d ?fi `?6lS@僞 @q^ @+eX?GGCGAB쿆?S@e*?GGCGAe*?#?3dn? uä?} >d0R@Ǻ @k+Eh?A]_:S@s @liз@n?GAGAT"F?q?Ln8?R o6>p=R@* @1J%f@Mb?AGATC+DR@3bT?AGATC3bT?:?uhDp?٣K[\? k>p4VbM@V @Ϲף@j+?GATCG%! M@C&E@9?GATCGC&E@9? rnU?1τ?"6t?g?P@ y!@PA>?~:?ATCGG "P@yv?ATCGGyv?@?Ɲ/h?*4=?#:B?xR@3!@JhtA?&S?TCGGAa/*5+R@̤b6?TCGGA̤b6?+.a?ө~x?Ѷfc?s>ysBQ@fc]!@y#3@UN@?CGGAA/vQ@KB7O@ q,!@˓5@:v?AAACG'ɗ`P@mtB ?AAACGmtB ?M?nT?i' nB?LV}h;?kY|P@HP3!@QO3?HPsׂ?AACGTF)8P@б(?AACGTб(?Te?4?Wdפء??K~!Q@hs5!@*P%?H}m?ACGTGY eQ@B !?ACGTGB !?yMR?uE.շ?+vI?U?= ףDL@_6!@Bv @Mb?CGTGCh`]%qJ@iѾy?CGTGCiѾy?׽y>OP??0?J:I?rL@h"lx:!@Z6Um?ZӼ?GTGCT A08bL@ۋ9?GTGCTۋ9?F3|?m?#\?T̫)?# cP@Լ=!@ @y&1?TGCTCΛQ@v`?TTAGT?0?3/ZS?u?_SZEt?oXN?+QQ@?D!@`x;?a+ey?CTCTT8-P@06#5?TTATTwY?$.?g?P -?7m:?v< P@Z8E!@ժ0@+e?TCTTTY3rO@&Yqr&?ACTTTĽoz?̇}g?kآn?,RI?cj$? OO@8EGR!@\Gz(? QI?TCTTTw'O@/?TATTTXw5?G!¯8?hk?uq?,$f?gfffmI@Y!@Qt ?_L?CTTTCcAJI@z ?CTTTCz ?˩D=L>M>v )>*H?v$I@\^!@S?oŏ?TTTCGL]SI@ƭr?TTTCGƭr?)zn=V>0QtL>v}(?ƒ_lN@ݵ|p!@oF@~jt?TTCGGR0E9O@Sj6 ?TTCGGSj6 ?~Hqq?۩?ڑpr1?A&+ ?DvR@av!@Ծ@J4?TCGGG%R@H U?TCGGGH U?)?M_Fۤ??,ɡ| >$Q@Ax!@zs?{Gz?CGGGG 2P@ ]?CGGGG ]?꩝)?:?Մ?w?Cc7i?nR@7>W{!@ (9 @_vOv?GGGGG%R@}wf?GGGGG}wf?tA_AN?^>O??}K?H·">R@#|!@|H^v@<,Ԛ?GGGGGxLӝR@((?GGGGG((??"?Nѧvs??r}?]poC?VmeS@W2!@'Z?Mbp?GGGGGIsR@vX~?GGGGGvX~?8=_? L?zH?偭A>җ01R@48!@7 @HPsע?GGGGT;!ZR@0g=#?GGGGT0g=#?˞_b?f|?}:?nBu/fi?_R@U!@R ! @ZӼ?GGGTTe$R@(#&?GGGTT(#&?;_?T[:?ptB?0uX?~'vQ@!@D٧?b2U0*?GGGTTZ$R@G.'?GGGTTG.'?&?kt}?gJ?Etu3mn?1'OUM@_!@4Ӡ@?GGTTAW5 #T@ j?Ȝ=n ?S D?DүJ@7>W!@܌?n?GTTAC@UBK@o@?GTTACo@?~=>pa?62r?}L?GaN@bٝ!@fj?Ǻ?TTACArxO@g?TTACAg?8|l?#_O?{T}?:>R? s1R@n4!@n-?{Pk?TACAG;Q@,(ɯ?TACAG,(ɯ?hD4E?&?(s?^VAO? R@(!@{Q?Mb?TACAG Q@a7:A?TACAGa7:A?x19&?v 2g?̊? 1?P%³R@FGr!@̉?<,Ԛ?ACAGA0R@pM#?ACAGApM#?w?x$ͦ?j/-?j<>?|I!R@ˡE!@R?ZӼ?CAGAGQ@2?CAGAG2?nW(?e?QG nR?HqjB?Hz:S@6 @F%u?AGAGC'S@D?AGAGCD?QvH?j3?%tP?&>ʅwGQ@|г!@O;U@HP?GAGCGiP@-;>?GAGCAT?4]6?I?QE?Ktm?K~hS@ZӼ!@@&|?mxz,C?AGCGC'zm:R@?AGCAC5Me6?W춲K?A0?jLv?0q9 ?u5D=JR@7[!@)8e? 0*?GCGCTMQ@-{hG?GCCGC\ /Э?sM?)? ?.qi?R@O@a!@gԅhQ?H?GCGCT:$Q@[j%?CAGAA"/?f1q\ͫ?x x?d?+ 3?} NS@R!@&] ?HP?CGCTGl] R@]N7?AGAACL\?fk ?M?n`5?-# ?.ÈoP@U!@")%&@2%䃞?GCTGG-ыP@XGG?GCTGGXGG?c)?H-c`l?ʏ?0BU?|Su[P@ʡE!@Uk*]? 0*?CTGGG ,O@K'?CTGGGK'?B>?{=G?'Fb?"n>?bP@HP!@j\t=6?Ǻ?TGGGC~P@()x?GTAGCm,~@̲?~5?7}?s!?)?KA5P@H.!@ ~)?M O?GGGCT 9MP@?TATGAЦ)?S?hx&?N}-?)?EWR@ Z!@ې@q?GGCTGd3mR@3٠x?GCGGCy߾?\[Y,? |~? ?]H?N˾N@JY!@@9?b2U0*?CTGAG{*UwO@S?CTGAGS?+[?N>?9[ ?[dɱ?8kS@C!@V$ !v@`Qڋ?TGAGTp$UuS@h=?TGAGTh=?y?̘?u?݉6[>Q}EP@@߾!@g ߢ@_L?GAGTC]m߁Q@e?GAGTCe?wJ?8?7?(Á,tn?ۧt*Q@+e!@Qgw@ZӼ?GAGTCӴQQ@r0! ?GAGTCr0! ?% ?X6<]?iY4?h4?#K@!@NYba@Mbp?AGTCAغJ@K6Bs?AGTCAK6Bs?5Ah>?աx?-0br?կFt?/]O@?!@O{:@Mbp?GTCAT}@_c+O@zqK.?GTCATzqK.?.7`?0p7V?k@Mq?[?`O@d"@M%@n?GTCAT֊c+O@՛?GTCAT՛?.M}x?]b;?Ң1?X(?#R@1"@TУ.@HP?TCATTh$MRR@?1bE?TCATT?1bE?b/; ?7V/29?kX0?ݿ:@?]D:K@C "@X?`Qڋ?ATTGTpK@*OM?ATTGT*OM?W9>1d|>ue9? X??M@9gDi"@Vi.]?S!uq?TTGTT[ N@%/bn]?TTGTT%/bn]?Xh^?86f8?jQ {?aMEFM?2J@s"@KT@:v?TGTTCD"ɋ-I@:t?TGTTC:t?62u>z.R?d R?.?sI@b"@*~"@n?GTTCA;H@|(L?GTTCA|(L?]u_= ?DEK7]?^rZ?>'CO@/n"@*M}?q?TTCAT,O@M ?TTCATM ??70K?u?4Hr?9x ?W[R@"@pOU?H}?TCATC>9R@t)?TCATCt)?)-??gS? Nk(>[gO@(!"@=4(W?Pkw?CATCGNw N@n̔t?AAACGr ? #?ٮ!?]?ʟ ? )P@:p("@[?ǘ?ATCGCb"P@t?AACGCwC~?%PXO?,;C?gfq?)]'?/Q@.!,"@Hט?( 0?TCGCGwfPQ@k_?ACGCG ?])㳉?pӕ4? ?$%gaz[G@JY8"@}o? ^)ˠ?CGTTGI@|k4?CGTTG|k4?,R=oA>H㿍d]>?w"%J@D@"@b$Pk?{Gz?GTTGC|-)1M&mˑ?|›?V*0?YlaQ@^)K"@dkM@ZӼ?TGCAT*;`:MR@??TGCGGc6 ?{?@5?_?lT'? (WR@N"@W@ aR@|/Lf"@'7?_L?GCCGTnR@A]?GCCGTA]?`ݥV?l\I?R`+ ?* r@P#?hBQ@{p"@Q2@o_?CCGTC1ȨQ@?CCGTT? ?00Χ?rL%ĩu?jAL?gl?wI@by"@.O? rh?CGTCAH@ƪ/?\?GTTCADLfd?vwo>8}V@~P@ho"@~4-U?0*?ATCGAi*2P@G?ATCGAG??[l?h a*dH?{?Z7R@( "@hq?6;Nё?TCGAG;FR@(o?TCGAG(o?`kL?<?]O?x9>}ٗ*S@F"@/݁:r?gj+?CGAGCU:S@'S?CGAGC'S??b̕?Fz?Pl? ?j P@~"@K*'e?C>٬?GAGCT tdP@UOb?CAGCTo7?<8Jf? צ?ph]K?(~*'?s]@QdR@x"@H?Ǻ?AGCTG6+N8R@| ?AGCTG| ?⬻? Ϛi?qO??f?MUP@V"@y !?HPsׂ?GCTGAsNP@m/0 ?GCTGAm/0 ?m@}?pA[Ò?&w=?Py,??l*MO@2ı"@F>H?Ǻ?CTGATep?O@ ̂ҨY?CTGAAje5?(b\B?x.;`?м@^?a? +[R@ŏ"@_}ʑ@jM?TGATAɒ@*R@,?TGATA,?9'VXi?,(?+̪?Sf=j>5vR@Q"@aLEI@?TGATAֱ*R@yٕ?TGATAyٕ?3Z?oIiu?)P(9?* FUS?? JI@n#@? ?_L?GTTCCz2-H@ɱo?ATTCCǸ?]t`e=Pk ?96`K֧?fw??W$l?nQ@5;#@p/O?q?TCCGG=L Q@BHN?TCCGGBHN?Jr?XB?($s)q?xsF?Y\R@~:#@.e,B?&S?CCGGAt#C~R@)ԑ?CCGGA)ԑ?՚6?Ft?G ?~(]|V?SY]:Q@"#@0f?UN@?CGGACP@?CGGAC?#?J+ﯳ?7?KXZK?r R@z'#@oGmn@y&1?GGACA lE R@]o .7?GGACA]o .7?4ɑ?M>)?Tζd?w2d?61`vQ@C+#@=<:ZD?n?GACAT*alηQ@<~?GCTAA9@/0?̭r?A99p&?{!?Lyx?R9]'lR@H0#@rO? ?ACATTJpR@˻?ACGATSg?=Ps{?6?+?n#^>?askqR@cX94#@<E?y):?ACATT:'ŔR@ʯ_(?ACATTʯ_(?h?CATTT>?֝8=r1>Q?8l?2`~I@T㥛D#@pl?:v?ATTTAw!J@$A?ATTTA$A?d7l=J9;>s>G?Y-o-L@CK#@{Ga?n?TTTATK@躑?TTTAT躑?ibo>7RÕ?a?f ?,ԺƔP@8M#@#3D?gs?TTATCwP@痝%$?TTATC痝%$?H?JТp?MZ͞FCiRz?xL?eIX ?q(wO@?_#@h$= ?/nr?GTATTm._raP@A)?GTATTA)?>Ex?5V}s+?:5u?ӯZQ?>M@䥛`#@Xn/-?F%u?TATTGZq|N@]T?TATTG]T?}K r?njv_?-ז5 ?%.r?84M@2%d#@^ka?j+ݓ?TATTGyK N@6v?TATTG6v?p ?"??0pΈ?OG?~j|$gL@i#@51?~jt?ATTGAMK@t[÷?ATTGAt[÷?3dhX}8?-M&A? b£?en?0\M@Ao#@Q?"u?TTGACv k73 N@ԍEt?TTGACԍEt?2u[??^j/?l \4kU0?h?:W J@#@ x`?ݓZ?GTTTCd[QH@}(E?GTTTC}(E??>k=tK?h_]`@?T5?= ףAI@`TR#@؞@"u?TTTCGX%_SI@?/?TTTCAq|$?L>%Y?#lž ? ?%?FR@jo#@Z0U5?mxz,C?TCGACv:R@ %OM?TCGAC %OM? ʊ?΃ }?>5n?_>sQ@Ș#@ ?ea?CGACG]Q@vbd?CGACGvbd?3dp?|RX?sC8?xD?9U3Q@Dl#@k-GY?0*?GACGG뢌IQ@y?AGCCGM-?t?g ?G?ִD?i R@1w-#@I' [?L7A`?ACGGTTpЦ ^R@55[?ACGGT55[? qӒ?7zθj?ͨ?-\ͩ/?|K@s#@d5Q<@Af?CGGTCCLP@,E ?CGGTC,E ?ږ~e>5a"?$?Q5=?둣J@?#@Ua b@Mb?GGTCG. 2K@:[Lb?GGTCG:[Lb?k{>]Q%=?<~W?Wh%?*K@qΈ#@Bz@ψ ?GTCGTj'N@k<1'?GTCGTk<1'?2>{Y ,?>F/?|r`?UGQ@=yX$@DH?H?TCGTAAQ@:[z?TCGTA:[z?uW?{^}?GL?ٳa? L@ݵ|$@KQ@Ǻ?CGTAT>K@<|Ʃb?CGTAT<|Ʃb?dU?eF!?Y?#Y/k?9P@KY8$@_k?/n?GTATCꕏMP@B.3?GTATCB.3?jP?h?ko?BĠCs?O]ȧ"N@Zd;$@f?&?TATCTPqCN@pz?TATCTpz? 4C?"@CI?W9Fa3?Rn=?/P@:p($@"9Q6?q?ATCTCw||AO@+OW?ATCTC+OW?<ټ?^]|?nc?ե` ?[J-P@,$@Z?W}b?TCTCGJO@7w?TCTCG7w?X&q?!'?dXp?lJN??-Q@$(~9$@[֛?Mb?CTCGAa0LQ@8˝8?CTCGA8˝8?LF C?=N=W?G? WT^e?_>4R@OE$@, ?/n?TCGAG/oFR@FJ?TCGAGFJ?#aŧ?r^O?M.j2?)4-8?7CA7S@wOJ$@%d}s?cZB>?CGAGC@z:S@/?CGAGC/?(EZU?@!?p?k4F?ݛqJP@p= W$@dn7@NSt$?GAGCGm ->T@ _$@gGM?_vO?GCGAA- &'S@q~Ӱm?CGAATC!Ds T@՚g$@<@a+e?CGAAT3]S@`TFX?CGAAT`TFX?z8kS?7{Ŝ?7֊r?|4:ڌ>nEQ@ŏ1wm$@v@q?GAATAɑZ(R@U'?GAATAU'?e ?1wHr?ܚ!N?Nm+?)\O@!uq$@)u?`Qk?AATAG jy7o>O@-] ?AATAA?lR?ye?ݾV?n!?%i[YR@e`Tr$@v? ^)ˀ?ATAGADb@Q@G`?ATAGAG`?ƔLjh?ͨɩ?+?6 5? p瓞Q@9mt$@.ds?0*?TAGACäQ@w_i?TAGACw_i?$g.?Nܺ~?s?ڴ[ ?Z??GACCC3P@mx?GACCCmx?t/z ?t?&.?A?4P@d$@?,0:f?J4?ACCCG{}qQ@[?ACCCG[?O貘?b0[?qp?E%4?5NR@8gD$@_?@y):?CCCGTçR@-y?CCCGT-y?1?h?oo?r?h?7,_>"<9Q@ҍ$@S@UN@?CCGTCեQ@LW+J?CCGTCLW+J?:4|#“?&=4f?O+[?X*JSc?xeYG@~:$@Z@/n?CGTCT_H@q``=?CGTCTq``=?/i=Xy6?I">`i?w%M@c=$@R@{Pk?GTCTT jM@^aw?GTCTT^aw?>?P?Gx?^`T?DrWH@؟$@ßٟ? o_Ι?CTTCG=EnI@R9?CTTCGR9?h!.^`= 28]?vd>HŬ֑J?{)M@|/L$@ASD@ rh?TTCGA*xM{O@]l&d?TTCGA]l&d? =>@P!?hR P? mp?1M@3$@R6 ;@?TTCGAT1I~P{O@?TTCGA?x v??Ps?#z?TM_T^?UxkR@?٬$@ƢuQ?_L?TCGAA*=bR@ʱԋ?TCGAAʱԋ?95?{?cH?a?Z4ts>OkS@ lV$@!,g?A`"?CGAAAF`S@'*?CGAAA'*?18??lAD?|^P>ƒ_R@f$@N8?H}?GAAAAB xGS@]@=ֳ?GAAAA]@=ֳ? ?R?] D?7ĝ?owQ@O$@V:T?/$?AAAAGHQ@y m?AAAAGy m?s+Ne?LI?t?_n?/eQ@$@\?~jt?AAAGGdQ@PD'+?AAAGGPD'+?n1Ġ?`?Z?5h?U$ŠQ@2$@ô3?S㥛?AAAGGX_Q@,d+?AAAGG,d+?Y29ނ? l.?Ç?^'\>΅iVR@/$@y?~jt?GCACTR@;M?GCACT;M? ?{N??[B?/Q@-$@#$:Q?{Gz?CACTAQ@"?CACTA"?dgKJ?+?l#ӓQ@wpr?CTATAwpr?Qu?g"?'U.!?M>.J?F P@$@c/O? ?TATAGANP@OD?TATAGOD?&Rq\N?<2,?J[?j}vf_D?Dže#Q@O%@EPU?a+e?ATAGCkÛ7CSQ@\]?ATAGC\]?fW?@{?19?s?fBP@T%@Ure@q?TAGCC(wP@?ɬ?TAGCC?ɬ?;??)>8?݃?Ѕk?GnDAQ@o %@8? ^)ˀ?AGCCC0WQ@ ??AGCCC ??jرa?K k.?ɀŒ;?br}?ikMgQ@C> %@ Jى:?n?GCCCGh5s9Q@\%^?GCCCCzoC׵?Z?H?VIv/ZjqTT@"%@"P?+eX?CGAGAe8;S@l?CGAGAl?t?3?.+UYC?xsځ >ԻV(Q@e!%@T%_9@y&1|?GAGAAڽڏR@1X?GAGAG*?at?^7 y??!b?h X Z?n`S@鷯#%@NQ-?+eX?AGAACY S@Z0i ?AGAGCg? 8?e?w?Mڠ>y]Q@=,Ԛ&%@ 垣?S!uq?GAACG$*P@D۾?GAGCC~?İb?K(fR@٬<%@Na? 0*?ACGAGQ R@pP?ACGAGpP?['?0CAti?7!?@>G_S@&SC%@˥(?`Q{?CGAGC* 9:S@`DX?CGAGC`DX?IVd?pǓ?8Q?P~Y:>kycMQ@7D%@ D#@J4?GAGCGD(OP@)䉷?GAGCG)䉷?@u?NKNZ:?S?(X(p?1M0R@xF%@_+?+?AGCGAzfU~R@+i9?GGCCGAƻ?#"o?(k?]6͛?0GO"?s R@A`P%@_TGCGG%0?@2? _IP(?=T9(?8&c>\vPS@"uq[%@g#Ųe?{Pk?AGAGC&ZS@ȔuL?CGAGCYI+?AW?f>Oݣ?/s? z4?uoO@_I b%@[͝3S?JY8?GAGCA{R[)P@?GAGCGTR?MA{Y9?=]jO?d7~F?}TlE?p8>+S@(m%@. c?9yS@X2q%@%;?*Dذ?GCAGTmtmS@C?GCAGTC??u?xS6`?C6Vϳ?fs>lznuQ@lw%@A]@'Q%?p6lS?6MZs?X?HqCvD_1?T@G@C%@I$?Ǻ?AGTTG%'%K@՜XW?AGTTG՜XW?<89 =Glph>@vt:r>yq+?{I@R!%@F=?gs?GTTGGXeJ@_D?GTTGG_D?DRJX>O<|?ڧ?>Vf{]?O@jM%@ 1r?H?TTGGTԞ=(N@Iٛ?TTGGTIٛ?"CA?D٧?|?¼kg?eBLQ@n%@hQ?ec]?TGGTA_懇Q@_*qk?TGGTA_*qk?`?=B?3M?6?ҘÂM@%@>o. ?vq -?GGTAAe&dHN@\% ?GGTAA\% ?2™L0?ɺg?(<ݕU?:?Ad3E)Q@.%@ @gs?GTAATL!Q@Q~Uh?GTAATQ~Uh?=?X$?4Z1?;j_[?7_M@ O%@;h? ?AATGCAKIvN@\ B?AATGC\ B?Dt)?DYk?,o?փne?JCҵL@cTکe?@bFL?%֤?/ 6pQ@Q%@\,V@Ǻ?TGCTTGR@| ?TGCTT| ?]?G?(m[?GA[\^}? ]P@=R%@%eţ@ʡE?GCTTASQP@`?GCTTA`?(g?(i?s?<$?#G4*M@_L%@V?ŏ1w-!?CTTAA)'.L@}?CTTAA}? LYV/?õk(j?&?6Ct?SFaQ@ 0%@" ~*?`Qڋ?TTAAC5L$Q@ 'N?TTAAC 'N?l01`?;[ݣ?aJe?R2?~,fP@'1%@?~jt?TAACG3J%P@t|?TAACGt|?&?E? Z ?Z?`Х[P@gfff%@Y J?St$?AACGGNb4P@A,"H?AACGGA,"H???Eȸ?"^@>?AնF?'45uQ@1%@f{f!v?HPsׂ?ACGGTL\6^R@n#ƍ?ACGGTn#ƍ?#֯?!9?_͘G?9צ^?"P@[ A%@&?䥛 ?CGGTT*^kwP@bM?CGGTTbM?܏"v?^ƨB?^jeU?}'?V-2L@\ A&@@Mb?GGTTClK@uP;?GGTTCuP;?DkHԊ>;]?O?\_#8?PH@ h" &@lR52?I +?GTTCA84H@0?GTTCA0?/A=!{n>1?ۼVn?x|PȅO@X2&@rq@Q@&@q?"u?TCAAC.m Q@ kӳ?TCAAC kӳ? V~i?¬'bʘ?y#?ãӵ?~IR@Oe(&@p@:pΈ?GGCGT= S@?GGCTTV?A\O:?Sʅ9I?lÈ? l[2?y(!,/P@m1&@ :f@J4?GCGTC3;Q@eGl?GCTTC 0cQ?x-;?B2A2P?tL~?b?bY I@|3&@T+@w?CGTCG8cpH@w_?CGTCGw_?5V='b.>]g;z>Qtf?s#O@_L5&@5&x@ͪզ?GTCGAVN@ޑ?GTCGAޑ?4he x?ym?_o?4kE),?aR@n4@&@c,@S㥫?TCGATo[R@l<{'9?TCGATl<{'9?Ldu?/'?L?=f $? ͥd?꞊?bˁI@oe&@Bں?Uد?ATTTG}I@N'?VTv>ci3?V׻K@Dt&@4=A?<,Ԫ?TTTGTW"VG{K@Z'3?TTTGTZ'3?3=8">L>hñQ?QƓgڳM@ cZ&@0%?1*?TTGTG9~M@DoR?TTGTGDoR?nN ?\򌬛>kCE?s~Yg?͑zM@u&@?v/?TTGTG1M@1"?TTGTG1"?wQQ[gF>hX"?܂u?*÷?ԕ K@T㥛&@ ?n?TGTGTj_\?L@ֆI?TGTGTֆI?ھK> ?y&e&?!3W˟?W9ȦpM@y&1&@p#Q?y&1|?GTGTTWM@-t?GTGTT-t?>Q^P?0?|[x ?Bu J@l&@xL?ZӼ?TGTTT VJ@м !z7?TGTTTм !z7?U>*9?f$ H? Ћ,?-]:K@_&@y?Mb?TGTTT)gJ@n ?TGTTTn ?\~nu>b\?l߹y?~? M3J@U&@;O?=U?GTTTT)T.oI@P?GTTTTP?&7>픅7>xx/?ed?uo?nwI@~&@ iQ?_L?TTTTCi҅(? +4?[Y?;@utI@ʡ'@$e>@ o_Ι?TTTCA[8 _I@`?TTTCA`?8h9Y>PK?*bq?QL? :/R@_L '@>?Mb?TCATT6kRR@G?t˛?TCATTG?t˛?]As?>_?V|? *?bAD= ?~nnL@Qkw'@-O@a+e?CATTA}S6N@ԑ6S ?CATTAԑ6S ?dZ >ȊXV??Ƞ?B&??4wv8O@?'@5 .> @q?CATTAa& N@*HK?CATTA*HK?\ f'W?\Ɣ?cD?P1*?(\+L@.n!'@cx6@Ǻ?ATTAA9{K%L@qߣ?ATTAAqߣ?Ke?Zl?fW+?,[ij?;҈xaP@io$'@d;?St$?TTAAGw)Q@=5l?TTAAG=5l?$ĸK?,4?c?;t-?5"R@T('@Ld?y):?TAAGGq["^R@ei ?TAAGGei ?.'?Wi??aWO؞?{MLQ@e;O-'@4(?NSt$?AAGGC>[Q@\?AAGGC\?^m?Z<-T?$Uŭ?j?G,O@HP3'@Ytƣ?S!uq?AGGCCArP@O(?AGGCCO(?=sb?ӆw?\\ ?c0z?>"#P@ѳY9'@;(?ψ ?AGGCClbArP@z1?AGGCCz1?-5?R93+i?u~tw7?`K?bfR@Q>'@9䈯?+eX?GGCCCUeQ@mVG?GGCCCmVG?΍S6??=^=l?Is,?Bt ?w̓ R@qD'@OW?Q?GCCCA)Q@Ce@Nx ?GCCCACe@Nx ?"-CeX?ʙQ~?*?OIK=? `MR@N>핐?eQ@e'@"?{Gz?AAGGC [Q@W?AAGGCW?{1?,9J֝?;oE?k]F?i OyP@=yXh'@?ݓZ?AGGCC ErP@C(?AGGCCC(?N^d?(+S?ϰ&G?rhJ?/Q@r'@?# }?ǘ?GGCCG1*1R@ya?GGCCGya?OS_"f?'P x?jJSW?6R@Mbx'@UZ?_vO~?CCGAA!.!S@v?CCGAAv?k ?Lz?r8, ?cfTu>q`S@ѳYy'@^{]@a+e?CGAACsj[S@j/B?CGAACj/B? r@?y?ʪ?O&>(Q@I.!}'@<?ߧU@ґ\'@G @M O?GGAATlHCU@L?GGAATL?,ըn?xXbf?lCf\D?KPV=ЅXwQ@V'@҅uؙ@ea?GAATA-(R@E-?GAATAE-??Ȧ?Q$X?ajܜL?F-R@e'@wo@HPsׂ?GAATA)R@7a~=f?GAATA7a~=f???Krm~?|m:IP?̎fTQ@`TR'@\@V-?GAATA*)R@:R?GAATA:R? @i?&;?uk7?sU 1ȱ?WSP@@߾'@d?^K=?AATAG>O@d﮿Ի?GACCTrf!?̱??MY?-6 f?O>ftkQ@$(~'@?FZ?ZӼ?TAGTATQ@%|9?TAGTA%|9?6x?S({?{X?-d2?PX8L@/'@ o'?ˡE?AGTAGE bM@^8`?AGTAG^8`?[ ?t1a?*+?e4?AJP@z'@&% L@b2U0*?GTAGTibP@0)+p?GTAGT0)+p?SPO?Ksm?fK?`򜆧?zQ@9#'@`?6;Nё?TAGTGW"Q@cZc?TAGTGcZc?VLf?[)??2I̺?(N@ h"l'@oU`?}гY?AGTGC-%>M@h]*?AGTGCh]*?Qx$!?& Je?Ü'?2d0?³(lJ@(@S#?tF_?GTGCC [[QK@k6"?GTGCCk6"?qw>(jn? ;^? B?6P@ (@֞fT?_L?TGCCG^Q@^o%?TGCCG^o%?u1?oz?ȶ)?qty?$QzR@K4(@^,s?Mb?GCCGTo)'ynR@ o?GCCGT o?n*?F;4?B?@Ri#[?ˡE4N@_L(@j0i @~jtx?CGTAG9*TK@Nhݳ >GTCAA >\T%k{>O>h0`>;ʇZ>egA ,R@Ϊ(@7Sٺ?a+e?TAGATalhQ@|Tn?GCCGTa*?l!"?]#(3?  ?dÁ?d~R@F%u(@?Y5;N?AGATClqܾR@=l?AGATC=l?bNcS?f?jY*@?{"?kYJ@ "(@[D?v?GATCCezL@O?GATCCO?->uaQ?lK6A?f.n?hgN@.1(@A?ZӼ?ATCCA,ZN@~?ATCCA~?}a_?^0?r.i?ǚ٧?&Q@=5(@܆?/n?TCCAG=lyQ@'f4?TCCAG'f4? g?錖`?ŌS-q?%_?ˇqS@7(@>y?mxz,C?CCAGA^MDOS@Zռ?CCAGAZռ?1?&??>UzrR@Zd;(@ι7@X9v?CAGAAlo#R@dZ?CAGAAdZ?li?h f?2a,5?p};??R'"I>UxQ@BM(@fC@HPsע?GAACGCv\nP@Qw(?GAACGQw(?S ?JqTa?0g? lsƆ?=P@mV}V(@Ă?ZӼ?AACGAu&P@ݧ?AACGAݧ?m+?X ?1&?2М?ףp=hfR@[ a(@ƟT?w?ACGAAɢR@Ui?ACGAAUi?+zb3?xښ?B'`?L+(+n>!LkS@lwb(@'rj?mxz,C?CGAATv *S@ɤx?CGAATɤx?Ă(?O5 MU?XK+? RGx>x_rQ@/$f(@oe@:v?GAATAH7A)R@6E?GAATA6E?)q?jR+3I?=Ub?QIK\?>M@l(@Cg?_vO?AATAGAv?O@gT"?AATAGgT"? ^s?=?(<`ܞ?w5'P?a_gQ@o(@i;?ׁsF?ATAGGۍGLQ@/?ATAGG/?:~E?J:?] J?Ѩc?XtQ@|гy(@Jr`W?"u?TAGGCRfkyQ@K,fR@~(@6FW(@Q?GCGCT utQ@jMto?GCGCTjMto?&i- ?n]2?R"?l\}l?R@=U(@JU?-C6z?CGCTTRxR@ &o?CGCTT &o?X܍? -;? ?* s$?yYcR@k (@Yީ@ ^)ˠ?CGCTT9xR@Nƕ?CGCTTNƕ?7[??1r,? }U u?"]M@ ^(@uH@J4?GCTTC8O@xQ2?GCTTCxQ2?jy7>J~0[?Ϊ$\M?#v{&l9?"""b*Q@R(@$ @H}}?GCTTCDQ=8O@Lk/?GCTTCLk/?d?+O=? q?"3C?o>eQjO@ڬ\(@r&] @0*?GCTTC7X8O@:*?GCTTC:*?=mn>FA?"2,Š?Id?@p[I@&S(@}zk:?Mb?CTTCCINI@"?CTTCG—?$yn=]4At"?uq?[7i?^.ӱP@ O(@rUE@?jBR?2B64N@1*(@$?46إ?GTATCO>إ?tGs?Xdr?{F?vh-?ArD O@(@9@+eX?TATCCyejM@g*#bS?TATCCg*#bS?X껗?~AZ?kZ?^Z\?QFO@( (@U1?~jt?ATCCC̓oN@gޛ?ATCCCgޛ?fxlz?7"?PJh*?R>B?֔9M@C>(@X^f?sF?ATCCCax5vN@m$?ATCCCm$?Კ?c'?7q?1 ?dP@fc](@:o?Q?TCCCCpQ@y13_r?TCCCCy13_r?ANg#|?l=HG?G!?|8]jX?wR@Gx )@?ʡE?CCCCG$R@Kѩ?CCCCGKѩ?T?|ch`?7bJr ?b%v? 硵R@Fx+)@c?;L]0Q@Bi>)@@H}m?GCGCGŚQ@,c ?GCGCG,c ?ƴߊz?!|?@߮j?Tk?I:S@=U?)@,Bj??Ƭ?CGCGCN&S@6d?CGCAG7j ?&U*G? zA?!SD?2SN>GኅR@ǺM)@HJ@Mb?GCGCAbCQ@s2̩?GCGGCfXHɴ?O=Ys?]LvV?w?1te?2 R@;NQ)@u#wA@HPsׂ?CGCAGEAS@8zh?AGCAG@[saE?O^, ?2]?k?WZ?,*]zS@<,T)@pPF? 0*?GCAGAt+JbS@&?GCAGA&? ?lX!?R,O?>sfaUR@ŏ1W)@5ˍ/?HP?CAGAGGRQ@u ?CAGAGu ?(fѯ?O!?m ?$ ?F6?ǼS@QZ)@*0>@ rh?AGAGA,T@\OjM?AGAGA\OjM?%`?WNz?ehim? l z>MR@)~k)@oK?y&1?GAGAG(h|R@0^RRK?GAGAG0^RRK?b%L$3S@M Oo)@HW?q?AGAGCO5?GS@pY A?AGAGCpY A?r?`d+?a-?GTX$?K>P@jMs)@|0Eǃ@b2U0*?GAGCGcP@PՔ%7?GAACCyŁpt?v?LTR?j|}Z\?EhlB ?'%IR@)\u)@Ҝ=?J4?AGCGGmvR@-\L?GAGGGڎ^?Ck?BQo?喝 ?Q3/JS?7'csR@z)@ l(.? ^)ˀ?GCGGGty9R@z-*)?GCGGGz-*)?_e߅?[)±?3Q]b?̀@?AWP@(|)@ёqç@ZӼ?CGGGTEu1aP@Y!?CGGGTY!?im2?i?-=ٟ?nެ?,DwQ@ű.n)@1H@o_?GGGTA&w|}Q@/lLݜ?GGGTCՄl??2s?ݭ: d?Iׂ?$JK@t)@cxmLL@a+e?GGTACos:M@6v?GGTCTڞ%?ܵ֜C>bu?]z?g?5{L@/')@BU??w?GGTACY:M@Sߑ?GTCTC ף)@:u@HPsג?GGTACvZ;;M@Ǧ?GTCTCoo`r-?3s]{? 15&?2d ?%U ?+O@}гY)@Yt?Mb?GTACGkгNO@y^?GTACGy^?IjSJ?&`p?>\xjb?)b?wR@ڊ)@)= 9?&S?TACGCƺܷQ@u^wA?TACGCu^wA?*ݭ? Q?\7n?n.%5?(\vQ@3)@34?Ǻv?TACGCʏ@Q@_?TACGC_?}*'6^?P871c?5)N?tGaa?N9Q@w)@#7^'?HP?ACGCGvQ@??ACGCG??'?5+ ?OPF?A&O?/ZS@&¦)@0?b2U0*?CGCGTQ\Y@S@6a}G&?CGCGT6a}G&?V]?U^z? ouM?hl>rmQ@K7)@W |@ ?GCGTA6 R@X+t5?GCGTAX+t5?KFݨ?+WU?=Ӫ#?KgTnz?>u K@`)@:X'@a+e?CGTAA=_K@K?CGTAAK?R]>*eZBu?Bǡ?ܛB?38P@Qs)@)@&u?GTAAA]P@9c?GTAAA9c?loc?<]+?s?h Alp?ņHfR@")@ڹ8?}гY?TAAAG󩑒R@ZCҕ:?TAAAAf5&m? (? qX?ZC*u?;T?Z:?Q@V)@"r? o_Ή?AAAGCƳsQ@=?AAAGC=?c+?Ce?~>ȶ?ax q?TP@)@. ?o_?AAGCGZGe_%NP@FE9f?AAGCGFE9f?f?H6O˧?t?2,:tW?yP@I})@r?a+e?AAGCG/&NP@\%*l?AAGCG\%*l?LIY?: k#?cw~,A?Χ?BQ@:v)@]}@gj+?AGCGT:; R@gtzt?AGCGTgtzt?ߝt?u2?koւ? 8kW?e3êR@St)@;EM @(?GCGTAY R@牖 ?GCGTA牖 ?Qha?bt ?G?XCM?4PSL@)@tnk}@/n?CGTAC P)cK@?GATCA3G?~)q?'[ȕ?ѨEB{?pŘE?'Y;P@K{/)@ƷE?_L?GTACAxKO@qŧ;?ATCAA &?y?G-?_ع!?ƅ?f3} R@ )@S` [?ZӼ?TACAC%ƢR@"?TACAC"?'?XS?UG?ogvVZ?e JgQ@x-!)@0??ACACC6![Q@^/?CCTAAA9B?z.n?qc?h?[fA?o(UQ@)@O?q?CACCG(Q@jY7^?CTAACL|??/4GcC?+ (?)7?# a?P@( )@5a%W?UN@?ACCGGSc1Q@8$?TAACAmh? (l? rS?Y h ?!=:?O~>P@*@D%|C?L7A`?CGGGTVqlP@xH_߾?AACAG F/?!>?z?.ˉ?L(޾?gR@|P *@3q*@ψ ?GGGTC47ZQ@gx?GGGTCgx?HY? R6䑰?N?[wQ?fNL@1**@p@Q?GGTCAeK@.е?GGTCA.е?>v>2"²?W0d3*u?~ \?mO@k *@4jvch @/n?GTCAA=7Q`3O@$??GTCAA$??5Izs?k>?M?l('w?=s8R@9#J*@^{1? ^)ˠ?TCAAT̝6R@$}$E?TCAAT$}$E?$ ?O~?}9ָ?Jޤ?(_ϯ-Q@鷯#*@4~c@w-!l?CAATTذfQ@jSz?CAATTjSz?:P?X[!_?x}?o}I?l'gL@1.*@̉۸@vq -?AATTGwϮ4M@[}?AATTG[}?ٮ`"C>&‹&?(?kK?VXrjK@2*@ìޖb?St$?ATTGCLp/K@&:r?ATTGC&:r?܊ >Bא_?4 phsX?$u?]vZ/K@ŏ17*@3K7]?I +?ATTGC#0K@Me,h?ATTGCMe,h?S:>Bn>z??ƦM@ F%uB*@)?46GP@e`TR*@ k/ @ׁsF?GCGTC;'<[%Q@Sa̴?GCGTCSa̴?ksX?݆ަ?ei&d?-Gz?Q@ۊeW*@l@Q?GCGTC%Q@_?GCGTC_?S &cW?q oLXP?YI?A"H^?3nEG@L=[*@s_@S!uq?CGTCG{W/"H@=K?CGTCG=K?y%H|s=&#p\ ?L >)?CGTTG_>)?{Kwx=O&d>t4>5 ?DK@:#J{*@?I +?GTTGT ,K@ hr?GTTGT hr?%c"QX>%&䫋?CRi?,(;? "׫J@|/L*@?kt?GTTGT~ВK@&"3u?GTTGT&"3u?~k>9]?a2,EE?0k 4+?+IAN@6;N*@؇:?I +?TTGTT!N@wo4?TTGTTwo4?+\brH?@iluI@*@8-?ŏ1w-!?GTTTTgboI@?GTTTT?-D= "?iM]n>pa?-zI@Ϊն*@U8d?o_?TTTTC=I@wWoC?TTTTCwWoC?b$l={^> .@>h~?B+X9I@~b*@Vw?a+e?TTTCCaըH@`AL8?TTTCC`AL8?c9B=Jz ?b2>9>3?LQHmM@(\*@}9z@F%u{?TTCCCaTمM@Fd?TTCCCFd?fEo)?Fk?Fάt?O 6?LFQ@?*@0!?QWP@=yX*@")o@-C6?CCTTCRA&O@R{R ?CCTTT,גit?,^.i?ՙ P?Þ_N?x<1?lZI@1*@$tw0?ŏ1w-!?CTTCC"-ƨI@.[s?CTTCC.[s?; N@2=$x>6f4??K~"K@W*@( @H}m?TTCCA/uN@1J?TTCCA1J?l\>ϭ?8p㚢?Vb=?mO@ˡE*@oIC@-C6j?TTCCAN@&̼%V?TTCCA&̼%V?%T?Xl?]?? ~?3HR@$*@Nv?S!uq?TCCAGsQ@<d?a?TCCAG<d?a?O(?~ /Q@ *@ܗ?~:?AGCCATp uQ@-쳼?ATAGAt09?jdž?)=k?}'?"o.?8AR@Z*@U-?Mb?GCCATS0aR@($'?TAGAT@+y? % . ?چ@?2 ?>>0?B̟R@Af*@GI@ŏ1w-!?CCATC0R@BD2?CCATCBD2?)cL?KzC?_ D2e?3_M*?%=0sO@J*@V@;?#U?ze>!YJEP@[B>+@TmhL?ZӼ?AAACC|_P@7dy26?AAACC7dy26?V[?f*zM?cQ`?1E ?d+aIN@1w-!+@?Rsu?Pkw?AACCC4eO@}(?AACCG4J? 2:i?^V6?$  )?}#?xBEQQ@9gDi/+@3?I +?ACCCG+Q@-O?ACCGAk?֢?V+?!H?c]4E?ok f#S@z):2+@{M>@+eX?CCCGAr-lR@"?CCCGA"?RJ$?<F?,Sm[?э> "R@ F%5+@_q?"u?CCGAC]MR@GcdG?CCGACGcdG?lMj?$l?mѕA#?T`G>ZS@fX7+@p,q?S!uq?CCGACC|R@fާ?CCGACfާ?? i?A=Q?8bK2?Q@*:+@ _?ݵ|г?GACGGe6JQ@OD8?GACGGOD8?tG^?Qj/*?Q 9K?9?$\.R@l G+@c?ǘ?ACGGAhZ MR@`߈?ACGGA`߈?YNjiw?4 ?vm/?jrQ?gQ@K+@@wOjM?CGGAT gQ@E(?CGGATE(?0ت?z?B )X?%*!}?[T@_+@?bرf@ŏ1w-!?GGATG髋S@)8H?GGATG)8H?)m2?kMxVyœ?,#o?yAM>Xմ3N@0$a+@v?@{?GATGCxg(O@y]?GATGCy]?s}]?S)Z?&!h?vz=ޫ?_L@ h+@L?ZӼ?ATGCCZ]L@y7͠${?ATGCCy7͠${?ynDtQ?'F?\S?LNE?> C8Q@B+@=L?-C6j?TGCCGQ@5#E1?TGCCG5#E1?0"o?:?;/{C?CM?ېR@#~+@Em@L=U?GCCGTw:nR@B?GCCGTB?z ?;.??1X?(, R@e`T+@~mh1?-C6?CCGTGU}R@7tq??CCGTG7tq??b!X?:9.?RR]?6ǂHr!C?}1I@o+@+n/@Pkw?CGTGAJ,;K@^5/?CGTGC]E?U @e>t$?e( ?=s݁P?鴁N+R@U+@o @+eX?TGAGC5J2R@M0t?TGAGCM0t?cFJ?\I?i|Ч?|8?4LP@ׁ+@LlQ?&†?GAGCG^匬P@h?GAGCGh?XC?4??Ůː#?̚CxR@=U+@_? ?AGCGTR1R@:j?GCCAGMM?9?6 ?3U?yŖ?j)t[S@}8+@>':?!SP@hDio+@r|@`Qk?GCGTG(.~I@KY8+@s J@_vO?CGTGCK&gsJ@*?CGTGC*?9T@0뛪=4c>m_2?,2A? KJ@F%u+@Gj9{?V-?GTGCCZK@էhF?GTGCCէhF?Ӄ #Y>9P!D|v?Ӏ_?^i?˭LQ@48+@$4?]m{?GCCCA |@Q@f(?GCCCC9 kN?1Ih?H?B9i?c+o?>mXR@3+@{6?" r@R@_vO+@&ao?^K=?ACATCgD+QR@e,(?CCATCh 0-?R4I?%~"?Bs%5p?+6:?YcBZM@ ,@ە:?~jt?CATCTo=N@:7Le?CATCT:7Le?}F>k?R{(D?s??aN@A,@n!Mo?Mb?ATCTAs{΃O@~'Հ?ATCTA~'Հ?_?W.?xr? 9l?OoP@6;N,@ wm ?ŏ1w-!?TCTACP@zHs?TCTACzHs? P?KP?lxb|?G\~?q/5LQ@+,@ q?n?CTACAFqP@R?CTACAR?}q?kk??~I?,S?3q`FQ@,@m?I +?TACAGܭ&Q@bގ҃u?GACAGMRհ? ?I?{LVD??/W?rR@D ,@iMbe?a4?ACAGC: R@%3W?ACAGC%3W?\O?=57>?l?$_)?z@#P@"9,@tz?A`"?CAGCC߻jP@~?CAGCC~?Qm?nF?NHZ? ?{?3\?abnk?oo8?rK_x7Q@]h,@Ck@n?GTAGG0˱P@[v,˭?GTAGG[v,˭?Hx?`9?>PQͤ?sJ9~?]奸Q@Fxk,@Q%? ^)ˀ?TAGGCLQ@ ?TAGGC ?C_n?PG?|?FL>p?<<<;P@rhm,@8 ?`Qڋ?AGGCCL۰rP@9#ť?AGGCC9#ť?It?D<??l `?B ?3`[R@ꕲ q,@VEV?HP?GGCCGL2R@89?GGCCG89?ѣ#L?ki?4?U$l_G?(-R@<,t,@?J?-C6?GCCGTnR@X ?GCCGTX ?"p?,6ҷ??b"1?RL)R@Qsw,@mOR? q?CCGTT7ImR@D42?CCGTTD42?Жh?_a?v3?#lqt,?qV>H@48,@Tg@"u?CGTTTeH@ѥOO?CGTTTѥOO?uޛ@= a(T">v->}yD4?!iJSI@UR',@j?~jt?GTTTG%"Щ?w'q?q ?{:N@|Г,@ʛ3/?a+e?TTGAT*LMN@$l?TTGAT$l?3?TGATA:k? $ ?ɣ,?z#9?t0_F? uP@S㥛,@ٺpP?ψ ?GATGȂҶO@\&/~?GATGA\&/~?NI/?2R?&?? ף N@a+,@n;LCC?Mb?ATGAClvkSN@ެHm?TATCCnKeD?Y??aǑ5?7?oQ@l,@ e?F%u?TGACAQ@-qMP?TCCAC̎/?(?.?q1?fs?HzQ@m4,@֤z?b2U0*?GACAC4OcQ@ס ~_?ACGAC?Q.?X5?9? U#?TQ@ѳY,@YEkA?+eX?ACACC +h0\Q@倾?CGACG Q=/"?x,X?H-+?S⓸?'j?OQ@ʡ,@Z`%?b=y?CACCC-.IQ@j ?GACGC2$wz?Z?]ht?x?sOz?D_5Q@Ci,@Vɔ|?F%u?ACCCARtAQ@Qw?ACGCGm)ި??FƖ?AHzm ?~ `?B8@O?`H5/OS@-,@|΂? 0*?CCCAGݶr+R@y|B??CCCAGy|B??!i@P?r;?3|c3?vW>GS@S,@r/?St$?CCAGA2>CPS@훶?CCAGA훶?ϫ*?hZd?Z8y?洤d>"FES@2%,@P%?&?CCAGAPS@bz˽?CGAACIY\.? )C?ɭxi5,?g^?^xMP > P@Ǻ,@z~9 ?Q?CAGACaxQ@ts4dR?CAGACts4dR?7?^H?2BE?ݗm?ζJiQ@ŏ,@%YZps?_vO?AGACGVwQ@LZb?AGACGLZb?9~1?ٷ?/ _I?}eo? 5Q@NS,@$#@Mb?GACGT-SQ@fF⁖?GACGTfF⁖?{Xa?ˤ?F`#?zˏH?8_Q@_,@p)@+eX?ACGTA/Q@3ϑ?ACGTA3ϑ?C8w?c??B?x~ ?_sK@J,@R*8PN@ rh?CGTAG'':%K@Rk;?*?X=#?ބP@,@IvҺ@~jtx?GTAGTB&OP@8__?GTAGT8__?'4 ?BdUE?;?c"?YEK@H.,@)~Kh:?{Gz?AGTGG5+'"M@ H ?AGTGG H ?p9>XYr^?J`P?gz?ދN@:M-@R?S㥫?GTGGThN@l#g?GTGGTl#g?G+LDE?^W9w?杷?vB?;P@-@an?HP?TGGTA@>Q@,)?TGGTC?~ 6?^r)%?p?D Cث?cqb8L@_-@@? ^)ˀ?GGTAC7.+ҘM@$s?GGTCA>7N(?<"?tν4-?˛`?o ?6N@h"lx-@قB@cZB>?GTACAuӕO@8k"?GTACA8k"?9?9R-l?&_[C9ԭ?.Fd>??vPQ@Cl'-@؈?cZB>?TACATԋQ@b?TACATb?!!p?N o? ɱ?gh?u.#jQ@Zs-@0C@:pΈ?GCACAQ@nss?GCACAnss?8?̓?I?aZy?t7]Q@|-@o\? rh?CACAGKo<\R@?CACAG?si5?:_E?c=Q?Vʟ?CR@k -@ݧ{?ZӼ?ACAGAy>\-R@3(d?ACAGA3(d?0'$?8x%?mgu?ukV*>2$j&R@%-@ a?+e?CAGAGA;%Q@r"ܭ?CAGAGr"ܭ?Ld}2?rC薒?h{S@-@3??Mb?AGAGAކT@,dڹcq?AGAGA,dڹcq?4¦?kQM?1?6l;:t`>ӂR@`vO-@`%UR@&?GAGAC t46kR@6X?GAGAC6X?ު?bTo?ҀSD-~,Q@8gD-@v 9@_vO~?AGACCf] <Q@b>?AGACCb>?#}6n?*d,?F[?K0 4n?@qVP@^)-@"YNO4?w-!l?GACCGs59VP@XHT?GACCGXHT?k+9d?"d9?%P?w.tzK?Q@_-@1C?~jtx?ACCGA}c8JhQ@3~?ACCGA3~?DL'[M?i>p?HhJ?[雙;?]9S@s-@6=i?+eX?CCGAG3 S@2/c?CGCAA',?>?}J?l:I?Jj>L2|S@H-@fϘRK ?~jt?CGAGGNS@/?GCAGGI?2Ih?P?[ [?Ux>6Q@lw-@d؞?ǘ?GAGGTȏw}>eR@:Ϳ?CAGGTʦL?2ߢJy?s?iӰ9?.ZUe?Ϭ.Q@&-@ξ1?HPsע?AGGTT\Q@\)93?AGGTT\)93?3wu?qvKΠ1?(#?gl$?ub'vM@ --@3ֳ/?q?GGTTG/4 L@}LpM?GGTTG}LpM?3 ?P /P?,?.}?5OBK@aTR'-@$iL@ͪզ?GGTTGVL@0*-?TGTTG䎰?/#>>7-]?U>ɿ?'x ?p63J@):-@eޜi?a+e?GTTGGt' ?J@WS?GTTGGWS? ̲#>%2r'$8?/^j?[@d?DWM@-@x+G? ףp= ?TTGGAN@TpMr?TTGGATpMr?N.+?.rq &? }?M^"?Q>ǗQ@ ףp-@y @-C6z?TGGAGTQ@ gc?TGCAG.j??9-?_@q?1o?ѽ󄋓Q?lT@-@htdj@Mbp?GGAGCY tpT@YB?GGAGCYB?nK^Ԥ?k3$?MZ?k>2,jaqQ@6.@wú#@ŏ1w-!?GAGCC{P@}Q?GAGGCg-vB? @o?9۪?Y.vx?"K?yELP@ґ\.@>Dگ@`Qڛ?AGCCA 귬Q@>8;?AGGCC?6#?ᵃ%?%w!?;k)? ޴R@E .@\ix"? QI?GCCAA7[iuR@;5z?GGCCG`(?6?A?qn$?dWW[?GGGTC3[Q@+?GGGTC+?ϱ魘?s"?)p?i>|;?wL@ cZB.@`65ъ@+?GGTCA' K@48?GGTCA48?UiA\>r__o?:c?(NNZ?n̥P@VL.@7'@Q?GTCAA4O@Q0X?GTCAAQ0X?)MA?W?[7VT?k͡?p?p= Q@ -P.@$cb7J?H}}?TCAAC8f%Q@|y?TCAAC|y?ڟb?_?m ?[|/?ƒ_llP@R.@v͟f?b2U0*?CAACG#pXP@( ?CAACA 7t5?)6m?33?"IC;?ڻ?{+Q@GzT.@1c?F%u{?AACGTPP@\sU2?AACATd ?؛"`l?X?fsW?ˈټJW?RܮR@j+V.@v.?ͪզ?ACGTG/ Q@ M+ ?ACATTZ?c*?X9E?8qȹ+?x ?gHI@=Ra.@sin?Ǻ?CGTGGHX͚J@iC*?CGTGGiC*?m=Q >Q~M>ЎK ?ZSO@Std.@+9@Mb?GTGGTh8N@ܝ?GTGGTܝ?<?S H?Ƀ?0+x!?13P@h.@m`@a+e?TGGTC 32P@r?TGGTCr?SIlCү?5/!?&?M4Zį?S9K@)~k.@{+@y&1?GGTCC:ĘR\J@>ɗ?GGTCC>ɗ?K\ZW>^0kp~?(Bʃ?֦H?dj7L@M Oo.@J N?_vO?GTCCG˖WK@Ƀ.@Uvc@H}?CGTGTqHuJ@-.%?CGTGT-.%?!R0>M7>_T\P?L֜y(?DvMe?YT?8!?BmP@ h"l.@P@F%u{?GTCGCdIyN@)?GTCAA{?'^O3?;\i2?:W3"?##9p]?;.Q@2.@%R$@d`T?GTCGCyN@>5ڹ?TTAGCOy?5?~O j?xc "?oWg#z?cQ@d]F.@;?_L?TCGCG{~іQQ@b?TAGCANrW?S? Q,?V?am?KR@kt.@2ek?{Pk?CGCGCo&S@Ś??AGCACC~d?Z[ J?>Gr?!n?x $2?[KO[R@H..@fvv%?q?GCGCA㠊Q@[lp"?GCGCA[lp"?{sB?MCM?ꇃIӚ?az(u?I-WR@1w-.@N0cnG?gs?CGCACJQ;6S@%J}?CGCAC%J}?b?|?${;?n6[?YycR@%.@y?5;Nё?CACGC'E[)R@'ki0?CACGC'ki0?w 9?CC?{㉷?;.F[?7666^Q@=yX.@hY?&?ACGCAdEQ@ې?GACGAhcд?? Qѷkt?001n?&7ܜ?bߔR@.@Z096?:v?CGCAC(b=6S@D?ACGAA"PhWٯ?~v?ȋ.k?y(?{L@?ԕޙIS@|?.@8eT?ŏ1w-!?GCACT~@.R@UJ.?GCACTUJ.?/?-?QBJ? [$&?}`&R@x#.@h)?HP?CACTG\{Q@pHQʶ?CACTGpHQʶ?2ݭ,~(?B ԥ?zYq?: ђ?gQP@{,C.@DE?JY8?ACTGG,wytP@'æ?ACTGG'æ?jHB? ܴ?w]? ?*' +?JP@ o_.@`!d?_vO?CTGGTzO@Db?CTGGTDb? l?Ip ?Y8ci?g-aaݷ?}DHg7Q@.@z @HP?TGGTTt3|?? )+ZL@&.@?vq -?GGTTG1Z3L@Ȗ{^?GGTTGȖ{^?7&t>D3{?+YcKz?T"|?(MTK@ŏ1.@?"u?GTTGTIxrK@AW8`(?GTTGTAW8`(?o ">bx64W?3Nȑ?^?o.?M@+e.@|=ѯ?ŏ1w-!?TTGTT3_"N@Q?TTGTTQ?6KF>H?'5?Zb?oy?Lò[J@7>W.@?V_?TGTTA =>9wJ@9'?TGTTA9'?s->P{S?oOt.I?EVZ?wL@X/@E$?Mb?GTTAC)q)EK@s`B\?GTTACs`B\?\T?[ci?>"?L`""?vkP@Aa/@;LK?Uؿ?TTACG{O@_"?TTACG_"?AD?^n?K$?^b?4 Q@3/@9: ?JR??GTR@AX/@#>N0O?jM?GCCGG΀WTR@l͏?GCCGGl͏?&?Lʦ*?W?yf@?X3R@(\b/@YԘI?St$?CCGGCFRR@v!AW?CCGGCv!AW?7V8?tWj?dH[s?|sϵ?ٌ#hO@0'k/@閰V?gs?CGGCT!O@c O{?CGGCTc O{?οu?`sz?u'?R+?JMS@8m/@ X8@J4?GGCTCE=+R@cW?GGCTCcW?~?Ltz? 1ʰ?Zݭ?|O@sr/@/_&@5;Nѡ?GCTCGZdP@o@?GAGCC>B?8? Mk?$?&E?zb[Q@~z/@Z?X9v?CTCGAXpMQ@l?AGCCG?L@ ر?Z9&?.J)?G6qq0a?euqR@-C/@\]?)\(?TCGAAN$cR@P!yo9?GCCGA-Tu?a]ؤ?!I?7^׸?ٿ>%rS@/@rrcU ?Mb?CGAAGĴS@ Դ?CCGAA$ҵ_?wv?ٵcM q?0?M8w|q>W[S@58E/@t0@5;Nѱ?GAAGG^:S@7^P?GAAGG7^P?2'V? ?.+?5p/F>B -O1T@<,/@i@L=U?GGAGCpT@?GGAGC?tiV?'2-l&?1I?4UD>?W[wT@ /@$sI,\@{Gz?GGAGCE<']pT@?GGAGC?I?֊? {?? j">H6P@48/@1H2d@ q?GAGCGˆV2P@j?GAGCGj?y*x?/:-Ý?$n??Kg?vuuR@]m/@ ?ZӼ?AGCGG#'R@?@?AGCGG?@?D ?'?"?W7DD?˘N@47/@fyi@{Gz?CGGCGyO@n};?CGGCGn};?Lv%'?މ>e?|(M?!?\:TS@ lV/@Z@St$?GGCGCk2vS@?Q]?GGCAG&a?vR?k{t?:C_?!-.>JR@=R0@M*B?T㥛 ?GCGCTڡQ@˃H?GCAGGj& ?#7W?/?҅_?vJb{#m1?fŒ2R@X0@ O~? o_Ι?CGCTT R@x)?CGCTTx)?g5HA?Z?-@? [?~VQ@0*0@l)M@n?GCTTC[9O@`S|??K>$?U-R@wOJ0@/G"?ZӼ?TACTA xQ@>­?AGCTAj5?T?c!?PE2?jo?6>WP@>W[Q0@:{'P?{Gzt?ACTAGS P@[?ACTAG[?&"??uMO?Fhk2?;cR@'SR0@7k&?S㥫?CTAGC"R@SvoO?CTAGCSvoO?Hu Q?jLU-?t_?-P?YD_P@"u`0@_?"u?TAGCA|)wP@iٔ?TAGCAiٔ?vc)߀?zV?+ng ?/ on?F}"R@ b0@@ǘ?AGCAT-?R@;`?AGCAT;`?(%Mݭ?(??6 5?SB{R@Af0@1U?:v?GCATC@>R@ ?GCATC ?`jd@?,c?Ld?|{`?rMWVN@9#j0@0#?ZӼ?CATCCa#jN@9U$y?CATCC9U$y??/S YM0?ji?mc!k?>Q@8m0@Q5o?n?TCCCAw;Q@n#U?TCCCAn#U? n?x ?\?M}_myS?.R@Hp0@2\Lr?S!uq?CCCAT=\R@7v?CCCAT7v?ӁpH?_?|s?`(`U>|WS@~0@6b?/n?CCATT R@`Oft?CCATT`Oft?pO?0UTZ? WG"?L>jdN@L7A0@BvWTS @"u?CATTC{eiM@k #?CATTCk #?f*>&ŵ?R?(?8`[H@T0@+kk?N@aó?ATTCGkz!I@'?ATTCG'?:xY=ֱ>gȆ>&?HWA&N@ h"l0@˞k@J4q?TTCGGxHS8T3?TUR@b0@Dm ?J4?TCGGThsC!IR@L~o?TCGGTL~o?aP?E?9Sg?oz>LLO@Bc̝0@h@b2U0*c?CGGTT8OxP@|85}?CGGTT|85}? }.|/?t4?h?nq{?CK@Bi0@.M@Zd;O?GGTTG H{L@MȍH?GGTTGMȍH?RxĮ>0?hD?֙J?ZC4mD?)J@:M0@^OMF?~jt?GGTTG|L@ДA?GGTTGДA?3+>t} ~?q~,bz?cݿ.M?qgCh?m>?@:J@k0@h]7o?1w-!?GTTGC_3J@c ``?GTTGCc ``?Ņ =-=A%90?ec?P-7?zL@ڊ0@*bB(}?H}?TTGCTFqziL@Ml?TTGCTMl?{a@5R?+R` ?k{?_,[Q@:0@>(@b2U0*?TGCTGh{R@'=.?TGCTG'=.?|rV?ws?nW ?L&Kk?%zFO@鷯0@ ^H?:pΈ?CTGGA}`O@ C?CTGGA C?2h8i?l(BBx}?fb)#?]2@_Lu?TGGAG[(VQ@aֱ?TGGAAq>zQ?pIY?b:Ǵ?"?̅? 3S@H0@'PuE @Q?GGAGG QT@2k?GGAAGjR]?c-K?Yc]?} h:?տ>q&R@0@Ojf@Ǻ?GAGGGP_DR@\?GAAGG];4h?Qu.?߼?VnM 1u?$y2? θBQ@k+0@`$VUM?ׁsF?AGGGAk`R@թ͆?AAGGG!b܈u?tm?b/?Pܱ?B\?6/PR@W/0@v) @ 0*?GGGAG2ۑR@v Q?GGGAGv Q??0t%?3#Zt?Gz-6?Us>T@|0@L8] @ŏ1w-!?GGAGG[TT@xh?GGAGGxh?YM+~?c-?~b?<>!>Q@ǘ0@! @n?GAGGCb-R@|I1?GAGGC|I1? P06?|G/ ?P!/, ?zl?Y9HLQ@QI1@Vo?Mb?AGGCGD5P@Bs(?AGGCGBs(?mv?;v? [H;?b׳?xM T@ 1@-@HP?GGCGC9ҁvS@?GGCGC? #Oȧ?g~Z? `Xբg?R (x>VQ@/'1@ʼn@?vq -?GCGCA+Q@.=V9?GCGCA.=V9?|O?zfcQM?\K #'?Za?cR@43331@di#?C6?CGCAG4STX4BS@&?CGCAG&?MIɼ?m?W>??4}F>-٨S@ g31@?F%u?GCAGClCS@SU] ?GCAGCSU] ?d*?b)?t Y? k?[6P@y):1@8'?_vO?CAGCTuIP@F?CAGCA{N?I~|?[)?.??M0'o?6XQS@A1@cnB?<,?AGCTAAЉjR@`?AGCTA`?n"hG?U]?l_=?5e)-K? /P@aK1@ ?/ ?BzQ@9EGrY1@\?0*?TACCG'ŋ&P@QD\G?TACCGQD\G?Dc2!P?->?J ?ple?4=4Q@Q^1@!&?HP?ACCGAx{Q@Rre?ACCGARre?a!\c?#l?ʑ?ك??hZS@a1@?ZӼ?CCGAT S@j?CCGATj?$F?Hx?ph8p?%щRX>+Q@Std1@җH2 @HPsׂ?CGATCWR@DZw?CGATCDZw?5M{?9e?Fmp?B@@?f,L@Af1@8}j*@_vO?GATCGԜ M@c?GATCGc?1uNV?{t?63?;YQ?7~? lP@0j1@]S%??<70o?_@,'?hT1T@Dt1@ ?(?CGAAA%pT@$!?CGAAA$!?1?, ZdS@Pkz1@π.O?j+ݓ?GAAAG1R@ㅿRC?GAAAGㅿRC?ūw?:A ??V2d>Kо6R@~b1@"? ^)ː?AAAGCVQ@=T?AAAGC=T?b7E?i+椖? iC޾?;$8?/6#CP@%1@^Z?n?AAGCCb,P@X%?AAGCCX%?^Ʉ1?}\?l?/'6?BLRJ4Q@&䃞1@b;EQ?_vOv?AGCCTkАQ@M+s?AGCCTM+s??`l?ڃ B?cVĶ?+$$8OR@h1@}{9?UN@?GCCTC hR@?GCCTC? A?\?"?bH F?[ŋ"P@|Г1@J`8_?H}}?CCTCCeb1P@bX?AAGCCO4B_?$ ?Tvc?*?m~WS?w*oQ@>yX1@?ǘ?TCCCG *Q@].al?AGCCGؕ4?N8ԛ?t̠?'z?ji?/x!R@p_Ι1@pa?Q?CCCGTR@G=̫?CCCGTG=̫?+Ʃ?_+?ޱG}?eRC>6^|Q@R|1@C6'@Mb?CCGTGP ڥ]R@R8?CCGTTNѸqm?(0?^n?1p?81D?Qj=/I@O1@FQ;M@UN@?CGTGCwчtJ@mS?CGTTAL/p?jo=W.?Ђq2H?=!~Q?*K@#1@$|u ?`Qk?GTGCCz@K@|McL?GTTAGXe?V>`6];?{g{?HT?"P@qۨ1@g6.?Mb?TGCCCkµP@r=?TGCCCr=?w>,?fF?'?dp 9z?(Q@.!1@~R-S$f?ZӼ?GCCCG!Q@P&S?GCCCGP&S?J)ۚ?CM9?`b?/l.g?,R@cX91@f^9Z?+eX?CCCGTnDR@M|?CCCGTM|?KwK ?$F?\vt`?ʁ>KLJ@St$1@Ux;@@ǘ?CGTACa@eK@~8@?CGTAC~8@?,֯b>Dy{c?q[A?4AD? GP@ lV1@\.S.S?/nr?GTACG׾O@d76?GTACGd76?<%?nT?m0w%?DO?$(X"R@:v1@g5 ޲?䃞ͪϥ?TACGCeQ@Y~?TACGCY~?~L?[.Vl?e@?ߛ099C?MQ@ ^1@?Ǻ?ACGCC~VQ@-c8$?ACGCC-c8$?G.H?8:? Et`s?_¿/?U>uR@w1@fR?HPsׂ?CGCCG+墁R@gx?CGCCC1u?i%*?.$%R?G.-:?߉x-?/A[R@!u1@uRyN?Mb?GCCGC&ڄoR@$+2dz?CCGCT̯xOw`?CB?ܾ>O?-)?EX?贁Q@H}1@ȕUeu??(?^?@o0: ?X=H@%2@=C?@Ǩ?AGTCT;%xJ@ o~3?CGTCT?Z۵?ibΎ m=M7ͮ?S(>&XKr?Ґs,P@FGr2@N`#A@J4?TCTTCjO@i j/?CCTTCq>"т?נЀ?H?]>?ܭ1#?[ـI@؁sF2@.G?8d`?CTTCA2T I@^`?CTTCA^`?B*[oA\>QMm?Oa?KO?S N@^K=2@KrXj? 0*?TTCAA&D:(O@ |5?TTCAA |5?7Le?̕,?6>Nw?`j?{R@nC2@qsd?I +?TCAAA4{YQR@hYZ_?TCAATߍg?^sQ?%J? b_?(9e?D1Q@X9H2@ "^?gs?CAAACN q [Q@EO?CAATA!$Z.?-**o?Rw?I&2R? 3? n.GO@gjK2@t? o_Ή?AACCCgO@NM?AACCCNM?06?[?CQ@UN2@" ?ǘ?ACCCC`&WaQ@G?ACCCCG? NK?խ?çyC?} ?*R@WR2@~y )?n?CCCCTtUR@(*?CCCCT(*?4?=%( usg?8 n?BϔP?kbP@):k2@E`]?(?TTAGC@2Q@5M?TTAGC5M?! s?2j:?"?*8? !;Q@ꕲ q2@lO&3?_vO?TTAGC5މ@2Q@Ew?TTAGCEw?%6E?դ?J:}"?;z? P@|s2@p5j?&S?TAGCT/8qP@">?TAGCT">?z̃ε?ƞ L?*j?4&?ٓ8R@=yx2@RR5@+eX?AGCTTUSY^J@?*(v?S=JP@$J{2@nj@?ܵ|?TTCAG O@펃?TTCAG펃?ʈHc?b?+<\?NÚk?p=^@R@2@:v?-C6?TCAGThR@Qe ?TCAGTQe ?XS0X?Qn?#N?q)(?q%R@/ݤ2@k|?~jt?TCAGTbR@ׄ萤?TCAGTׄ萤?̦?ʀ?&c g?>HzQ@Q2@iO@ZӼ?CAGTTS^Q@?CAGTT?̗\?w!,?TnBO?H0?7BI@2@tz ?~jt?AGTTTq]K@n?AGTTTn?ٯib@=9&@?h ,?"?%%M@G2@&@b2U0*s?AGTTT G=K@B\?GTGTT*5_?PXd ?lx!N? g?W ր?DQI@L7A2@ \p?+eX?GTTTCZI@*Pc?GTTTC*Pc?'B= I*J?d ;?H 8?)G@yz,2@;0,?( 0?GTTTC݄I@dR ?GTTTCdR ?%V'X=zz)">Q>Ο֞u?. J@x2@,? rh?TTTCAa;'aI@+?TTTCA+? ݰ=>o?c =?kQQ?e(S!O@2@FC~@&S?TTCAGYO@ґC?TTCAGґC?88p?Ma?DARDy^?{ 90?4)UrR@St$2@UŦ,?mxz,C?TCAGCotvR@92\?TCAGC92\?o?ÖZ?q?eEc?î>79P@M F2@,im?_vO?CAGCC{tJkP@)_?CAGCC)_?1u-?(^?=~W? b?I@-R@Hr2@uc'?"u?AGCCTHQ@Tl?TACATM2$?:LӮ?sB[?e'?8T ?־aGR@C2@?/n?GCCTTqF].R@a/z"?ACATTt/?a*B?wY:P?Wt?$['?a'O@;M2@XY,w@Zd;O?CCTTC$ 'O@ `$?2%`QM?81?Q5EI@ g2@=Ft??CTTCAQI@# ?ATTCAX1w ?D.s$>VpE'?J5?J>ݏ?p= hfP@H2@q5)?y&1|?TTCATwrO@5?TTCAT5?41^Ϸ?c M?b|?? Pw&R@N@3@?a+e?TCATCR@ o?TCATC o?>G,?%de?@?B3 ^F?{O@?3@P~@Mb?CATCTD hN@/31P'?CATCT/31P'?z1TJe?+~nƔ?ɛ'?N*_? P"P@|/L3@ .?n?ATCTG\H&TO@vLER?ATCTGvLER?K ?PWU??_@? *O?z˓P@}a2U3@B??Q2]?lKPݩ???{e.P@'S3@LbR!?p_Q?CTGAA8zO@?CTGAA?E2ϰ?%? ףQ@M"3@z8@HP?GAATTZC ;wR@Qx?GAATTQx?].K?Uv9d?j]2o?8/0b?l{fO@Af53@T?䃞ͪϥ?AATTCL@J -?AATTCJ -?5!B_?W؟?ssP?I= 9E|?zz@I@¨N@3@\F(D?_L?ATTCG{AcI@{ ?ATTCG{ ?dO$>g)??2&1]?(\_KP@7B3@ lBq@Ǻ?TTCGCٴ-yO@JE3?TTCGGJ).?0_?Vq?))b2?C>?{eQ@X9H3@ 9*@J4?TCGCG^.%QQ@/=?CGGGAx?(Fȧ? Xj? q1??W)?HzR@ZJ3@D pt@ZӼ?CGCGCܛ%'S@zLfݰ?GGGACӔ}?Һ1?ۂ_Xx?I&=I?f>c?Y:ɁQ@ŏ1wM3@-N%0@"u?GCGCT"]YQ@hNH?GCGCThNH?Hrtү?.[?*yx?ZBḠ?ȹϞR@ͪO3@mSP?Ǻ?CGCTGR@Oea?CGCTGOea?t.3?Il:o?J\?Ppxb?~EQ@AfU3@CU?H}}?GCTGG(NP@ňH!?GCTGGňH!?+n?W3@My? o_Ή?CTGGGxkO@˽e(?CTGGG˽e(?QrT?Z_Ġ?*?Dqu?@ӞQ@h"lxZ3@;0?C>٬?TGGGGSQ@Il׍?TGGGGIl׍?m?Y80??ag?/)R@]h3@+Vy@3U0*?GGGGG4tR@ܺoc?GGGGCc? I*H?!C??n80 F?O&yQ@u$p3@=or?<,?GGGGC:8R@?GGGGC?(܌?ZK#? U?,ttL?=%lP@s{3@P%>@/n?GGGCGBP@w*H?GGGCGw*H?*np?dan?۶N?R̟?]%j0S@ lV}3@o( @_vO~?GGCGCwS@3s*i?GGCGC3s*i?Qs?]?+kkq?%SB>\mE)R@Zd;3@jF?{Gz?GCGCG6@ Q@I[?GCGCGI[?%[?.?sP?XɈC?sS@ Z3@@o?_vOv?CGCGC8& i*'S@( #?CGCGC( #?@ƛ{?K?|$ˠ?JhM>:`dQ@o3@gԭ@ o_Ή?GCGCT'5I]Q@L?GCGCTL?r+I?yKuI?fo? Pr?ƤULFR@]3@[1O`@F%u?CGCTGaLR@+{',?GCGCTQ㘘?hm?K }?IN? Z?RQR@V3@H?_vO?GCTGC͏ P@G,%*J?CGCTG﯑?wcq?;T?(>?]R& ?z(L@w3@(3/?<?L5-i>dJvJ?ެe[lP@n3@B? 0*?TTCTTpN@Z*S?TTCTTZ*S??~nD ?Px "?/S?_'LrN@3@ ?0*?TCTTC{}~LO@gy?TCTTCgy?|1&??x܇?24 ?R-?= hH@> ף3@*Ѧ5?Mb?CTTCC$ I@;?CTTCC;?aI T=ȷ>Ckw(> *? fM@~j3@HJl??TTCCCy dM@ jW?TTCCC jW?: yi ?b?$[?5eӱb?W"Q@33@E\?-C6?TCCCGX~D*Q@5>?TCCCG5>?ݝM? |_?&W?uSS.̀y?_nuR@~3@_?_vO?CCCGGh2R@t?CCCGGt?ی?.?Y?5(4>e$]S@9#3@p?/$?CCGGA=FR@b?CCGGAb?QIm?%R?xÕ?!A>-uP@[Ӽ3@FQ'?hs?CGGACi":P@|fb?CGGAC|fb?FJ?vhy2?ly?$lն?lO,R@FGr3@U?<,?GGACTH}F R@)$?GGACT)$? ?ov'I +e?nN?7Ѡ?ӯiR@ݓ%4@_T د@UN@?TGCATD!R@˲Oc?TGCAT˲Oc?;Ѻħ?|D?3#NM?]?R@-'4@-?Ǻ?GCATGR@#u?GCATG#u?XUD$?+D?ucP(?Y=\?a7a(O@j+74@ YaX@St$?CATGCCyP@sPL?CATGCsPL?5#i`?ؠVa?ȑz?BY?mKL@46<4@0\R@!݋?CCATT!݋?sz#?N?ܡOZ?O=z>GKR@ZB>H4@Vr?&S?CCATTΫ\R@,Z{?CCATT,Z{?]V?^fS?9W?eX `?h O@L4@\@~jtx?CATTTTWN@p ?CATTTp ?ůCk>ේ',?jo`?8H~?vQ!2I@:pN4@yl)?S!uq?ATTTGB3I@Cyc2?ATTTGCyc2?,ɥC^=\fS>Vwi{>&V?D'/aK@CiQ4@[9I?Ǻ?TTTGTf}K@_L];?TTTGT_L];?D.> .][2?g2t?ut?p= M@~jT4@C*R?-C6j?TTGTTiy#N@Js(V?TTGTG_"Iڳ?\>WW*> ?^B >?&N@S!U4@Qgp?ZӼ?TTGTT#N@k?TTGTTk?az&5?_#r6?riQ?>n?N8J@ 0Y4@r㘍?:pΈ?TGTTAϲxJ@?TGTTA? )g^dM>e#"h?%M?^?;;? M*Q@ F%ub4@&?sF?TTAGA/4ApQ@)gm?TTAGA)gm?'f?N ?hVQ?YpBP?ƌ{/Q@.q4@ZZ?(?TAGACQ@&Ji~?TAGAC&Ji~?OL?lZ,?|[?yh?0CQ@Qsw4@=;?ˡE?AGACGGQ@d]?AGACGd]?]W]?L}.*?ɰ-a%&?O1?}[Q@t4@MZ;QO?镲 ?GACGCc\?Q@l\?GACAC2`i?4OͿ?d0=?mŷ?{ޠ?RjQ@]m4@$Ñie? ?GACGCHM"]?Q@1[Ts?GACGC1[Ts?z?s`G?3 :a? rc?M<+4&Q@64@z߹?c?*9?B?P9WdR@( 4@U&I(?=U?CGCTGLqpR@SS?CGCTGSS?Ø)?{ѷ?6?*r7H?ځ4^Q@8d4@(Ap@UN@?GCTGG+ȰP@mz$?GCTGGmz$?N?>?Eށ?QCH?޸?]P@b44@&R@q?GCTGG˟/P@)=&?GCTGG)=&?;%Y?Ӌ??p-?:m3Q@43334@; LB?b2U0*?GCTGG脱P@?GCTGG?Ck?8ŷ?r?/> e?fffFLRO@I}4@a&d?b2U0*?CTGGCD`JhO@?դ?CTGGC?դ?l ?b{Ժ?D?40{?F8P@^K4@.1 ?gj+?TGGCG6bL,O@8^?TGGCG8^?uևx҂?,l.ݡ?V0@?r9xY?_S@&S4@f+Kf?M O?GGCGAVS@t^?GGCGAt^?i"r?=b7?/Ѽ?r&M>E9R@y&14@>$%@_vO?GCGAGS S@4~?GCGAG4~?H-?pD[q?j0?3P?͔S@_vO4@Y&w?S!uq?CGAGCOM3??ATATT>3??]lI|? Ï?:㼣p?a8?D a]N@x $(4@Kt,\@ o_Ω?TATTC%R N@r@\/?TATTCr@\/?Ǽ>d r)^?Hnֱ?\|@?KUI@0' 5@JGV?ZӼ?ATTCCe+lI@? rӊ?ATTCC? rӊ?ܽq=*CU,> !>n oj?:@bL@$5@֑m?St$?TTCCGw M@`(#D?TTCCG`(#D?w#p??gCf>?"sT?~`Q@5@M?+?TCCGC)K?TCCGCU>K?фn0N@d#?GGTGAd#?.A?,:B?H?XWEt?(%.M@sW5@;'?y&1|?GTGACOz0N@Q|?GTGACQ|?y{?l2P?ALD<9?hU5?YP@|гY5@*0? ^)ˠ?TGACC3P@48I.?TGACC48I.? $m?$Sů?T#?35H?EgJ6P@+eb5@w?UN@?GACCC!U& 5P@a,V ?GACCCa,V ?D?&l?b?m&?=IP@xf5@|? ց>|^#sR@ͪo5@|󀸭?Q|a2?CCCAG hR@ 1w ?CCGAA͢5ɐ?іW?vv?dRMI?~X9>Wy:]S@\Cz5@ا?ŏ1w-!?CCAGA34PS@q[?CGAACxegtr?^?_@9?߃J+5?ؠ.7 ?|8Q@x $(~5@~??߾?CAGACTwxQ@l?CAGACl?WO K?n4o?:?8?P@a+5@ ˦?j+?AGACC#X #Q@a`kP?AGACCa`kP?%H?k?833vJ?M?[VP@5@_s??GACCCoP5P@6?GACCC6?%۵?lv?nlE?ff̾?_P@5@nD;R?UN@?ACCCT( ;Q@2?AACGGyu?wYzŁ?3s?Tm gTr?(O?.f'R@65@Z*W&?{?CCCTT˜R@2OL:?ACGGTT_?^d?Vg?={?Z*u5?P@ q5@ ѓ+ @"u?CCTTTIkO@dba5?CGGTT? M>C?a)A2X?\>* }?tm*?m7Q@V0*5@n2C @S!uq?CCTTTykDlO@z ?CGGTT9?q^?8w?%=6?~i?sOI@X5@)h?i|?5?CTTTTHXI@1+=?CTTTC&_Fw?׻If=t>Wq6>*M?uI@_L5@&?n?TTTTAaW00I@zɞ?TTTTAzɞ?p!t=F 2)?i-,V+>d8?[O@=U5@b_NC?&S?TTACT*o P@Vy(&?TTACTVy(&?S?0Ɩ?Rp? ?ULjQ@5@tP?/n?TACTTeŜQ@7b>20P?g<TfK@ 6@k󥸖?y):?TTTGA0iK@{P?TTTGA{P?%㚖P>p)? ٝ5'?U^K?=CM@ 6@C5 \?St$?TTGACNN@A`5㝬?TTGACA`5㝬?n?X&?-[qѷ?y.? 8,P@؁sF6@P% m4?St$?TGACT/yQQ@Ac|?TGACTAc|?~a_?(?rL1?w71?RP@JY6@["Ҋ?-C6?GACTTA Q@WCt6?GACTTWCt6?Ǔg]?eAlX?+(̱?%(k?Lp00Q@Y56@7QQK? 0*?ACTTAy`^O@)>Iu/?CTATC???#Tf?5=v?ߛ?ol}?1iS*M@qΈ6@d ?/n?CTTAA߈L@ ,k ?TATCGg74K?ciO?Ny/e?zJp΢?XW?y>8PP@S#6@JB_@~jt?TTAAT q4Q@Kʻ$?ATCGT/fj?#Y?t%Bw?فq?}E?rqqQ@gfff&6@퐳S ?ZӼ?TAATCKIQ@UT6?TAATCUT6?_yh?13{? pR?rfȳ^?!""[JQ@c=96@6?-C6j?CCACCO#wQ@ kmx?CCACC kmx?uJ?~F?Jm- =?(4%k?rR@:6@?Mbp?CACCA,RQ@ o?CACCA o?G')ԩ?I?P'?_]c?jP@s;6@њ?HPsr?ACCATOQ@4`V?GACAA^u?׹]?4? Jg?!4?s؋R@{,C<6@U/?ZӼ?CCATGK!}R@$j?ACAAT";?Ң?=?Hqf=?x"W?㑍 ?d"=PQ@Y`6@j@S!uq?GGACCfQ@,Nwjr?GGACG p?u?ݳ4?<P?.gw`?^r3Q@?d6@^G?St$?ACCCAHABQ@W-?GCCCAUDE ?FkiYnӨ?Ѣ??Ot?I\,?d}=KS@;h6@*#L{? o_Ι?CCCATxmR@-bҮ?CCCAT-bҮ?w~?[õ? %? B2ܼ>`rS@jMn6@D3i5?_L?CCCAT>bnR@~~,?CCCAT~~,?ѵ9?ں?gٵ?lZC> ҷ S@uq6@a8惊? ^)ˀ?CCCATtMnR@6?CCCAT6?ogzG?%jS? I?U& >UJhS@ˡEs6@7R?_vO?CCATTfɫR@Cd?CCATTCd?-?Rݧ7"?$Ҫt?IT>d O@zv6@Ar\@_L?CATTCW MhM@ fOP[?CATTC fOP[?/J?Lqy?U/?+^_w?a.NI@x#y6@D˓y?`Qګ?ATTCA9 I@l|?ATTCAl|?-;=`= qWy>By?iZ?rEM@_)6@y6h@_vO?TTCAT-x\O@˭/v>?TTCAT˭/v>?6,c"?ʘk ?|5C?]ݹxvQ?6#R@+ԉ6@6EE?(?TCATCjZR@kf"?TCATCkf"?\;,?Iݐ?-L?qW6?ZXP@M O6@Gq3z?Ǻ?CATCGX wN@2>?CAACGQ*?G>8?q'8?Zn?O(o?+XQ@V-6@Ks%?Mb`?TCGCG?j@RQ@.6?TAGAG]]?'<lJ?41j?T{?O1"AkX?(XS@ 6@l@Q?CGCGANZS@h?CGCAGvfxp?q?%?D;? rR>ZӼ!yR@}?5^6@Z}@Q?GCGAGQv S@ ϡt[?GAGAG ?Lt?*?HJe?ۜ20?I݊HS@|?56@y? ^)ˀ?CGAGCr? ^)ː?GAGCGR:P@ɞb?GAGCGɞb?85 7?;в?OB?L?IVR@io6@"?a+e?AGCGC/1VR@Ʋڰ:?AGCGCƲڰ:? 3(~?*i?uŸ?S,3?UQ@z6@@v?<,Ԛ?GCGCA Ѱ3Q@2fP?GCGCA2fP? 9J2?z?Aot?6zm?b!}S@gj6@&C?a+e?CGCACЙwp6S@G_xJ?CGCACG_xJ? Nq?,+r\/?j3H?RR{>@15lQ@X2ı6@ťnw@?GCACCfy]uQ@?GCACC?d2?U؇? uj?Y?Q@~j6@5P?M O?CACCA\Q@> x?CACCA> x?sS>1?g?( K?f-Bm?DgR@[B>6@C ZJ?Ǻ?ACCACl/bQ@iov@?ACGAC ?O?濆0?7f?]#&?:Q@?6@i4dx ?d`T?CCACA>Q@ݽi?CGACA#9>w?FG?>I?5:?f ?R Q@:p6@hf&G?/n?CACAG82]R@Z?GACAGP]ׯ?mn?lqC=C?sw?y¨?yzR@e;O6@4%??ACAGCQfR@ Ugv?ACAGC Ugv?T|?>je?uK?YP?T<%cP@26@$?F%u{?CAGCTS"P@3?CAGCT3?x q?t lK?&j7?&|s?7R@Y56@2$ v@vq -?AGCTTA(bR@Jj?AGCTTJj?ȴz(R[?T5>+?BG2d?j%j7?)*>tP@6@S@_vO~?GCTTA ٫ P@pU?GCTTApU?@r?^?|vY?jY?!IuL@6@Xx;E?D?CTTACϥk#L@k*?CTTACk*?%?ĖU?o?;O?& `P@mV}6@( }?ψ ?TTACC0r/O@;u?TTACC;u?GMZ?}i8!8?j`ԫ?kE? GQ@"uq6@CZ?~jt?TACCA3F Q@OT?TACCAOT?D{?}9 ?գo?\x]w?EOQ@=R7@u3ٵ]!??ACCAG'7Q@oWS?ACCAGoWS?r~?bH&։?nTNR? 8w${?_R(S@q7@ SsK?Eioɤ?CCAGAevPS@.@²?CCCGC85?{" ?[)O?@hl?МH>?T. Q@jM7@]?l?CAGAT㽡Q@JQ?CAGGTW]?KPT?.RW?w~"??+q_W?RYR@ h"l7@\|?Ǻ?AGATG|6R@Zk?CGCTG\C?f7#?8n?w;?`h?@LtP@x $(7@eru(@b=y?GATGG+1O@I8,?GCTGAhDC? Nҗ? m?n?-?JJݎN@8d*7@`@Y{?n?ATGGT!P.wO@eX$}@?K*G ?!L ԅ?d&M@:MD7@YB<?gs?GTGTCB@M@]"y?GTGTC]"y?&Uq? ?\I?ֶcv[?zόL@@5^I7@}T@b2U0*?GTCCGj<X>M@E] ?GTCCGE] ??=;?U :?iS?pdY'?xߔQ@K{/L7@ޜR?`Q{?TCCGGIQ@'/+),?TCCGG'/+),?G ?K1??F=L`?@WKR@(M7@>e.b?<,Ԛ?CCGGGܲ8R@Ë3n?CCGGGË3n?{%?= ?VB?[j ?tzP@AfU7@xG'Z@V-?CGGGTy@P@қM'?CGGGTқM'?_k呣?Xm?kdr.??Lt?7t.Q@Z\7@灭?W}b?GGGTAIM~Q@lJ?GGGTAlJ?ԁҰ?^C?4?`?jE0N@ i7@1 ZN@HP?GGTAC"JM@ӷ|wЋM@y{Hǿ?GTATC.?r<:?`I?Ĭ?ZL_?t%Uu?' ZN@s7@!?#? o_Ή?GTACC'IO@ι?GTACCι?,U a?Y7g?C(?tB?6#|իO@Ϊv7@Ä5?+eX?GTACCﰪIO@O;r?GTACCO;r?/OE?@?nҔ]|?&?P@y7@Mp?ˡE?TACCT Q@L;?TACCTL;?R /g?th?sJЂB-??Ȥ?$R@?7@44?J4?ACCTT7SGQ@sܺ7T?ACCTTsܺ7T? kD/?'Xf?)Ά ?1ـ-?&HkO@猈7@?@I +?CCTTCA&b(O@g䙮?CCTTCg䙮?{!Q V?RqR?L=Y?O?E?{]3N@c]7@1ZU?a+ey?CCTTCYc(O@)K?CCTTC)K?(h.-W?O'a?T?ej! ?\u uO@.!7@¬s @Mb?CCTTCɝc(O@7/X?CCTTC7/X?8玣IR? g>?Re?9?+BpI@h7@.˿ek@_L?CTTCAfTyI@SgR?CTTCASgR?b$ȕ>t AI?XR˽J?k?K~EDP@m7@F@H}m?TTCAA<$ O@CP6?TTCAACP6?T{e?o?Wj(Y1?h`C?~R@镒7@+?+eX?TCAATJi;7R@sX?TCAATsX?R-ʗ?Q)Z?H4O?&Nh'>\Q@$7@+i?_vO?CAATA=?3Q@^C?CAATA^C?$)͏?ՠXp?ᐲ?~Nmu?`N@J7@_3?L7A`?AATAA-l[O@ AM5B?AATAA AM5B?OYDt?=tV?l!&?A ?)챍Q@b2U07@I*@y&1?ATAATPZXhQ@ CV.?ATAAT CV.?[cr?oo"uj?z4IT?W$U?Q4Q@8ŭ7@2*VS?Mb?TAATAw&YabQ@<*Y?TAATA<*Y?2?)T?p8?c&U`?\Q@ү7@Zώ@ ^)ˠ?TAATAm!bQ@ ף?TAATA ף?c.t?ž ? ?[525i?ClGO@477@ji ?{Gzt?AATAAқҖ[O@UMA$$?AATAAUMA$$?C+?衭 蕲??Xh?R ?}Q@b7@RF+?F%u?ATAAAoLQ@񶌑R?ATAAA񶌑R?F6 i?6 ?5f@}?]yo?Uq8AR@u7@Z5m ?(?TAAAT 6R@; >e?TAAAT; >e?Tv?><妥?Ž?J?̈́ M5?X{BQ@ cZ7@r$?Aǘ?AAATCT@ Q@R_]x?AAATCR_]x?u5?TE⒣?Cs4?}^P˱?orP@ 7@lS#VI?j+ݓ?AAATC8QQ@9b?AAATC9b?{Gr?N ?N?G]?v?CCGTADR@Q?CCGTAQ?XZ?p?DB?u4Q'P?orI@S'7@|•@+eX?CGTATTRK@-%?CGTAT-%?I *C>zΫPY?7uG?7>?_PP@_7@Yq?{Gz?GTATA6`4uFP@euS?GTATGt8?CwlL?D6?4p ?o}?#pUO@47@;5?ݓZ?TATAT"N&P@ \?TCTCTj>P?]x3?ZYĮ?܀?V?#icxP@lw8@] ??ܵ|?ATATG(jP@g0]u?CTCTGWk??xt?͗?G?Y-oDP@Z 8@Dkۙ?J4?TATGA\7fYP@+0L?TATGA+0L??siԬ?،?, ?_,Y]cO@: 8@˙?b2U0*?ATGAGhO@w@o?CTGAGyم?hňy?HŲ?T%?}5_?;cޞ S@8@H(h<@ rh?TGAGTr`wS@%% ?TGAGT%% ?y;v!?]th?ڤs?I!I>59R@ʡE8@„Aa@?GAGTT[*RQ@ґz?GAGTTґz?TgP?X^Wޖ?؋yq?exH0?Q5sH@c=8@ K@J4?AGTTG(޻(K@Ulm?AGTTGUlm?lJ|u0=-f>64a>6o=P?'I@iq*8@X?:v?GTTGC J@7m`9?GTTGC7m`9?ppP= "? Z?`{?L@vE8@}?Q?TTGCCruL@|r?TTGCC|r?Wm0>)SF?ti?ի[\_?C,'kQ@o_N8@$qo@ 0*?TGCCGlتQ@"8pz?TGCCG"8pz?jt8? hƲ?wya?p7Et&!?pgBR@ꕲ Q8@mŜrB?=yX?GCCGG !ZUR@;/?GCCGG;/?8S&̳?go^u?W:l:z?80.zr?L6tR@( f8@q+?"u?GCCGGYUR@}R?GCCGG}R?e1V?%?1$p? yH!?~SR@h8@;l?Y5;N?CCGGC64R@F?CCGGCF?Jf L?k?Ut?[ q!?Ҩ\AN@ŏq8@,@_vO~?CGGCC$0O@W'?CGGCCW'?uw3͇?4F6`Ln?B#?N7?>P@jts8@>Yi?W}b?GGCCC)Q@U#?GGCCCU#?pi#?6[D?-@?{AN?6^|Q@m48@Y?Mb?GCCCCFcvQ@ L7?GCCCC L7?Ud?B'?4pn?fBFv?NWQ@:M8@y&9ܻ?ZӼ?GCCCC3;׺vQ@ltv(}?GCCCCltv(}?@ ZQ?]?/*k?=Vٲέ? Q@x8@? ?{Gzt?CCCCG I7R@l?ACACG4-/?a?#kc?lu`5~?zJ L?Cx*R@y&18@>Nt?"u?CCCGA FR@7o,?CACGA36?'L?`uP?kD?7ʪj??jR@8d8@Vq7?Y5;N?CCGAA8 r"S@"62?ACGAA™Lr?,?W<S@ 8@gI??߾?CGAAT+B S@jbC?CGAATjbC?p6Z?X˽g7?#?Ħ? i>(@]yQ@8@HT@n?GAATG FGR,R@&s68?GAATG&s68?|?+MKJf?=ۂr?L? ;P@8@4H@ʡE?AATGA?SN@A5e(?AATGAA5e(?…i?M?D?ľ?w}?UBP@}гY8@Oj?S!uq?AATGAC9N@$;2?TATGAZ?-tCwK?W_d?e%Xf? _қ?gk?UO@468@<\??ü ^?4ӝQ@MJ8@Vrd?_L?AGACAt<ĢQ@\2??AGACA\2??B?J@;B?s[S7A?2:k?ҷ6Q@.!8@Ddyp?{?GACATK??Q@2?GACAT2?f=e?ck (?Q?NiK?BOVP@_L8@>ܪ@i|?5?CATAC7H YzP@N|P?CATACN|P?m+??6j?pP:?*AN P@~8g8@)hD?F%u?ATACT_i:P@XH??ATACTXH??TKiI?"Lݠ?Iq?)YL?Q@]K8@&?%vM?NSt$?TACTG)eX/yQ@`?ACCTGGjj?/??b}3?}~Ȕ?qLO@rh8@ CM.R?ZӼ?ACTGA5&P@ ȳݰ?CCTGAC ҭ?oIs?0`oeĐ?2j!? Z%?- O@K48@1l[?ŏ1w-!?CTGATzCO@'m?CTGAT'm?GAY}g?0΁>?u/?E{?!ոO@&8@= @S!uq?CTGATT){CO@0?CTGAT0?I,}?~X+s???ʅv?dQ@sF8@P'?Pkw?TGATA9x\,R@X?TGATAX?WDŽ?>[iFV?pLks? W?lgO@V-8@:?@ǘ?GATAG2g£O@;]?GATAG;]?~2hH?8D@?[\?79n)?jG0 ?MY?FxQ@a"9@נVEY?1*D?AGCCCUtYQ@E,X?ACACG^z"L?$W{??d24?$?m״?أp} R@58E'9@M~@Mb?AGCCC)xYQ@BЙ?CACGCF2?^9{K?X /[^?Ȟ~?47D?n\Q@Q)9@][?I +?GCCCA|\Q@˗q1}?ACCGC˾?8?mh?Lś`? _?}'R@ h",9@Vbg?#?CCCAG'2R@3L?ACGCTs= ?X$s?^?T?Fx$Q?27 ??4;?B-68?*;L}JR@ޓz9@Qz?_vO?ACGAA_vrR@߄t?ACGAA߄t?krm?}ES?yt`x?q2$?oSQS@O9@9kl?mxz,C?CGAACm1_]S@)~?CGAAC)~?>P 8?kq ?a?>YBQ@9@`@@HPsr?GAACA)Q@މZ?GAACAމZ?r?_4gCW?ڄI?ۙs?Yi!Q@MJ9@?P@e;O9@$0?tF_?AACAA kvP@?5VO?AACAA?5VO?BpZ?\?vj?q? ףAR@b9@K;0?H}m?ACAATGu:pR@7(BK9?ACAAT7(BK9?)إ;?Yxx?Xg?IL?tZQ@Pk9@n6@ZӼ?CAATC2FqHQ@`J?CAATT 4?29?mh? Nt5?^g?jԾK@(9@{?v/?AATCTX L@Ny.?AATCTNy.?DOA>$t2 ~f?ʼb?gH??)\œO@H9@w.B?J4?ATCTTx&O@k ?TTGGTz(?VE%?-2?ᄿژ?%?u(U"N@Pn9@o;b@&S?TCTTGKO@)?GGTGC|*{z?E] 4?qBH:?JQf?I6? ~IK@v9@ƿ?3?CTTGC1xYCK@pU?ATTGC H?m>x>),Z.?iAYkT?qu?xAQ@?9@|}oDV@ 0*?TGCAGfT:R@?TGCAG?,j?V;?O$B?3D?U`S@*:9@{(?y&1?GCAGGahES@C+?GCAGGC+?fk? 1?n?Z!`?sـQ@O@a9@oc)??_L?CAGGTt( R@SCؿ?CAGGTSCؿ?2?h`W?4B*Q@C>9@ը]48@/n?AGGTGBnfQ@گ9?AGGTGگ9?<[,?羺#?(, d?L4o?homN@>W[9@YR9^@{Gz?GGTGT_N@??GGTGT??AZ(T?X0ʱ?W4y ?>qJas?7N@ǘ9@[a@J +?GGTGTN@,g,?GGTGT,g,?\f+?:G ?pbF?~_c5?nKM@x $:@N?|a2U?GTGTCQ"8CAM@kxa?GTGTCkxa?5\ֆ?P8|v?PEU?:=Cc=?i&a ,J@=y:@yX\?<,?TGTCG:ԦI@D_?TGTCGD_?YbCSX>,6?e`?sf?S9gO@(\":@ D+-@H}?GTCGG?^#eN@6KT?GTCGG6KT? }?{Eޣ%?qK?BGv?fQ@?&:@v@#O0?S!uq?TCGGGs'R@?TCGGG?ȥb?8?=mB)?E)$ a?)9Q@uq-:@-@(?CGGGT]XP@3X Y ?CGGGT3X Y ? 7?s ?H(?%~?гP@2:@@ܙ@b2U0*?CGGGT}#zP@f?CGGGTf?2ˍ?,zv?$4U?)ܨS?PQ@' 5:@p @HPsג?GGGTCO}\Q@Ŏ?GGGTCŎ??CЁ!u? ?,1uR?G,^L@9:@}G9@_vO~?GGTCT]k5J@i?GATCTG?R[bc>?;S2x@f?@l+?O@S;:@eq?y&1?GTCTCW M@$&#@?ATCTC|? Tr?ؑS?*ZDze?nd?B%P@B`B:@M!?Q?TCTCT7-O@J?TCTCTJ?ZItn$??2ܘu?]ڝ8?+P@F:@5q?Aǘ?CTCTTF,CP@ d?CTCTT d?džefA?wfL?zJh?dk?QWP@R:@M$?_vO?TCTTT[bO@au=?TCTTTau=? ڃ?V?|EˤX?k?y*I@pT:@ [?@ǘ?CTTTAI@^S5Os?CTTTA^S5Os?ZW H=HENy>^M?{ҧx4?KjL@~Z:@ 3?Mb?TTTAG_WvOK@?TTTAAU?&FH>D\۟r*m?"da?SCQ?]Q@_:@^jN;?9#J?TTAGG$^Q@"a?TTAAGI??Na?t4E?Uhڵ?t?scP@}?5^z:@)_@I +?TTAGGq?Q@^3(?TTAAGZ`?˺e ?j?(qm?Meڌ?R@/}:@7^uC?ǘ?TAGGA NR@iIO0z?TAAGCIn>?:?>:X4??G6?g:u3k?κ R@#lxz:@^,_ @(?AGGACR@R&-|u?GGGACջ?)mf?@"C=ѡ?eb?Dvz~|q? Dl{R@E:@%z@䃞ͪϥ?GGACTC R@9m?AGCTA?se?`^N?\a2?`0@?Zr?3eZQ@?ܕ:@ wN?v?GACTAg&_P@܉r?GACTA܉r?dkq |?iK "?6`?S?9A2usP@a+:@?^N!? 9f?و_Q@;:@,?{Pk?CTATC8[Q@.Q\?CTATC.Q\?fkf?M!ke?0,?%nu?,o`(O@w:@ {]?Ǻv?TATCAnvN@S S?ACTCA.G_Y? L?uMH??ȍdz?Ch.*BԺ3?3Z+O@ѳY:@.[ Q@S!uq?CATTTAE* N@L0@?CCTTTv9W?l?uCP?٬(Ã?Me3?,q~gJ@Y:@ƒ/5?_vO?ATTTGV@GI@w\q6?CTTTGW\?z=1l&>w{ e>~?^ =8K@%:@&ʂ?ea?TTTGTy~K@1^v:?TTTGT1^v:?=邾3>>t=:>ȝb?(?|JM@1:@(d0\H?&S?TTGTA ? M@sܑ?TTGTAsܑ?5?ދaNb ? 0I?mWRϔ?YeP@jM:@Թ1Ө?~jt?GTAATQQ@/y?GTAAT/y? 1?m/{J?pa ?y@V'?}GQ@ h"l:@ ?"u?TAATT+͒Q@E7?TAATTE7?t ?/Nͳ?!z^G?EWy?wL@::@k E?-C6?AATTC 1L@HFf?AATTCHFf?A97~>%=R?Wwf=Ӕ?3rT=?xI@io:@/$?Aǘ?ATTCC!EڬI@*>?ATTCC*>?A \>$Xǚ5?C}LA?^p?R%6sM@L=:@%$r?Mb?TTCCCߊM@G I?TTCCCG I?:/a?MQ`]j?O?&W+"t?jWbQ@=U:@Yc?{?TCCCTy9Q@Li?TCCCAG*=G'a?D_8?Hե?qg?Ey{?ΩlR@;@eH ?0*?CCCTAAGnR@48?CCCACΥX?3ZX??U%?T"ޓ$?sגՄQ@_L;@e?Q?CCTAGhwQ@GB ?CCTAGGB ?"U.?8E>?MLĜ?oĆ?R<;jR@٬;@tKiY?:v?CTAGGWR@:R8?CTAGG:R8?/&_?{?e?^?AR~?[Bo;?XЄ?DIP@#;@ .?:pΈ?AGGCTШP@;u8F?AGGCT;u8F?T8q z?7z?-&?sYޗ?T[Q@V-;@["}@Mb?GGCTGW/vR@i[_?AGGCTl̶4^?毦?@Ģ?Z?6]B? 6P@w/;@NG??HPsׂ?GCTGA0?ܠP@]?CCTGAtm?6q廴?I?˧Ǘ?2}ga?}|||P@!u1;@>7?ZӼ?GCTGA/5P@//ؽ?CCTGAA?V?U>?KR.?HBĖڢ?W P@4;@u$5c??n?;{ͪS@V8;@zB?+eX?TGAAC>:S@44f?TGAAC44f?h-?=?;e>?Z?+LP@ǘ;;@e|?/n?GAACA\1KMQ@?GAACA?ݾDցI?*M-B8?K? ? Q@6@;@@ I ?<,?AACACduP@sň?AACACsň?iD?i^j{}?}S?P?? NQ@b2U0J;@lj?a+e?ACACG R Q@u-Ӿ?ACACC-7?$"?u?=QDt?q?v,R@DV;@ϦBb?M O?CACGCc,V6 R@lڜƐ?CACGClڜƐ?MH?B{^"?'y`\?OQfI?߿!Q@:a;@KF?HP?ACGCT-Q@p?ACCGGzp1?`\1R?DLd6??&]8C?9')ĄR@ yg;@||h?gs?CGCTG0R@\yH ֺ?CCGGCpr 94?&&\־?1.?_pO?.|M?C'O@b2U0j;@6ï@gs?GCTGC^HP@`vS?CGGCG*:?^~WzAb?Cݍ?g?L rV|?ZvQ@l;@{E@ZӼ?GCTGCrVK2P@qS?GCGTGl.?Qۨ?tى?y?o|[?K@r;@%>% @H}?CTGCT4L@LHﱬ|?CGTGC4LJֻ?ֱ >ԜN+!}?$%?2??6vhR@JY;@4ĥ@y):?TGCTT4R@*/?TGCTT*/?\8H0?0 ډ?*: ?|('?GUP@_v;@ @-C6?GCTTTEO@ alk?GCTTT alk?/r?7*W%v?F$v ?SkWi?=U}gI@6<;@U]?w-!l?CTTTA=I@Hk[%?CTTTAHk[%? yW=}&{ ?M?Դ?XIkL@E;@9?b2U0*c?TTTAC|=ٴK@Z#?TTTACZ#?|7[7?<ԟ?NQ捐??MD?`7ÆO@%;@ݼW7<@0*?TTACGy/[O@)r?TTACG)r?KCh2-sS@1w-;@|'[ d@( 0?GCAAGNR@ j?GCGATX.2Կ?h(?|TbCQ@ y;@}n9P?HP?CAAGCbW]Q@sjf?CAAGCsjf?fh+a?̤?mX(?u2;?Z|O@;@-Y(?Mb?AAGCCr -P@~ԕJs?AAGCC~ԕJs?Bj?-?όԂk?Kb? ֢/Q@u;@ 6?ZӼ?AGCCGGNEQ@J?GCCCG W?a4?qnd?ncr?O"pa?{րfS@"u;@ppKN@I +?GCCGTUt!pR@#F2 ?CCCGT:?\I >2}?yKһ?.ʟ;?}\*?l/-Q@;@3ne?NSt$?CCGTA )R@=b%?CCGTA=b%?ne%]?k vtS?e}?FhZ?NV˛q~L@m;@"=Fm@Ǻ?CGTAGLKK@l?CGTAGl?X?Kf@~?]}?~? l7Q@$;@7';@+eX?GTAGT28P@4)#O?GTAGT4)#O??ۋ˓?2?20?yb(L@Qs;@;@{Gz?AGTGCC}|AM@ 7I?AGTGC 7I?#ݐ>yDu\q?B&}†?8IM?y5[M@F%u;@$D? o_Ή?AGTGCķ|AM@>Yo?AGTGC>Yo?Ṛ #?hbY?Xx[)?lk_?Hch L@46<;@~Ǩ0s2s2R$0@?)!Rb?ו^?¡qQ@Q<@J_g@NSt$?TGCCG\2 Q@Ʊa1?TGCCGƱa1?J۴㸴? g?^vVLN@?}C?TXyR@f <@/}?UN@?GCCGC7n_pR@B7?GCCGCB7?G~7l^?eQ?;̂?ss^A?Ьe.R@<@L?NSt$?CCGCAlGQ@XP?CCGCAXP?ھȞ?+ѧ?g? /a?9?R@9#J<@*@w?CGCAG - CS@\飷H(?CGCAG\飷H(? ׷[L?(xu?0c{Nx?7${ ?1<1S@?<@r? ^)ː?GCAGC@*DS@T?GCAGCT?b?U᳭?dTÏ?)ds?fgP@k <@u?Y5;N?CAGCC2JlP@f {?CAGCCf {?h׎?81$?-&St?LA?{9'Q@UR')<@ )|SC?Q?AGCCTzIQ@+h?AGCCT+h?UC"X?3?6r?@?Ji*Q@ŏ1w-<@+?H}?GCCTGR@XvA'?GCCTGXvA'?g'?gFl?#2w??2 D}? P@x&1<@nDK?_L?CCTGTB.AP@:?CCTGT:?֢?1$Y?՞h?.?j@N@z6<@k(<l?H}}?CTGTT܌]UN@p=?CTGTTp=?j?Qڜ)t?mՙ)?Z2Ė?׬uJ@Q8<@&?3U0*?TGTTGCqK \J@yFs?TGTTGyFs?5\t4>1JB?XAR?6X?鷕f)M@OeH<@z =:?ec]?GTTGTpݫ K@fP6?TTGTC|ɢ?-kD? R?by?ݚ]?Ҷ$mN@sFV<@0P? ^)ˀ?TTGTCCҥM@c4?TTGTCc4?2Q?4~Xuo?L?t zp?o7WoM@VX<@t??TTGTCҥM@ %?TTGTC %?xS>&+i=g?Cr ?"Z}2*?6'csOH@S[<@ڧ [? ^)ˠ?TGTCC\)FI@W g|?TGTCCW g|?uS=9K2B*?Bi>V2?6W[?CAGCC!%lP@T` ?CAGCCT` ?jT ?-uV?fg?nݘ??qWQ@a"<@ ?ZӼ?AGCCARQ@UWIkI?AGCCAUWIkI?-X ?/e?~iP?d?bP>R@7[<@ Zc?_vOv?GCCAAN].*wR@tl?GCCAAtl?Xn.=?Ӑ?T.? u5t?NdzR@<@j?_vO?CCAACX!R@~7?CCAAC~7?ϲ?FOT?)R8?\?IP@ݓ<@>|?ψ ?CAACA=FkP@2S#?CAACA2S#?4H t??%1Q@fL?ACACGfL??\q.?ܑ<Ѳ?>`?Q8~R@z):<@ssn?~jt?CACGAUH ]IR@t ??CCCGCͫ~%n?h(? ?: ?e0 ?Gy ,R@_L<@t]?St$?ACGAG"7R@u#?ACGAGu#?Z ?Qt=s?F?#qIb?ѸS@Bc<@0krb@-C6?CGAGG {zڛS@n ?CGCGCp rrP?^dKy?ƍe?r%;?z}t>(\Q@N@=@Q/4?y&1|?GAGGG` dER@W"~&?GAGGGW"~&?|?Eq\?Ie?-fDW?JSS@=@/W|?gs?AGGGT[}R@=j?AGGGT=j?{n?(2?v?:?_D>܃u?%%? c?3%?=.YJ@Af=@Si,?~jt?GTTAAK@wD?GTTAAwD?5O>.lHm??t[(/?N+P@\C=@ ?q?TTAAA\(l@ Q@XBzuO?TTAAAXBzuO?GA9"%?}?+Bqc?0`D~?3@*R@5@"=@4}?AAAATnJ>?,J>=?O.:w'? Nыݟ? ۂ'!?X|׽Q@lV}.=@K&?y&1?AAATTF"fQ@UkR?AAATTUkR?*=7?~;w?Wķr?4l?y@M@s2=@GN"?]K=?AATTG;͵7M@$.?AATTG$.?Oǎ#j>,}f@?Ɠ(n??eOK@,e8=@DI?S!uq?ATTGT?])K@SA?ATTGTSA?e\g>Z7N ?arip?4R?= C N@HP<=@>hV?-C6?TTGTC#`?va&7/?`t6P?8N@k @=@(^ݜ??ܵ|?GTCTGW@)M@[?GTCTTo&u?@xv??n/ ͥ?]̲r?,<O@K7I=@C1G?/$?TCTGCZ4;P@?TCTTG (4H7?G\硲X?+ZiЗ?N?#@>R?mЦgL@Q^=@NT?a+ey?CTGCA+!L@ =*?CTTGA7|Dej?9w?P?$!ؙ??LvH|?>S@¨N`=@?n?TGCAAO*+R@v?TGCAAv?R@ E?h? (9?S@I>νR@&Se=@,y?vq -?GCAAAϔB@R@B}?GCAAAB}?K3C?GCjS?w?kncO?(\RS@Pjm=@&ce?_vO?GCAAA\G3@R@?GCAAA?@TZ?_ڿ?*+})?г%OV?>ޅQ@ -p=@=7 ? o_Ι?CAAACtl\Q@Nq?CAAACNq?" d?2VS?W9?MgF+8?ĄE9|P@av=@b'3?j+?AAACCh;tP@G!Af?AAACCG!Af?qKO?yFC? &d'?<?ƬN@\m=@ؑ #k?I +?AACCGmsO@>R?ACTCGm??yH*HC?6@G?El?DQ@0'=@E?~jt?ACCGTU3GQ@ə+F?CTCGT\ܲ}U?W?R c?2GiW{?ipz?XP@R!=@7ی.?l?CCGTC1ymQ@=?ACGTCea?\Nk`?]ǹj?6I B??^D@?t~G@Pk=@OO3@ o_Ή?CGTCGx{gXH@j$0?CGTCGj$0?]IZaN!=GQ >)J%dqs>0"? qvXYN@<,Ԛ=@˭$P@0*?GTCGTYZZ`nN@͟r?GTCGT͟r?. ĒN?8-?a3,?[?C5zjR@6=@j^N ?oŏ?TCGTGJx/uO?d滥~?⏒V]?q L@۷=@ߠ?y&1?GTGCTvMfL@rP?TTGCTGy?zv?aW\?]bU?6e,?sUR@"uq=@]*?ZӼ?TGCTTDR@Gq?TGCTTGq?Lw?@dOb?WǸ2?^d?oWsO@=@; u@_L?GCTTTPvMNO@Gv!Tr?CCTTTQ%f?4d@?o`2E?x??&<_?CTTTTB>_?C1F=z">jc^>=B? [ 9I@o=@rT?eX?TTTTARo'I@HE?TTTTAHE?PC=)N >פpz|>v)?嫐L@R|=@C7?H}m?TTTAC:K@7?TTTAC7?A>5)H|?d#&?)9؉?2#[N@ h=@ڞu@0*?TTACT9P@Vz>?TTACTVz>?@?eC?] ?sZ:?u"Q@.!=@Fˎ? F%u?TACTAjpQ@W I?TACTAW I?X;?++D?:4T?{Qu?ִլP@jt=@(sPL?j+ݓ?ACTATYwsP@}8Je?CCTCTrDSֳ?J?`#[?HL v?i>;A?$~Q@ h"l=@Tq?H}?CTATTYQ@&ͼ?CTCTTT2 ?Ћ?}~'?i~?!?]U?DV6O@Q=@mM@V-?TATTTj N@Wu?TCTTT\,1?>vmUL?I…*?eqv?ǘ?}bO@E >@Ef,??TATTT N@D?TCTTT}?1 *Q?*0?ۜEʃ?Jߜ?I@>W[>@X{?JY8?ATTTT~I@5N?CTTTT|Zd ?cx4=͠> iw>P?Ya I@Qkw>@)?/!u?TTTTC+@I@<8?TTTTC<8?EˌfR<=9>bdv>gay$? H@ec=>@em?9m4?TTTCCl*+H@ـP?TTTCCـP?aTl V!6= A2>r= ?zu@[ѧRS@HPsr?TTCCGToM@]@ی?TTCCG]@ی?0.V ?^3G?yqF?u ?Ć-R@4V>@`ӸZ?Mb?TCCGC!i!Q@А[?TCCGCА[??@Ȕ?S `H?Z?i?ᐛ_u?x#kQ@Ϊv>@I4Gk?mxz,C?CCGCT{.LQ@D>?CCGCG|uv?0%V?qv?Z;Ԇ?e3"g?B<9Q@}?5^z>@F?gs?CCGCTôMQ@+,ڴ媭?CGGATvrأ?-^?O?i/P? lp??E;I4R@48>@&ek@F%u?CGCTTGLR@#n3?GGCTT}{P?,DŽY?w}?z}Nf?I~@?xO@&u>@ƅ`@7[ A?GCTTGSctiP@2@?GCTTG2@?\z?/8L"?Gi4WkҪ?Hr6?HP@"ۙ>@,?6d?r?GCTTG R4kP@:,pi?GCTTG:,pi?{1kOP?:wvަ? ?s?~gK@-C>@Jt?<,Ԛ?CTTGG3K@tu?CTTGGtu?)# >>tn?n&,`?i}O?(xPO@罹>@ɰ?_vO?TTGGTUXN@<ן?TTGGT<ן?$cw? ܊?+=t?v\me?W / x@Q@K{/>@ع?&S?TGGTG@eEP@:4I?TGGTG:4I?ו?7V?̬=M?W?Pw+M@$>@0{?ZӼ?GGTGC֞BXN@ Ϭכ?GGTGC Ϭכ?H0>㔼G*I1?zK?޳?BQ@Y>@6aw@$ۧ?TGCGG )R@YЬ?TGCGGYЬ?Pb F?O?5P^g?oPX?p<=R@>@h@`Qڋ?TGCGGqA)R@J?TGCGGJ?#|?gP5?v»k?+?]?R@9#>@t@y):?GCGGG\pR@EW?GCGGGEW?lh?x.ӳ?&S?K6XP@?CP@2ı>@=C؜:?S㥛?CGGGGC" P@/q ?CGGGG/q ?gOצ? ?V}?s-$ޱ?(R@=>@]ױ@/n?GGGGG6R@eN1?AGCGGeb?K8?׬P4?hOv?p X?AR@2>@2?vq -?GGGGAh7 TR@8ܻ?GGGGA8ܻ?vGύƓ?_8?'[;:?CHcP?MLs.xR@x $(>@ [B@Mb?GGGAA@@͡@q?GGAATZ̑vEU@VT0?GGAATVT0?3;ʮ?X|Lu>gI-?yLlN@f9޾ @_L?GGAATRvEU@2`qp?GGAAT2`qp?KϪ?raY>s,r(?4<127V@m4>@VC@/n?GGAAT'3wEU@ T??GGAAT T??Yr)8N]?ކ'>u-^->HfC@eNp8@gs?GGAATPcwEU@šhg?GGAATšhg???`͙>+>Y]9@ _V@ψ ?GGAAThVwEU@+k.]?GGAAT+k.]?S㺡?fUM.b>$uF>%4g<(Q@\ A?@ 6:@w?GAATA*R@lx?GAATAlx?wv?U鑚q?x?aV #?N0RO@\m?@+'A*A??W[?AATAG 3BO@/<~5M@|Q&?GATCA|Q&?ho>XͫW?7=Z?k8 %mC?D;?CZ/?|I@BM?@_?5;Nѡ?GTTGA|x&K@ J ?ATTTGFdm?R=r.(>*"QG? q l ?]~Cl?P@j+V?@ݪ`?ݓZ?TTGAAs=E!N@2"?TTGAA2"?Ȁfn?lDvd?P?,K<7?S@_?@‹ @ ^)ˀ?TGAATP0JS@ ?TGAAT ?BΑQ?y%%ͣ?s{/w?|00>c8"R@ta?@򔥮<@Pkw?GAATCFи0 R@ SO?GAATC SO?Iw?$(R?&? ?l3UL@Bi~?@(Ls? ?AATCTw۾L@0ޱ?AATCT0ޱ? hF?ȾGfC?QN^H7?KX?:;O@ cZ?@kn?F%u?ATCTTO@4~#?ATCTT4~#?">?A:XS??fay?EX?z7SYP@o?@?_L?TCTTT͙O@L%?TCTTTL%?q[s?N D?`RDuv?^ʡ( ?ȃhvJ@0'?@Ϭ۠?HPsע?CTTTTe I@|tO ?CTTTT|tO ?uj!=Ib1T>(tӱ>^?]_I@Gz?@eԊe?a+e?TTTTTXiI@5=d?TTTTT5=d?u3=PDD> rt>?]u$%J@'†?@ۗ??q?TTTTGI@,?TTTTG,?\b=>Qe'><?yUK@S㥛?@iZX?Aǘ?TTTGCf2dK@5?TTTGC5?뢸SvP>g+Ո.?*B? s>!?ηۅQ@T?@s@Mb?TGCGAѪ jR@?TGCGA?V?zdPV?}7&㏄?=io_?<{9S@O@a?@2I @Q?GCGAGO S@lz/w@S@}8?@B֠}?/n?CGAGAOnrS@8uK?CGAGA8uK?fKM? 1?p ?- ;>nxR@x?@fI ?5;Nё?GAGAAR@2G?GAGAA2G? 7?=E)p?[C?'E]>x~7T@(?@TO@@6;Nё?AGAAAYAHT@L3:J?AGAAAL3:J?.PoC?cZMْ?g?caÅ?1ܾ=9pJR@46?@P]@DJ?GAAAT,Z {S@zn?GAAATzn?o(a?5d}?Rb?h=n>.qhQ@q?@U[ @ŏ1w-!?AAATC_*Q@a KS4?AAATCa KS4?F4?8srGYQ? O?7dJ?IOL@X[?@2VΆ@a+ey?AATCAN1uL@pT?AATCApT?DyS0j?w `?̗J[.P?X?Z|N@V?@Vl?Mb?ATCAT-<^P@We?ATCATWe?٤C?/?3fˇ?z?G`Q@Mb?@k_?Ǻv?TCATCe R@?TCATC?z!~?U+?x?<+n?e+ O@;N?@5?ZӼ?CATCA0~N@IM$?ACTCA!H?5;>?}F(rY?!?o&? HR@7[?@' C?`Qڋ?TCAAARoއ|RR@$3?TCAAA$3?h(?|{???7 79F?[Q@q= ?@ԾC?Aǘ?CAAAGUQ@k?CAAAGk?f/?I$p? ňع?FQ$ԏ?>,djQ@jo?@p&v?MJ?AAAGApVQ@EA?AAAGAEA?']?k'uI?;c͘?na?ySQ@ڊ?@/~?F%u?AAGAA=Q@^v%S[?AAGAA^v%S[?/H&?%]?Iߧ?Nms=?#^)Q@՚@@6m@Q?GAACAAo;ͳQ@J?GAACAJ?yJ?_~[}?Dy?^f?J sP@E @@dM!E?/n?AACATjDQ@Jec?AACATJec?L?i?_nY?l/??N-R@zX5 @@s[ ?a+ey?ACATC.\RR@L?ACATCL?D9?~.UV?$>'.?Cz h?  O@@@i ?S!uq?CATCT3N@S:=f?CATCTS:=f?isx?U,%$?Ρ? .?ۈP@>yX@@S G?I +?ATCTT$x7O@ ҄?ATCTT ҄?- ^?7+M?{v3?ut?O?OP@9#J@@Is?<,?TCTTT$ȲO@&ȡe?TCTTT&ȡe?(*;p?pBз?LĔ?Q?0{BJ@8A`%@@%Ny@F%u?CTTTAD,嶩f?qʄ?O|?}K@s2@@Ih?lV}?TTTAT!A?hK@U?TTTATU?@3>vf_?I1ۚ|?R}N ? {]P@TH@@H=@H}?TTATAdR mP@FHD]`?TTATAFHD]`?.A? 1΂?Dm??DF KL?gP@m4W@@:}?I +?TATAC}VP@!0?TATAC!0?YK?nx\ز? A?N(#?8cP@QZ@@7j^u@NSt$?ATACA0;3P@pg?ATACApg?.7E?R\} T?md?Bn?SvR@6`@@ei D?tF_?TACAC\TR@>p?GCCTA %-?o ?ne? E ?/&Kp8?D2N4Q@6^Il@@9 ?/n?ACACAQ@?CCTAA)" k?՚Z? 4?HO?M?XS;W[?CACAAU=mR@Q?CTAAAvLK8?j]?z^`D?!3 {?o`2?aљr)R@J&@@dY?"u?ACAATxpR@N2=P?ACAATN2=P??aU?КH1U?R0]}?<Q@ ^@@Tb?3U0*?CAATA Q@69˓?AAAAC+%wB?e? eY?lj~U?Ώ 6?,eO@!rh@@eo?( 0?AATAA5*]O@3Qv'?AATAA3Qv'?V_?)Rh)?\ ?*j`{]?TG^/?Q@@@m??ATAATXsiQ@pҕ?ATAATpҕ?ܻO?\rK3?]1ٟ?D}Wh? R@\ A@@0V8I? q?TAATCQ@ '5 ?TAATA~?e^?I3?I ]?rrfr?hKulM@X@@njﯘ=?L7A`?ATCCTzx N@^?AATAAf*Qֹ?nEys#?RصI?Q硢? IZw#?4R@y)@@BTp?y&1?TCCTAUy3wQ@>oS?TCCTA>oS? 1kvי?A?G?yv z?$Q@H@@lS]'?{Gz?CCTAAdbJȌQ@Mju?CCTAAMju?D.?C?4nݥ?DA_?koSR@#@@e8? ?CTAATnpR@fD;_?CTAATfD;_?L? ?Xo'?2~)e?eqQ@[d;@@ ב?HPs?TAATT? Q@ۈM?TAATTۈM?;^?R)x?֚iI%V?~Lq?AL@ǘ@@6LJ@Y5;N?AATTCIB_1L@cJ|?AATTCcJ|?>C;N?!?X/?7iI@?@@$H?~jt?ATTCC8Y I@n?4?ATTCCn?4?3<>0y?J^W?pQ?dyNQ@8d@@:S?N@aã?TCCAA{Q@4?TCGCAĊ ??N?YQ!L3?iy9֏?(\RS@؁sF@@5pC?"u?CCAAA"R@f}?CCAAAf}?8G '"?5xgo?q ~?=">xQ@z@@ 2?<,Ԛ?CAAATfQ@;(?CAAAT;(?b?E3?І;?ڈ|?Q>0P@E@@Kנ?gj+?AAATClQ@⬑E?GACTTI?5G; ]?l/f?E?ÐHiwɾ?:pg*L@\ AA@"?<,?AATCC @ cL@Im?CTTGAYѼ,?6q>`>Ǣ2 ]?1q]?.|ʀ?+N@I}A@aK]?ZӼ?ATCCT;C&N@4"/d?TTGAC~i?_8]>[?38N%?81/?'N?„YN@~bA@>? ?ATCCT ]N@GZXy?TTGAC.c"z?vvĘ?&ª#i?Şz?YsY?qĴ'vs?;SP@/DA@~6?M O?CTCAC4A^Q@mn?ACCACo?%qŒe?L?zmx?ֵ?ċᱮQ@ JA@`a? ?CTCAC(7^Q@ ?CTCAC ?Ϟ_R?;=p?{_xB?h?MbeQ@QA@3L1I?{Pk?TCACTխL0WQ@icL?TCACTicL?2K2?Y?5=?XE?CR@2w-!_A@Ik4xW?X9v?CACTAB>5Q@7?CACTA7?15?N`0["?TXc?hZeO9m?¡'P@_)gA@椭4?ea?ACTAA3=P@?ACTAA??a?M0h?W ?bɯR@|arA@?~jt?CTAAT%U pR@q; ?CTAATq; ?ICu?hc|F`-?.s:?KeB?/AFQ@hsuA@sŵ? ^)ˀ?TAATA@u3Q@)?TAATA)?%Ez??Ҕ?ۂB^&?"Yp?N@E;߄c?|'nB?NQQ?Z~\3P@OA@`#"Q>@ ?GTCGC^N@%)H?GTCGC%)H?q\?v?fwW3?koow?ZYQ@zA@8?{?TCGCAɳVQ@F ?TCGCAF ?Y+4?6:?:UCe?B.E?"""bT@qΈA@F |=?J4?CGCAAGPS@?CGAAAJ?I$$?w ǁ?O̱?ȂF"U>4=ndS@ A@s?"u?GCAAAR@}V9:?GAAAAf?4-Ⱦ?ѯ?AMҰ?㝉G>4τNR@&SA@EU?]K=?CAAAG?Q@~p?AAAAAӻ +$?M?Gu?%?Re?j20}Q@ h"A@ ?3U0*?AAAGCmxwQ@l¤\?AAAAC /?& ?[ 6Sʤ? &i?U;h?cTP@<,A@_1? Zd;?AAGCG)PP@"@+Š?AAACG|m?twd?b&? Y?m-?tQ@B@qꄃ?~jt?AGCGG(2]R@9"Į?ACCGGCO?B|4l%?8ߦM?~e?p=Q@VOB@ɪ/@-C6?TGCCT+q&Q@+g?TGCCT+g?v?{#'?Yխh?-5Z?&B R@4333SB@׾ d׺? ^)˰?CCTGAhQ@ ?CCTGA ?0W,?O?6`p~??N@{rB@A.,?Ǻv?CTGAC]gcN@"O?CTGAC"O?@]??xߴ?+$?i!?FUP@gsB@l;?a+e?TGACTMRQ@ueA?TGACA p?u9?Nt.?3#R4?-&7?PN,Q@\CzB@y*:M3?/n?TGACTRQ@[bM?GACAC:u`G??Ə?.;K?g?jkP@\m~B@?nc1?DJ?GACTA~Ju?P@QIa?GACTAQIa?e ?{T?E\E#?#K$َ?@5^Q@gjB@_0q ?Mb?ACTACbP@hBAž?ACACCr?]?$*l?Mib?]!{v?t-SP@ŏ1wB@^ ?+eX?CTACAzP@>-{?CTACA>-{?fS?*?{92?wysM?\mrQ@MbB@(0%?{Gzt?TACAAHTR@d?TACAAd?KAu?\_}?Ul;?Q@[S?CAAGC[S?) m?;_0??)Z?6?ҺoiO@6EDDDQ@8dB@>b]@ZӼ?GCGTT9i\'R@m\D?GCGTTm\D? e2?pq?c?zaJ@vB@/{?b2U0*?GTTAAK@  ?GTTAA  ?Lh94&>V 6?&^(?\q?d?c9P@1B@!@J4q?TTAAAGAe Q@r?TTAAAr?Z޽i?U.X?ޱɷgW?ڷ2i?#ы9R@FGrB@TD??AH倶Q@8EGB@y?ZӼ?AAAAGm^kQ@@,?AAAAG@,?ܯ{?gڣ?>? RKsU,?2|)^Q@YC@#?+?AAAGT@2 R@2T?AAAGT2T?0%V?*y???uI_?:wQQ@pC@1?M O?AAGTAQ@ ~?AAATGEj5u?z?JT?H>wU?%, ?-YEP@ ZDC@E53?_L?ACTCA@QO@#.'?GACCC X!?7DI?_&?+??KM?dHQ@BIC@?H}?CTCAA }GjQ@/TV$?ACCCAv:?ԢR@ꕲ QC@pL%>?S!uq?TCAAA^RR@Nh?CCCACftR?!h?P2f?pY,?g|*'?:m9R@\m^C@š?H}}?CAAAA>R@aֵ/Ӷ?CAAAAaֵ/Ӷ?a%a?<~2(?w5?BΤ?xR@QI`C@2gi?{Gz?AAAAA&ߘQ@Lޙ5?CACACi?>}1X?Y??"N?N"UR@ZjC@d)F??߾?AAAATd=Q@3Hѻ?AAAAT3Hѻ?9ۈM? R?&?c{?)%;Q@CiqC@_?:v?AAATTmRfQ@GZ-9?AAATTGZ-9?j+`?Yl?X)d9$?YW?ڽN@|a2uC@L@_vO~?AATTCOƉL@kh#?AATTCkh#?vU ؍?5WN:?=6Fvz?@?A`I@XwC@\t?Mb?ATTCA0$I@4??ATTCA4??ѯmc> ~( ?j^L'+?{RY? hN@HC@X ?W}b?TTCAGniO@7v`F ?TTCAG7v`F ?p?5P? ˄r?ʋ_Tx?gPiR@&1C@L02?_vO?TCAGC`wR@nTč?TCAGCnTč?U8?Vᎁ? ɱ?'sM>wIP@ˎC@c o>?46?/?ˀ?/h?]5 R@@5^C@3f0T5@q?GCGCTQ_n۶Q@&Q?GCGCT&Q? au"?;k@Bt?xx?y?zR@ǺC@ ù ?J4?CGCTG7AkVR@?u?CGCTG?u? 7?u?:?Jtl.5?G R@[d;߯C@ާi$@F%u{?GCTGTѹP@#2g?GCTGT#2g?\}%?iFpG?eq ?H?镲O@ŏC@x0C?{Gz?CTGTTN@͇"?CTGTT͇"?=pUT?aX%h?\.f?lk?E!^[J@Y5ͻC@ ?_L?TGTTTJ@LϚ*?TGTTTLϚ*?=w=ݙ ?!ٽj?Q"?`_@UJ@:vC@O?䃞ͪϵ?GTTTA5O.I@,l?TTTTAMjxи?,)R=Oa[>~s#^>%Y?oK@؁sFC@O,?HPsׂ?TTTACp8K@'b)?TTTATmLAa?ZnlA>u8?%R?*!? VP@aC@< 3?C>٬?TTACTy5P@(b;_?TTACT(b;_?q sy??~?ۧF|T?$R(Q@QC@6tLu?"u?TACTA0(?Q@V?TACTAV?6'?Nd?A}1?:a?EKP@`TRC@%_3|? 0*?ACTAGU[P@׺FH?ACTAG׺FH?5 ?%S?T!?6 l?=) lR@ڬ\C@ֿ'a=?I +?CTAGC$ߛa$R@ ?TAAGCzZ?t'?x?مE@D?S[7?֧SJtP@]mC@ ? 0*?TAGCABP##P@u;?AAGCAn?z?lk??U?ҚDК?q= w8S@k C@,dU@?AGCAA6;!VR@jķf?AGCAAjķf?A?+/?RTƓ?=8e:?I-ТR@JD@:'3z@?GCAAG aR@j??GCAAGj??>i1?9Ӵ??Fľ)b?O &R@Z D@xBc?6YR@6 D@.;w,?E4PS@ZӼ#D@}yj?mxz,C?AGAAA;4IJHT@?ҐP?CGCAANarO?Nhm?|H?EOv?=n>PR@58E'D@>?_vO~?GAAAGl;FXR@~O.4?GAAAG~O.4?(N?ڿ?t_h?H8?JQ@3U0*)D@kR?{?AAAGA;xQ@Af?AAAGAAf?}f3H?TZ?*K3?ʨ">Sz?'Q@ 1D@?AGACA^ >?Tɣ?MC`? l{2?v?n+@ Q@?٬:D@ Nٹ?Mb?GACAAzQ@({2>?GACAA({2>?e!g`!?zVu? X?c8?DcR@( FD@?3?&S?ACAAAXZIR@r@(?ACAAAr@(?=?5?O2?@,?:Q@PD@7?ۈ?"ޮ*P@ǺXD@?_Lu?ACTAG^ӵP@ )?ACTAG )?}A ?{M ?N?! ?z.R@ZD@S@-C6j?CTAGC}j$R@ά?CTAGCά?Ϯ?!g\?U/[։?2X?mP@GZD@֑3?ŏ1w-!?TAGCA4όP@P!' ?TAGCAP!' ?\b|cJ?mP?@~ó?FS?Q׿R@Z\D@3K"?/n?AGCAC=[R@ %5 ?ACAGCU%p%?i1+???$lԧ?Mo\F?eR@,Q@TaD@"G?5;Nѡ?GCACA|6lQ@V?CAGCG[-c1]?XO?Q?9K2?? ?\R@ףp=jD@ɯc@Mb?CACAG5S&^R@g?CACAGg?4V?P? 7Ŷ?TvMHI?_v=S@VnD@}9?{Gz?ACAGC/R@4vQ?CCAGCɩn?+?v/]?kU$?X:E? _R@A`pD@0q08?46Oɢ?\$,f?KT?ZJg+P@?K?,Q@MD@*?M O?CTCGA]2OQ@"_ݪ?TAGACzd?0 `t?}d?ZC?f?,MQ@mxzD@1wo'?cZB>?TCGACڞ=R@[uA?CACGC>qD ?ypWl?[3% .?"Hru?K s?~';Q@D@7?F%u?CGACA*RCQ@s?GACGCѾI51?ɒ?\?_+ [?֟)խ?䆓lQ@٬D@2rM ?&†?GACAA8Q@&?ACGCAvp=v?T8e3?AGCAG5>e3?u 4&?J[?v?ۦ>?S@ -D@8Mzj?N@aã?GCAGA,eS@vd?GCAGAvd?nZ.;?%Q?ϽӼ?\6?y^FJQ@D@>e(uY?_Lu?CAGAG*Q@[8!c?CAGAG[8!c?ה2]3?A}Х?6b1?Lmݙ?kvoQ@ZdD@J]n?5;Nѡ?CAGAG G3Q@X[e"(?CAGAGX[e"(?R'Ɣ?br?::R?'OH_E?mBS@:ME@h@Un?q?AGAGCI唘S@o~?AGAGCo~?83eJ?A?>O>oH?pN<>`SP@|/LE@.@Y5;N?GAGCC8#P@ySH}?GAGCCySH}??iyO5?B<}?/˂çN?L(3'P@jME@&|@gs?GAGCCP@ V½?GAGCC V½???ο??7`\?Ie? ?XP@q$E@kC?2%䃞?CGACC JQ@%a[E?CGACC%a[E?&F3?xc>?N>?T?BvdxP@K{/,E@.0?a+e?GACCA#fmP@,O0?GACCA,O0?5ѸT?ϫ?7m?? ?/$M)iQ@(\/E@?Q?ACCAT40Q@!+\&?ACGCTn?TƤ̖?(O?/?}LG&>?%"dS@p= 7E@V?tF_?CCATGr]R@G0Uc?CGCTGbm? rN?vV0?lgz?n/~zD?Kg5.Q@I.!=E@QӞ@Q?CATGA*xP@?GCTGAfR?Aϭ?8T|?Ռ_? ;?\•SGO@Q[E@ƁcX?-C6z?ATGATTr *O@7.V?CTGATC?Cc-?vKv?(?p=I?~b+S@H}]E@&6BZ@ŏ1w-!?TGATA>1-R@MG ?TGATAMG ?'? NJ7ѭ?'BY?^hXv> pO@faaE@|x4?UN@?GATAG\ƹO@:?GATAG:?:|(?y0η??Vk{?4tEP@cE@g!~}?HPsׂ?ATAGCE.UQ@vY?ATAGCvY?0Q@,?-T?\H?h^>?!DP@/$fE@[.C1?M O?TAGCGVP@֔j?TAGCG֔j?e?eLF?sN? i?`ҟIR@ݵ|pE@+Rإ?vq -?AGCGA-R@唨8?AGCGT[5R,?#O?yzY?\аx?jo>>S@$tE@y@a+e?CGATC61߀R@]9G&?CGATC]9G&?-}5?R1|/?G3?(uQ?~vRL@3wE@qߠD@F%u?GATCC%݇L@z?GATCCz?P>.i@*0???doq?]b%)L@s{E@[(07@F%u?GATCCD9YL@*e/?GATCC*e/?d\n>`#?.?*sc?{GbO@:v~E@jj'@~jt?ATCCGyN@i?ATCCGi?$R4U??^$t?Sq xٙ?8R@K7E@7 6xվ@n{?TCCGTuQ@o]?TCCGTo]?o~}ѷ?9fF? &,5?+? @~^>R@{E@x8q@@vq -?CCGTAMYR@}?CCGTA}?8敫?LY˙ƒ?KF?ӛӛHP*?rwAJ@ +E@@V_?CGTATk*K@!TT?CGTAT!TT?M7s>̷b4q?yHJ?dbQ?DY%Q@E@P|H?<,Ԛ?GTATTPI>P@Uç?GTATTUç?o?ߞf?8? Ww?^+O@E@}z7x?`Qڋ?TATTG_MISN@4c?TATTG4c?, e?-Bp?w;?_?ߖ:tK@XE@= 9q?~jtx?ATTGGA K@eB ?ATTGGeB ?dF>gD!?@M [?^D?ipN@-E@d?oNT@}8E@7u@q?GGAGG/T@(A?GGAGG(A?hQ? q&?>m?Œ>54Q@K7E@ ?o_?GAGGGw"FR@$?GAGGG$?ބeF:?E-;?ն??h}])iS@X2E@sb? ?AGGGGZR@ ?AGGGG ?$ ?IP ?#o?f>>U LR@ E@CeՍ@Y5;N?GGGGT fR@n)fr?GGGGTn)fr?=Kys?gS gN?R?b?#?HzTP@MF@g)4 @Mb?GGGTAt Q@wx?GGGTAwx?7*9ng?N4Lk?:ho?MY#?xк}Q@ ZF@st@gs?GGGTAKQ@:?GGGTA:?Q܍?#IPܨ?>?Zl̏?\'P@_)F@=ڰ@ZӼ?GGGTAm˅Q@3@?GGGTA3@?|nɤ?6>79?HMsK?' ԉo?V## N@B F@ D@ZӼ?GGTAGcTN@EU?GGTAGEU?d v?N? ڶ!F?Bҷ?\_L?P@1F@9nT ?w?GTAGAu*P@i?GTAGAi?I|?3w"?~ùd3?\ݞ)?o;R@MbF@R2?b2U0*?TAGAAVR@3-?TAGAA3-?Syѱ?z`%ìM?XK?GKsM?dD6U@_LF@6՛'@&?AGAATtLsET@6=?AGAAT6=?i!s?Ź%?+-dm? çq>*  O@?F@z+S r@Aǘ?GAATT E 1yR@a4Fz?CGGCTU" ?E\?6fi?R?Ȅ֯Gz?j42QS@ףp=*F@21t@Mbp?GAATT162yR@ĭ?GGCTTq^w?RK8[??YȖ?:)l>"U%%N@C+F@-g@q?AATTCšquL@h#[z?GCTTCE:7?w?>Dk?pЃiT?Ɉ?傦0VI@B-F@ӑ.4?HPsr?ATTCG&+I@p=2p?ATTCGp=2p?&%5=qa÷>psf>N+u?`'O@:p.F@_@NSt$?TTCGA1GO@.иQ?TTCGA.иQ?N?l轆?Ȉ?tUg?YQ@cX94F@M̕? ^)ˀ?TCGATlLR^R@-[()?TCGAT-[()?m{߉?B?fc+?0rT,O?-BS@6oB1L@vEF@|j+@~jt?GATTCt_L@ah?GATTCah?霼ve>H6? oL?G/?I@x $HF@f+ة?H}}?ATTCG=SɨI@r?ATTCGr?T[>>=F:>:y@$?;uH{?iL@lIF@Gw? ?TTCGT:O@M?TTCGTM?$Y0?:Z?7.e?jlp?qS J@(MF@|C'@UN@?CGTTG!9,I@:?CGTGTߓS?5]~i>\?Eh7pN!?mإDt?\uL@}a2UPF@Z`?H}}?GTTGT.ݳ? x H?D0?= I@V-RF@X^?-C6j?GTTGT[fY K@} c?GTTGT} c?X>rt2m?<# 1b?9'? M@]mRF@[o*?ZӼ?TTGTC܏}M@IOxFh?A6(yQ?TTTCAFd?:X= Ǽ%]Ʉ?4>?%Y=N@%^F@a=f?`Q{?GTCAGu،N@3jŸ?TTCAGe{Ss?O;t%?G5B?`/L?fE -s?־R@¨N`F@t?F%u?TCAGGkA՝R@^mmz?TCAGG^mmz?k ?S`5Ef?eh9?{N3At2?)ۆ R@_)gF@rS? 0*?TCAGGi^֝R@wƀ?TCAGGwƀ?6?tM?y?2O?9l?R@wOjF@nX?ZӼ?CAGGTd(ȼ R@)-?CAGGT)-?v^&9?5?+Ȏ?ioO5P?F]wQ@镲lF@Ơ?F%u?AGGTGIGygQ@̒Z?AGGTG̒Z?U[?\?^3X?B$ BO?9hW?'- N@PnrF@{P< @mxz,C?GTGAGIdpN@|d?GTGAG|d?ܘyxo?ls?SOR@?~F@A3(?&u?GAGGGi.FR@]L?GAGGG]L? I;@?m\?O?ۧ|?R@gfffF@ɘC~?H?AGGGARM:bR@xf7?AGGGG݁"Z?a?g(?a[3?Ҍ=+?SnQ@jqF@J@a+e?GGGAG%4p[R@ED\-?CAAGCH ?&6^?83l?OxW ?dKS?HzR@[ӼF@+ @-C6?GGAGCBrT@0XY?GAAGC1\?Ҧ?/ALGm?o6dR@oF@S1=@Mb?GCGGCX R@nWa?GCGGCnWa?5/av?Qq?h" ?$? ףp?O@]KȧF@wx1?HP?CGGCG&>oUO@~Vu?CGGCG~Vu?-Տ?V,@H??Sb[W? uQ@GF@& [@b=y?GGCGG+cS@4LQ?GGCGG4LQ?J$h1?y!??`>tW?L~!{S@՚F@rH?~jt?GCGGTYNR@O?GCGGTO?Q,ui>^7A?[az?1}G@u$F@$`;?a+e?GGTCGi8K@?GTTCGgCB7l?=t]>mz5>cXm0? :=N@fXF@3W,@:v?GTCGGWhgN@>5T ?GTCGG>5T ?vB h?NY?06jng? ꅵЉ?7_-R@F@n ?&†?TCGGC$-R@>?TCGGC>?}VN ?(]?X?[?O P@+F@ `s?H}}?CGGCG4w`O@VWN?CGGCGVWN?탑\?M<Ď???7T?vk~X:S@ qF@}@ǘ?GGCGG`ʨcS@pwO?GGCGGpwO?&o2R@F@*k?&S?GCGGCn^=R@YO?GCGGCYO? Y?{b M?ߟ? hJ؃?r0RP@x#F@A̵? 0*?CGGCAU0O@ (G?CGGCA (G?l?Q}8'hJ{?oSm?W?t_"S@H.F@,TS@ ?GGCAG)qS@_  ?GGCAG_  ?q?zs?u8{C?`"Gѵ>쌮Q@-G@fNҴU?J4?CAGAA&h&R@r4*?CAGAAr4*?3 ?¯Ŧ?ᓗ)?%!>>h?^'S@wO G@v}N@x $(~?AGAAC=^S@@޽v?AGAAC@޽v?2H?w2v?X_'?L$l>ǢgQ@w#G@tjy@?GAACC3P@x g?GAACCx g?F}?6z?~)j?,5%?6RP@=,Ԛ&G@NWp?J4?AACCAjUO@$Z{e?GACCA0,'?/]?(?*46?{6F?)R@T(G@Cȹ?Mb?ACCATMhZQ@t;T?ACCATt;T??cE+0?K+^?VP>ĦFR@C>,G@`j=?Ǻ?CCATCTitR@-O?CCATG^t??˟ ?6N=?˱2?%U\^P@2G@"@~jt?CATCTW{N@%#A3?CATGCĮ$?6jY?NźX? ԦЀ?ʁ?.bO@Ǻ8G@Wx32?`Qڋ?ATCTG?=,WO@%۵A"+?CATGCҫJ?9?q?sx`y?Gcv?T}PP@46Te?pe?}{á?p=CQ@:MDG@x/@{Gz?TGCTTR@g3?TGCTTg3?.q?^3?] Z?YB?k`OQ@c]FG@8LnMR @_vO?GCTTA1R P@ 0ɉ?GCTTA 0ɉ?$ ir?o?D̿?(f?& M@:pNG@˕md?d`T?CTTAC)&L@򙺸"?CTTAC򙺸"?"g?7^ S?|AC5?%*:D?y<9+O@䥛`G@Ńʎ?~jt?TTACCŘO@ :?TTACC :?~O*?-H?BTxw?ۏ ?vmB(Q@ʡeG@4G}?gj+?TACCTwzQ@O\{?TACCTO\{?7?nO?[U(~i?j@?mQ@uqG@Ixʎ?gs?ACCTTbQ@z/@?TACTTȓVX??vx;M?Φ?\?݇rO@p= wG@M0lR?j+ݣ?CCTTTcO@z?ACTTTs3t%?cɯ="?rS?$`?8A׼?hI@k G@s/:?Q?CTTTCH)3QI@)?CTTTC)?k]=,n֛>`Ȩ>`e?!vsG@rG@-L?mxz,C?TTTCC܁?kH@G?TTTCCG?ev=rϔ?X'E>+$?$2N@0$G@7~\?&†?TTCCT3]&N@(?TTCCT(?Pk*X?$ΊT?d?#KxMa?i،R@C>٬G@.]l?UN@?TCCTTnJQ@U.?TCCTTU.?AU%h?4 ?z:?mu^?bThcP@mG@3t@{Gz?CCTTG7?LP@ رx?CCTTG رx?n3v X6?\v?j?uN?]cnK@DlG@R׮솼?_vO?CTTGGR'K@A&GG?CTTGC0?-4jQv>r\1L?z(z?P]7?K~P@hoG@P){#m@b2U0*s?TGGTA>%x Q@hA>q?TGCTC94F?ſK?{?*?jkIv?xx:uO@ G@8@q?GGTAA栈=3NN@Z{?GGTAAZ{?`͹??L{(?Sv6H??]&kP@ H@p@Aǘ?GCTTTbO@eX?GCTTTeX?iyăc?j?eئW?BH?5RvI@H@o[?a+e?CTTTA9שSI@c 2[?CTTTAc 2[?R=4rS>OSLʋ*?oJ?PQK@4H@X#H?HPsג?TTTACK@oӴ>?TTTACoӴ>?Yh>z ?7^?,}?#VyO@*H@_2M@`Qk?TTACT&P@ M.?TTACT M.??D?ݻ?>Q%? *0vQ@SH@)/ֹ?ŏ1w-!?TACTCuvQ@:y @?TACTC:y @? ?) ?Ǽ?. qО?O4t)P@k+H@cu?H}m?ACTCG(,}O@4qȪ?ACTCG4qȪ?iJ?Ho?a\?g?Qa XQ@%H@V?<,Ԛ?CTCGG$VQ@+>?CTCGG+>?˙5L??+?%^-?[@Ŀ?%%?ޔ?RQ@0*H@Mf@gs?GGGTCQC]Q@%cU?GTAAT*$Q6?px?T?nJY? td?@ wR@0H@?`Qڋ?GGGTC@]D]Q@z-f?TAATT17ƺ?[#?'c?Df?VPl܋?qM@ׁ3H@Eά?HP?GGTCCKޠ`J@ dŬ?AATTCz{5u?"`R?~=?X3x?CK?N@a6H@tA3@ rh?GTCCCrM@FVއ?GTCGCil5?l܎?/~?ߺo?? #6Q@=U?H@/î?H}?TCCCCNS:Q@$?TCGCC6kK?m s??;H?"?+Ewr?wQ@( FH@_1\? 0*?CCCCG8aR@$"o?CCCCG$"o?]T?I>? %? ?p`R@@5^IH@>JA*??W[?CCCGG [R@p?CCCGGp?$F.?n"?8D8(?f>AKK S@!uQH@R%'?y):?CCGGTdIR@3an?CCGGT3an?˂X?XX?~?9 #>gP@uVH@SHHx@{Pk?CGGTT (bMJzP@/[?CGGTT/[?wy>dKe#x> {KO?aO?$UHP@\H@WY @Q?CGGTT8ڔJzP@o_=?CGGTTo_=?I1#?Вk}?O^?ƌZ?>|I@:MdH@T,zA@HP?GGTTG=sL@UN׸?GGTTGUN׸?ܡ.=&3?g>&p?+zujJ@ClgH@DTN?&?GTTGGeJ@^t?GTTGG^t?& ݌M>h&?UI+?֨7t?$I;P@u$pH@{Bm?J4?TTGGCŦN@ӊ `?TTGGCӊ `?'O3?y?sz,?]Q ?oqZO@&sH@o_B?o_?TGGCT<-P@Pr?TGGCTPr?L!ZH?>f?)~Y?5 ?G`Q@?H@*\@-C6j?GGCTTH"-S@:?GGCTT:?2??x ?7]2?o]E? AT@vH@ ܧ@ׁsF?GGCTT>S@?GGCTT?C/?wO?,?ApՋA>yyO@b4H@ u@J4?GCTTT cO@C^%?GCTTTC^%? 蠕?0dEe?j1~3?7B?M!UP@>W[H@4k@y&1?GCTTT8TO@-h`?GCTTT-h`?k\ێ? l"?Zu?>'?aZ=I@DH@Kc6z??CTTTC 64aQI@mM|?CTTTCmM|?=Oc>YA?D##j?Z.I@sH@*Gt?ͪզ?TTTCGYI@9`?TTTCCd]c?xg=FbAT?c-*>C?qO?xM@SH@nW?w-!l?TTCGA PPO@y3Q?TTCGAy3Q?څ#ohX?Y,p?}7%3?letyy?bQ@jqH@KWG?/n?TCGAGwIR@"S 8?TCGAG"S 8?fR?#?`?LVE?gS@&XrHkQ@+eH@ @~jtx?GAGTCqHQ@ ?GAGTC ?-]%?!Z{2?l?US?dF?J@cH@M{*@a+e?AGTCT Ngd|J@΀pt?AGTCT΀pt?ǧ>H?;#:?6?;n\P@{GH@ߦ?D? rh?TCTGT6mP@ <?TCTGT <?DŽl5?0q? 2a?D !;?IZbN@ʡH@a0|}?"u?CTGTCðM@k?CTGTCk?Jao ?m)>Pʴ\?*"mS?L@2?`-J@ H@8?ZӼ?TGTCAF*I@G- 2?TGTCAG- 2?;N9Qȩ=wb?;';d ??'V'N@AH@jJf?jM?GTCAG-N@L^s?GTCAGL^s?i?l?~Z T?a)|x?fA3R@k H@@@?V-?TCAGCFKxR@6[j?TCAGC6[j?lOrX?&~j?|?p LK2?}!pP@"uH@ֲ? rh?CAGCTiNߣP@h6t?CAGCGՁo4?=8x?g]Ԧz?դs?W\ Ƹ?7ywR@+H@ye@_L?AGCTTI'dR@`С?AGCTT`С?9ko]?gt?S.?} ?]Q@ yH@U[=?St$?AGCTT dR@?AGCTT?X1K ?|G?Ȩ컱(?P ?7P@)~H@4*X@_vO?GCTTG&VpGP@kx6?GCTTGkx6?l??Z?}J?&O)1?@PʇK@$J{H@dy?n?CTTGAVAM L@Pf?CTTGAPf?یV)Cg?yr`4h?3X?a&?Q7N@H@BAb?Mb?TTGAC( wN@_I?GTACC$s?(??ͤ"[?-$ ?WQ@`vOH@Pb{?/n?TGACGf`P@]H?TGACG]H?`?$n?E0?PL?èfP@_H@*H?vq -?GACGA,Q@΍< ?GACGA΍< ?C(?v\? dȄ:?Sl?|LR@~jH@G K?Aǘ?ACGAAR@YRbk_?CCCGAYgO?BԷ?_?Z?S@]KI@&t*?ǘ?CGAAG),S@?CCGAA^+z?TP8?< [? [?;.> ףS@_I@LTTs@y&1?GAAGG jZS@]*j?CGAGG+R?bmŃ?=L?>]r\?#ҴE9>,JQ@I@x?vq -?AAGGCrE^Q@n~?GAGGC0G?]N?76?Z ?P=)^?GQ@Gx $I@MS1? ?AAGGCo%^Q@J!|z?AAGGCJ!|z?|Iƺ?7Qp=>?(x?zd?fsy(P@#'I@|?<,?AGGCG<]P@I$n?AGGCGI$n?M?յ*ڰ?w8 ?:?V(S@s2I@ @y&1?GGCGT3H S@p5k.?GGCGTp5k.?,T?]w?\1sAw?Yi7>yX5I@B@<,Ԛ?GCGTA3# R@fWGw?GCGTAfWGw?ؤ2k?k*?ă6?Uq?#N@+e9I@.2@q?CGTACv-iK@,3V4?CGTAC,3V4??\T?S/Ė?|"?xI~x?N-J@Zd;I@v?F%u?CGTACL5.iK@.'??CGTAC.'??);G>9k|B?)Xa?e9?sGrO@\m>I@Ki?Af?GTACC1\LO@λ"?GTACCλ"?Ju?q-KT?*|?~?GE9Q@xII@}?v?TACCT Q@,}z?TACCT,}z?݇?C?OFv?Qgj?DSlQ@AXI@.͑?"u?TACCTgeQ) Q@L F?ACCTAAhL?=iC?_x?28{|?K?Ö{7Q@~ZI@w0Cy?:v?ACCTC$H/ԍQ@1j(?ACCTC1j(?*nl?G07o]?3^"t?Ǹ;D?;V L4P@_vO^I@||f$?ŏ1w-!?CCTCCq23P@Tт?CTACC1t?$3ơ? ?.ƅ??T ?d~P@3bI@8O?y&1?CTCCG|7sP@uqJ?CTCAC$*Ak?ŏ*?UQ?˅D9?< ?GbRQ@ ^iI@”? ?TCCGCu}_Q@t?TCCGCt?E?/S?B?DX-O?(OR@e;OmI@ ӈ?ǘ?CCGCTN$7R@zzuĦ?CCGCTzzuĦ?4#ڰ??йeFz?p/b?\b R@=uI@10&?ZӼ?CGCTCJԧR@nRp?CGCTCnRp?l?!hQ;?{U7?we '?oqo'O@u|I@S\+o@ ?GCTCT}gO@Jȳ?CGGGTX<à? 9 ?:?pW?Wj?w@VGQ@7„I@̿O?/$?CTCTTfP@l#eW?AGCCTa\HrG?6`eŵ?[XO?&MS?:7?E[LvP@\CI@@ F%u?TCTTCpC' O@jN?CCTTCY?8V<Ή?1A'@x?4qmb/? R҇?D2I@䥛ĠI@{v4?/n?CTTCTN)rI@n\`5,?CTTCTn\`5,?yA3@2 >Hf L?_o6?cgR?j DN@M FI@_OjC{@&?TTCTGS8WN@5 >i?TTCTG5 >i?=ʜp?눰?Bnr?] q?`VBP@+ٮI@ 7RS$?HPsr?TCTGT!tmP@ܿ-?TCTGTܿ-?Hr?F~{?vLfe?ޒx?NeN@I@~Kc#v?M O?CTGTTN@]ׁ0?CTGTT]ׁ0?L6>fB?<0??l?+(ipI@}?5^I@V'EB@"u?TGTTAZϰ{J@DtX?TGTTADtX?A I=8E̝?W-Z0>a,?5ؕ@K@=RI@f?/$?GTTAT<zK@ E?GTTAT E?_>qgo?m@w3?3R ? PP@tFI@wY_)?Ǻ?TTATT|!짵P@I?TTATTI?s"K?Ĺ?0b;x?? i%E@?<=mO@+I@mー?:pΈ?TATTCb v N@|u+?TATTC|u+?H#nՁ?f{?0;?3<'?y F%I@HPI@&B? o_Ή?ATTCA-k4I@y{Ś?ATTCGXR(&?4#=ZJph?Ot%G?'q?b !K@62в? ҥ3$?7?D aZQ@I@D[l$ @J4q?TTCAG KixO@xDn?CGGTCTzu?l?!p(?}s/J?o,@? J@,eI@%Z @V-?TTCAGCxO@rP.?GGTCA E?ܠ]/a>p?ȑ\UI@kaBo?ZӼ?CTATCW9 ]Q@>O?CTATC>O?(!V?V?Is?cϥ[?OyO@ܵI@WQ?Mbp?TATCG|7aN@(a?TATCG(a?]/?YR}?oc?6֪YA?ғ&OP@ڊI@ll>u@q?ATCGA.)(6P@ |\+?TGGCG$t ?z!o?L?K(?k`#?GdϦO@ I@=Y???ATCGAAE(6P@ƉvL@?TGGCGR>MQ?D1d?Vl?C"?N?zS@H.J@. 0?Af?TCGAAj/]eR@[|?GGCGA?P"?=2?Ѷt1?Um.%9> T@)J@ZDzj?a+e?CGAAA9T@^?CGAAA^?+ó>&?RbA_? Bl#?giOJ]>rhOT@sF6J@V[?Mb?CGAAAVIT@q k?CGAAAq k?Ih4? [?Uf?ٻK+3>mw'%T@-8J@NV?y):?CGAAA(T@$?CGAAA$?OӀ?XQl?('.WS?>bRO CS@AJ@0$*?S!uq?GAAATU^iS@!?GAAAT!?|'nk?,ml?qkHw?@^6>9Q@a+EJ@1?Ǻv?AAATC#ŝQ@#,m?AAATC#,m?ˤd?|*E"?}?6cT ?'8`L@=,ԚFJ@ב??_L?AATCT$ӱL@U$o?RN}D?9?vN@8gDIJ@ichT?M O?ATCTG;Q4 XO@J?ATCTGJ?Y(=?3$ʔ?oq?O2? KazP@:pNJ@#v?_L?TCTGT.mP@.S??TCTGT.S??ت?C4·? xQ?ڌ4?(N@`QJ@/ռn?ݵ|г?CTGTCM@^H?1 " ?37?P I@E]J@N+n=?^K=?TGTCTOfhI@ev?TGTCTev? {:u=bv?>%UW?rh&M@ThJ@Ñb?Mbp?GTCTGQ[M@ʋV?GTCTGʋV?['?y?vMD .?!uS?q0OP@yiJ@XJ_?"u?TCTGG#Œ|P@Hq%?TCTGGHq%?lj@e?"?ȅm?M|I?QoN?שO@rJ@w1?Uد?CTGGC7SfkO@}?CTGGC}?h$%@?|vo?G1J?#z5?(P@@J@Yذ?q?CTGGC kO@G?CTGGCG?e$?ENjb?QP?[Pn?A)tO@ioJ@t^(?ψ ?TGGCA?UP@W9?TGGCAW9?LO ?bq+K\?=ɫ?[.a?JهS@8gDJ@O\?@0SR@):J@>?"L?vq -?GCATT2NR@W]~p?GCATTW]~p?(~?'3/?fj?oJD$?I4M@V0*J@b>2A] @/n?CATTT ̲N@I ?CATTTI ?!+4>hHvP;?+'Bh? %q ?T>tN@J@ t-@ ^)ː?CATTT@^,N@5mI?CATTT5mI? ?=uim?aNI,O?Ji@k?O VJbI@2J@O_?5;Nѱ?ATTTTӅͤI@}.?ATTTT}.?%0<ʻ z>4 >;?NL(/I@CJ@w%?:v?TTTTCS$BI@?TTTTC?-X=hf>C̍jA>X9j"?|D9rH@镲J@5fPM?_L?TTTCCIH@^(?TTTCC^(?JD/=g?sN'>S|?`O@46 4?9"?&da?HfcQL@QIJ@??tF_?TTCCGW,M@bWA?TTCCC(4$@/?x>:M?Oi?Qi;?. .Q@( J@`?ZӼ?TCCGCt Q@MxC%?TCCGCMxC%?ݤ"?8n?f~~DR?裟u?ҕ7 R@QJ@iz@?=U?CCGCTX4TR@î,k?CCGCTî,k?i F?I?iyXJ@6/ɕ?#_٤=4?]L@9#J@U e?St$?CTGCAkʊIdL@Y?ATGCA5IbX?ٞvd>A@7kN? wIɔ?IJ?$!T$5R@ cJ@FHu@=U?TGCAT-R@U?TGCATU?$T?7?-C6z?ATGGCu+O@T ˘?ATGGCT ˘?r}@? Kj?1dQ ?ʫ ?pO@C> K@Yj,?(?TGGCAnX$P@,e?TGGCA,e?eā@S?`'f?2˛?\q?Y|T@e`TK@|)@J4?GGCAA$BS@`RFH?GGCAA`RFH?9KT*?֔^?tT''??ˆ=} 2S@GzK@#tS4? ^)ː?GCAAA dR@SsPU?GCAAASsPU? ?^k悢?a@O 2?H>1>W~Q@VK@@B?Hg:?SP@,C+K@It?Aǘ?AAACTN8;P@nG||?AAACG);W?(7?lA?v=?ys-D?F!FtP@^)0K@mt? q?AACTGP`HP@q ?AACTGq ?؜m?f`?~Qiڴ?^?-P@%>K@0B?"u?ACTGAwxP@Q tP?ACTGAQ tP?3n3W[?-"?ōEC?h+z?x US@EK@7%E@?TGATAN.R@r?CGCTC0;D?JO>ή?}?1C?no)!>%LO@K{/LK@ @I +?GATAA- @O@*}f?GATAA*}f?,k hS@|arK@5nrzX@Q?TGAAT_S@4!Ø?TGAAT4!Ø?Bt~3?0j2?R ù?>BPP>Q53S@zK@:@/n?TGAATS@n ?GGATC{S?| 8#?rY?w9?? >`PS@HP|K@- @ea?GAATT]ңyR@͵??GGATCb˷? ?{uQ?wW`x?dlb#>0&{K@l K@a;,i@<,Ԛ?AATTCL@@ph?GATCGlJ?Og>)ꠁ?~'7? ?O@wK@[@-C6j?TTCGA4́O@a.?TTCGAa.?: \*|?!x?=Ij^(f?[m`&?n*2T@VK@,{T#? ?CGAAG/S@ܦe?CGAAGܦe?>?Mh?P?. ? {K>hASS@,ݓK@6?gs?GAAGTWmj=S@ږ?GAAGTږ?eZ?m?˘1? rC>b/P@sFK@[ PXx?ZӼ?AAGTG9P@D E?AAGTGD E?m c?B2g??S\9?I|W9?b)"-M@ 0K@PYf*?=U?AGTGAaM@Z?AGTGAZ?VV&MH?i?3%dQ?:sM?-Q@ݓK@٭06@F%u?TGATCŮ7R@xH?TGATCxH?\uJ?b?ŰH?vz^L?OBM*M@K@Zq@V-?GATCTyL@c*x?GATCTc*x?a+cA?溃?"##G&c?5'!_?b@P@}a2UK@x1?H}?ATCTC@HO@(7?ATCTC(7?6?ZM(?Y&#?U E?U!O@K@+xe?46J9R@,K@ sa}@HPsr?TGAAAS@aU%I?TGAGA@6?0>T?,%?zz?"*B? MQ@' K@aϓH ?Ǻv?GAAATw{jS@~] ?GAACT`/??A?Q~5?Hr5?leQ@zK@fzga@ o_Ή?AAATAU DQ@~?AAATA~?oN#?_:q?'?d/S?eŠ?N֤ )P@|гK@4r5? ^)ˀ?AATAA.N _O@o]S?AATAAo]S? s?)?7r??SM@oK@MI&?q?AATAT£+O@#'#?AATAT#'#?wLZa?xe?X$?D5]g?(vP@:K@ G?-C6?ATATC&pP@f{݊e?ATATCf{݊e?jp ?}e?*LKӴ?x n0?>M@HK@)@ŏ1w-!?TATCG/ (bN@\)?TATCCg֮p?6T?]YY?!}ڒ?|r"?O@<,K@rʌ6?Ǻ?ATCGApR6P@w+F?ATCGAw+F?魿ޭ?;FJS?h_f׷?i/l+1?b<~BR@p= K@"d#w?j+ݣ?TCGATD ^R@]*r~H?TCGAT]*r~H?. (?.?8lO?㟸?f,R@k L@U*@Aǘ?CGATAĔ,JnR@ڡڜq?CGATAڡڜq?ս?L}-y?,N?pC%$?lO@L@8nu?ŏ1w-!?GATACu+HO@_ c?GATAAW! )?\}a?;*?,8G?đ?ZH@Q@L L@v%b?_vO?TACTGnzQ@XLR@?TACTGXLR@?WTL?'k@:?'鷩?Tv?ZN@ˡEL@&gnL?&S?CTGAC}eN@;8M ?CTGAC;8M ?Tw?蜡?y?)e?f> )-Q@_L@U?Q?TGACG ^P@W_?TGGACx9?:j(?+I?En~T?x?uQQ@vq L@Ԏ@S㥛?TGACGP@X^&?GGACG`bC?Xy?M!?[;?@u-w?NyRQ@tF&L@ę\4 `?Mɍ֋?pjMH?mxyI@QI@L@a?N@aó?GTTCT VH@oԁ?ATTCTW1Ń?iljW a>! #4h?hO)c^?WMГ?dO@d`TL@2Z?b2U0*?TCTCTY2O@jt9?TCTCTjt9? {Gר?ĂI?y?Io?AtP@ hL@Tם?b2U0*?CTCTT\xP@U ?CTCTTU ?$Qn??%I?'D?(\O@#~jL@&Ƒ?J4?TCTTT{O@hrp?TCTTThrp?C1ӽM?nu? ?ĄQ?1G[>J@mxzlL@y@J4?CTTTGf/5FI@2on*`?CTTTG2on*`?zf=2!?g.P5?;?JqؿK@{pL@}9;r?=yX?TTTGCMDVfK@qɘ ?TTTGCqɘ ? >NQ>d D?ؗE?X?u..`L@=,ԚL@ژa?_vO?TTGCGYL@`ZY?TTGCG`ZY?Y-E?~-C?? ?e)zf?έrR@ h"L@y(<@NSt$?TGCGT Z?R@t_Y?TGCATFg̿z?@~-%?V`N?[hA?(u1T?J} S@3L@C?`Qڛ?GCGTC{cIQ@.?GCATTu\?0?ڽ?Qް?c4U,c?JH@z6L@\ ?ZӼ?CGTCT9H@< $?ATTCT{0 8i?Z5gI=6?RD}>ފ-v?׌N@{GL@q/@HP?GTCTGr- M@Wt?TTCTGQ?WaՊ?:*Wu?, ?-$?MgVP@8ŭL@=?HP?TCTGTZnP@?TCTGT?#]p? " ? x?1:d?X3$KQO@A`L@>[?ZӼ?CTGTTqN@DKf6Ba5?ٕ#?XK@fXL@$o?_vO?GTTAAԲtzOK@  5?GTTAA  5?HL7>RA;?U?})?3+Q@ hL@#ĵ?gs?TTAAT5Q@d>t)+?TTAATd>t)+?s|.?7}9?(Q?Qoc?$=.Q@BfL@!uq @n?TAATAd%Q@[_?TAATA[_?j\=??´?i? " 0O@ÆWL@dI?_vO~?AATAGV"O,EO@?AATAG?Lg?ιeS?y}?/tHRP?D1Q@?_?va?z)MB; Q@?L@נu?ׁsF?TAGTGQ@z̟?TAGTC? 6(I ?g>?s?2n? |]{K@L@&Bl@_vO?AGTGA'9M@?CGTGCF+`;?C,tMb@>Tt??k)|?QD?V?(\R@:pL@L=&@b2U0*?TGATG!V&R@c)H?TGCTG9/?gNI?;b`?3/?Y(Kvi?ۍ)aP@A`L@Y0T?J +?GATGAQ[9O@c@Q?GATGAc@Q?Qi-W?r E?@,(q?!\?l^tO@ ףpL@x]Ȇ?"u?ATGATL R+O@>t?ATGAT>t?i\^?5N' ?0^U?p0jC?ER@?M@9Y&@q?TGATGX X&R@?GGCTGc$?43)}?ZEc?j(?li?mY;mP@5;M@k2w@+?GATGG8?5O@hr/|?GCTGGy`?d&?6u]\?ǷhU?cg}|k?Z=P@47M@N)?,eX?ATGGT1SzO@u-?CTGGTǠ ?B$퀘?N_Yu?g/A?Y?XCQ@M O/M@2EH_@b2U0*?TGGTTX87B&Q@wm?TGGTTwm?~Ֆ?At?#?;[q?y>L@x#9M@y#1 @y):?GGTTGBL@!&?GGTTG!&??nj>ٻ/YR?yg|#?7g#?Q,]K@V-=M@ ?ݵ|г?GTTGA]u1)K@H)N?GTTGAH)N?:!u>Ee Zd^? k&\?4?9O@LJM@3?F%u?TTGATlbN@ŕ?TTGATŕ?!>M?8؛ c?f1w?{l?UUUER@6;NQM@:@b2U0*?TGATT-AR@$Ak?TGATT$Ak?OgB6?M?Ts?\D߬>罒(O@AaSM@l\  @F%u{?GATTG)pM@WJQ# ?GATTGWJQ# ?hY?&>ŋ[~f? Lf?"K@hsUM@2?S!uq?ATTGT<کK@+?ATTGT+? WG8>,ab#?vj?Boyc?-f^]N@,eXM@^oV?I +?TTGTA]N8M@=1Z̘?TTGTA=1Z̘?`ֱP?9H#?}t?TGj?iiii_M@n[M@A@`Q{?TGTAC"f-L@H/?TGTACH/?bW?Qt?dP?T~?/N@ ףp]M@5:X(r?_Lu?GTACCMSMO@N?GTACCN?C?,3k?Y?qj ?%sv{5Q@\m^M@`O$?s4WrN@ͪϕM@o<[ @a+e?GATTAVlM@;g?GATTA;g?<>x>5]zn?A?g_Q?mKy`aS,?p/PR?-We?I݊ԊmP@~bM@@XE@ ^)ˀ?TTATT!P@͇'Rb?TTATT͇'Rb?Bz?]W؉q?Z p*b?h4}?ȓO@R|M@}$1?ǘ?TATTAFE N@?TATTA?DY(?ِBj?/P?L\֎?.*D L@yǩM@sp?S!uq?ATTATRXmL@Pay;?ATTATPay;?R >wu?{h?wNP?2Pw㗔P@> ףM@$!?z6>W?TTATTؒP@߅W?TTATT߅W?]#B?a9m?Z鄸Et?=di??TTAATzG5Q@iS'H*?TTAGGHs?|?۔F?"Kr?iZV?KQ@FxM@Dq?V-?TAATC[9Q@'ȳ?TGCCG[+gkd ?v?rzڙ?R5ELޚR@,M@hA?5;Nё?TCAGCMhxR@] jHq=E{]%?[։Oӽ>RjK?lʚP@gjM@u'A@"u?GTCGG~ hN@ET"?GTCGGET"?ĽMUK?T]̓?E}up?F'V?iVO@&䃞M@u?b2U0*?CGGCGPIdO@jC4Ƿ?TGGCGh\N`?FVxk?8ZD?_b"V5?Oqg+(?_$S@1*M@n@_vO?GGCGTirS@=+P?GGCGT=+P?Fdf?)?%ʶ3?bKI>{DP@,M@e9 @gs?GCGTTĶK(R@5Ų?GAGTT??=A?C X?iPcv ??7VH@sFM@>'@ ?CGTTCM{H@pA-ţ?CGTTCpA-ţ?G:o= %_>?~s> +Q-!?xbhNJP@tN@?jP?r?TTCTT,N@{'t?TCTGTe_6?..B?j1b?*ލw?Ą=?3 #EN@( N@`(N?mxz,C?TCTTC\^ O@[g8g?CTGTT-?1c?>`A?|J?6C?!?P&]x?Xlk?2^? ;J@aN@ 5]?_vO?CTTCGuI@/L:?TGTTG|?ke8gE>鴀2?آ*l)?$n?XuN@%N@M5??ܵ|?TTCGG BAO@듄 ?TTGAT_n?_va?߫?;6?,g%j?UUU>Q@o_.N@3 ??b2U0*?TCGGTd7KR@>JsC?TCGGT>JsC?SG?H"?s#!]?KG?/N@7N@h LnQ@H}?CGGTGSGCnP@?O?CGGTG?O?#S?.p"*?X`?_>K?2ouO@ q;N@%j@ZӼ?CGGTGz`CnP@8J?GATGTLp?򦹙T?y4? XS'?o?- O@H.?N@b';@{Gz?GGTGTJ b N@64[u?GGTGCo?+ט0?ƦR?6?a9Va?#sB(N@:MDN@Ǩ/!@Af?GTGTCdDM@,C?GGTGC@'?' @!?׸Ƕ`??YV"??)6J@hON@FAv ?Oec?TGTCAtt I@_yߢ?TGTCA_yߢ?k>Gf \Q?Gajl?w 6~?8饔 Q@V-]N@G}@y):?GTCAGOSN@n?TTAAG Ⅳ?V<{!?Ic~;?f&g?)ϖu?ndPR@5@bN@Yq&U?NSt$?TCAGC_qxR@#1?TCAGC#1?ǯ?x ?>??CHc{?|P@ hN@|O?_vO?CAGCAωBP@Tr,?CAGCATr,?g03?Qv?w9Û?ebl?mS@僞jN@jR3??W[?AGCAT͓EXS@F1?AGCATF1?(5۱?eV4?sF ^[?Eg9>D}Q@;pΈrN@" ܅@~jtx?GCATGh=7.R@K?GCATC--B?d%o?ls?[) ?r6{? t@sO@tN@7<?dM@VxN@wJ?ŏ1w-!?ATGTA嗰VN@ˡ@.?ATGTAˡ@.?ۅ?Gg?ML,@?kT?°цN@vzN@<L?:v?TGTAAr M@\18a?TGTAA\18a?FИ?~U#?5 H?|Wzq?7."(Q@E}N@\ܚ?_vO~?GTAAABQ@"T ?TGGAC#TdO?u(?4<RU?; Hs?O[S?͏2R@N@_8m?`Qڋ?TAAAA7-lGR@)Fx«?GGACALh? +D?U??;k?k0t~Q@SN@b@+?AAAAA2Q@E?GCTAA][?d?ȁh?mvUf ?fX?6ܮ?'R@e;ON@?/$?AAAAT ʐQ@~lm}?CTAATLx㮖?9N"?r?>:? !p?,Q@ N@(7WB?L=U?AAATG"6Q@mrGY?TAATGţG(J?1J?&>"? r? V?nYM@ cZN@u_#U?"u?AATGATFN@ZQ?AATGAZQ?[z^?S?c?F&P@x $(N@%奇@q?TGCCTl['Q@R?TGCCTR?kW?Y&h ?uc|0?azj?_񕞂R@aTR'N@}&? o_Ι?GCCTTXI1R@)jiV?GCCTT)jiV?xk-?]V?{@?HG ?$!Q@=,ԚN@^S?Mb?CCTTGNQP@ޙ?CCTTA8LM ?CY?k{? /O?])%F?eK@'SN@6?~jtx?CTTGGg"K@= ?CTTGG= ?~>ZW?8؈?3?0X!RP@<,N@ 9Q@+eX?TTGGG%N@3M?TTACT&#R䩷?FΟ˥?{h|?^E?_?U1Q@XN@`?0*?TGGGC1P@i5?TGGGCi5?f??XZɇ?9|?[c-oP@fc]N@U_ @_vO~?GGGCTar`P@=5?GGGCT=5?,##'?d3?Ѱ<\?“?Ǖ|?T{ѱ?'E=z?{XK~N@J&O@졞?n?CTGAA O@@X?ATGAAvi?L?"6QT?Q?Һh Ə?M T@TO@6 @Eioɤ?TGAAAATS@*=y?TGAAA*=y?BVי"?ok?[eoRh?51T>S@M O@b&@5;Nё?GAAATw$S@x?GAAATx?2x?c\~?-(˔?kt>xi.Q@ׁO@d?HP?AAATC Q@œ9I?AAATCœ9I?j;?yԓ6t?k't{?!Xpg?pOdL@aO@<Bc ?F%u?AATCAWtL@v~,?AATCAv~,?!?;Z NZ?1&cy ?!NI+ ?W N@ecO@~4fo?ׁsF?ATCAT"_P@JI/|?ATCATJI/|?۶1??{?D&?xp?u)*R@&†'O@ݷ?I +?TCATCh R@I?TCATCI?y-? m ?0)f?5QWK?BeO@W2O@De˟? ^)ˀ?CATCTZN@Hf.?CATCTHf.?Cq΢?5Ipɹ?䈮0P?wăpp?'O@[Ӽ4O@?Mb?ATCTCGHO@sR?ATCTCsR?X;RX?gzB?oQ`Xx?ϔK$N?h+O@6O@פې?F%u?TCTCAMZO@ݥU?TCTCAݥU?{E?DR)? c6ĵ?6h#U?\]pP@Q:O@ɭ*?"u?CTCAA*kQ@06?CTCAA06?? Y !? M %?Z?b cCR@CKO@ń?U?F%u?TCAAT:669R@~3Ț?TCAAT~3Ț?]G#?dζ? Esj?Jo?e#ShQ@ RO@r^? ףp= ?CAATAƲ%/Q@?CAATA? ֧ ?E?Ke% ?(0냹?紁uN@|?5^O@(Nw?b2U0*?AATAA ^_O@K;(?AATAAK;(?{9z)?HEi}˹?߹&j?`ۜ?5TQ@d`O@ ?ZӼ?ATAAA=xNQ@Q38?ATAAAQ38?24?QA8?}V:?ѪM9?fB\R@d]FcO@Gv??ܵ|?TAAAC*OݿQ@knЯm?TAAACknЯm?t~8?(z*5?CG??V?Z;oP@RkO@k ׯ???AAACCTh P@_PDm?CATAC1vG_^?fld?K֣? O?eŨ#?O1WO@!uqO@RT?:v?AACCCډkO@KhO?AACCCKhO?)Xw?R@ec}O@a#?n?CCCCC [Q@Ͱ;?CCCCCͰ;?,aR?"P?Ƈ}?rj0A?Hz|Q@O@A9u?Mb?CCCCC/.Q@*wY?CCCCC*wY?VMu?¯ &?GG? "?Z* Q@O@?yzQfz? 0*?CCCCAd'R@Vge?CCCCAVge?vKӪ? &?gX=?fm?>%R@,CO@1`Wi?j+ݓ?CCCAT0RR@\hng?CCCAT\hng? ?_?dʔ?;^%F> |TS@1*O@E?Mb?CCATG┚R@6?CCATG6?*?8c?MfQZ?=<[.?Jvm-7P@O@@O8??CATGG,_?^P@L{sm?CATGGL{sm?x, 3?MGVg?3_?J]@?學P@O@o¹w?Y5;N?ATGGAMK7O@2?ATGGA2?#̻ڈN?c>?_,9`?,^?۲V#Q@罹O@ý0@~jtx?TGGACʹ?D?hw?p]Ld?@[&wQ@,ݳO@yM6?Biޱ?GACATԢoQ@8>g?GACAT8>g?1ob%?p4x# ?샋?D+w?*.|\tR@oO@-[\e? o_Ι?ACATT}MR@?ACATT?y ?eZ?#C?:C~>r?_M@K{/O@1_@q?CATTGi@N@Z.?CATTGZ.? "n8>b>d=CDn?E8?ˠ7qK@3ı.O@_4?_vO?ATTGA /K@]f݆?ATTGA]f݆?U .>U`>" ?!Y?^ O@.O@"?mxz,C?TTGAGNzͶN@t@?TTGAGt@?mYy?N.߶A_? 9?3>4?N ɋS@k O@)? F%u?TGAGT 4]yS@ɘJ?TGAGTɘJ?TC?=Q?B?Q9\\>٪9Q@ O@;@ŏ1w-!?GAGTA8:^Q@.?GAGTA.?;~BZ?a nwt?晀4}?Φp?E7;*K@ű.nO@N?gs?AGTAT`M@z6R?AGTATz6R?lΟ>w&2v? )"%h?(ɂ`{?'gwP@HO@"Gg+?eX?GTATTۧP@v?GTATTv?CJwX?!=߾?=V?z2?e/+5:M@St$O@)@HPsr?TATTC N@Wp?TATTCWp?r>S/}Kx?Y???sl2H@QO@mX&?H}?ATTCCM 2#I@E?ATTCCE?ԥ =#?oz<^$?@c?D'+…M@?W[O@҃2?Ǻv?TTCCT+::N@yIN?TTCCTyIN?v~g'%?=?ǡ|?B_<?Ѽ P@[ P@Q3:@ ^)ˀ?CCTGG^(P@N<?CCTGGN<?( 癋?*ݐ?$#?# ?zN@9P@wч?b2U0*?CTGGCKVlO@T(3?CTGGCT(3?M5e?$ݴ?4C?¦΀?SO@x $P@'c[?Mb?TGGCGєBO@^a2قP@VP@{"@H}?GCGTT 8/x(R@B^ޥH?GCGTTB^ޥH?kl?LpZ?wʟY?KB?F@P@e/?fU?eX?CGTTC+|H@]w?CGTTC]w?\=f>A K>D?UbdpH@GP@ X+@$ۧ?GTTCTuXK>SH@"Ks?GTTCT"Ks?@{%>@8ߒ?V)T> /?fz(pP@A&P@W? rh?TTCTAnN@Ù ?TCTATkg?m_?"?Sz?!_ ?!Q@^)+P@d0&?ݓ?TCTAT2/8P@/'?TCTAT/'?N͜?ftۀ,?8"R[8D?每?W?aCJ@-GP@(L?_L?ATTCTKuI@P@M?ATTTGm?O.mE>2)?s?=K7?]CN@0JP@S2K$??TTCTGKa}N@]?TTGGT\s?[`1?Au?ap?ik53?;JN@S'PP@|O)G?J4?TTCTG;Q{N@"?TTGGT$;?<)?O/?B9zќ?T!?BP@aTP@Lá@:v?TCTGC&=P@'QO?TGGTGAv'?(ݠܧ?:Ѡ?U#:?2?w)mL@0*XP@ H@0*?CTGCGg L@dr@?CTGCGdr@?g>X'v?+X?u?{[tdR@W}bP@ ĦY@Q?TGCGA"|@R@_X'H?TGCGA_X'H?+9f0v?[4lp?Q?W$r?d pXS@(\oP@Xc;@_L?CGAGTkVD$S@`Ѳ?GCGGTkt???4?F[w?eÇ>. JR@rP@Y8@?߾?GAGTTA ZQ@'?GCGGT,Q,?-E?b'Z?&U&A?b:M?`ggP@k yP@ն̉@/n?GAGTTC}[Q@:O?CGGTT8"?~qq_?pϫ#??P.k??^d?TFF@9#J{P@ YB? ^)ˠ?AGTTCFJ@śM1?CGTTC@A8K?&1sy=$p >!4K8>R1?`yH@鷯P@_?:v?GTTCT!jdH@4h ?GTTCT4h ?[=!q}@?ZHd>K[?c2J@鷯P@^|h@Q?TTCTGBÃN@g-x?TTCTGg-x?c|H>7$)?m͠#">RKKβ?,b{P@ZڊP@gE?gs?TCTGT9TnP@;F?TCTGT;F?Dkh?z@D.?Bl<}?Uxĥ?bVP@rhP@NOnb?d`T?TCTGT STnP@gη?TCTGTgη?jØ)%?o?VCeA?C?>@vaM@ǘP@S >?<,Ԛ?TGTAT^kL@a|G?TGTATa|G?.?mQgs?A&?c[WD3?~\N@h"lxP@ P?a+e?GTATGsxZP@GTو?GTATGGTو?=?K$U1?0_g?u!"j?9xO@P@hŤY?_vO?TATGG%`9P@&i?TATGG&i? .H?*$L?4b$8?̞cW?oN@hP@ ?A`"?ATGGCע,O@k' i?ATGGCk' i?EoE?kDC w?m$?WT&m7?M|fO@]CP@CN?Af?TGGCGcj!O@J?TGGCGJ?O??WT>Z}?BJ~?޳f}? =)S@VP@Qp@?GGCGA^0}=S@)ja?GGCGA)ja?Ŀ?~m?;? V鴥>_IR@S㥻P@!y?{?Mb?GCGAG  S@CX)χ?GCGAGCX)χ? ?2E3.? S@?GCGAG?œ.?c FKP?8H'u ?m>h8>@R@_)P@@@@:v?GCGAG.  S@X?GCGAGX?k?C:h?&vQA"?M${S@ǺP@a?HPsׂ?CGAGCo>S@yE}e?CGAGCyE}e?$Dx?1+?7([?.>^XFS@1*P@%¾`?_L?CGAGCȵ>S@Id?CGAGCId?r9yF?bJ}?_5f?.9̊a>2pR@YP@2Z,@?HPsׂ?GAGCG/nHP@p9?AGCGA\@DY?b Ë?()?o+?s?{R@ԼP@?UN@?AGCGAs!"R@˼?GCGAAM7?p[?@X w?Iש0?T5>,3S@( P@`a?+eX?GCGAG{ S@{?GCGAA>5 ?6l5m?x=(1 ?y~ S?9Y-.>C !PsS@UR'P@/+~?Z8m?CGAGC#פ>S@p?CGAACK z!?b??R{\)s?\0ܩ>GS@{Q@17?HP?CGAGClA>S@$-?CGAACD?c4O?GBPo?]aɌ>?&a>UPHTP@.Q@Dq~@NSt$?GAGCCpP@ vb?GAGCC vb? ?t?bhQ??K(&o?i'Q@*4Q@2?UN@?AGCCT[uQ@R5e?AGCCTR5e?.̳z?/?r&1޴O?*Cu?.R@|?5>Q@wb!U?_vO?GCCTAd^1R@s_?GCCTAs_? M?G9X?^?'Q4?sfUQ@ZӼCQ@S#bMPe?Bi?CCTAG:JwQ@ ڷ?CCTAA~C)y?Jb8T?_ϔJ?)yq?͝`E?davu]R@RQ@ Ԯ@UN@?TAGGT; R@?AGGGT۬}t?H?34?j5?:صW?í[P@1fQ@f?~jth?AGGTGchQ@NY)?AGGTGNY)?PJ?s6`?'}-?ܭ?:;M@tFfQ@lVb@_vO~?GGTGCP}a[N@S%?GGTGCS%?hI?Y(^?7R?lY#?h O@qhQ@/*yx"?/$?GGTGC/b[N@fe6?GGTGCfe6?!ϒ?Zuf? дL?U2?6omL@5;nQ@/Q?/$?GTGCCV;K@nFTq?ATGCCLy?c^#?&1?dd?ol0ᨹ?aQ@sQ@J\x@ ^)ː?TGCCAQgU4Q@WL4d?TGCCAWL4d?iG/?9J?I?T r\?s@ WR@wQ@!U?ZӼ?GCCACvafR@$H=V?GCCAC$H=V? ?9?J?*GAm?E1B? R@PkzQ@n_*@ ^)ˀ?CCACA6 &Q@#fFu?CCACA#fFu?)B?mB?:V?TO?sS@ܵ|Q@g=Ј?+eX?CACAG3*a >_R@5;b6?CACAG5;b6?sc@?S䀂?4fW ? >7(E5S@oQ@*3v?mxz,C?ACAGTؼ!R@s8h?CCAGT??}&?Oo{?+;?jF3R@7Q@yb_?<,Ԛ?ACAGTWomR@N:Rz?ACAGTN:Rz?4S?%?l^D?BHނH?z#HQ@( Q@/U?_vO?CAGTAXK¸L?k&u?C G?K+ذL@HQ@iQ? c?AGTAAd#EM@M2~?AGTAAM2~?ε8U?"::SG?5\#b?_X?;>}m,P@6Q@-nR?gj+?GTAAC OlP@?GTAAC?:J?v? ?C?kpWl_P@Q@"F ?+e?AACGA3IP@ux?AACGAux?k < ?ߛp?Ʈ]?˼KaT?ziR@3ı.Q@>q?tF_?ACGAALwR@<"(?ACGAA<"(?UЉ?g?1=:? >iTS@؁sFQ@;TX@H}}?CGAATvyV|%S@A,m9?CGAATA,m9????Om?o^'ơ>z` T@`vOQ@mQ!?-C6?CGAAT콣%S@zG?CGAATzG?%*x??'?mKST>d[R@'1Q@en@?ܵ|?GAATA|,R@7C?GAATA7C?N ?Js?W1?U>SfN@JQ@Y]7Y?ea?AATAA8^ `O@EEVK^?AATAAEEVK^?Md??$RLuŴ?׫cΧ?70K?o UQ@ qQ@{?ZӼ?ATAAAOQ@%"?ATAAA%"? iL? Ʀ?FQA?ɂ?_"?+0;`R@x $(Q@0?ǘ?TAAATse R@WUX0?TAAAAv=9?z:?rPc?,n?tCߔ )?@1G&Q@ׁsQ@@@?J4?AAATA\[DQ@韽?AAAAC+ S?FtGd?{.D?a? ?RZظO@&uQ@2𯪒?q?AATAAT`O@jL[?AATAG,*?35a?, ?j?4?ϻQ@_Q@^KV?Q|a2?ATAAGw\dLQ@W\?ATAGA5;W?ސE?phߞT?3|;κ?Bti?ϊiQ@R@Ѵ?H}?ATAAGn )LQ@4?TAGACt=?5?7?и9?aC?I?Q@S'R@#?HP?ATAAG&dLQ@hr`Ը?CCACGwP?Ա?kH?*?<?ŏq-R@V0*R@o?{Gz?TAAGGڷaR@O$?CACGC3=~]Y?B}L?bz@?W]d?㧂?z݁Q@AR@~E?~jt?AAGGG!eQ@OfL ?AAGGGOfL ?p'?li!??E`r?Xŷkg?ܸr#S@R@R33?ŏ1w-!?AGGGT${R@40?AGGGT40?KX?] v?6(^?b8>)AR@\m%R@Q @F%u?GGGTTw#(R@T&)?GAATT??-9t?WGnL? [?"O?^AL@:p(R@b2O@F%u{?GGTTT^L@%Y?AGTTT'1_?7Qr>jwj9i?&Զe]? ل?#OeD+I@#~*R@p]5?\ Ac̽?GTTTG/S0PlI@ߘ?GTTTGߘ?$NG;F=kL>K?k?")?jt(L@d]KHR@h?y&1|?TTTGA0bK@fwmx?TTTGG^7ϑI?vR>uw\?Ic? Sih?mQ@wOJR@Y@HPsr?TGATG3KC&R@msS?TGATGmsS??&9?d(?x\'t?c M@CKR@F-@L=U?GATGCO.O@Dz?GATGCDz?2癉l?Q91H?2tt?KT ?[NQ@HPSR@~9@`Qڋ?TGCAGnF!R@+@~U@}8gR@EFU+K@[ AqR@4.)?&1?AATCCƃ]eL@'|0&I?AATCTo$?mQ>/ :<[?r|:s?wh?t6 P@_vO~R@p]? QI?ATCCC4mN@ K?ATCTAp/r?͑+?{'Z ?]wCr?[6?"x}P@ʡR@%yp?6?TCCCC/gQ@t6,?TCGCCgd ?wU?t?št?N3??Q@ׁR@5L?F%u?CCCCG"R@X`?CCCCGX`?`PqPi?Ogk?6m ?za^PB?MR@DR@?gs?CCCGT:bKR@T0?CCCGTT0?g ?SWu?&HY?/aK"?=R@HPR@Ktv'BV@?CCGTTDdR@C0$+?CCGTTC0$+?:[yw~? !?M>/v?]I?$3RH@HR@Jf?46_wn>X]?;KI@7R@8T?镲?TTTTT-I@D d?TTTTTD d?=sS61=kA>jH>֍'?gu>J@fXR@Sv\?"u?TTTTG/=>I@̱)?TTTTG̱)?VU*=斓$>u: ~o>* k?z`K@$(~R@pf?+eX?TTTGTWZK@"G?TTTGT"G?oGA 1> }1> UH>3־?ƆnM@QkwR@?`Qڛ?TTGTT(N@$(̯?TTGTT$(̯?n״?Hq>a?f%?:I@ű.nR@ύ?(?TGTTAx8}J@V?TGTTAV?R= r ?AC7?m\9? *K@ cR@w\?ŏ1w-!?GTTATP|K@;RZ?GTTAT;RZ?h>8滚?Мͦ?Z?H P@j+R@8r.@_vO?TTATG>P@4?Y?TTATG4?Y?t?7?2#?ݬR?QT 7P@HR@Q9s @r?TATGC s-O@hA9?TATGChA9?f2ݓ?kQ?^u?Oz+ ?LL@AS@gL P*? ^)ː?ATGCAH2L@Fb@my?ATGCAFb@my?.5++>D$J?:?a!'?`,S@I  S@6 5pb@J4?TGCAA 8R@6.?TGCAA6.?GV:?jXW#7?xvd)?d%>}R@S@ ; ,?Q?GCAAA[ďR@?GCAAA?^2?.2?ĥa?EhYb?q0S@QsS@B1jDY@?GCAAAR@kJH?GCAAAkJH?f+(Q?VlUƇ? ;x?V@Sk?8L6Q@PkS@Kڶ7y ?/n?CAAAC#]Q@AUI21?CAAACAUI21?1Hĵ?V?=/\5?P'XB?='V?Ba?qUP@1%S@'_^?q?AACTA֫kP@?e`{?AACTA?e`{?e (?5h)?dPE4b?񱼲?U>P@B)S@?gs?ACTAGF#ÑP@vl u?ACTAGvl u?nqd?;-z?.Opۍu?g:Ҍ?TR@!Ac,S@RXa|?D?CTAGAYgܒR@Xi?CTAGAXi?;n?||?]F?RVXOv?,ŲɾQ@TAS@MZ?q?TAGAGXQ@-?TAGAG-?U?4Z?Y?YHN?p02>h?(K"T@6;NQS@+:u/?-C6?AGAGC(<ƙS@sg#k(P@*TS@4Um@ 0*?GAGCGl'P@%Ǵ?GAGCG%Ǵ?]G?g^?5z?<=%?`R@PkWS@a?gj+?AGCGGWsR@ں@0E?AGCGGں@0E?dWfD?!|?dUͽ?%of>OjKR@k+]S@cH?ZӼ?GCGGTphR@`vFK?GCGGT`vFK?Ir Կ?3Kx?tJ8x?N%zOc?ѱO@:aS@i'[@ o_Ή?CGGTC}{P@DX׫,?CGGTCDX׫,?+G?-k?6M?P֎?FuP@StdS@:Y<@H}?CGGTC P@_O?CGGTC_O?`ǔs?\vr?ͺB? `JP?ٳM\J@x $hS@[T-?I +?GGTCT#ZJ@B)Ӎl?GGTCTB)Ӎl?j+K>`?Cז2J?m#8?uTM@EjS@ؕ[?/n?GTCTGoB|M@*?GTCTG*?Cć?0\? _w?;;?Ci#aP@٬|S@bNT?Q?TCTGGvN}P@+ w?TCTGG+ w? F?S ?q4.? ц? MeSP@EioS@uK?y&1?CTGGT*/O@5 HWL?CTGGT5 HWL?x^5?c?·?Ul?L@uqS@#[@I +?GGTGGxŀOM@\[)?GGTGG\[)?C:>w D9?$?T?0 pr?p7N@VS@ʿVH?Zd;O?GTGGTvN@nU?GTGGTnU?QWQn?2ڨ?B"0?Bww?8bQ@ͪϕS@mw{ih@V-?TGGTT??SY??A=aI@( S@Hڦ?Aǘ?GTTTAtքI@Ol?GTTTAOl?4~}XP`=T>l# t>`+4?^"K@!AcS@swA.?"u?TTTACu]޸K@ 4?TTTAC 4?m`?zJ^?qe~?m r(P@OS@c~?jM?TTACC1<O@G?TTACCG?u4?;?k?hIh?DxQL?ĞkQ@_S@ս?UN@?TACCTQ@ q?TACCT q?Ը%?d" ?8Oq?\6W6?Q{%Q@H.S@ or?j+ݓ?TACCTQ@ sn?TACCT sn?Z$j?Qz?X?MĹa?D}Q@tFS@.\?vq -?ACCTTO)Q@dtK?ACCTTdtK?t)w?֍_Iv?=Q?x?mS6O@I S@8@~jt?CCTTT/,rO@.?CCTTT.?Zc|gg? A[4? yJrL?iQ'?fI@[d;S@\~?ׁsF?CTTTC}N]ASI@z4 ?CTTTCz4 ?>#4d=ڮɡ>g8~>" ?q"kbI@F%uS@lV|l?/n?TTTCTKI@&BEI?TTTCT&BEI?ac݌w=:"6>4>X>tA?vsUlM@%S@[?5;Nё?TTCTC"N@?TTCTC?i>l2?}ó?fvG?O4I܁?_ʦխcP@7S@Do? 0*?TCTCT^6uO@ p&?TCTCT p&?b1?'?I㲪G/?cl:n?\V*P@ڊS@Y|+?NSt$?CTCTCXP@4??TCTCTe?ČM?iEü?b?+dw?5{ P@S@Z?ψ ?TCTCTvO@! ]?TCTCT! ]?lfu?mn ?]Eg?$"?2 N=P@S'S@W)|^?}?qdR@ǘT@yt?q?ACAGGa?R@ ?ACAGG ?!?\f?fN I?_h%j? /R@%#T@\$?Zd;O?CAGGAg3R@DFX?CAGGADFX?.I ,?nB״?] ^?y&"t?R@x)T@zҌ8@n?AGGAC6R@/9`?AGGAC/9`?Dl6i?YFQ?r ?wZ?Ž[)qP@t+T@!Vx?`Qڛ?GACCABcnP@u??GACCAu?? j(?R?oL[? FҰ?k.Q@2T@} :? 0*?ACCAGf_7MQ@@}G/x?ACCAG@}G/x?T'-?&Mt?'?Cbb?ÂaS@"5T@gv?_L?CCAGGn.S@\t?CCCAG/?j?ghK ?Jȵm?&9,>Q53S@-8T@ym?n?CCAGGao.S@?.\;?CCAGG?.\;?`?hA?Mݭ?$9H?"u4sR@a";T@b?Z8m?CAGGG]dQ@9t ?CAGAA ?XG?g?vͧ?@{5G?[Lg1Q@OT@|X%?+eX?AGGGA`cR@$e?CAGAAp?!$F?!(x? ?Hw0ڣ?> chS@{RT@_6Q?F%u?GGGAA4j]R@FVb?AGGAA1u+T?U?3B(?R ?$FHbq>~T@c=YT@âx>@?GGAAGM\ U@;.?GGAAC[O`x/?$ٮ?3t?r$ꋶ?x $4>gQ@0L fT@2@{Gz?GAAGT'>S@?GAACT@qf?r"s?yh?)"D?Ό68?:9P@&uhT@_'p6?b2U0*?AAGTAI="KQ@ظJ?AACTT-B'T?g?/:! ?xd?WJKm?%sśN@;MmT@Y@?Pkw?AGTAT(wM@x_w?AGTATx_w?HVHB+v?ˀ=ɵ?I ?R\?M!;P@3tT@[.@JY8?GTATTzP@X~] ?GTATTX~] ? ͌$??Pr?EL|?4ouN@¨NT@ky@_vO~?TATTTX&[N@:׃?TATTT:׃?_!?Fqn?mB?5J?{\I@3T@`Δ?jM?ATTTG/VI@׾j?ATTTG׾j?8(zEP=A+b>@+T>kXm?-)5Ԡ(K@tT@6?UN@?TTTGC$4gK@@Ah?TTTGC@Ah?bT=P伡&?Gz0Mp?}?~~~TvK@^)˰T@`?ZӼ?TTGCC젲L@?TTGCC?Pi~>KL#?~X?Bh3?`~/P@uT@p2? rh?TGCCC ) P@Xr?TGCCCXr?<8P?$0+?۵?8?X?` Q@ClT@`]?p_Q?GCCCCґQ@rL#?GCCCCrL#?*P?]?rO;?Pe?=cffOQ@T@?L7A`?CCCCCO>cQ@m ?GCCCChU=?E?~?so?Ub?Xs5WER@b2U0T@{@|?&S?CCCCG+R@@,?CCCCG@,?QI?mN?A?ׁ[>C3S@+T@dv?`Q{?CCCGTI9keR@LO?CCCGTLO?_*? ?TX?~'ډ>?POj+Q@ȘT@/@I +?CCGTCXQ@ hMX??.}?fL0HG@KY8T@E7Yv@NSt$?CGTCA/ÐeH@3!?CGTCA3!? ^.=L>Es1F>^ٗ?rQrN@/nT@~ZJ@5;Nё?GTCATVgT3O@)Ԭ߻?GTCAT)Ԭ߻?1;K1?^h?Qg,?.ϺF?N30R@"uU@{l\CR??TCATG?M-3R@V׭J?TCATGV׭J?lє?C?'W?|M$AG? ]P@V U@"~SA?x&?CATGAu[rP@iܞ?CATGAiܞ??ohy?(nu?1WBw?!M@|/L&U@9 @ q?GATTAu M@ha?GATTG@f?Qn>vcX6H?.Bu?;Z9f?(.>K@4U@RQ?b2U0*s?ATTAA,L@?ATTGG+E?+X~E>e?~s?<x?a2yQ@_L5U@~N_?y):?TTAACt(Q@;e6?TTAAC;e6?9"?jYR%?+C}*?n&yQ?emQ@"9U@@_S @ZӼ?TTAAC"#(Q@iĚw\Q?TGCTCh9??ŀW:S?S3?█e?ߙK?x, P@OeHU@m:?Q|a2?TAACA h4P@ V?AAACAD9?k{?Z,C?{8{?~J?@5^,P@]mRU@-sb`?Mb?AACATgQ@Sc!?AACATSc!?E]?$?"C?ƣK,?IRL~R@' UU@\?~jt?ACATCħTR@LW?ACATCLW?Q.|?kETc?{n?A *?4'N@I}XU@pm?Ǻ?CATCTj*G#N@"7?CATCT"7?y'e?v̋{?LRg?p.B??^P@b]U@I?Y5;N?ATCTCfIO@$K?ATCTC$K?=&C?p&?@o?R?4bC?} O@RIfU@T?Q?TCTCT7O@b?gK?TCTCTb?gK?ܐA?]?w?;ҡ?fp?vˉP@3ı.nU@V?HPsג?CTCTGkP@b :?CTCTGb :?vERm?QQ?w&up?z0?@hP@rrU@ag?y&1?TCTGCX.=P@Nnq-?TCTGCNnq-?Cyà~?? >"vf?L.{?u5L@zU@?ݓZ?CTGCG=L@z:?CTGCGz:?m> 1&?֞L6]?:sƶ?\--R@ZӼU@E\@Q?TGCGG͑++R@ ?TGCGG ?I9,?4f?CU;m?[\px?pp\R@HPU@n?gj+?GCGGC+޷R@aE2?GCGGCaE2?RD?`m 2?861N4?~e?x`N@+U@62,? rh?CGGCC4O@_iX?CGGCC_iX?or?dKZs? {f>R@1殥U@wu%?St$?GCCTTЖ1R@z<?GCCTTz<?`6/t?7*(k5?+E?ĢC.8?O,M@U@ @gs?CCTTC-W$k-O@w?CATTCfWK;?wW>)|"l/D?z0aF?֎ӌ~?d҃I@mxzU@[}@vq -?CTTCT{ tI@Nb?ATTCTo]A?|W3f>Y1?Btݼ.?c 4?ۭ0O@~jU@?Pkw?TTCTA8 \N@$q?TCTCTn? T?bQ? 6a?zS?2Q@QڻU@aw?"u?TCTAC~JxP@xSjE?CTCTAsh|?,]?Y?nT?|ɩ?8F01߼P@( U@YkT?Ǻ?CTACT=2Q@T> #?TCTATy?1:y?$W'9= ?f<Z?tK3t?>L"hQ@DU@W ?St$?TACTTɽ-nQ@F06N?ACCTTcx:?6xFP ?Itr?O#`?TMy?gffJzP@a+U@)"?-C6?ACTTAcO@4?CCTTA.K 8x?Om?-n?wèS?} ?Lw9L@ rU@Eq?St$?CTTAGpĆ(\uL@7#>,?CTTAG7#>,?>G'ED?WS5?cp? ףpQ@{U@30?H}?TTAGGQ@愾?TTAGG愾?7?*g?J校?t"F?BQ@3U@.?3U0*?TAGGA={3R@ Hԡ?TAGGA Hԡ?+`?L?4Y?r|c?k%uR@'1U@sQ% ?ǘ?AGGATAJAwR@ڰ`?AGGATڰ`? 븞?GS54?ToI?u P?sXT@YU@ d *@?GGATT]S@v?GGAAC;/xJ?9G&?_?*]Y?5sNYr>I4/P@U@-H@Q|a2?GATTTsM@'?GAACT?3nwK@'†U@'|qE? o_Ω?TTTGCuegK@=sbb?TTTGC=sbb?ڡbl)=чV>F0{?KfM?\ʥ\L@qV@Q:?/$?TTGCTωQpL@lk?TTGCTlk?س{~ >D5g> YJ?F%s?uľ# R@ V@noa@_vO?TGCTT> R@tЭ?TGCTTtЭ?Im|? 2E K"?c{_ x?ݫQ?xQ@_vV@7EM@-C6?TGCTTc+ R@c}N?TGCTTc}N?3WX{? g9?u5k>?}-P?;uvR@6<V@iG!2@?TGCTT}q R@P ?TGCTTP ?p?O?E@AU?CAK?<P@sV@ UV@{Gz?GCTTAaZ P@wILh7o?GCTTAwILh7o?Gp!2? 2Y?JA<{?^8'?ML@DV@_Oi?~jt?CTTAT񇛱qL@^C?CTTAT^C?}uO@T?"s?&R?Pu,?(Q@q$V@`?-C6?TTATGJP@k-?TTATGk-?׼? v?Č?("r?)kO@,C+V@=T%r?"u?TATGCO@, x%?TATGC, x%?hiV?x?ٵi(pB?on&~?1(XL@e;O-V@=p5_? F%u?ATGCGdL@dtf??ATGCGdtf??X}>C?MBsv?ą񶧐?wQ@|3V@N!!|@w-!l?TGCGGA[+R@#p4?TGCGG#p4?eVׅ?;aT?\;?.T*_6?NC?oT=ߚ?O0|?#0I?Mb'O@o_NV@:A?{Gz?CGGCGO@^LJ?CGGCG^LJ?>&rD=_? ՜?B?hH?R%S@ȘPV@iþ?r?GGCGG eS@I.3)z?GGCGGI.3)z?oҟg?$H?aXY?8Q?0R@ YV@sbY}?ŏ1w-!?GCGGANR@3[?GCGGA3[?"'?g?1@?"(gR?gfff$U@ڊ]V@@J4q?GGAAT jkGU@㕮?GGAAT㕮?c^|?Bo0?NWu?O >xeYR@^V@VHz@/n?GAATT_;zR@x?GAATTx?}:@?16 ?h?rѹqkG?M@ cV@XW/? ^)ː?AATTC&ɨL@g=5?AATTCg=5?5|x>5KT?*?\J?PR=I@`TRgV@|^?Zd;O?ATTCATNI@77{?ATTTCP9U?$=?;I|><*]?ܼp?!>@J@zX5mV@~}? o_Ή?ATTCA POI@ے?ATTCGK ?\=4,l?#I8?jˋָZ?||M@hDiopV@bO}?Z8m?TTCATwA@O@Z?TTCATZ?mXwv?1{?(#B?ycSs?SQ@/݄V@z5 ?d`T?TCATTU lVR@@T?TCATT@T?a'%_?ABv?*0?zN$?nP@o_V@5p]@{Gz?CATTA|!:N@u7 ?CATTAu7 ?i5h?:lvV? o?3M!?{|K@ȘV@Nn?Ǻ?ATTATyL@1@ר ?ATTAT1@ר ?WX>.i\v?;˱?hڪAW?koP@߾V@]X\?&u?TTATAԩfJP@@d?TTATA@d?du;?2@#5?dBx?nǾ1o?0$P@%V@~o>?~jt?TATAT;PP@A~?TATATA~??')?.S?u?84??X`aP@e;OV@Gx8u'?n?ATATAo>P@A?ATATAA?P~M/?K?b'?MBe?Gn!x?+]DžP@e`TV@`7?ǘ?TATATP QP@.Q?TATAT.Q?.ʉ?F_Q?ywxf?h15?hP@vV@L=H D?a+e?ATATTRK5P@!sV;?ATATT!sV;?-z?NkE??i?s ML?=+ĶO@Bc̽V@JCг?H?TATTG}ؖ+N@b@?TATTGb@?:9QA?x|z=?ABB?aUv?O<¸K@EioV@}g^?&u?ATTGCAK@-F?CTTGC,?$+=ǼA>H?6a4?rc L@ŏ1wV@Ɯa?"bH>4KOi?O/2?Qb[Q@sV@B>@:v?TGCTG<ߨR@3Msr?TGCTG3Msr?ZE?a͹ F?u-t?mxKߕ?)\S@ǺV@8C@@-C6j?TGCTG#9nR@ r?TGCTG r?9z? R|C?Uy˸?G5tt?RkQ@$(~V@Շx@Q?GCTGA$P@>?GCTGA>?/yXV@/G`q? o_Ω?CTGAA*`tO@T#]?CTGAAT#]?;MF,r?O?W'?Av_5?d~)S@(\W@jt6\@C>٬?TGAAAȜS@^ {?TGAAA^ {?Lag?s=G3?}'Z}??>>@jS@ꕲ W@iH'rq?跙*?^Ks? hJ@#lxz%W@ /?Ǻ?ATTTT˨'I@9ZG?ATTTT9ZG?z6izv >s/(?v}E~?f?}?5I@$5W@| ܐY?Mb?TTTTA3; I@NJnB?TTTTANJnB?j\!=4 AqG?r;?DNS?7j4 Q@ec=W@=CRZ? 0*?TTAGAvdYQ@$1!?TTAGA$1!?@͛~?ZR;?t&{?(R@?UqQ@h@W@r}wXQ? rh?TAGATAJXQ@"Ue?TAGAT"Ue?{os? Zƺ?~K)z?N:J?N`JS@7DW@L=W@?߾?AGATT|`HS@:cY?AGATT:cY?d?UhT?&r?) m&>־aN@KW@vU@F%u{?GATTA# M@iYa?GATTAiYa?P ?"lLFQ?"?=X?$ڬLK@ŏ1wMW@HS?_vO?ATTATR/} L@(4f?ATTAT(4f?C:>'s7Ux?`U?8'൞?ڎs P@~:PW@C(?c=yX?TTATGྲྀ P@囆?TTATG囆? T$?V8?(I0?X:?/L@5@W@.lo @ ^)ˀ?GCTTCZ;@O@s|1H?GATTC?G?S+>b)H"?_0vy?(L?yI@ ZW@3D? ^)ˀ?CTTCGMwI@dO?ATTCG?Y>w5!^r?^TRVj?C?ZiP@ׁsW@jA??TTCGCOwO@pc?TTCGCpc?'v?Tg?Qi?<㻅?Q@kW@4Ur?HPsׂ?TCGCTQnQ@ M}l?TCGCT M}l?ؠ/~?^wa? XF'?[?pR@ƫW@ի*x@_L?CGCTT6GfR@h?CGCTTh?@Ak?jH~?U?+BK0?$%M@:pW@)i@_vO?GCTTCD@O@w_?CATTCJG?[>>H-?cO(s?Z2R?;SJ@z):W@!+?"u?CTTCGzwI@:BT?ATTCG}თ? zK=v ?Kx ?R;?k ,N@aW@,@{Gz?TTCGT !4;O@ Tо?TTCGT Tо?d?Z?a޽^'?y_(T?mQ@ 0W@pn @ ^)ˀ?TCGTAQ@딵?TCGTA딵?lKA¬?$bb?ԠdJJ?r9^??ȐcL@9#JW@X@v@H}?CGTAT02K@`@?CGTAT`@?6 T$?l뒑܋?s4g?a?O?P@"W@?Zd;O?GTATTzP@:j!1P?GTATT:j!1P?v?&?_}dž?9? BAqM@oW@T2? 0*?TATTTwN@FI?TATTTFI?"jT ?}^< u? ?!B?kI@8W@i1>?<,Ԛ?ATTTT\1CI@9P3o?ATTTT9P3o?aҺr=/9S>|/>-o1?vwH@ W@V0);@Mb?ATTTT,VI@"?ATTTT"?k/<=J0?f 6=L?0u8gI@jMW@8gV? r.=Bg?RJ@0*W@xՍs?M O?TTTTA*7I@;?TTTTA;?^Hz=0%ؔ{>2Gė*>HnS!?K@ lVW@ Ί?vq -?TTTAC6K@(VC?TTTAC(VC?Nk>=83?K:0?Q_?E|O@\mW@~RT?(?TTACCZ#O@y[?TTACCy[??bC~R?iפ? σu?oiQ@MbW@+<aP?( 0?TACCT|bdBQ@LM?TACCTLM?,Ō?&53?Lnh?䞮a?{R@mV}W@҈pbg?_L?ACCTT-Q@rg8?ACCTTrg8?<-?80 ?s?z+ 3C? UO@TX@^^@HPsג?CCTTA7(#P@ ?CCTTA ?B``?h>Q?f츼?\P`V4?^b9L@0L X@;`?q?CTTAC)(L@KA[?CTTACKA[?ϴ;'?Ȏw?-;z?9?N@ X@fj?-C6z?TTACTـ] P@[D?TTACT[D?rdf?\z a?khU?b;?mzAQ@ q X@`2[?4vȴ+?my#H?޸GnQH@a+%X@ ˗l?+e?TTTCC0\/H@KPH?TTTCCKPH?ֆk=9F>iQ]p>y}?wڐM@u1X@P.?~jt?TTCCTeIN@C,?TTCCTC,?A#?،X@u?S!uq?CCTCA㌛#qP@S;m?CCTCAS;m?S0c?H?Tב'?΢??q= AQ@mxzLX@A?H}?CTCAGgɖVQ@vhϴ?CTCAC~\۾?_ P?5T] ?Fb~?[f\?ʊ'Q@JTX@6?:v?CTCAGCgVQ@3?TCGCT:? ,@?uyK?w?^+P?TR@fXWX@(lMʒ?_vO?TCAGCU&PyR@q?bmQ@HriX@e>? o_Ή?CGCCC. R@XY ?GCCCCO2~?UuF?:ro?|?rZc?D`k R@6^IlX@9(?z6>?GCCCA WfQ@Re?CGCCAgX?!^-?'?ZD瓪?7,n3?F1R@swX@6]??CCCAT<FR@aa?CCCGGJ?0w8N?z}*R@GzX@B?߻?2%䃞?CCATT(ՂbR@ @?CCATT @?+&?v$#?λ?},wF>DQ^R@@X@z~?A`"?CCATTj%cR@".kP~?CCATT".kP~?Ϯ?0J,?+8*n?Ԟq]>%XP@1*X@2sX@&u?CATTGFΤN@˷K?CATTG˷K?Wp?8!S?0ZO??m5?ƉMQ@PkX@Z@Mb?CATTGܥqFN@Tle/}T?CGGTTcԿ ?JJ?JQi$?$*?LJg6Vm? @6{N@ X@L69@UN@?CATTG4N@! ?CATTG! ?b?u?Hq -=??`3?^B?J3K@߾X@/f?l?ATTGC-K@c?ATTGCc?n6MQ>,74D?& ?܈?v>vL@ݓX@@bnޜ?HP?TTGCAe~]L@o펻.?TTGCAo펻.?2ĥ>@>8ZM?Nz|? A?|S@ƫX@Snl@o_?TGCAG_c=R@.sU?TGCAG.sU?:?,Q?Oz?Z!>*@w;S@NSX@a?vq -?GCAGA&jfS@mQ@_X@@ŏ1w-!o?CAGAAu'R@a0?CAGAAa0?b'|??i?yқ? 9ZFq?YZNKS@NbXX@I?镲 ?AGAAC|aS@gG h?AGAACgG h?o?-m?)z4??X>筘P@8dX@Ry?ZӼ?GAACGpezP@"i?GAACG"i?L~?Q7?Qv4?? (LQ@o_X@839?F%u?AACGT^P@Y?AACGTY?ߋQ?+?fܴƩ?\H{?qR@!rhX@Q%?j+ݣ?ACGTGz6\Q@S3?ACGTGS3?1)n=ՠ?Xi;?R? |l:?`J@7>WX@ J@mxz,C?CGTGC~?I{J@ٛ~?CGTGCٛ~?? WzUe>P[K?t{3|?KsO ?6R@?X@{eU2@ŏ1w-!?TGCGTFR@v 9?TGCGTv 9?m?N?9X? X?4qP@X@;]5@ ?GCGTCB" Q@Q:v?GCGTCQ:v? ?%+?kP"_:?`}y)?֣p= M@0X@^^@`Qk?GTCAGX3إN@d^{?GTCAGd^{?*a?"oL?J1\B?+\?ˆR@FxX@3t?NSt$?TCAGC6uyR@Oh?TCAGCOh?+_z?#?&;y?%Nl0?O@p= X@ջ[?( 0?CAGCCXZNxnP@ט\?CAGCCט\?8qP_?[t(}?J=Y?b?C3KQ@ lVX@Еr?n?AGCCAHNQ@yF?AGCCG?m2?URsY?Syma?/@"QTlG?CAGAG>"QTlG?:[ͪ?r?fGJ?ɈKK(?#VR@NbXY@Y^WX@ZӼ?AGAGCqlu7BS@ȣ?GAAGCt5?b]?ZL?CN'G?G:y;7?cy`P@Y@=56؂-:S@:v>Y@zcH?_vO?CCCATDVR@ x7?CCCAT x7?٨?*\w?T7]R@:AY@.??y&1?CCATTJ'sR@Z:"?CCATTZ:"?y!h?UiA?4?GD>ex`O@OeHY@KZ @ŏ1w-!?CATTCfD9M@o?CATTCo?&Q>Çf>Έ?{cM?%I$H@ÆWJY@wYK?n?ATTCGeI@1.?ATTCG1.?7Hp=2>ʩ[>^?H7M@C>LY@,ؠcC @_vO?TTCGTߨO@,b?TTCGT,b?%>|s@? As9?ِ _?9dP@-OY@l?Gd@UN@?TTCGTuLމߨO@f&p?TTCGTf&p?Է͔m?硵P@^K]Y@[Ou?:pΈҮ?GTCTCj/M@eO?GTCTCeO?Q_?S?3?QoD?z=O@ qlY@j?_vO?TCTCG/O@ih?TCTCGih?k8?J_)^?C^N?YQ>f?[h_eP@~:pY@w6???CTCGTdXUQ@s,w?CTCGTs,w??9fNBL?L?]E?)͜G? =ET;}>GB?ǘJ@@Y@8+ݗ?@Q?CGTTCp}H@⫦?CGTTC⫦?qS=0-?N>fzY?A`尧G@)~Y@;ɯ[?Mb?GTTCT\H@:+u?GTTCT:+u?m-7= 5⼧>̇tI_>ծ}?+⫅N@gY@o Jd#@Ǻ?TTCTGsFN@U ?TTCTGU ?s f T?@nٕ?&v}A?-\-H?*"P@ Y@A|?a+e?TCTGAP@t!?TCTGAt!?dŴ|?}SԴ?ʚdKS?C9 ?N꽯P@Y@w?ŏ1w-!?TCTGAgnP@ ?TCTGA ?A|\ќ?gJ0??ꉢ&z?wO@%Y@? ^)ˀ?CTGAGc9O@tRH?CTGAGtRH?5w.n_?搨?l+?p)MZ?GfS@ڊY@ģqA? rh?TGAGABgb8wS@ڳM,?TGAGGgQ?[q3(? U?]%m/g?cz=/u>KTR@ÆWY@2#?M O?GAGAG_L̀R@J~?GAGAGJ~?3T?/Ar?+^'?ʶ#?8RIR@$J{Y@d <@ZӼ?AGAGCreNS@4??GAGGC=UEC.~? ?&Z?5o~[?p?:xP@~jY@4Pr.? rh?GAGCGr?+P@%9?GAGCG%9?z=Py?.7]f?@M?W \y?OYfS@+Y@]x?HP?AGCGAqR@yHt?AGCGAyHt? kLC?T8?^>o?'؜>me%T@46Y@Oǿa?HPsג?GCGAC昚S@s2Pͯ?CGAAAE8չ? D#?QW?9?Q >]9ݽR@DY@>W?ψ ?GCGACKS@ǫ.?GCGACǫ.?v?Ӓo?SU8'?e&aI?o9Q@1Y@o:j/@5;Nё?CGACGQ@sqh?CGACGsqh?l?4ItF??8. ? 8H(Q@9#Y@kQ?ŏ1w-!?GACGCP2FyBQ@mh?GACGCmh??a)fL?6cET?FQޘ?;rQ@_LY@q=?"u?ACGCThG5Q@y%?ACGCTy%?O0?>??Ԝ?:I?+vR@ݵ|Y@3J݃@~jt?CGCTGVb/R@Z"V?GGACT lj?-Ԛf?Xu]?9h?3zNS?b,P@aY@sUt7*@ ףp= ?GCTGAFcP@zYK?GACTGIɮIĽ?bvaũ?|&*?޺??2P@J&Y@r?<,?GCTGAIdP@ "a?ATATGd>?l}7?)t?aK a̕?:|5?>O@O@^)Y@n@~jt?GATGGߑf7O@6Ё?GATGG6Ё?B{?8Y@G?( 0?TGGTCյP@õ.=3?TGGTTK*|?̖?6w )?"F?t'R]ʒ?1?xJ@m4Z@6Ec?y&1?GGTCTi9J@A ?GGTCTA ?,Ӎw>gJYX`??'l?Iv?,vM@ o_Z@L; ?ψ ?GTCTGuM@VGVx?TTGTAk,^[?)3p?g֜?IE?FyW?!WM@A`Z@AM ?HP?GTCTGq&M@<}a-?GTCTG<}a-?ME??0?Ḿ`?PaO@JZ@M'a5??ETN? +5?W wCL@-Z@֖1$?_vO?CTGCGL@)y?CTGCG)y?<.n<>遱gb6??+ E?A| R@x $(Z@"%@@?TGCGG4$,R@Blx?TGCGGBlx? 6[Y?*"?yn֕?C?-aQ@[ !Z@x@I +?TGCGG[t$,R@]+b?TGCGG]+b?eC9?#R?Mg?U1qʌ?<ݯR@\ A#Z@>[ @ŏ1w-!?GCGGCpV?R@خO?GCGGCخO?&.0kͥ? *JR@ 0Z@?ǘ?GCGGT(qUB&R@D+uU?GCGAG'L?']PI?' @/?^G%Vb?LBz?tKU?Ad}G@ 9Z@z?/n?GTTTC6ܳI@=*R?GTTTC=*R?(ظҬ<H>8Iۦ>/b?ΔKH@Dl;Z@t;~?37?TTTCCp H@^+Zg?TTTCC^+Zg?]է^K( '?TgKM@aZ@)g@/nr?TTCCCϓM@#O/D?TTCCC#O/D?U6>>$[? ~J>] >;`dR@ $(~lZ@!a?J4?CCCTGmNrR@ W?CCCTG W?^ ?U$?t8A?jѠ?QM@1*uZ@.t^?( 0?CTGCTzHL@Ͱ}?CTGCTͰ}?`'th4?$xr?ܶ*wG?2?Xk'R@Zd{Z@@/$?TGCTG[&R@Yu?TGCTGYu?ÿ?1$?+=̕?A:4IK?fO@/$Z@7)]Q@ 0*?GCTGCuKP@A+ =?GCTGCA+ =?hfCG?GR?M%=ds?./e?ݗVL@K{/Z@mrb? 0*?CTGCT$LLL@J^`F:?|T? "(̔? ` R@b4Z@N>[ @ QI?TGCTGR@S?TGCTGS?#~?i ?pDXMXZ?Fʋ'?S6~R@ +Z@Fy@gs?TGCTGz jR@!׎?TGCTG!׎? M?TWVbΥ?a&r?K2?jSSQ@faZ@qݧ?+eX?GCTGG~fP@9d?GCTGG9d?Y?b?S#?c ?ojDO@:MZ@n3i?F%u?CTGGCؓ͟nO@Ol5?CTGGCOl5?\5p?nw1?{?? :Y/? yQ@KZ@ug\?y&1|?GCTGA>[vP@|v+b?GCTGA|v+b?(fa?O5Qv? ???eS}O@+Z@x?UN@?CTGAGCgO@J?CTGAGJ?,gf+]VJ?-fպb?z&4?ElR? z_S@W}Z@}`A@_vO?TGAGA:)PwS@Fq?TGAGAFq? d ?fy9x?<'ڒ?qd:~> ltQ@RIZ@y(@ŏ1w-!?GAGAC4nrBnR@Wk~?GAGACWk~?k?q?| ?Q'R@ rZ@%?ZӼ?AGACGχQ@##?AGACG##?V?MV"?te?Lā?#^P@0'Z@1IbgQ@uqZ@|-[t?HPs?GACGTKWQ@S"3?CGTCG9>S"3?ͻRq(=/9<?5;%i>kD?b/M@1w-Z@,g?b2U0*s?GTCGTb!RN@We+A?GTCGTWe+A?<{l?shL?tΝ?"3̶?=֪;N@ hZ@Hb*1?"u?GTCGTQBRN@}6?GTCGT}6?YWBsq?WzIc?ApDH?obݭ?~w!Q@UR'Z@ۄu|?b2U0*s?TCGTG/I>Q@vb\?TCGTGvb\??bv?s4??a ca?';tK@ZZ@C@F%u?CGTGGa- J@#"?CGTGG#"?O+j(吖>Rѝ5?NO?3?k7 ?N$DM@_Z@Fh?/nr?GTGGTd2,N@(?GTGGT(?fP? P ? R?Pv?tد+/Q@bZ@T?w?TGGTAnf Q@˛Hl?TGGTA˛Hl?yO?'3W:?!)?6)B?Yhf9L@~Z@Jd>R@_Lu?GGTAGCRN@aa/?GGTAGaa/?0{?ݢ?ٳtW轃?6Bă$?1 Q@HPZ@+?UN@?TAGTC>aVQ@o7e?TAGTCo7e?? Z?Cf?.ЯL?c?)ŢeL@[ [@@S!uq?AGTCA7^J@Bhu?AGTCABhu?ŸŴ?ư?)`?hf?Ӣ]vL@q[@7@Aǘ?GTCAGظ@N@IB2?GTCAGIB2?i~?s( ?fƂir?mFɏ?#'S@ףp= [@:?F%u?TCAGG!R@`2C?TCAGG`2C?esI܂?(:?k|[G?b,Z?\KTQ@&䃞 [@~Ɛ?+eX?CAGGT\v R@ax?CAGGGЋ,S?CV:?B}g?o?PO߻?榅dR@jt[@/6? ?CAGGTߒ|v R@\;!?CAGGT\;!?xΝ? -] R?3??`wuM?R@ۊe[@h?ǘ?CAGGT1v R@TYVw?CAGGTTYVw?k?4x?瓬?Bkr?`:VQ@ q[@FlӤL@F%u{?AGGTA egQ@k~?AGGTAk~??KZ2?sBk?`Է\/?dXXP@46<[@%9KPAu@5;Nё?GGTAA$,nQN@&u[?GGTAA&u[?EY?.d??~[?TYéP@(![@E@?UN@?GTAAC @P@>?GTAAC>?)=?~(p3?@?Y?C"2Q@|P+[@39@)\(?TAACTlZP@.kN?GCTGG4?_3[?AY:?bu?wy`O?~ %P@+e9[@5!l?[@ըt{?gs?CTGCC[(8L@ipI@?CTGCCipI@?j״T ?PpE? hg?gƅ?QP@N@A[@w8ou@F%u?TGCCG"Q@qD?TGCCGqD?A]?f,?0.WS?LL?(\+R@ON[@$J@-C6?GCCGT~_rR@_6?GCCGT_6?΁}0?fJ!8??~́?sQ@CiQ[@@]K=?CCGTAJ3ER@i3Ώ?GCGTAwK`J?Yj?W6?|CK?3?EݱlK@VX[@ @HPsע?CGTAC4lK@2xr?Q\6?8? -@`\N@+eb[@A?"u?GTACC\sOO@>s,8?GTGAC ]9e{?\;?ST޵?B?Cd#?HOOP@fj[@?(?TACCA9Q@L?TCTACܚ{?X?`s[?G?2L?nD:YP@?u[@qы? o_Ω?ACCAT!*i Q@wX\?CTACA3!YU?йq6?:/?\vU?6N1?_VR@Â[@kr ?W2ı?CCATCr0&R@Zr?ACATC]ȼ~\?dR?:?fP?ǃXrYE?˰2N@$[@yYl?&u?CATCC/]ΒYqN@AM+?CATCG{R@aӫ[@^"{?-C6?CCATTR@j?CCATTj?[ZlXp?#?!Za?,? ?0z^S@w[@\C"?_vO?CCATTۨR@}^?CCATT}^?˓?Ӿ?RZo?o!0>h N@Ciޱ[@FVxI@ŏ1w-!?CATTA(|N@N?CATTAN?8!\֖4)?m.J?P+c?p?;?f>PO@)\µ[@dC- @{Pk?CATTA"N@+}&?CATTA+}&?qGWA?_2^wѝ?};_ ?ww?-tJ@fc][@+}?jM?ATTAGL@ KgTE?g)7r?]%W?6ӂP@/$[@{]yt?Bi?TTAGTh4Q@O!?TTAGTO!?KȺ?Ҧ+ 3?5rϢ?g'x?XU/PQ@}гY[@z? c?TAGTT:_Q@]?TAGTT]?^X?=iy?;2?uPp?dVL@B`[@C@X9v?AGTTApK@υ#?AGTTAυ#?> >QLHp?n dp? (?`sK@o[@>] ?Ǻ?GTTAC@LK@FS?GTTATU6*?Y>??UQ՚?Y&i?vܢP@ݵ|[@K?ZӼ?TTACTK|8 P@ T-?TTATAκ? ,?) ?$V XՐ?~Z?'.P@8A`\@6b?<,Ԛ?ACTAT83NP@"\?TCTAT:)◰?֟ ?qwm?D=?Q!?PQ@ \@@?( 0?CTATCL^Q@Z*?CTATCZ*?I i?N[?c?:]?cN@s\@ߥb?ŏ1w-!?TATCGbdN@=?TATCCP׻?hg?;Oo?0P?~@o2?fU1^M@\@t!?Eioɤ?TATCGS$ dN@l?p?TGTAC{!lv?*%ބ[i?o??-C?EN@ґ\#\@?{Gz?ATCGAݽm7P@G_?ATCCA%x?uň?gf?[0?j?433KR@5;.\@hcZuI?Mb?TCGAT?F|(`R@p(?TCGATp(?,?p?,!,?1C ?OO4R@"l6\@Jq0?b2U0*?CGATA|PBoR@ I5?CGATA I5?G$?A? C?4pd??ZQ@If=GGGTTXmS?: B?)>_LJ"?R YV>Ÿ+L@/Lj\@)p?( 0?AATTC j˩L@}܊?TATTCA?m?s|>#Q?i!y?ZR*?-rI@{p\@qY?_vO~?ATTCC>ÈCG%I@>Cc_?ATTCC>Cc_?4EP=R? "?Uglr?+ =M@sr\@@/n?TTCCC2M@nË>?TTCCCnË>?JFXz ? (?Wy "q,?HפM?*ArQ@1*u\@)]~N?/n?TCCCAs-?Q@{ʑc?w^cR@y\@CG!.?Y5;N?CCCAC<,R@%8:/k?CCCAC%8:/k?jY?f'z?wx?  ?I)RXQ@5@\@.2? F%u?CCACA2@Q@m?CCACAm?H5..j?[~_/?1E?s?-546R@gj\@-E,)?n?ACAATk+%sR@|n?ACAAT|n??bBH?JK?,n1LJ?̏?E[ ^Q@i|\@"H1?HPsג?CAATAԛyKQ@,ig:?CAATA,ig:?8&H?0.tYm?PגFH?VW?aE4O@W2\@6.?zG?AATATeo.O@lSh?AATATlSh?375??y9?w?"?N@\@թs?j+ݓ?AATATGt.O@nIÏ?AATATnIÏ?o֤֠?3R=_? ?.}-?L6P@Gx \@,k;?7[ A?ATATTxYP@@;r,?ATATT@;r,?`j?ةvt?Y߅?d*K"A?8QfO@_L\@ 4? ?TATTALi N@t?TATTAt?9e?Q́?p'E??7Zɫ??B[P@&u\@Q$? o_Ή?TTAAA Q@ Ph?TTAAA Ph?_-!j?&rP>"G?Vܝ? gb?SIR@a\@5%r?DJ?TAAAA㯻HR@R?TAAAAR?5B?:]?x}?`=?kx'Q@=y\@/c|?z6>?AAAAAhQ@EܞPE?AAAAAEܞPE?ޗHR?V#?iҾjk? ^?^l&kR@]@tB?(?AAAAGgTZQ@u3s{?ACGAC[D ??`v1ž?tx>D?UFn?64hcQ@?٬]@ i?HP?AAAGCWÐQ@΂n#?AAAGC΂n#?TD?$?0W%Y?BP?ώ,+P@Bc]@jᭈ?_vO?AAGCC&c0P@6:7?AAGCC6:7?uʂ-?L%y?}Qe?@ի?xQ@=R!]@.=n?HPsג?AGCCAe(Q@p?ACCCC{?5(/Z&?.BSMg?H0?=fv?gffKR@|/L&]@#Ii?-C6?GCCAC.AngR@٢>9?CCCTAꍎYf?zjz?K9?$]C?$(v ?JR@C>,]@X1 ?@ǘ?GCCACcgR@Vg}?CCCTA H?7к?fnU?&t?e,Q?%n\Q@ 3]@SrX?HP?CCACTQQ@T/A?CCTAT_ԲP?g&ۇ?}WW`?w*?e]? *V*R@j+6]@nL?UN@?CACTT[΃NQ@|C?CTATTؤ8z? ?.-? ?1n?JN@kt8]@;@+?ACTTTa|9O@\2?ACTTT\2?˷>2!h0?1gB{?3.߹?_#J@(\B]@7z?ׁsF?CTTTCZ.STI@Kmk(?CTTTCKmk(?F1}- =* >'?:D?m$I@l G]@n?vq -?TTTCAchI@?Jr?TTTCA?Jr?DY=5?>Hr?;O@O]@C^?<,Ԛ?TTCAA(fYO@mqw)s?TTCAAmqw)s?.?nU?"?Ȥx?2IR@jtS]@M`l?ŏ1w-!?TCAAAfTR@pI1?TCAAApI1?7a/?o 8'? Rd?>%IQ@fXW]@b+u?ׁsF?CAAATÏ.Q@-?CAAAT-?9 ?! Ysj?< :ո?K\niJ|?pBsQ@R|a]@ ?"u?AAATAKʁEQ@?+?AAATA?+?/{Y?-ݗ?؟N?[可?]dwQ@Se]@rW?`Qڛ?AAATAm(EQ@S?AAATAS?v? #@W%?, ?[@~?ugO@C>l]@U:@Ǻ?AATAGFeGO@>?AATAG>?+SvI?X?F?uۓ|?_QQ@o]@7\謊?(?ATAGA] $EQ@?ATAGA?S5?^P? R0?ⴋ98e?]$ R@|a2u]@g'?JY8?TAGAG ەQ@H]?GCCAG*JZ}?>m?x?E ϖ?%U8?8S@¨N]@5O? 0*?AGAGTkT@Mq`'p?CCAGTwvcE?,҂#?&=Ƃ?D?>xQ@S]@Sw ?Aǘ?GAGTAUҁQ@ 8?CAGTA^/?O ?ڪ`M? -?vwu?V工[L@]@e?Y5;N?AGTAGu}YM@Vێ?AGTAGVێ?{ z=>n94P?DJ.˃?2#?W0aQ@m]@9q@+eX?GTAGT*P@_?GTAGT_?WiJI?UϾ?sog?m QpR?> ՙQ@*]@ۏ}M?b2U0*?TAGTC* WQ@?TAATCE ,?]k?1d?%~K?Іq?̼L@ZB>]@0 W?-C6?AGTCAJ@>Ȱ?AGTAC07?S܆`3?蚞6p?_X??N?v RT?J@R]@~16F@_Lu?AGTCA2+xJ@w> ?AGTAC!%?c>Euڌ?{p:?j?5{O@C>٬]@wB?JY8?GTCACrN@in?GTCACin?~? ?h+\?pvΝ??ߕ?_Tz=Q@j+]@[w?UN@?TCACT$hYQ@%qG?TCACT%qG?X?Qg~?HmgH?^#?m;fþQ@}?5^]@?HP?CACTTRYQ@^?CACTT^?NQ?Hvz;J?ɮ? rb?cwO@H}]@C@~jt?ACTTAo~`SO@j$?CCTTA702?q7JB? N?+k?}?t2L@w]@t5=?:v?CTTAA*$iL@ͿY?CTTAAͿY?%, ?$ٯh?>i=]ƞ?:7?ȻmQ@tF]@=x??]K=?TTAAC@)Q@y,?TTAACy,?z@?lpӤ?E0.?̽1?Cz@Q@*]@x U?&?TAACT >GP@ "p?TTAACw??6?z$ 9u?a]a?|.+?QP@x $(]@~; Z??ܵ|?AACTCXSTP@ Gg?TAACTv#?o+9?SJLC?Ѭ,L?jfLbǼ?F'O@gfff]@?1%?ACTCC#Tk>Q?)8ZO@|г9^@P{z@F%u?GTCAA5qT~Q@ψ@^@f?&?CAAAT?qvQ@zvx?CAAATzvx?Wpצ??qORpA?4ap?UuQ@iqJ^@ū g?S㥛?AAATT\zhQ@1*?AAATT1*?B;t9?Jk-(}? ? /=`?Y6]M@>W[Q^@o3*@q?AATTC˕(L@ng?AATTCng?jm%(=B> i)?QgS?>U?u J@ZS^@GcQ?]K=?ATTCA. I@?ATTCA?Y*-C[>$9A?Z?~ ~?/oGQ@y)Z^@.f>@ݓZ?TTCAGvNO@_5A?TTCAG_5A?-u?3|@?Ez]l`?n(nX?>îR@;Mm^@K|I1?+Q@r^@ j@Uد?CAGTGˡ^Q@0r?CAGTG0r?'0?) V?oqw?a_' x?q= ׍L@_I ^@ -ٖ]@HP?AGTGC} YAGM@"n?AGTGC"n?z>{uX*p?T撖?UU?Oz8M@a+^@AZjI?_vO?GTGCGa]2L@?CMP@@}?CGGGG@}?  k?l?{{?y%}H?۲FQQ@pɔ^@ sG?~jt?GGGGA_VR@?GGGGA?lY?R?_?Ryzt?Z R@N@^@?Mb?GGGACB\R@r?GGGACr?] ?RV"?2mB:4?;+p(:?H\Q@8gD^@Z|@0*?GGACT~R@/?GGACT/?OUb?0ҿ?G&w?V*{l?pXGQ@jq^@E'?/n?GACTC~aP@]_?GACTC]_?Od?>?n cي?jYq9 ?q ^eO@PS@:^@!|?N@aã?CCAGCŜ#R@U4?CGAAC0? if'?d9j??RJ?@cO@D^@ ś?+?CAGCC|.nP@?j?GATAA}?P?Զ?;?5a?aӚR@M F^@g7&z?{Gz?GCCTGYӻR@T,i?TAAATTj1?/US?Z2Sl??Ld>ȁ?c{r]5Q@Bf^@FL?HP?CCTGG4SP@@*?CCTGG@*?Y-?>^i?Ӱn?wqw?uIN@Hz^@V׮r ?HPsג?CTGGG=F)O@l<?AATAG}7$?UK? /YE?5?"j?ct*7Q@W^@^?46?q?./BR@E^@َ @Mb?GGGTGLjZQ@He?GGGTGHe?(?|b?hp?"%nP?W'UaP@_@ǖl@+eX?GGTGT ]T. N@?GATGTXT-?7O,?}KY ?@XpS?{b?1eDM@-C_@Ֆ#s?ZӼ?GTGTA2Um>E/ק?arK@Pn_@ ?H}m?TTTGA4XK@5?TTTGA5?4> 3?_E?_i_w`?& N@Z_@?NSt$?TTGATiZN@*;Xd?TTGAT*;Xd?X?CjY?e?G=Ä?Q@x#_@mE?b2U0*?TGATAG/R@ m[?TGATA m[?-Q?Ni:?y5??vÖ?9!DO@ǘ_@1G:j_@qUKD?R^Qk?*x?W!I@2ı._@PZ_!?u$~?ATTTTpFI@,`?ATTTT,`?y|p=`b>y>KbCVq?'UưI@b2U0J_@~enUW?ŏ1w-!?TTTTT&3EI@v;?TTTTTv;?Ȗ1RV={x?* 6K>7>X?J:>}WOI@ h"L_@>F??gj+?TTTTTEI@1v1w?TTTTC Ï?eD{D+Y=V?I@R_@\ ?~jt?TTTTC֡TFI@{V7?TTTTC{V7?͍/q<.`=1p>Pecq=f{ ?H@/!V_@s".?_L?TTTCCkL:cH@)?TTTCC)?mZ"m=F DK?Kxr:I@ Y_@6,t?~jt?TTTCC&ӬcH@?TTTCC?߰L0= ߼QO5?5>?J| M@%^_@6+ ?w?TTCCT:hN@5,a?TTCCT5,a?q݅#/>-?3~w?Vڞ:s?ȬT_-Q@`_@29 D?<,?TCCTT EQ@?TCCTT?7?`3%?x&?^f?VZ-M@wOj_@q 1*t@ۧEf?By?j+''? OSK@2ın_@JJ?<,Ԛ?CTTGT={K@,?TTTGTQ+?d`1>Ŭc ?g2O?8?*E?U8lN@Pnr_@aVC?_L?TTGTT Rx*N@)n%?TTGTT)n%?۹B ?ۘ0? )S?wFh6?9n0WK@w_@>?HP?TGTTT]ZJ@9ܯd?TGTTT9ܯd?C'#>(]?no}J?Y?Gz0UI@?_@Ƶ> ?ݵ|г?GTTTTSxI@Bl?GTTTTBl?;n0"=[݅>/v> E?(GI@`_@QIb#?~jt?TTTTT9d QI@L ?TTTTTL ?݋>oo=2jAu>*OI>}?c9)I@<,Ԛ_@]#CH?( 0?TTTTAW*I@Uz?TTTTAUz?VXq=*O>tx@>x?0cɘK@[ _@5Q>F?ZӼ?TTTAA MK@6Q?TTTAA6Q? C%>W=d aN?qä%O?C? θBQ@ZӼ_@ ?F%u?TTAAT}7Q@Pu?TTAATPu??֖+?,p?r@x?s]a?뒥Q@՚_@:?HPsׂ?TAATCJyQ@ou?TAATCou?V D?o#?Cg?b%KmG?쌛SM@x_@"l? o_Ή?AATCGBL@OpŇ?AATCGOpŇ?7?jE?&.Nm?NKB ?v~O@镲_@_,?Mb?ATCGCvz.'P@?ATCGC??vU?h·?V|y?]16Q@[Ӽ_@3#V?~jt?TCGCTnQ@ _?TCGCT _?1%??ܷ?dl?&~?ٱaxM@6_@# ͻ@ŏ1w-!?GCTTCكAO@MCJ}?CATTC|D?J/w>ޢ+8>|y?o?Z ,H@V-_@F(O֫z?ŏ1w-!?CTTCT QIvI@S?ATTCT]N ? 54r=γv޼>6fq>^?%.N@=R_@*.@ ?TTCTAd/N@ F/?TTCTA F/?C; 8`?s?H [&?!U'?} Q@x_@ꊵJ?/n?TCTATP@DU'?TCTATDU'?;F ?R%?腟d|?#K( ?\@sQ@~_@%69)? ^)ː?CTATTQ)cQ@N:;?CTATTN:;?Ji? O?l^n?Gù?wh*fO@?W[_@ h?ׁsF?TATTT[AN@@X}?TATTT@X}?c?|Qg?>{0Bp7?vQ:?o+IJ@7`@_ O?B`"۹?ATTTTR~8I@Bi?ATTTTBi? aFCD=n?G~>yE\>9?@I@`@+\?/n?TTTTG\"I@Y?TTTTGY?8% =xeFj*K>LSʔ>9%?wK@ψ `@o g?ZӼ?TTTGAK@=Z2?TTTGA=Z2?cX>X;:!?uI#?`'X?z N@&`@|G?-C6j?TTGACaWN@N?TTGACN?q?n-6+"?.cm?x !?PO@MP@x&`@"˰?H}?TGACCҗSP@2?TGACC2?C?4E t?R2?ܖfg?-P@G?`@ӞKq%?Zd;O?GACCA/oP@/?GACCA/?G؋q?9??y3Y?uQ@ˡES`@7[?y&1?CCACCΧzQ@S"+?CCACCS"+?mǴF?۝=,#ftP@x-!t`@Y"@mxz,C?CAGCGcP@]"W?CAGCG]"W?j?tT?E5 ?$F@&IJ?BZR@'†w`@v%!^?gj+?AGCGTxR@BEA?AGCGTBEA?P!&?lUr?)]?0VHB?A tKQ@}`@<'w@b2U0*s?GCGTA>L4R@-?GCGTA-?G.? \yt?gwQT?ز,?_Հ7L@?~`@AA+?{Pk?CGTATXK@"%%?CGTAT"%%?Z?,8ao?.&?i<?@EoP@#lxz`@RE6P?L7A`?TATGT'$S|1P@Q$v^?TCTGTӚ3e?mk? -?"3P? 5V?%h_N@(`@m? ^)ː?ATGTG 1BN@$nˀ?CTGTGID2?~Pë9?S {b?) 9? }?>K@`@e)9?B?TGTGG|IL@\0?TGTGG\0?Krd>h7I?~i|?v4'#?Y UM@#lxz`@*@HPsג?GTGGGAX(nN@p>9?GTGGGp>9?st)M?0#?i=ӛX?C]'?M4fQ@b2U0`@ #?{Pk?TGGGT3 xQ@;~K?TGGGT;~K?ǜӠ?0T? F+?.EWC?VB.P@^)`@gwG@NSt$?GGGTAQ2Q@4g塘?GGGTCw)?? ~3Su?ͽS?WSQ?TIh"J@sF`@ESH@2Zd?GGTATI>N@SA?GGTCT_C?>c R5b?Y L?-m@?f}3P@.`@` ?>@ 0*?GTATA>IP@dx?GTATAdx?.LI>?>r0QQ?7B+}?,!?o5EP@^F`@mX?q?TATAAg .P@dΧ S?TATAAdΧ S?hu?xXJ?~ܙ?JB!{?GACTAw?,BM?xB?K?x̤[?6o[P@|P+a@C'?"u?ACTCAO@ Թ?GACCTVi#?Ϗd/?WRC?1tf?Iu?W"R@sh?CCTCG4(? }l(?y?Up?Ӫ?mxQ@x $Ha@.91?Mb?CACCG/{y\Q@h!?ACCGT╖?2?61~H>tm@ǧ?pH@Dta@Ry?W2ı?GTTTA>wA%I@$ W[?GTTTA$ W[?ʾyV=k)cM ?#*b> ?0uK@( a@H%?ڬ?C*ϕ?yt{?!")MQ@|Pa@\te @a+e?TTAACKz)Q@ |?TTAAC |?b5?0nS?9ĭ͟?3{K?{tIQ@lV}a@X "?J4?TAACA:P@ YS?TAACA YS?j1Wn??F.ϞT?hkW?ʅwGQ@> ףa@Y,y?HP?AACAAxP@OԳ?AACAAOԳ?;ž~?N?&ތu?{T?OZQ@Da@v?]K=?ACAAGbvR@qH?ACAAGqH?u?QC^?er;?aH~?:V)kR@V-a@mR@Mb?CAAGT_vLR@T"h?CAAGTT"h?鏹Eb?$?v$`?j^?e?}+nZQ@va@H /@ ?AAGTT e%Q@p?AAGTTp?ѓ?ߖ9?K_?Őئھ?gffboP@鷯a@~D?-C6?AAGTT_T%Q@ ބ?AAGTT ބ?E?Jէ?kŞMk?J?NbXK@^)˰a@Nd3Z?~jt?AGTTT^ؓgdK@B?AGTTTB?M[NS>25`a?7r j?ޝEb!?npXH@a@M=u~?y):?GTTTC{:I@b[Do?GTTTCb[Do?舉a#e=F>->E6?[RaI@~a@?a`EW?HPsג?TTTCG^I@Zy./?TTTCGZy./?v]4ܻ=~5O$?-Xs>)u3?,HP@m4a@S@$C?N@aó?TTCGT!hdHO@ٔS?TTCGTٔS?H k ?ĥ?FFX?: T?Fa3R@a@#Wq?w?TCGTTjt7vQ@i?TCGTTi?I?| y??C1%?K', I@hsa@" @"u?CGTTAN0LI,I@~?CGTTA~? !=SDm>{h >5"?7+K@'1a@Ff1?+?GTTAGi{K@:Ã?GTTAG:Ã?Ŕ6?M-l?o?h⨹? ףLQ@a@}?-C6?TTAGAN=Q@w?TTAGAw?C#?߆u?oo? >|}?g%*R@a@WeN&?S!uq?TAGAAFR@yE,A?TAGAAyE,A?)7?oK!r0?7/?YV%?SVT@ڬ\a@C/X~Q?<,Ԛ?AGAAATKT@M?AGAAAM?J[?aa0?Zu?;>>۳lS@a@Ia%?gj+?GAAAAjbbS@Do?GAAAADo?j?H ? 3W?8϶> iQ@vq b@%<h?_vO?AAAAA0]'Q@5?AAAAA5?et?**?PS?jwzj?E(mQ@B`b@C k?b=?AAAAA]x'Q@w`?AAAACdg?)q-?ɊJ?1g"?4m/>?_0l[nQ@߾b@fϸ'?HPsr?AAAAC0{tQ@kkȾ?AAAACkkȾ?>Z1E?7?Gg?wm}? ףJO@46<b@Al$?-C6j?AAACG-$P@-$:4?AAACG-$:4?(EF?Ѵb^?B2qa?ڊf?"> R@( b@/>W@J4?ACGTTYQ@º?ACGTTº?װ?2a?+{iO?0-?;&+J@ cZ"b@_} @ 0*?CGTTCt/H@~r:?CGTTC~r:?i%/$'>ذ%?"|!?5ŋ?yFYH@Oe(b@A@0*?GTTCTWH@폙G?GTTCT폙G?G'V>$l?~!;?s ?1MP@U-b@*w?ea?TTCTAm[aRqN@-F?TCTACXҬ?Ѫf?J(?49G1?."F?4a~P@:MDb@䝡|?mxz,C?TCTAG߿P@!hKMr&^?<?#ʭ-?ThM@X9vb@Հb ?Ǻ?AATTAwM@L9?AATTAL9?WLC#?١?i&?P$?xpK@ yb@.A ?-C6?ATTAA&o4/L@a ?ATTAAa ?纡>'ߛ-Q?%MJy? ?T ?P@m4b@sdD?Aǘ?TTAAGl.Q@ L?TTAAG L?h?J밼?fNsH߶?\[whD}? ף0hQ@):b@VA?Mb?TAAGGcR@6&?TAAGG6&? B[ ?h R?G O?HS?BŁQ@&䃞b@{Ŭ$??HP?AAGGAH5Q@遢+r?AAGGA遢+r?#aר?e&?H "?؄t?I]R@b@Kg U@vq -?AGGATR@\6]?AGGAT\6]?2?* u{?CD3?Yq{k>,T@]Cb@<nw@Q?GGATT$g S@Z ?GGATTZ ?bvD? e?)v?PX?=mtg_L@b@۲@tF_?GATTC^wL@$?GATTC$?~>Rw'>;KT??t7 H@^Kb@|6 +5T?:v?ATTCTaxI@uL?ATTCTuL?jō6Ռ=ST*>Ua>QnP?}lO@ÆWb@ETD?_vO~?TTCTG мoІN@g@?TTCTGg@?st-D?* }o?5~d?oё?ƒ_,P@w= =?~8?- ?R-3\J@-b@:LI?Y5;N?TGTTACJ@?TGTTA?Rӿ]d>jIo?}k?(l?G 6Q@Db@%mBt@?TTAGT4Q@LCnv?TTAGTLCnv?:?X?`ɜU>?Twv?mn>Q@b@; ??TAGTG7 vQ@};?TAGTG};?G)?YQ?j7D?Zѝ?:_:_wN@ cZc@ss?p_Q?AGTGAM@P\Qa|?AATGAL3n?r&S?WZ|r?IoP?ۍ]?"`bS@$J{c@kê@n?TGAATU1|S@.vQ?TGATT*^?4P-e?<$?D?Z@%>Q@c@ز=/@ ?GAATT{R@0'˰?GAATT0'˰?Kmy?,q2w?VjړE?;e '8?9hL@"c@zNω\@ZӼ?AATTANb.4wM@s?GATTA[?1r@ >slWӯw?G#Үz?\Z^? [cK@c@nrn?_vO?ATTAAP&O/L@ /?ATTAA /? ^L? r?ۚT 6? ? $N@ecc@,]} @F%u{?TTAAAxH`mQ@qpu?GTCAAyL Hpr?~qtv??`HK9k?P=? ;UZR@c@}PH?ZӼ?TAAAA6lHdIR@,T?TAAAA,T? &Qjj?M@lS>CGGTC&R?S>~=ܥ> l Y?9S/?HM@٘cp?AATTG٘cp?9nY q>"V{g?%?[䲻c?+L@>c@F@kt?AATTG p6>M@eN?AATTGeN?&x1>ahȳ?9F?7z T%?VmL@Ic@M]Y?Mb?ATTGCW:K@hV1y?ld ?4e9?EL@0'Kc@3WT?N@aã?TTGCTHsOrL@A ?TTGCTA ?+b)?Mx߄?]SUh?D?S@DTc@O t`@Oё\C?TGCTTu(!R@9?TGCTT9?ă?R #? v?!W5<>´VP@b4oc@ kL @HPsג?GCTTGڡ~P@Z"/?GCTTGZ"/?jJY?ܞN??Is??4K@gsc@?+?CTTGGF7K@ha?CTTGGha?ej=w>F7ൌ?I]ފw?qJ%?D3Q@c@埗@X9v?GGGTG:[[Q@n?GGGTT]R??ů?J=?jts?zb6v?sDN@j+c@Z,@+eX?GGTGTf N@yu̻?GGTTGQÐ?%K>A =K{?M۔:?vDGMC?\$K@wc@~sP?X9v?GTGTAǓ+M@:?GTTGT?P4B>a0n?,lbQ?b?_-AaM@):c@ ~??߾?TGTAT |_L@}e?TGTAT}e?Z~G?5??0?_!?3P@镲c@Y?ǘ?GTATAJP@s*?GTATAs*?UvW?̴B?z&?ݲͥ?T1P@Gc@5?V_?TATAC+#YP@D>?TATACD>?z0;?ls_?C?B"u?aR (P@[ Ac@?^K=?ATACT:>P@W?ATACTW?STgz?!zF7?ye ?ܸkw? MQ@c]c@Xi~l?H}?TACTT [壜Q@L`?TACTTL`?Ӿt1?_Dc6?%3=;>g}[H?+QaK@a"c@bCLA?jq?TTTGT[K@5؇I?TTTGT5؇I?J[U>@s?Gb>n?hq[N@o_d@敛!?{?TTGTAm>M@hhw?TTGTGIT`?#S 7#?1&P$>,^?D8ch?-tL@_d@U?w?TGTACNL@ey4?TGTGC䛚d@:5Wmc?Q?ACCTGt76Q@/Om?ATAAT$^=ܽ?UȰ?@3?!rC?+3\# ?Ph=Q@ hBd@<l?ŏ1w-!?CCTGCP|P@vM?CTATG[%?ʠH?D#6?N?eF#w?!Ce9M@.Qd@%ti?_vO?CTGCA;L@k8]?CTGCAk8]?0$x> % =U?Y/ d?Vr*?Y(R@~jTd@7cq0@UN@?TGCATSR@4Jbn?TGCAT4Jbn?A‰]?Ĉ@?Br#>`;B>ϊFR@Oё\^d@ɂ輺 @ o_Ι?TGCATR@}_L6?TGCAT}_L6?όy?6%`?ߙuS3? H>]oyuS@+dd@Ś3@?JY8?GCATAQR@H?GCATAH?\둌xn?X/(?) ?G%g,?MP@Vod@W?:pΈ?CATAAUP@vw~?CATAAvw~?x e?7?*)?$+?>oٸQ@ F%ud@]?46+VS@ cd@1d6+?r?GCAAA^R@z=?GCAAAz=?Y #?>~<j?"s?>~ ?8CR@Qsd@?16!?L=U?CAAAA\#yR@ܸ?CAGGG#?Jt?QiDe?~y}?ȓne?D&Q@Hd@tM?DJ?AAAAGB"=Q@- x@$?CAGGG 6?zǮl?7v U?7 x?Y;{? ףQ@Cd@&]?Mb?AAAGA#-)kQ@vyC?AAGGA} Q9,?UhH]?X0?9'?Wo-i?t <:R@d@;Q̊?L=U?AAGATqIQ@⠼?AGGATgV?Ң?%_i)?J+?z?h~S@d@xt@ψ ?AGATCzR@9Y?GGATCȮ Pd?cհ? #f? W? p )?zL@d@ԩݠ@gs?GATCA,bo;M@|h?GATCA|h?{0g`?WxJ?5?ax?i+P,R@=Ud@̖FI?gj+?ATCAGIy2;P@ÈX?GGCCG+;4?H<|?; 0y?d?uEF6?+3R@&Sd@6k?:v?TCAGA4AR@ri-s?GCCGA?'E?^ P?.R?XQE?QUsdS@td@/Ԓ?+eX?CAGAAF(R@-M.~?CCGAA>=m%?U>-? !sO}? 86G?# XԹ>L.aT@1d@<3ih@n?AGAAAP]KT@:N?AGAAA:N?Rhlq?fwu?1V ?avc>T@gd@zD@_vO?AGAAA.^KT@`P?AGAAA`P?b?hC?sUM?O2ܖ=袋R@~d@qIKx?F%u?GAAAT&:S@i?GAAGT@`(<"?uC?㯔Gs?;#?O->-P@?d@-16?"u?AAATCR9 Q@Î3??AAATCÎ3??!}G?3U?"GY:M?a`?G`2J@N@e@"#Yb?5;Nѡ?AATCT*7JL@[bT=H?AATCT[bT=H?0Yj>u%4V?^XhFU4?TG?Ӻ@RN@l e@wo?Pkw?ATCTA@RO@?GTCTA_?಴ؾ?`vw?,F(wԵ?00|ә?ۋP@47e@FcZi? ףp= ?TCTATMP@D?TCTATD?Nb1u?V4[H?U?=? Q@ZӼ#e@y̧?_L?CTATAW0Q@?CTATA?E1}?Q(?c? ;?-eP@Hr)e@A1M??ܵ?TATAAؓxP@@׊?TATAA@׊?~,?Stz?鏦j? \ S? vP@\>e@OYFq?UN@?ATAAGs"NQ@p8?ATAAGp8?2U}?,""?FƳ?MŴ2?o:R@He@y w?Qs?TAAGGYaCtRcR@`h?TAAGG`h?]%?0ƐP?d-ձ?QepkF?WpBQ@vZe@ ҈?1*D?AAGGA-LQ@uvX]?AAGGAuvX]?:?S?&f??wKU-ף?2cR@&fe@']?Zd;O?AGGAT1uÝR@B.?AGGATB.?6ij?[h3?S?SP$2?-5XuS@;pΈre@?Ql@+eX?GGATGVwS@?GGATG?`r?2W6?[AAX?qxۚ>P@_xe@ ?Mbp?GATGGB$S9O@UHB?GATGGUHB?q_1?zDJD?xc?qA?EZN@+eye@G?ո^?I +?ATGGTJ~O@U!pt?ATGGTU!pt?:kWϙ?%&z?]rMP^?&?9a]']Q@46|e@&];V?St$?TGGTAZ Q@IB?TGGTAIB?m o`?Il?oNSL?͎?;N@"ue@4@O@ o_Ι?GGTAAE*SN@B3}?GGTAAB3}?8|;&?1m7\?,20?%l?eP@xe@vbn? o_Ή?GTAAT>/u-vQ@@c?ATCACDx?YB?;,(?` 2?# #?r-Q@9#e@EA'?Ǻ?GTAAT8jrvQ@[o& ?ATAATwxۊ?$O4o? &?3?(]1?cQ@:e@v8??TAATAJB 7Q@d?TAATAd?|G ?#N=ͯ?u;ํ?/⶝?">N@FGre@|>?&u?AATAA~uXcO@tU#?AATAAtU#?~㙋R?+?g/:(I?M,?|_Q@m4e@f])?_vO?ATAAA+PQ@} ?ATAAA} ?fF?S?zm??j;Q@9#Je@+Eo?r?TAAAG:-GR@ߩ ?TAAAGߩ ?0WN?z%?7?@ҝ?0R@ Ze@ LX۳?"u?AAAGC]sQ@*s?D]?AAAGC*s?D]?uܥ?,$_bu?"?]V7@T?(10`P@Te@mW*O?Mb?AAGCC/N1P@9#>8#?AAGCC9#>8#?? DS?7Oo?l?\,(zQ@pɴe@ ;͑?_Lu?AGCCA\y^Q@4Hq?AGCCA4Hq?RI?çO]z?=A?Z9$?[[R@`vOe@ܥ.iF?)\(?GCCAC$ha%hR@629?GCCAC629? K[A?W?8ߨ?amC?.WI Q@W2e@ޟ R?_vO~?CACTA `Q@$w?CAAGCk7w?),? A?_?;-?poP@e@b25j?_vO~?ACTAT@|?P@aA?ACTATaA?WhѺ?j5?GQ?e2?eP<̷Q@#e@aA@UN@?CTATTɣ߯Q@ PY^?CTATT PY^?cLr?9m?&0\?l{$?z˒ O@8de@oO.?a+ey?TATTTI8N@= ?TATTT= ?^m n'?|A`?%'B?LLF?XѪI@te@nN?`Q{?ATTTA,sn> J@Z0\?ATTTAZ0\?æƏ=NQw>ܮ>#2?%!L@Ǻe@1b?UN@?TTTAT8K@y|*:?kp4w?;?kx'P@ e@Zk ?M O?TTATG CP@,LnA+?TTATG,LnA+?!p76?H!T-j?=}fx? g4? O@+e@!?gs?ATGGCwy0O@`Hn[?ATGGC`Hn[?;YϘ? 7r?xR7?` 3?37#O@&†e@LҰ? ףp= ?TGGCC.k}O@N\@>?TGGCCN\@>?jy?ҥ@渫?|fZ? ؕ?f:|j!S@ e@Փ 6@_vO?GGCCT »&R@.&:?GGCCT.&:?ķM?Be$?[!?5V}N>ITN%CR@Ϊe@}aŽ~?S!uq?GCCTA>XQ3R@xR?GCCTAxR?44Z}?LU?!?|]=?YA\Q@qf@) ?b=y?CCTAG02Q@VN?CCTAGVN?\ؾ?2r?9?Z˫?64R@^)f@ }@L=U?CTAGTN'v*wR@籽?CTAGT籽?͊-8?j? sB?v.w?[?e@T Q@-f@V?vq -?TAGTA7PQ@r :?TAGTAr :?pCS?-?cw%j?Պxi?xeL@n4 f@Zt@"u?AGTAC?AM@Ӂ*?AGTACӁ*? l8?Y|ē?V6/c?9 }*?% O@Q%f@2A j?Q?GTACCvQO@ipo?GTACCipo? ښ?a?`A ?1h?WSQ@Gz4f@ɇ8;?`Qڋ?TACCAb 5Q@s'?TACCAs'?2?7#?=k?i u?ƒ_,5R@j+7f@VKN@W}Bf@uXE?S!uq?CATCA`~N@kJa?CATCAkJa?i,?}% >? (Wn???NrQ@ If@HR@K7if@D?+?ACGTAr>Q@w2q?ACGTAw2q?B?7+?Fz?2P8w??obJ@4333sf@8G?Aǘ?CGTATWUeK@!#?CGTAT!#?!e>_?ftV?eaO?MrN?eP@,exf@^1?0*?GTATTc P@K!D?GTATTK!D?dD'?(3??}k?v4?X8E+N@ű.nf@w{T@d`T?TATTG?ͽN@i?;`?TATTGi?;`? I?O'_(W? 8+a?*c?&CK@_f@*PY?`Qk?ATTGT6)YK@Y8?ATTGTY8?/}"#>1D?>XgS?v ?_ON@ŏ1wf@-`Tz?V-?TTGTTi+N@d6?TTGTTd6?l#b?.m?G#}-?t(we? HJ@[Ӽf@@"p(-?0*?TGTTG~cJ@jB?TGTTGjB?c?n>\zqf~?#P)J>7`9H?4hiK@y)f@2^L\F?0*?GTTGG&J@טO?GTTGGטO?[r>NUp?ػyd?ht"?[ N@@߾f@`jgҖ?ZӼ?TTGGGy(1N@u XZ?TTGGT?ǝ??ٻh?5p)?,@?$M+Q@uf@:^`?"u?TGGGCqgզP@½?TGGTG@b?z@y?]J?Qi)?X)=?đO@Pkf@6[?`Qڛ?GGGCG?P@IC83?GGGCGIC83?"?Ų,?+#$? }h ?&1'zQ@faf@֙ @Mb?GCGTCHP1Q@-?TGATC`y5?@׮? ?n? )8n?&o5qN@ű.nf@HRN@I +?GTCGGGmN@nW@?GTCGGnW@?x,?Jc?5|v ?V~x1?; R@?f@'>:T?{Gz?TCGGCAR@?6.ŷ?TCGGG}CD?Z坱?@r7?IE0?Sw?Pk$7RP@ݵ|f@FFO@ea?CGGCA6O@İy?CATGCo?ú?T4?)?ֱ?GQ@Y5f@G 8@*@y&1?GGCACs4nS@#{?TGCACC;Ї?녽?KH e;?3UO?T2?[Q@~bf@6.ȅ@St$?GCACAMQ@=Q?GCACGzƾq?IˋA?)?4Kn0U?X?ӒR@wf@ Dgy`O@jMf@I4 @UN@?CATTA+,N@#K?CATTA#K?JGM?I{}>>4%?{}z?B:oCK@I}f@*O6{?5 ⑮?P ?\;fQ@[d;g@Qj?mxz,C?TTAGA6Q@۞V=?TTAGA۞V=?ue?n?Ksy?Dr?#Q@g@pckl?n?TAGACSQ@/rN ?TAGAC/rN ?L}1(?}z?DXs?c_ FT?OUP@9EGrg@m?1*D?AGACC[o Q@M#?AGACCM#?C2? Se?x80?EzB>?xսM6P@O%g@z?_L?GACCC;q)39P@z+l?GACCCz+l?d??kn?P@?c$?L^#;Q@ZB>(g@T~f?^)?ACCCCŢdQ@+$?ACCCC+$?E;b;3?*0L?&Kڣ?=Gnv?,dG4S@_g@'X?ŏ1w-!?CCAAGR;R@ލ S?CCAAGލ S?3AF?l.ԓ?,n@?~ hB#?DR@7bg@wLb?Ǻ?CCAAG*iR@x?CCAAGx?q?Ͽqgp?Vc2?sQ3aq?/ R@X9hg@8_"a?_vO?CAAGC(QQ@" =?CAAGC" =??Opߋ?X ?7YJl?1[KO@ $(~lg@ʐL\"?gs?AAGCGJSP@Ї`?AAGCGЇ`?|'^? DdV?Y~?]l6?R@qg@2p+?? ^)ˀ?CGACAR.Q@}?CAGAC;A,?Y{V1?g/W?>W?ցJ?i<~!Q@猈g@^PҦ?tF_?GACAGZQ@0Y?GACAG0Y?dC[??|,?FQH?qcR@Dg@=y?d`T?ACAGGȣNBR@) Bn?ACAGG) Bn?2m?"65?x?@l '%?vQ@wOg@ ?ŏ1w-!?CAGGAbqR@N؄?CAGGAN؄?-?Z?|[N?H?R@&1g@?sF?AGGAAFqR@9:?AAGAA \? `~{?kY?i?;e?lT@ qg@ם@+eX?GGAAAHU@lF?AGAAA'o!;?FաJ?Hd}Ѻ?nK_?ZRT=+_cR@:vg@Kd@@ZӼ?GAAATvS@9N?GAAAT9N??ZSe35?OM١?fnQN?%EQ@鷯g@U?Q?Y5;N?AAATA_FQ@è~ ?AAATAè~ ?hkbO?\U( ˜?˃A+?#ġ?.R oN@Vg@S+?q?AATATVRL0O@pĶB?AATATpĶB?Qvt?+n?3D J3?+?M@}a2Ug@? ?AATATzM0O@ kjN?AATAT kjN?_` ?,L?aCG?*'x?+gP@47g@wΝ?gs?ATATC;ŬP@&X?ATATC&X?F5O6?~7[?m^?rC1I?/N@cg@>Eɡw?b2U0*?TATCC5zUM@]?TATCC]?u߹;D?/f99?f5?X ?:KZO@ecg@j?Q?ATCCTyN@c??ATCCTc??;c?? n?N0c?_R@:g@PĖX?~jt?TCCTA5Q@yJj?TCCTAyJj?#>+??ɢa?'!?d5YQ@ Og@!(J?Ǻ?CCTAG8b\Q@×>?CCTAG×>?r0N ?Z"C?0ʔ?s]?` R@Pkg@$b@(?CTAGAf+R@:iH?CTAGA:iH?m39?CWK?%ϲĿ?# L?Q@g@3|,?~jt?TAGAC٘LgQ@֐Ra?TAGAC֐Ra?&Z?MBgH?H3?xS?ީvCjQ@UR' h@r?ZӼ?AGACA.Q@Ў"Ts?GACGC#?n:(?[Mt?zg?2WJ?eN5Q@< h@KJ?St$?GACATXMxQ@!r~?ACGCT-?Q[?GZ`L?o |>?;j?qR@ݵ|h@.R?F%u?ACATAgrR@!}:?CCATA?W5&V?׊L?t?vh@"Xz#?0*?CATAG3+̷P@#Us?CATAG#Us?;V? a?Ρ&̲n? ?R Q@ܵh@@V?`Qڋ?ATAGA FQ@ ]~?ATAGA ]~? q)D?+O|?@sL_o?KJ ?%NR@ h@M]|6?ŏ1w-!?TAGAAR@jOA?TAGAAjOA?#Q)? M;l?nQb?Tqצ?RyWXT@%#h@ I0:@ 0*?AGAAARKT@91S?AGAAA91S?)]4?2UƩ?,S?iS> x-kmerlevel_mean ?@4 4level_stdv  ?@4 4sd_mean ?@4 4sd_stdv ?@4 4weight% ?@4 4_$ deflate/- uTTREE'%'M%u'1- 8scale ?@4 4x*F0? 8shift ?@4 4"@ 8drift ?@4 4@`U? @ scale_sd ?@4 45-:(QFJKHBFFH%"$%!8.#gp~t?u_z]}(o˧GLī=zl y྘cCG_wR|5\VVsL>jQ\|riNjx\LWP8<W1_l6MG0%tIa</0G?ȅxM͏H):OTn"{]2p.v3FW_߈%ayʃtFcax1gᦉY=>6ز& )-IQUG\*xbd n UE˜Vw@9ܶ 1 AmA| QT "X `^9LsRh&NZjY,<k2p)3lZ|:dVɁTٳgf/ch,<YIԫRgH S)cϷn-C|p̞. 0F>f>@m?= qjϥ[)rUBq-vfg pbd:M#5q$LKt^}]/¤fMd(h>֡A 2Î״?[Dӝ|XP:/Xe?炻J슴K@[Kwrv+Y|xXc8,+''cHzs1˗.z*eΜ-y3GĢ1 R÷RUhP)4|Xw$ (: (Djt +vm[I| =޻--,<=kҘf*p'sR)QR9hJW~O7K !LR_)~3CίIINl;Vۙw1¬OR$LH45C˜&8Aå|qzh:Ѡb"a}ZO^Q,ֲR !x'AA-k/ʛiNi- 2OLMcjgD9Zާ=!CQlG x/KڦTƃJ# ؐh}R S mNɣ?y_w:yjH4.Gȶ}{18˃e6|=Ɇԣy|Q1*3ⰜٓƎ=^ٴQk?U e6s8(HnB_~c"Mx4ա׵/k 3/ SNdg.eӑ=ЩWDW `Y>gg hv}<=_icT 8x?~Dl_U.fkѱȶr ɰF5G࿉X%S!$^?o{{ƨz3#ieiPe㷔嵩$'aڇQ+l^1P;\qypXJ^pK][C c5u61;^|-y=7Nz5s+ogBMЖ`p.-K1z P[ 2CP'.hr{.4{^ 6sC' К ]x^{q (̹7+1 5CsG#!~ţП$"S v:Y?(XJyuEXm zĨS31 !3A$*_/Ju*2F󛷙iSYMp&o >))"5=;ZBfO@n8Fv_"&Tj!D޵KZv#^'`brޞ2C.R6;{8q^>#3hT695@tezo\3pU2hhC[Mb ң^kjӬ hgY')kT\ k4{ 4޺O0F)Lx RtqTmvcs$mZt:L"08.3 v#K"h̷#7A+!Z N~ FCZϻnOڃNNm05Vyh"N,aI[po6 <<#l {{%[Нy!Q'5`r֢nH SeMf62Q-!jQۓx`-|=az: Ӿ_7Jf޶P f Pˋ_4 9xߋ1W\Yh) :0,мG\4A<0R9[;82Q$[7،gh-IT@J\gG0uRSV5yC2MwAޱ$L#(lCo~;3L vItLN/xlwM  me>?" kLYH\aCHFm+K@iT2`&خqx{5|KئfD7kD Fe?&X @3M<\Ǩ]hkӔ@y:'rm M[C j)E´kLd?DJ;x?c%LS&0 C>L[ 8]{Ф>- -_ޔD0F C`[^64G\՚x oQY'O0u2Pi'.:ضqi~QxV训!$LsذG#b6,(lۡx +sgVI: l -ưɯ(%a-18粰?&.Oo!sh뻗#軾| ϥxV0f7xC˜H.\rƅ]hڨ,םP3$J7Owk]`q{1JHd S۫|X|{t_9}BV'vgX=lkdU m3 Ifz2bÐtۙ >4TÌ[?H;ӫa#\5-?`GGl8x:UWD 39Gś AbϜx>iU䑢FPp|n4un̆S2 ?GaCG7ثt-tU"an:-GpTۛ?hz5TV!Z G6:C3[ s窖t" ϝ t=ز)_F Bqp.kpz*>k@h|_ДQzџϼ?2PT&>1Y I5_egRcfC~3}v$_lw֮:jEp@Čq\fmʹEKg&AVC\;F~ Fm 9zſ;yiF!JMZ] uӹcQ1fm)HvaV8yV{qy1 0d,R={k`tģvws #aͷ;cQyI$8pݿ= ݂r[a+Xb8Lc9ɻbHi-4zf24{djA$W^X$nHOvU&+q'c+]OSm@lgNL&0btKr/h, tE(y1u0]ݕiDlsԽ[i'n6/uq"L÷O05}|9z'2͎$ѯk3s%gAjwvwn }Qdឿmu@3EnL*ɵ­bHjh3vI#) r5ø 4ǿqx4\G)Ei7Z LO˜!wYq/0b4:B*2"R (G bjm<^SյMcIz~(WFOث+1k'FB3oEuoIF<T'6Qx(XK\$a{U~M97r!,V\m ¢?-MB"pG a9oC ͙ VL,[f]0%Z̴6E05h˘~KP aom0mP.{S|\:;&Jz w>KCFID'x\gg])AKk5 &A櫭=#V51:ͱ{ǜ 1 򖇩lIzc"Eۇoz{E+NRWA}5R>1~kl)":J9U] Qa3rd#ߕ2e7ѓ#x:$ /Ζ<@gJ)Bpx硿D t~w7ų넠y!!hڇ̸+-NJ4 j;O qBRkY J~F\YeV7htDI^E_ ǒo Pt)|_q,2MKB8VT~L6Tx Sm.0u0e)z4S'&UYT;8=i\x1ʀ9.rvU8\q Z$do%{Ud"yQ#t/AϟCVLL=+uN;JQݸLV7B#&Z#ؗj tm+;Ͻ$jo,S d"¿}JC كO߸IKDҫpAyl v 4| FЙL8@BK=\iʣ'vyr-;Hm; S]]DrOtY|rfV9jh8Ax.iNgK3Jv]JT(L ~ Jΐ0< 㝥{\&ayFoBHn.ϩbiOQ + [?etI<'Fog6i?,!a_Xo ώ,~tz {Wnh]BӃ}[g5 q{{ dgܪ>H~ 9gn1Pi0ѝ̬B}6p@7KE @Z7:$r#Bhii_{q;$Luρ[e.t4[3׾v= Hj @dɬ .`&0W Hm/K>v;+KT ;hfȇn(Ҳ=m4 CFQ]=u`!"quoe~:ҜMV q\{;0 Jdxdpe_9ّ`wK[AkZ3de{"Qσ 0:50{PQbSznȥ| w3uXGLy6eQ|g*ק&0FFe+pi[mr>R;3Toa0f9!wj`~s-8A2 & SϬ o4E!k~- =< ,RD"٪餗g}޿`+>;q xd3uOW'%>H@=bހ{/HtG ju;̈́UaCtS"%>=? w  Id7=pa{{lj0jwzO)a*nƨ2DsV9PfgFΔ|[E⍕2NzAy "^ 3='Ѿf~?@r01 WW&pc-[Cw6$ ²Vy+ֽZ )ZDbl{ڛN#~mǯ?aF/#v #9?sBŠ,x2 n[>2:{/<5zs =Mu `v&:9Z^aGs烦jM4+ms#Kyl2LV6]7Mbk$L |*g*]TGOcpaD:,GIP0=T΍|#tڷh[.9j\a{-;ob1Zb8%™uL1)lYC} +ZG|`!\W6d>lB7 c+;`EY!c`&5XΧ;ӳ%ٕ@ar.Q`􉏧aCbu3|%JK֋6O( ~u\XR|\zwgP[Ƀq7QsRd? A2^/qwmI-(D8ms∁&߼5qR6A'AE?t4#tU"FB) ꮡ5"YzAFA\.쌑1WlȈ!8ʖd:ixnqc{nG1R94z{߮0?#tڗY>!cnlTwe3ZV\d3T;]1`|+= Pq$yЙfS!:xAV^\ImO?|OCM٪S7hō&=?7H$3݆HفnAV}{=:ՕM!1ڛSV>4Fo; Ř-YQSN.(cX*r}:KFȺqh5Em VtB\UB@nźਫ਼v$naݳ&+ uO*4B—s%yQ/), ZZrH}qe⽆q'~Ey®SKt@wv&u8N}oÂ㵅.&H^os'{a.d8zj<#y‹{~\VGU8nq(>t7|lÇ}} ZeE~SلQ6ב8h©{/Sܜ3BjyZjATo 6 ^}=Ȍ [L+/י?+aǒU(Ok;Dr %Q_aT{o dz/Z`=Z6'R0ntws> ןASq5pR'-j~C?Ƽ[SD½C5`5g:]՟&Ya>yj:P0fFי27JWwA"I:}"is) <زͮ́G2wag$:N{{ g]êor[i5쟸 *Zw1Qw\U\dƅW!e٨68d ƆԔ'FH'Ga x[zMO9 ^:JgF#Yqd<̉<&2TƀPg _I8-<&6G.*_ M|Z Hn_(d\4N5!.j*plɷOo0Nk# |qc.-ݞVo񪋞 &"aꪭ[z!\)?8)d$5e2H(9FjVJ&j;! ?snx67+|fNCѿ+OWB۽s%ikG؉yHd׶kCRnpbuy][p`ǜ{:{@:jXJM.)E1ȁ3~m$(%tgKwl\IpV}RJ~cx/s y}*SnmoƋzbRsṣ އlXqqs%TT1#c="*Q'\ V r|W|Uvcx~˭Lt M8<~?t2H_ V/.!al40@規%{wB6nWwΥ/`zrg䙨怾'NΆ8֣.JH:N39q1vL% n-'@q$±йae?RD=[fYTszuM8f,\RU -bi 3n:/OEi=78'[`߈E7$9_)&ΏVŝҕа2w0⚄ϗM`#Ƈ.=Ә%/nB`}$<b4F b[l&tÉ*\j }Z:چ5lK.v;sue.,<:?vذJSܥËZԽ j*9%& TZNⴷh ~&+gU!-dqTZgXn׻gh =Em+WmNǚByl9r Z}+. /m8 "2Bt7AO#e{BJ fUi[@] Nd36$`^T jPc;-Aq^҄(y.>SQ4gk}\Asဣ4UC*@Thw\w nWkSJ-iy%_ 6ֱqx/%T7rcsH0nn2&`bݺD}o^Xn.hㆵqȌOI%{ލ_lӞcm44O ^YϽ}I~zg7Bֳ0/}n߷l?#$qdJ>^o7YΪ$B7mc"7pt:6XxpCNJeP ۙ߯e1uW肿U/]|zv}pR@!b y+j: 9D+2W)\FRx>DHU5/z5Ql`o02yjrd?o&Z3DuyPya)v>F!Ltv4x]10izXeW݄NYUw ';~; u.wv6iLįk3M5þ<|UMTfJKiic/.g]DMzJ*޵qa8|x#(T_@UpT΍GYH_ 9 `,3.*0p dJlRw`@t_;3@6\ (R yuh'4֚:BДv"ҴOG;L c1b"e,Ȝ,+Y;jRn;Ճe? ͊|v/:-qۦ5 76@aoɈ M?O1I4 j 1Sf38M%g$dm9U:K\ uu-iaO ;KN%GFNb^qxU|tu)2D{󪘊;QZ2њ:AKy^cN`/eC4Q['6\?u$25BƩM[kԆlw&N2 ?igG=S |E Izmq1{MZh8Bv[rj=0oR0FH"GRޒ5[TNke"D?\,~01\`Ni\@mĞ`&0ks<NfX?6CS𡉍5GCz;aV49J<>]z-?:Cm՚VtyfFr9!JZm-̏ow8No$}[Q=aM/Zn;iC5I1'&I_Bg݌;j_GW>Hz!-+küA~^꾻V $\QȋZ#5'mE-V=FI!C6]*[uQ(y  J·3i@U"L4AW6D.lys+-\UJK'7߾` ?0YAjҖȰIK?5_D}$\ĉ[GݳSXB^{khY<-_ª-vHN>G[=+Q$L ?5OWa_L)^+GXrB^yf;{eɶKz` Pbz,#k叇laS{Yڜ FTWFu)ټ,a;P%25gFvF0҆ :PO⬮O7vQ0}#7eJ.Rƹ`{G' B ),YD^f_e UA273S`3jLqpk[pk9چ95pyvi7>0kU9YlXa%y d+$Y@No^+\-ǾDmCE8W@/&,{Fi8-)Te ۖ8v~HʅĺJ,xf?SOx3kT@ ѯ!Y:+JXCtoN>i o7/fjN 7^~&cעn-b znWPcag5*jn' Q잞0"N z7?tjd:2u`1B Cv<|)|VDQ/v\.>>Y})SL-g䟗@a~T<[#JjRj6/BʓM Ga",s=A+e7in>Φ#iJ[ q@w4. r`зm>nzTr`I*-E!`LݽG IoR7Yf/4p/AHI56?d?}0ziK 3`kX5}Ox" N%&2Bk~1I֋c &`g4:v1@ᜲ=p3WݳXЕX=1Y߹͆hidJ(۟O4dj᪕F΄L%Vx8oؿn ~P~D)5 :o[ջd~5>?$ +ѱL@my>zdޭ'|;'>SD,<`Ӑ96TiOĭ+jDYsD1'k:VGC@-K"kơ=Z t%<52F'܎of5pgUi:52Fo9tn"tB8TgjYi4otH[F};to3 mySUt}` 3W͍NY Dr., U׊Y4pڏυ%Ch9y>abذtD>юV=6&).'>4(]nAAҵԀw⒧x0@Ku:0WO_*aI.x& :?Z$C94S.lj ?Z m<S sBX$ڥJrI{CDl"m|x㪁>ʖQ%AX3go:#M1fNbC1%n%\RrvELg}t[np/~ 岁rJ]'@ "Xɺ}G(wN0 v ߟ$jJcCr5PK@Q =^$ոB](_~.2Y{lNv7Lj8|C(R2f;j=L/l=BOK]Du>類!Xa26H|cs3]42_={8\9N}Ă[Ie}>u}yLIngl#V^:tGe1=f>oylHln\z J {*:?>7Uo ]`L v.&Uq(gMSTG{~'K+qh%yQRy®$ӼǼwڇ9+l\ 7V˕EV-t8ErK]tlOř!-+HowY6s}j786>Dnn0sU^ i?򊄀qW%C}p7Gʟۭ C;D(cHx^My8g٥(I""r42ecHE!Jv"dP.k*)ʚJ Bhfwn}>;?s=}Щ؏3Oc&&RzE]ٰkJV."':1m!iD_YNq+#r.㮺x+EtCX)'=|&$};fcTlw i-Њ$` LZi^(ḱ]vx:zFyj4Ө'h~cByX^}wi45iIs'&o BO\H-:'Kp`I ꙇsc'KF;{eVljjn?&m$WZx'ؓ'o0Bжn&'zAm R+m8ܱLbVqmulz[|W; *~D[zY:Se٠yЫmyIhޚu-1@Mt:qJIyutIncpEM乗<`ݷߤZL_uE t|K(JBS^b3p &F7X$R~qPd|]\zx{يPf,WQxˏ)}xfx+ӨԔFtY( $d֎A[: wQz*89h[-LW Ȱţn`Y1qi 2=wxEIsUTTõiva,(cѻn;2,'`"KBH-XT,J=O[G Meic{g5F9Öt&`g_f8IK0dpX8픱c:]~dWÿ}WA z'0cNnha=(Q<*WpZde _!m]2G5## .]0>EܔF$mtˍN(0}Jtb?9={,#CAbd瀲XnvJ͓Zo[\b^`&-%ңHY)=%f V4y=>0!l<iP &-s@dll0Xjs::6zhbmk\煈,\; d׶AWl7e/1ɟ*FȰ%vG@rtBl2LxBA7=b$Ypv/pmb,+(*g͂xU(Ha3Z/ 9H{0=ϢAw#ݘF3MX ϻ d;xXu>X>5B|5"du Cw<6XTjvJ>`) (KiELY*EU^=y2X} v Ӵ jYKy¢җpERzָa,'/I)mw/\7&EV t3dC 3(uvl F\hm4Ȫt J<""~cvbE r-T\~ŋvóUIQxh,EӦڨeZ` 'd8:n_kspUv?F*<]dtiф9yk;(u%,өJW1|\jXP OvFJK,UEq#$+BvU', f8q(tqjD.*mUyY3  Qd[aKoXe 2F³х 3rNy n`}^ͣWZxQ^[W,+ s L"P@>̕q('is|f`w[Z>4o^A!JN_g Gޛ_\! qN5p3@ْZ+L6ӐB{mQL?[e7wU9ЭUHiDZk#`-cC"hJedζcӰќq ?,/#`*?!vrB,$~p~C+=|z134 P&7[9x['h䳬 $`D=WLt&-"!)@U?p:Cjo&<ƂIwNCsоQnDN޲.Yk{cۦ) JJ/NBW';@t':,?e%^:; @<=܈ v1'v%gۭ XiZSЬ>\Ntg}JLY^=G|ozkC*dB V[Ymg:XʳbZdq`=ɮ~~iMާ>#h!_Y8|N8㛏n#Isx~?FuQ-p S d5ima Uem"@5Ly5}h\>Z |njAQZj8Y,+Te[{U<7: kw]xTȕ‘L8Cs+ e"1|>EM h6Ԯ6]e F92]Y sѹ')P :\7s3| \5siCͫ #)g'3P.o4(\ܶvul)62]g`z>?Whg:dKƭz"Y|W2i@:. Nǿo trJȭbхPvf4̻g4ksWrgXwNXqޢ#3ЌmZL:nlXDTmϛwrh]Mg xL+&R_2'dk4.c`CGG16mAx23G}5PηX%A)k8H&08*ϋS򃓔.'Fsxsq;o9|71KLol;E-#rVS wehp+۪@-g3i\=S r o4Ĺ(;O]nM^=41 f1zڴܶ:41RN|5O -G'F$fw]4emA#*}` 5&[?f4|zh~\/]b0iT&SE]$dGj6x(MjsշW"`^A7Zi zoξJZ !zFl=Zv SaC3v!-_&L<^a1.ZUœHX,VXk]}"7ԇ20י&^8A^^֌\L?gWb>Ryl_ h˵s S #>/=…2^%'V-m@m,WגTfu>>lo@/|=F޵Z$$:,3]ev%Ж7v\S.ꁢ[ل7XB>%)cj)?.>*|k]n XfzJXʧ>N])ju~n(U|nFZA Qp03W2]rr V `߼"^k}؊I>Vxvӯ#L)V 9{ۖ= 5C>F>~~h+Xj>+ճl-}twCo,ͅL\hy{0?is`I a'^H_L1:UҮx`"H$)Ts`!~ xf v/Q_fQ$xvSOK K6d>'0m`ĖPa=\C~x0`187V: J<" ze{)E*7ں4qo :kN~?6 )L$`Z孆XrR_xFYcrKn40Nf#!?F+`hR^,=Y{[12UQ/nD0'~36T ,QOqn{0 Nԭ~h~y?}›DbNَ3p.f ]#`.lv?h4xaϬUgJo4A_^YFeli-.^%M>H/#~*u.8T:|ʁyNBp~ ub$,Ae[9CXb4"9K%~K`Q2cDgL#}d'5߉|r7X qEpaQk<|s\f*MDKʬ'§ԫxР͝ynؔ7 :/;~c60c1yËii2DQN5M1 7CSfvؾ6mUSkjH+!0B~:0k.DDjF'4+R ׿L~AwfQ7|KS\W1IhXUcv /=|ix,\ƁđS3nhUt)T&̢`(΁\$6mfHÓ`.$o CD~wv#H*U@u O`G͖S!";}mW~ѷ͙K1|uvA̱8|~bKe?_@]gEvcهs6NJOځsZ2^0<-mŰxP0l':@!Lv6{?x.Z52*ZkeeWS•}{r,ߘ%#Ѩ{q]6p/m~*{.)ngFWOjS3o?䳻٠iѮ9:rl_L-;Qbd{'FvYf8ҽFM+VכYs\x3Ne.nǿl`-~ e祃pE]xͳ-N*bFBl1j'\s$ ݘ~t],Uy:􌴨|ML? _q̧MC|Q-R~f)grA'])h>| |+ ,e@DOF[-e Pm9i| tt3C`'[?-NQUȋgIm={UH2\H.TM SW۠ۮ*׏Yzf]hʔTfhBʯg[Iʬ0QtjSguQԺ)53Ԝi0u׬l!˕0X)!!M1> |"&!"?9^~DyCF7T.\_4$v}, U ;upvczU~W=1S`<W1U$btdi a }֪y ]l0Bq2:}'ӈ/bhUS_dX4J5v`e(n ~ܣYp+c-Ī eX,v;`EFlX :!hK:>7{0z*Ixc2`ywwARx̉iQĆR3tiq`[CLLHh_eۋ#Ws!L?T)ǁ9;ܞdОwQhf=nʁӯ싺CFaPpQբԜ9֫逳 ^%`CF†FcҾmlץqc9癁pwK̓5y:`0xФH~VZ6K7/#;n'pa:u=8gL oa>2:;i_wÿ+`گ K9pQI$D5yl|39pnbNUdwp. ~xY'`K1)[3d9GZ*]/.0GbI&Κ?%0 RoJײ8Yūt^QhuI u18Lꁚipï +̃qcu:%w1o/Hi+lFؚ&:{(c:ݘ7X π(ώMxM_4-0mYzT1_1x7MBVBؾz8qk ^a1Y%:軋vsd$0Cb&Lc~]dw*eS(?j 'YAC3'FKWmz$L O2NK'0P,Di#G&!tʸ![w"g*OVq{F?)7ﳨ (*RT$4~&`pTY?Xlz6 c '#ԿUG*^k;4Q/?L·^VS_$6bJ.Ó9Vb=N<RlcĦ!nN$ mOӽ?׫_Z{Z|%&"*x( &;{xՃYVTc,y׋ '"SȥzXB@v=8 ^V# --&'B}ԁc,<ү5BF9L0\ʴ!;d_@D\ó:8ּ4ڞd̔ &- ݿ,d-c\&{ `U[hu:a8<;CehljѢ`{u5n`fwË́*ơJZXnSoU7bNEj\al|8k킉8L!NhU_KیB\ގrd&H՚np]uhnCaDeoZ]E F.fp{I$z/z򹲊yVčZˍLs %fυqO@or&5•iWSԫ>fІW+9NtG4ᭈ pN޹HiOLC'%* N#%3[Yp di`UPZK+)QzRt!?.M^/X55-60]&&ChX( ]q`lKy_J4JzI)$^6hHPADl |k&)N䏻u TGXW4ϞZ4OVN1`q`@ hu3MyL8BwD\I/LP6Y_ im ;Sju?h{-4UqeZT=Zև۠r>{7֨v骎q3ؒ磖 Pxt7IPRWÀ,^kaWCW޶"61Wly#0rs xД ok8 ^;ΫooLCcU]>#+H K;o`׀fcnL!n/LCXϙ؎i Sp@nVBcy0c)Ww?p+$gkE~,Ʋyt>4б[]/f9̄ĐZ(y恼;4ICw>L0El,s mk2pXVؖ) E4g1Y \ԯ,ppc #* n YTt{ɞ{NzܒNYf 4u+ͧb_1- KJI}mjTT'cܵaXe67o'fkI$ݢxZM!҂TZw[Jٛ Y>:!%Ut)|: PЬã%46^jުcxT3AgZ;!dX|Ghu5տ u'Ȃњ{Sf5 SzyK"sE.K <{q) NꍶƟ0]yVhVڈz['Wa I[;2*󦞒_c>39¯2@DnK$Xr?.#8q?jȌ`B~$h4~c4@{ʁ8L'Qƭ?=|1nj lYtgF#gu'`ṟ^7"y؍Y Yc͈S}/RXLUdPw;P=zm̍'`;ۭFsat:H$Fn)ుEnN_ .ŃB&VO|j3}" LǸ Lo\F9ma,F[ z7~ٴ@ byitj\M0 8V h0,ۈcM kA&ֲO2~vإL]rWНX Qkݿ&h߲JSP㨙 ,G&{˘=51^4TY21sqeA{j:TDL.kXc{ſM5e5|qt%0,+hH2 #si \ `wB[ZrREͧni,k XLX湨3=*8AL?oBCîܞN5jX57DjHo}L.use8²i$|ʨ~OqZQL?[sybsgy36dx\+{vMMXPw`cQp>j%Z1|IE8]cg3<G1[<k@wZM&->jW]*/uyXNFJ:E[s0}ĥ؃5izL\*wxh&)Un6c>DŽ3[Ӿ @鼝 d<}akl8(bu՘`EU 1'F~`]&m4ʓz]pjT—W ݘkC+u''#Ńݪlyޮ`lc2AB}~4s|7IO G.Dd@^EǝR>:=N/;pXPhd˄W(Ԃ`nk7l&R}1bLȷK+vϖܻuʑo6u2 K# ֩@?3f$f0]aÐEq 8CMdg!#OOgY+5y~"DF0َ(,=>n-E7O7B&KL˅],1̃b瞺 #`<{OE)$vS^{1̯D}V qx0$yKGN% ԰7(B]ˣ)<Ԫ :dž~0+mT4Ԛ>)n=*M,̵Bn +SoP/gQQeVHn88 t86AT~Pmd0ӅyLawѦ?V? /m<RE^F4,Xz~>S&TL:W)4;xۯmF";}.w~LFM^r|neŵ$C0cVPxPE}7?a:IU/ +n>QŔ۽C]DMa֠=}֌l".d{˅ 3V/7 w)_zi$y۝rGA~L?߶y罰tZQ^ubX ZsLqLZŵɑI$<΅o -BGʈ*gvK]Q }A+_$IloYwJ[.tYBs_4t.:r>s!o~xaJQ|.mp&G>\ cbRGmr xۤR$*~+%O||tgpanWD2xNX#3$ލVg^(;YXYiKywA;-KW!U[VnvpnGTuk-\=ov 7$K2= "{I% i "}|u/oO"`V> Z3&=st1S_ˌi<;Zvp!iJYh'y%{0k@1mEE:Wz噰֥EdyS-0~dSGr4ѐ*VKf!` Tsq Zs0jց) ^f@ح,N|2=l,~,{O KNs#w&Dھf NxB#BA4QyEQ `|h~]bd:'ԥNB@9fxMHӅHuuE:H/?>t2f4(=<6N9~UvkD)t$Di|N4'LG!o/SX;.hMSmrIS2~%& ЙviI_w)Ii GuS.D<\f\/.Wh[,nhBzt3UET~tsyjH}eg&$<4IgMDElNWجsX ]~eim<}.Y@W'gہ$$30^T y;*x FBeG9@hcM{^q\bYْocW5ڳd}i-b2< v/Ǻz]BEkq EUѲ7~ 'LVխRUٺul~cěAR&Fs^*Jz Y.onyYtك&͌P){9d^D|>R6Fzn'ޒe.076mV":'&a5.ζr?%`i^5*ޔpx|xjɨle{*d7NKFtda+㐦H:jD(RpMz)90>rmt5wv;vNUtX865&`2j_n6>- a) |Z?ՁVlwNP:]5e,Fq mL036ً,][nó(&F{Dk#| Lo0<(gSy[zxbϝCL'mqMB+0Ԅ+*TSE=Y8ݍ`{&뒯{S̄532jagK+Ϙ9:CNB~wzwGaBN+Q-x:[֞k7.e^>gvH[ۼX1ܪV/\B`-]g)`Ju&޲X0!Q>&oh>NX}$%zWj[uŸd`#'< 22DeMvƊʤʎH[%|1uǬ!nY#5$fv< ɤG1Hb>V'?̗Vց \`i4P|aqU*^g7{c\iƟ\/,>F*z9IBˀ.r-Ư(8㘣Tѽz9ndX` J7zv/Fk5 e)O_Y&{P>#A!a>MUGn.}\W6!w_CNG04C:w~>Q:H`꨻e!ݗq?+QG= V{&0Ӊ*pߨBN J~~Ǡ0>wpC2JX^.Dp௓w̜A\2gL=^T :FmγRPC M2 &+C"i3O(U TREE}HEAPXPL` 8 complement_end@ Paverage_continuous_alignment ?@4 46@ 8 template_start@ 8 template_end@ 8 num_complement@ 8 alignment_score@= 8 num_template@ @ alignment_length@ @ complement_start@template@complement@ deflate uTTREE~0ca|j:r - qHt f22TREEHEAPX0Alignment@ConfigurationInputEventsAnalyses/EventDetection_000/Reads/Read_24/EventsSummaryBaseCalled_templateBaseCalled_complementHairpinAlignBaseCalled_2DLogSNODx^]`CvH2Hlavh$TBHpE"$}|/89ILSO<N99 )x4䑜Gpji0NC>~3ȃ9y gY$#ù7^'Ayn\rAsg.ĝ0w"܁\ܚKp+.-[p)nƥ)&\7rܐs"J\7Wǹ\kp չW\*\+s\p~qM,72ܜKsK~[qIn% .\qnυ ~;Cܙ pOr>y?9'9;g }~38<`NC8?|_ox9 W^Ňy5kP9uyo? # x3[xx+y3M7Nc^ǻx-){x ռWg?/*| `eK_䣼bq^'x-S6[sjniep N͂rzn 97~p=u8 l\s 9gp.\%2抜s^~q2KC\ r .Ÿ0"Hp\b\0!.$G9/pi@pN.18+,\3sE?8W \sN85WT\Skq2I'Nu9!],܀|;7?opSoܜ|[/W5m _"w N|.l§OqW>DqǸ|毂qo>}K9}< 4xw'xăy'y(x?y8o #yKfo 'xƓyMjʫx:j+/,xi/L~>x1<yΕW\!|p9>e4 .\pI>%r1>E{~$_BK\ 8p#+\3?W9'9g_9Y783L|3m}|_rZp{ԜSD'drrN)81ˉ8%é8apNw=8-|;VMN7>wȿq&5g櫜g+|s%~\|1Bs^>,3\4 .ra>|"8?Ǹ((#\sIC\Ҽ?Ϲ,x/=\? +'\wqeG\5Zp 56uxGm[.o67෸!oF7 ܄sS~=x]Znίq ^-y5UܚWr^+ܞ_xw/r^]yq" x.9܋gqo<4S?O xby4?3)݃X~sx"wI}pmx*iܒs y&7YܔgsÍy.7 ~"apx ~<6/k"΋?Uy Wrp%^x痸\c? Gx^]ga{de=ITv(%EYQ)KHF6,TFRHDeEd-s{)Y~*?\qyey\?RgV>[ěrU &[_n5'9ļ2/dCpJ^̩x慜s:&kN8<7xNlȳ83,3,>|g)'O>|4Cy/xo y;/m[By1o^o&x5/U+y9eKy$;^/(x!y-yFoy3?xFtx+Om}'wp/>={ig[|y~/_.|;U ί ~or6r;m9AwܚpW8ܜSp3N_ܔp9-7t܈󳜁rF~3Ӝpgzupv~<6䚜kpn\-*G9W2⇸0W" Wb\sY.eK\"8bE.e@p~.y+pN~spJ\Ü?1r\S⚜kq8''8 \q=NOLw_osO _gJK/>Ǎ,?g1>/ nǹ) >/anƇypK_܊sk7xO]܆wp;ί6n[k'Λ71xwukʝyMWq)xEܕ/{Kb~{{W܇<ܟg9ĕ0?G >W|?|\:|E.Ɨ(_|5:\0||򿜇pnNrqBɉ8'8)gd98' {8ⴜpt*N)sFN3s d|;VM9_˗9_|1s\( >E\q >%Ha. e\>rx^]gaWVɵ*!l"MJH$+dHHJ$B{e+HJ{{)8; q.Ǹ( >,璼/xowRKV.[沼)x#\q^+*+ ઼2~ry1ɋ6/uxn.zySO<n 7y,71x8/% <[`n܎? ywܑ? ǝܙpq/={p7sWqO½]͝1wnϟp;myO5V-[ n,)Mx7܈qop#^p]uxL8Oį\'<_\<W\9 y.,y\sK.K8/b .+pp!^x5?k8?|o'y# ;8W5-rlv;83G3.~y?A>| N*8%1N^>;N'9 '|OpB> < |[|K|/|%|u|__߃+|3_|O7_<'Ho'8ap">lj,'3Os'N'sj1NG>a~q:>?9CpF˙ »9+ 63qʹk͛7q^Oz~q>^&xu^y9eKp^|.DpI<\gO.˓$.O<+\GsUՂ~5x(C&εx0A*ux Ɵr]?17䏂rcApo~{fܝs܂pK~[qN܆;r[ܞvܞrn5í"͂]1Ǎ+7n܀>~{p]u7pmõkr_2չȟp5Uy@@̟q<\p';|o!Ň/>| >w|Ok§*,_s|9矂/1_32+}I'>ׂ1-w>|m>wx?rw;x'|oD7o᤼sr^8 ^)y⥜/4 LN3O yr'Ox,?c8#L<#83Yy(??O{w'ɹ?xpكqo%83L!g ~$8q?~0ixO9ey σ>'!$8qp" y'w[< c˿8O<$ʓJey|g<,>˳ ?| ^y1KQ^GJ>_ᵼN^;xoƛx+o-uV&y;ow:;x/}W|WA^x9e|Q^xq  'y6ϳTigx:iSO|'<.x,_|Ge<"x8_a?<~x^]ga^I-pͬd{=Rh( DB+33=z~}<'sy3xzKӂ<:|||ܖ/pȭonp 7yM7ܘop# 7\p=u9}V'9Nĵ9 \q N9EpJ~&*ϕ95W4iqL\Sp6.ٹ%A.\sqͅ ~"#7Qy9? p.ٹgœp.ʙg✑ \sI~KqiSsN\s9N9ip\rENn{w | ׹_|klpmuR\/r>ύl࿸ >Mx?r3>n%έ߂r[Wn y7wE;܅஼ܝ-o{܇s_ [?灼&yoࡼ:ΟG'̥K#\(? q~OpǂI~Osg9< /_lY2g+W9#_ |?op N||]NDr$|7'8z5N_|%N/pz>lȧOqf>Y8g 8H9  yxO/#wq~o3x/0o"\rq-\7sIK:.TpY^?+\?U}~r5^y1w&/Z? vp~or}~ܐ_F<]p6<[n9Of<)ܔO ΍y7 nȳ>z29,x^]wuql=22#))222RmlB"%+ QFFF9w?y8}?}kbYdOi!3p]<ƳqM<~*W qx1.\.,^Ke^KDpq!.? ^U0^ 5`pßx΃?871x3Ήx+Ύlx{ę.)8#ލ{p_TxN"89'q N|?>ÇpRG_[|ŷw>o' |221g|1߂/_W > _g|>/+k7'>oCVm|}'Loݍß މp'ۂx N7Tx#N7i:qgkp&gƫplx%sW/yR/ ^ x.Bx.g"xVL\OT\O%$\Oĥ\,wp%*xtGa!q <q-<qe\ po/⦸3~ "+.2+$K8*.x.5\(`p<8s7p&ΎX.ΌLx<ΈO$OiSSq < 'N$x&‰l|_pB<ߣΣM}z:?xA"b[7K7˨ש˩ר+WP~HBz9REJoRPQR GOg''[o .(3ԝԃ]ϩ Un????!NO=9{s:Ns~~N~H\={sT~k$swB[%מ[~=״ `w%icp^{߻}={^}yHw^^{{as|/{/I ={={]={H)3u/={ ޓދ{peӽyg9ѾAgxϴj=>Gi}` .[>{}fؾԾ>־ {Cafpt]?ؾ޾6']iqyھ\F4:ھ\1ldldlSWcwsٗٷ?lnfoΦ 6w0lcs99 ,049p`s gBFڜɜ؜ʜ6G62g͡W99[Jlәas=svm.asD96ta6'uaYh(o9vNc\9`Dڹs'skRSs,ssxZ 'lή˙۟s>p;Gp9vS.5cvas[\W87vY?Υ8νsqF͝+9Ww];wn ;rkGL;go%8sps@$vbU8Wt¹x7vO ^vc/^8]sTX vƹ\|7=羳sar{;ΑS:'O s'8\ws ~;#xLhv?0ñ{xb`c^ŗ :~w⛸vϣ7vWpOI|wC%s ؽNؽ=g;D=vϦvm{X? z?G¿pmC0A~z|>n?񣼗=8FƼ Onnnq+ƭyk~7sm+n>܁ׅ׆ׄWWqG^ɝxEx9?K^yqxQx! <_9܍gggrw{4ş<_)ܛ? }O<_1ܓr¯x~'rg/xjxw܁?<#<3< ܆<ܚr+^ObnK/,Jn̟WWs#^ÏZn__y=/oGx# ?Û6ooZ ?}k|yW Uw~-\-|+)|# ?.Ͽ\]:|WpA.e|<_ʅl>/|!\O|^\.goŹK|3L.gKp1>O \|A".pY.ė/|%W1_O0_Ç<# 7o\wJoV+6j|oy /".k*W~CkRK// / /<\p} x7OF<5<O&7O<[nIǭy ?<:<{܎GG<; ~ _/?ǯ;w^"䗸ݹ wn5܅{Kܓ_^9kl#z/?<@~ ~[`nCEyYi .7a8Gy7~uy4?c6 Z"O;pD'q ^>&\B_‡y?| +?/SxoxOxw.>;pG .>BOo$:O_rQ^x]xmxMxux|:3x%|/Ⓖ ss s3>qi4<5<'|!O#8| O{9å'^|fD ~O\i:bS/|2…'@.>߄ >s¿Cÿ0>w <y<xx,qO;xy;O dV)%5OMxEx]xmx U+yټ2Ky/"^^^ x)eK/ ^̇yƟ^ | 'c>s<;C>˳<|{[܃o|wi+];s"ĉc𫜄_ɸ'痃r n܊SqKN/rniy 7\𳜉ܘp 8\7ڜk * W\q!.\rA.Å4R%b\sQ.E$?¥0B\ ~r~.y|p+q\\spU-8kpΙg⚜kq\rNu9\S<8Y}I 8QpBn Is7⧃_&|Un_nΗ_ |[_ɭYnge>wnϧ>ǹ# >|_ܙ.]w==y'+x'?@mx' ~w󋼇[7f 7g ?Çi n̿q#> (7c|I˧N|kgO\5Jpe>|E~/|?WLpi%7E6;\0'L{q"ω9y9I}qnNιsr )9[p,3s18CptpzN8g)8'|_p$' N|Opʷ}v9FuW97_ yo9_>| >\O|\$0C\ri>Qx7]\wW2o*5[:ok ڼ\z snȫ'y%7T3K My7 ~rs[~sK<[nqmC~?v<܁sGƝ_ %+O7]Ɠ yBxc?<&x4#><ǃ?x < σ/<{3?<ܝGr7ow1%3N<;dnr­y*iRpK-}n3,np&l~Sy.7yܐs^O'\r= ~<6/⚼K*/*| Nm>7 |kW |9࿃/_ |>\_|>|/iħO>|,ḣ_A3{n';s"?p9x' s Sk SN_x5UWrF^x9ge/,$x1gE?syNG? 0Oi\O<$.'pq%x,1Gq)exQx\c<0xW\qUW\{܃kqwq~#k];s]c n 7䗹 n:?-Cix^]a{MDd&%[6!^왕dDH)̦i4ȸs_9_~{o$ۆ:Up܈7 npcn̍nM>7姸 -6Z܊km܎+W\܁qG./pĥ3 .\" Əsw.=1ɏr/.ʽEop?.x㗂s<|7!|~_w=?];xoy+-71Mo y7|?>+1^.%|/ ~O>4 gxf >ӂy|{ܓds"ܕsN/w <'8ܖSpNɭ[܂SqsN8 7$|7 0Ap}83,\rmƵ8;꜓$⪜\8\ p.ȥK .xł"\4..\0@p~~b7894g2rV.Y˝ wܕOq7>DqǸ|"_ /<!9xἋ_;x$oQ-x+[x oF _5<1M^œx2y9Ox/ ~7xi΋ᙼ x~sg <#x:<~+x7' y|౼<_x8/aJCīx`_ ܇r/^=x}Fƛ+];w-ܑ?mܞs)ܖwrŭywgܒx/7/YǍ n_s\:-\>5Wǹ**|+)ħ" \.?qq.|%.̿rA Ͽs>?Asks 79 |38cp NrT 28EpdI9'ĜpBN 8Yp cmoq*ɩ N>8#|38 _|)b_89' >˹4S <|"8?ǂ > o Å@~~" ~b' .ΟK.şriexpy+W\7pjG\rM^õxu*p]~˹/x)7 /䦼|nrKͭx܆gp[xZTnS's7~;x+nw1܃_ =ydà }y0/q?y`xP`/<{pɯpy$wQܕGs~;kܑr<>xm[܊'sK-Tn܄qcx&?ͳ!<\~q=uy &/꼘~r*+r+|p9~\Wq)^%y y= oG&.›0oB 9?x?;9/ 9=rs}l5g%83Ù ;sbo>>(c|S'9%|Ng9)$_mh @decision_value ?@4 4@z,y2eXTREE}HEAPXPsplit_hairpinbasecall_1d_templatebasecall_1d_complementhairpin_alignpost_process_templatepost_process_complementbasecall_2d @ num_stutters_found@bþ}#^>Rݞe6B;[¾}nf>o e V|/a?fНK|͡;Y\_-;*}K̯} =_?~\m3>o-/a?5<>:Batk^[>Ҹ.-\|Y?][T 8ywf~RO_~Mhenl+ ]֏/t%+t]nSˬz9| t/{t= ٟDCEPF"]p|(p,y֟T K^¾QPɰGCXf9,p%Ic3|mE)/jCZ?'돬 築Pɰ&p}W&C'Z@?Slze}0>:~]3l}#?8̈́ϰgA'9ϰ\p돮yPgطַ_ -Ç 7gs8} /c!_OA2~|B}l}h1կ@{?.t%ePe2|%է]w֗*h77o j w);M> z}m ͠~Pao mVжr}m 5MچZ|[hk7x>_2EWfx{hSڄsow6rmh5 vֳݠu|w(̰qZ۸}7?>ߚ|}?~PֿX<ɫZ} S;ZW>/:CgAYg7[˸8O~w7`8/|K? 绣?Y|=c?p>>e?>{O:x'Bk}'A'{?7>Bta4:޸oπ~no?|LV,'^}gC?&OS=?wE^?;OoE 3_}øBn~ϟEPpC_(3K|//Z~/>o~rsOrY_~%i7WAϰϯ>'5Pa?kOXy<_}<?jO_}'|EY|u!z?]?7B` zW>1V_=̯}@fĭлߟYߑo^Co3J^#OЛl~:7:.zq?^O~^u?8~5O ^?e2(^'=+X?qe_=ߓKʟ^쭏~z㲾^`\Ƀ9yo@Ou\Sd`xzy}z}z[u}=<_?Sc}hW9Q BpIA9tϏk-6@s%P֑a_BuC,~B~p z z O@-t?w}>/|7W|Pɰߟ{|t4g3t7^~#oН?YCwtGX B 7tۜ2 ?_1t'~im>omk%ߊ[ 6?ߪor7c~^ :{_|W57W|/'?sxm_'_jc]%?[W|!x} ||#/po~>Gk s?6c\೭>=5e|& -g߷o>d8vOs>95O~ Χ-dvrxux>ί[t >/?19 vw[GEOn׺~~(x}C?L\?=|ztK }_iO?e|wڟ=s3ן|nJW_.uῳ/~[;!ǟ3~OC-y}`e8֟6f֜~yx+WϰxK/ti [7oxSWkq7$X~z/^$OpIX:6)̿4?)쫓U+ëi_?*'N}%'I{G }2 xc`6^;/~ϰ.5 }4?[~:/d8?DahEؿ BY_w93orK42/s/" ^^U3?3>Yx^eUs% QSiT@i,#ks3׵{NjYNA*u??9 ūCBx1ۼf5H1[?kA??~g/}1٣KQumgKB~}_H,COC#G ovSc>&'vLC7~7 m?}/~%wg~%o-&͏+V|7𖰿7y+u߀k% vKg >j?~DfL~ύ=1w݊7?+cxGW[62c/Q~bo_]r^_/_k)=O~>7I,/kw?p*o} /o|˵7Gίty~OS?͏kd̗5In~DKo7ѻ|͏+1|(Կ261h?G}g#4?2\w֏S >|bKU$п ca/3??ZDp [g])པCTH= `[?݉?v|/w)+ݤ? ~m])[? _H =t ρOD!O [ymo!xK/^o!uk)Z?7S) xS7/m×AȪm9xC͟bA/q+`_ ^Wx:xxm/MZڟU5~5~5%GSK1-Q ^ԏ_ uUg6WFJV6W4S|7![+hR4?ϻ?ϧ]Nz׷x^Fc!:>S>F|~ ^JB+ߟKw`>Ok}z~RT)C^?;1xJ#l˵_ ^XB1|/>i~>0iW>ϧAR;G/w~N+awv͟(O~+b1T{ / ǥB?&'TӿSX')CZ?%o|~U;/5?>")|?C5 w֗ooS~[[E;[?fv?ߨz?~?3Z__.u]_ Z/hxZW_Wj~ ~\s}.YKM}y/,Nuwd8;ޟHgml % _?k y?G;g||S_~/E?Ůaqf_}/>]*;w}Ar>/?#lwSJߡoC_`͟>ׂz#l=?{o~'zgm&߀_7wWߟnԏ-gg~+?nw}LyHOMhD_?OiwBR ?_w7}1^~(78#_C1A?(ZBbxz|zԩwK_<KK OO,cO_ ߮Q_}~·&)/O#;Rg}H??9`$ܹߨ1 A3[܎?3oy_Ao|п%9k[|N~y!Uܛz_) 3خa'I/W=/,:<4bbw+k~83>_^ |7qς/4|s+>O>+zgyΉ/¾a堟-Cy7,_3S_8J3D__e?kz i_|SL)F؎dw:%6!׀~&8̷kA?? iLx/M}x+L=!_ov=}wO"<@g&w1ߎ1)ľsm^wΟۉ9o}Mo[%1%k! ''6oLm9#7V|>k}#? |w:.N~. ^:1}meO}Mp@=k}~47K>V@_׻O_h}ǹJbM~T|}hx0!.C/+<~PFaЗ6{?p^ʲo>?xq oǀϊj|gE?? )ч~~xa?' %1|x',6}^cd_)Wx^c%Ggm۶csstƶmsm۶m۶mv;ꜭzzL}wUu\SP?x"KniSqd' ӿׁ>6}mIl ^zפU|ټx }s|x5/]WU"xe1Q_xL֏#x/%d /-ko뉗=|?āKq}~I? Ob?Cؕ1_0E1QE(~9?_"x^W77!#<>&?*o9Qض? <+W?< eGDze=_]~_~YbU| Clǿ4ObW}N؎''G_d8/KV}m+?b+?jCƿ_k>:ē֯MnP| 1|n_Ue"[wz |U_;]pE|P~|3ů7q}bkS>_O\ϔ: ~-|_|IbWSIl? <6?k~$_IWp}b_<KM}_4O΀/br~s|Obv+!P| ).)!sK sr~Sҥmy@?'ZēU|ZQ:K>#&#$2O$} oBQjc)o _2C?,ࣸYOmG>|8'_rj~j_O~(wvL|D@}?Aߟ+ߟ3I<>?mpϽ~>TBl/ /ׇ_n}j8x/9w"o H\$xOK*^m#x3?"2ߚGʂ2Eˁd<͹rތ+Ͽ<_U2xQ<|GvC\MU"Num} ?r>kn_kA+w~!z ?Jr?Pr}@bS!$6/(qꟐGO>Oض]dzş/{V~ `rj7ss~^S!O ?y=g- h~&s9mv~l_?'p|̜<}&ҫ۟9~3ٟ[qL3i<Oo|Hb7 b|]"S/إ@\?M?b~3s=gM|3\?iw??'9?/OZ'ZKG"aS?Q6O_]2_[r}?oO#H{ٿwc:6zX/.;ISW_Em8>9`+ŧ;o7GM|cGu|m_=P!||e/W_NSe_J\o8ÿwg 5@kXDI@Wr|p}>Ç\7'P؟eL _}/OPa"8 >'dA&e_>2i~>|2r~>>?L^iol軳}@ߕb; >__8h҇/H d|;y{__};˾kF6uoK_Ks}hˠo^ތѦ! տUU|5x_=k{6&x^e7www/w;z-EZHťXqwIyfM2dVgHϪBNdJd"~#yCigܰO?n9PAŧ4_&R/Ůo7_K^2~8>o/$dݾ}G;w̥Sg{/Zagq Lߏ_}كoSO/~ ŧ7?c|'n}'R)v?&pCj}vs>Οoq3Ώ؟ǰ|t1>"ƇG1o(4?N礪aOH[kh~R ^_s>K|?)ߏKup5ȯCt<~/|'rO{R}5~yS'w1%;xπw#ށGLT׎ۗˌкX_Ymm~"6_B<+)rs¯S춟 /)>Onķvϣg~KO"oNGo3g~}qw|~>~ !??DxaקEh}N׵(p}W ^?S)v/Z\ȿ&2j?D| |Qݶ//jܾ|WCy.SDTW)v ^^ Ës_ x1>Dr"\?95U ^ ^ؙ_/+ֽ+?y]?/O>uW3DxSħ'W/j}vfoI/m_[ v~)J5~î['~\Qq:_wD1_{<#T?;Nu~:EGߟSz>xc|}p/|~rH"_rP i'|~v [y~ZOx?O7obH/xr#_b|mj_5oحWC{1[J a ;\~4#'!G!{_#o4u|C1/_ӗ>AKO9?ž?O?!W)G!O'?{ߎO? Ydǩ)@48io:-[fLTP~?SߏUisQ~~2W_}?_?_ ry~y>%۾w}1_hyxυ(>Eg)>!'\Ϗ\7) Weɓҗ7 c7#Qb|+/i_P?o?翛-}VԿ>7wv7]{mpv߰ow׮='σh|CܟG~ߣ;h}$e}oþo{7I*/V_˩~a7i2!Kmb=>%~xi|EpþFsh/y|?vE^_/Ͻs#e+4~ux~-G>gQ}"Կ^G [\y~><)/ SxɷށO#O]O>>|,:CܿEGR}Tén'};?PnB<|7g>9ZF/?W/x|?~_}c*¿F~}(?7p^>";x#㿇C6vx|nϟ]i|)vgx xgD+;r7x~j.?#<ے'm8>~%y(P` [w57V/o-)^6ioޜO޿o[M~2~n_obOƶ o ސj_})ף__/ks|^Wפx/NCFa~ GU<We} NO+Wo? `'xy\gR| U?xiruKt/atR\ҫx2xK{&xIcf#/ϏEcHgE)?~B6|dC|A_ A]u> O /7<7ܰ;?yly9}y~rxF>n/?< ̟!x&'wg</W+]~/ ^~~8K@a_~cy(ߟ%I8Rk~B~_,?7쎯,<_%7|iU~*KEa<_R"^i|XE_Hx^eTU1RD%F.FBA  $TZA^Y{6>AyY;O{g|ysC2L/~8cKG8'O⋰_A/c Uʦs׃Vi/. C/.ƾ/b1໤8~ߛߡɤ|~3vߦKeB[x1T⏰qOG8ԟ~#|sIxCwc7؟-o~?SA~/, 賬|6w$Ky62GدYg My;ҟ/>OC,?ѯE'A~Ex}^*$yf_Lw<_H\OI_['ľYugc__|?_|/JЋZC?G lGط|_}Ksg8t0N]~4?>_Ow5cnS4?Ow_}|O|{B?Q'H! KoǹAcc}_I%>s3No4>j ?_?4`o}rC{(W_p~ߟ}G׏Q}$wnƾc{iy S=Dmݵ~?ƃw17c"x?Z;>y>Q A} 턧x>Vt6Zf_+.[j6/Y?/I~4o"<oy7x#r>~灋 ^O>p?x͟|>?,Ϫ}?rxMχkh#c%WQ*<>^Y J_}?b;|,(+phRl il)xڳI۝}Z?O\}i,8Y^VPˈ,χ+/#MK O m|r~Z }Igҳ%s෈>Gx~X}1͟_fW`7%Q"x37h}x}a/ߗY_'AJB_P9?D_ ^]Ck:?M}[WyWQBbo-ԫ3\/8( Z_>?>?Ox:ٹZ:ϑ#ǿlR)p 4͏?~|OMNПK} ~֗OOT'7wg|+#7_Mۡ?Z𣄛i'b?¾~o~y?b3wC ^T\/W࿩}ޟσBc '7ƾ߂,z3}gIOR,=?JY~~as?g\~Կ_#_o_K|?~']?ܟn߿t~~|rs/GU{ܿ#/t>|G= ϴwi}9_/y?|c%ˏKU'Oߢ9?$'s ?? YNߤ磧/Q9c, w6G96 ?|l ?\t_x瓋?}珋?%K~/7_#ܜ/"%4?_֏W~%/W~u~1s-뒿y?cj<__֗/ c"/j|@ F_-y*)>nέo:?χb+߯>#<_9 /ϟ/LrRwI?nBGo33~2|?_~xi>ʂ?&S?/O|I?yh}_ 3Wy?+w's~[_d"}}WW^ \{\}h ~u59Z|oϗ%cx}}MgJ|Zw|6 <f>kij׺Sž$)Wɚ?A|/o>Q1o}&&?F|Kߙqh}LI{Z@?T|7o+/6BA?ZmLq}ځM}ڃwSG~ oޟv-wßr+=χ{$nwl;x7fUKwQ| @x;J ov7CZ?x+g[j}hBAʹM߆7n?0֟Q}C_~p8Uz.?$x]͏^G|??B_[Do>5s15jjX諊}ƁW.~57'}}$J?O+ 7Ex^eUE/ !% H -vwww- "Hg˷Z<>[g9\pyD&/?1|wS7xxK6o<¡im3ۂ7" 9= M| ; "#¶#x}[ 7mZҧͻJv69x>I>_ 5oSjSa;^U?2ޗ/Kh)l ^+ss+yx+9T@|> ^S<2e</eKy~G4 > /h+-n↋c,x1⁜qWP|W|xQ?m>®-B3 (OV5^n?T/6^W¶?Cǟv3s}Oݼ1f~EsBKa;y9>\h<;WB. k1x6'Y=| Y8?-O6_짰͗gdxU|xzOg5i?[C^ҟПׁ%}(:|6!)zfMH/OGx] ('קG(>>NVl |y=_|Ob}&zoϣ?_o1| 9'{i]ƿ_;ٿ;Ⱦ=۬b}=6| Oa~G7jLv7OQ7r}s@~<z:.kM~"*OarO6__iT|__{ZHa;ty~d҃/R3@Fņ'"r} z/k}d~®sg~2\?>Y1|g>NtO=é0'SL}|_?)O$)l (P?'ΟyDZ}sl GQ&џ#پ>"?#׿r){xADWBߟK׷~^z"l_/Cf/{SjNW {0w=(F\_\ޕ6/ޅ/?;^S|HUKwO{/_Iq*KkMQ2з29^ Vg *+J'jj\G1{q}o'ūCOJaOt_Q&_r~rV |)^s|>F{Oc'~-LUW=8~rQ 7ׁ%7 oy?Eoob}-ҫFk &ů_&sfW[3MDKWR'Wsr# F&Lr3B?7Sޢa $}?\_oW1S*;"'=.r7}y\==<¶{`n_a^𻸿N_O}vAH5o6<7q|oOQ]Sq𤩿XߟoɓM)?uz W'GOC߄π'_o!_ϩ_Ⱦ=&? ~m{}oHOK7eHַW}9?נk˙_zu\߄Ge|oW3l_z *{_+d_`b}˳^~#r\_,}OprN&x~U /"gWz98 #le rEcx |-x!VgIk,Wm3y@3d_ϵ WvЧc~oo{/[=爫/zxGπGίi;m I9+پ\#{~tWG~@'xO{ 29{x_b.KӪ"G?|?W+owO`߈S?WSj{> y眿]Hw;>"Qogr>Fo՚[?V'v~}x͜NNHz7P$s븾2*)k~?18m*? |x>*tW^g }}W盙/,&>ѿK8>>):E?y;|!ů>|W|/WBf~|/G\?eϡb)lg}gq|.~&G/gXn'ʘsZu)ϵ~r>ׁO2\>j>7O|nOUS-cM~+mࣙ?|eo&pdX j C8>yK?¶I߸|}~x 6Cx^uU?cUL`n EPRBŖr9>{|̜g眽nRYZO Cҿ7p2Sa~ ‹_).Y~Ǿ~%I/}} u}q #W9\' O5Wso/!~y,K'8Kr9"_/T~_\~#П?'lEYX) 'ط'B_@S ~O TOL /0>OK>~6<? ^RW]_W|柿?Ey,_ %ct9ӋW~ ر)W.:4ɿ?j-5)[{kN[(o}^ l__HgԿbwji~@k ~7!sA_(z&o)nq?|}3 MSH|q7Dykm6{hxl ևW[oZ່GV^#]?r?;yû$a;jxow~3k  =%8Tm'(ck|~?.>&A||tF~H_OGh~0|o 0/< " ?#Z_ǀ]Xnz}~;y~}'H"xG/~|ۀwa[9?H|?msxNw)ہvc{V_vozߎ};p#;=Mo$fj?|m*z|lg D.x~Ϗ ~v_Eo3_O={~m}-7xMwžد^%Wv׾_I(1B?W_|`2??DP-J0)7|SMnwGo)#3{ߪhDo+O3 ?>t?ۿ3 =__T*73,_D|㴿N9ﯳ vɯO怯9ʺ~xk֟b?>ždU灯'+4?|?>/y#|>w.?Tͨ&¿_EF,@ 7? MgLOd!v?ˏr,@xg~?G_ߕ9\ߒ~|烿!y5_x~{UEп_/eaE@ps?)s)ws939?K|O>4|D<^.vRO>~q?@W߯=Wú|U?(\ ?=8\r .?dZ4?l:{]dz{<~o0F\PoN~ ~֏[os׭f})>oDwKKe}f&3?eOn]}=7h}*?_/c~=~/6?5b?~}Zaľ9=~֏//'_"ћ'/e_4?3Ţ9B/sS<~%N_/W O_?O/_j/h,oDf?# 8787Oψ-<>T?8K5n='I'J|pɇ\Of~l1?<~}>_@?S/ghy~ |54њ|Q6P~?{O#S32觸}9?V&1+n!n?y `ћi5Aj׀(u"ip~~׫|OV |/?{ߟo]OMo]Eq߿r>lIo&S3d]?I%UJ}3?(~,?<3S;I1W|G[|2vOSUm%1dۈfo~?W~xo όൠ/S||lU~Q<ϋn|;JHY#r ^I}|߆C`o~_&>)@ǃ<~F~?_s}]=]d5xڀw~7maps3x};}:w_$~wi;AVCg6_3?b?cl% SZ˿K\x?LLwj~|+&|'x#/P ٧i}MR?x] #zs5xJ53+F ս|x5ڟWU "3m84~rxEik(ˋ|?8~ //IHKƀ9և8|US7 7KAx^uEű]W}; B;( 0A" |+ܙ{s3o]v+8?v<9"%'%t/; /"}=eUy5rH}_y>O^y~wA oq'žo)`eM䱞-Yp ƿ %_0Xׯ:.k} ~_ߚ>L}J}7'YߵL?~u )}=5n| ?}˼FЯ1*X=GSw]R⧯2?rji0M3Z@ <~f$ - 5ҟX|'}["uBu~~௹_u#b_O(;APsg? |^]_G9>_f w<E/`AO/Gχ2c3NZ~9W7SOrޟ X1liCuzuj[~~a دpY I?|>W듾z}!95?ƀ?(E|<8SF}^?|p?O5|2R_Ͽ7u7|<9OYs&.?q?}oƿ1i6~Q.>#X>?>\zw9~uE_/gO@:Gg Or~q>f{73ۓ$~ p}~ ރܜwg}i2~NO;3߉_;G>\~*o)Eo-2xsYo7Ʈj,-~^{#>~*xCx7?%ue~k3?\d|fo"~u2|x5Ə uUe~T _Y> ^<?"߁_<|?/.e/O?3] K9["?G\;,;}`~|@1e(Jd3MRO"__gւ_n>8 ~5O>~| Nߜ> rS//K˼~߯D~p1G.r/ $F7<7L ~.S~߁_~6Vğ>~R} Ǽ~:~?S3) ~? }~x7~;Nc_~ϼ~W_7?R?s=<~Bs2~!Rmgӟٿ?Ϳ?s~Gb'~_访e>?G?[~>Kz?}BoOgޟ0䱾쏿ԛ=+~;|;>_|o߷OƏ|9şw3ŠMCj?KE??H}ym} O6mGZ~4Fo~ǂoqП~pg _{ן_J2_Hd?~<|=ױ>y|$,? Scϧ?֒}5 a3?3WUg_]?Ά~%9+<m_?σ~7kχ-ox~-f`}ԛEпFn·]X/r |c_C?M%/пW/Hy׬k/V7CI?}W o*O x*8o'<^|w 8F懾 hXZd|)u낏e|?אo`7F>| SB / fཥ>z}7{[miG!/m?߶]<ځwqUc{ΟZ;?wHn;w?sϺE.;#~[]ېEWӿvO}?hݡo)ѿނz^o.KO蛹J MO};}u#/ u}!~=կnxį-=7{ xMz ! ^O}?*w ^^ٛ~GWrC_#je"W;oX_1y^V꧿oN0D2_/'?? x^eUU_NAv PPTIAiDBPBByfp5f9=wjß p?}O>$x\eެexwwK1W'q';p^_7E/1xgq}RxGhAobp}x['qm? ]oM!ߊhA-`~|9B䳙8f/ľC0S ބ?^ϩx(i_#oXQY?6opc_}F7![?HMb߾Q$9eh_[uEC5xm?7C ^kпqU/j⿮ _|Fo+S>^3%O(it򒿜a_~&x9_,QU~^F{t OsKH|rʿ)b_<}Z?劦")^ Y^0@ ?BEПܜun I|uP~+CD?ğ7'yNwFp}+Qbې7B~7K _F ujo͐]Z%;}Y} BoQ__SFW%}v@~1|yχJtv "c | >?z ><{'w?俋Ey3gxӣŮiA~oZ>bOJFc|7s9|_w}-N;5_SNO"%%U |$_#xq_E+J@K_W 7h~Ku.>\|0yBD~[_s-9y*FRv8>@ r> ̟?H|ߟ~?>?U?k嫃Wx(j-W-^7Wmi/G }~ߓy^Y};)^"7d'H!:k⿮c_j Oؿ^NB%7q/~5ASFig߼O4FK3#ona߾Oq~[?)\VODW=q?߇ڀ?&W[G)o_p (?(=:~y~GNH|3ݔ7._] 'kG'F <-vY_L:wOFOzIS޼ ~k߬S~ԏ^y>ZL>t+Y?GU~~?_W?bѯ&~_/MBpɯ/W\~̯Kϥ?/ s99 ~'?ψ_O|F_ ~*wPY@d#ׂD@_!};9n7B+7緛7緛O< E{x; _GvO?ߩ]_UwBW)F?wAʛo-JQ"/6>{13羀p}Mt?xO/ xc7!F?ľÐ?88? Pu}?~70??=Q|U鰯wa?~`̯) _ 䁎g߇O9zIFŞv{1+_?;蟉/#˷m2_C0'O}zE~(/0y |7Ӿ Frp_o>o;3>9Q(~Y+>`| ~|qV|8p}&Ƨþ߂'*OO?]1L+R)|yeߩ&>k:Ɨp~ s&S޼"oǾHc|u9b|g^o?7q+ϙa~yK ։>g]YS}Xs߹nmsqep\3}}ʞwcI}:'qrr }>}>";}þ}ܷypؗ/7s!s<p\}y2l湎P}y.9yN<'q,繕{þ<7?ݼ'G>޳,繞4_ᙸx^sWc۶fLTO&m۶m۶v9̳?g=Ν;\|&i?sϦgWppNbg~p~ciߟjKIp)_'Wpl_c'3y? ?jxOW8֧c^X+8_/?+8/_}菴~ 0%OC-c~FjMӼ1}Zyce8`گ81 k~ yo~Wp^K-_jS[[AKuZm:{2?>=+8>~BSv|GX~l5뫃 Ǽ#f,_CS_1 v?RG.> yWS_7mX_?궎CU{oi߂:76?1 I8~KBe} g\7@ ko`_?O_/__ƿnN k[Rz}_5Y_~~ |_It>Ff4̇o͇?G*l %_g,+Z~8"1|EBT/&Ϸ&ϋSZ~gs|ٟtY? ϤcLgUn_ߦgA?T2l,7_xc $yw_YO`Kbx/. |`?w6/ ࣍"(OWiKZ/u/ >5F[_WJWb'2?k>T,kOdmW ۺ} >Ux=C~ |~oXoTo\/_\%I}7fp k/wtxg/xT#j+ۛ}=]O֯mZ~z~ہ֌?oMגc;@"G}o;7D;7/w+xSWiB/AQ< Cso|g'x]C;}k^/eRo3ñ!O2??SW??]r}P??ñü=;GfQ࿲>_ y O_$w?֯w?q|ǃoՉ';~)5߰q_~d}s_Xtt&硿R߳?lOs/(ϝ;oσ[~zpA|O.Z a_s?PY_.qg8z^o~&''AF[~JU2?|{I_fK!^U U|*ِDX|L?)گz~roIo7zO;oc]/ ]﯑7|ߟ/B'zx7M?x*/}~~X8O_a󓿿9eIؿ|E%S_L= ~Q35,Իsп=_ctf_E,a>rsNTKv,i*_׿O|:i~?__oB2\2?wO ],_dž~ůCX?w>|a'?<ğ|}XGCh _ߟ:~OOtWUK{g8[}m>-߁c߃?[== {n'ໆ/R_wwh߱PP?Wh߽ m-?=|ίoUoIs[TWY|_Ŀ)+?objc _+C/ب ߐԅ wU|}Ug?@ůkL5 xCנ}~X7>e ~_q4~_ο~Wpo J%=h"' ]?͡_]Z/|a qd8ַ_@}@?k Pv. siߝt+;϶~'?ñ3x9}Y>/|f~W؟{O/ݠf>ܽ?>%_Ϟ-?ݟ߽xc}'|x_gק|c"y]B?k`?2CGX|e*|8p7y0w;~G'Ff}hA/i=_GwKwX?w>0 u}Uxw/w7r ]~MbשY?i~};9;T to/3W&xޚgVCxW[~Ws[Xu=o;}3ri}/Do\@e}~\}믞-o?] k?ꐻ ]0Bx^uUşݝ㨟*Hwwww `c aE`w7'{yy<=uͿZOV*sfke\r?s:\qSƾ^oՍ}. 2N O?K|~9s.8oek@Fx_R|5+ǟͱo/_Կ*_q5j?+-c׵~-_ z﴾Iu3-W7( xɿO#i ?f_Jyo?n g:??dOEc?Hx뛌aߏп'؏4Zط |GC}G+п-]L+~) w 4~oJ{,Y{ g֯>%~~ɸ˔sߒkRUx}W4 ,I9ſ3`_ć/c/h~R0畇 7j}g"|8_ d2H؏Ӱ_ƾ~4S^}>I~pc,q ϱxr۟ǟoOϱ)8O7 -|*Cp >Os~D .3M|V)~vZ?wX};Prb_OGB뻌{? =~}g-ͿwEAğq~ׇoI })|'|zρ[\߹$?9ٟ*|-_$~͇)/!?#%8!~G1Z5Z'%5Gя.>= 5?%)aKϏeMl,3סo &xg>^729]Zk.W//nΗ__So/p~ ~֏;ۿ =yZ?`^Ewn?']~hT1-W__UMc3\á"<K`T ? ·k\߭s!|4TU߶zoޗvK3pE!|wnH}ƿ2GW>@y|7Z>ϯ}w;~o ?۪|=|?|kѧ\?-~ ^6W=ߟ~3gC7a\ x~a/ 7H諸sF?OP Do·ǂ/3L|oy_?|=uQNu2:"OU_T/PRi)<^ƾtW/}k" UKT ͱYK~>E)cW>??3ߟgާϷ3/E?|!eޯ/s̟?}ኋ+y5O%? |?R]??_U^W}FJUo RWV -/r|S_auU5\I'/uoI_|_8_ ֟u/k||?%rb|~ߗn_$?t>B b?7KC蟓?Er41?ͧ]~hiS6Ro3'ĿJ ׿9>|4[@7k<~+$~2o <7>շ \`~hyh Z_;:~8xou|2y ~ ]SOƽS+wi~~-»C?S`Rs]}}؏?nf &?>YC_IKb߼/~x?xS=?|'~?\FQ#G֧|g/  `.4?@/~B?@Y_3~?> b7_z`u/ xE~sB$Eq xɏ9o/_;ox~#Mo][i~oks;e۟\cη/Ooㇿ_i 7oV?x^wOe_HCE4~ Th{4{hP^}ysuΞ=,/0*-W{xs .|ϥy!s =Sa%1k_ c7>/Jὡk}pډ]c_9?BI"_:J};` f/]7'K"&?SO'fRXo#|ǃO^?&'+ ~ Ǿ6P-\OSz~}c?*y"#Y~~!~:xm^fz09O_Hײ?% c{wկ~x]R.;E׌oG i쿩Nnַ~)\ogاߖf-){<+/R?=>>F,kg>*k%~| U;k'_kM 1v~/+7]+MM-ܩ/eI}|y%)(_X>_$/,d 9(bs%>3'R?3$~N}$SO&gIҟPҰ/ƾNd}2O9>o?I,X?r{ů7FoyE/>JLgeRH p'IoA?z~p ?AR_}~>|oN}S]u_s>O'e9}TطV?3uG*篶/8xHO?i>jԅ#^(zQPo[}.o[zL^B.~>1@c b_Oǁ%z]ߤԿN})_K=_!7/%'I/&zB o ?GSg7? cyr*}Dz~j~;V,of~f~6M3H=Akſ2㻆_-|NWRo8+o~$5~"K%>G wH߯~7ϜUQGؿ2)w>Sxg;%)];J~?ӏEb Ŀ>v?uoL|~o_dK_G \~n߮o+G~Wa^߮o-:1NWY׀I_^ [I}?׃?}Ǎ! &3h?f-v=ws+3H+~{4;o~__?%j|L_kgx]M?YWۄP/Aߘ|0Ifowc8I|zXƗǾ 0d ^/Gf:)IԷ6yOD3x ^3? ؍1_=? }57We|~Ui?σ"KgR `R?|N;1v/W1v WbWt׬ޜ__7+0>M޿^N&/KY?~B}_~ c7Ow1v9'L}ax};og9_2gm)-쏙_C_ߜ@_O?9ѫ1|uD}g7%O=I| įCa|0 |=oop}7I|^|]_+@_1>Sc7Q_&/Rhc j?W%WЯ?|EWg| y_}4|,S_gg9s >[}yϤ}3Q?#χ~z2>TOB]Jg1_ d׿I)|)Մ P-'z1b_Vh7+G _FJ _=Nn5$?=~"Kx^uE?C.!}iPNP:V;DR{f<4qO׋w|x=^? M'ú? )FcX[9goa'E{~'_߬O |u7r|a 8`YX?A͇먾F/BVm~ר/AQHoyUk+*+T}"z|s|Q8?Y?ޗ)%!|q_B1_7o#Rro-g}ߚ,_gr}a /֟:cX64To.8ar)=~'iC~tS~1lT>Vq_\ڇ?cGtQl?"e G}#õma*?94qD?}0(tİ?<6>Qy&7dǵ=Izc}K}ߓ7xSR!Oi`M ރ㷯Cx7O]rӂwWgXA#ُaz@a]=qۏZk8x&؏[V!g{f!i<7__Yc?7r7t'q}Xg_?9Oc=CN}⾜{ :?b} ^(yk7/x K>T?c_?u^ WEE WcXϿx%9E+rẄ\Wx"UD}KE|//e4~RT_|,xI+^>*7*S^'S+!\HW@_HWW s9 p^|bj؟OP8ׄ>7_TZ?ϩ }/Gd?(gY5:(5+z|?*31{!?Qyl_1Ct*/'~j-?763x8x*Uo3JW͡O'-q}W6[" } ǧ#@<sYV/qhMK76GE`nٿb;h~/-#=iA| O u/]qw 8~>DEOW{WEzcr~VG\OS_č~(OO>_ ?Y/Tc!#č`Ô??oAT}Ϸ9PǁS&'AGdON߳ŸT$O|d7`]?5O C ?K? go[ޣ7w}߹}9?&Rc=zS@௓ޓ_SU8_\ OL3ro>-?[:==NvUٿ}CoVCg||qB~C"~_`ܿmLc7l&r^~#۷_6pe_~~꿘-Яք!|o=22+U~;W(C2+nŚH^ C| (~\\~q?%?y|g<>ȿ/WOSu'S|8~_&s?[mgU~3Os~r.8y|<7w'r><|,?6'c>t>Q)$QҏP3臫}>La_e+!_y'C kHܘoP|[#?w迃7'9~؇+Gɾg~xmtx#xwϷ+~ۅ/ׇ/OP|.DW;2xs~2?Qx[Ac~MP? ކ'ϷG9>y'Cxޒ'ף߂X_7ALO8xS_ ٿo_5)Q}~o}%Tax?]/~mߨZZ}moM8߼ } /xuF}i/Uɿ|s 'Ͽ+}Y#[WoWCx97? >4Ϗ| w/w/A9kB_{̏E^"/n^{MAx#^_ėK\?HG%>8` |&4DUEؿ<Nb*)xN|)G³9x2ofqg9\/0ߟgGj/i1˴ ;x4#xj?dOEܸ?dO;g>9۷p}W~Bq}Lx^wǿV{HP7 3Am;7B$}~D}o?Jd}o?\7a>Q7Ȯ?[=V?O񧱫<6Kخ/xxAEr>oMz5wQi~ƶd'6/gTտm5 |E~?P~ilW |3sw7W%i>To+u&?g|kgk<$9Xr}|#Y{Wԧ4מQχOY<_ao_y/Mb*hW J_we/ilcW_F]KIH^%ض_L'd~"d_?gV6|_j?>!y?m^SIPcl0'T4vs~)ߚ~-ٔ_BDGOϲַƾȿ63y| KOO~?>>ժk>r} X/Ϗ TPsu>o>3m}/]$?]O'aOSGqů秡 O&}J~BMG|9jk>KWo/k-s"QHe𡔟z[c'o6/\O59~|-7)?"j6?Gԯ-x~YsCW<{xRo: xwwוtu.\k9>txG/!xwW)=;pr^oox>{c.OoBSSopc[xk'x+%_l_W?_?x Z >d?m7Mf?}SO韥| ͇Z?C<]痧 S_/m(T4ޘwOc ސ#O(z?{r} ^(UG9~>k뜟Ǹ`x:}߇Gk5ؿ|?:Oc[?!ҧ~*Կo|H`~wI/3UW|zGW5qox~e_<(u?>d_oL}2<'חȿ:|^/Op~2yॹ~χ6_~%~J> /as/\,RyQ~)~\9_Kpeɿ%wx= m~k09q/`fyҽH<%/?7O8\O sR~ TdpO|~/ZO}V_cojXV_gkASr[1oGr>6jne\m~c[/#Ŧ~O:۪6ؿʅ\_9??CWO7#}|gso Sj~cl?Aw?l3@~M#'F_S||?B>9<Ʈ֒?ߑ^d_cwYVW/JƊϮ_珯|__r|y!rO"/il18c[Os/@%_BE|t)/&>AE$ǗAy/ j>y)W xm|ͯcUb}LjgP5D'w-t4˿ͯWc;^ݯBK<7|h7x^(~~nz}!$?g'Ǜ;קq~ c?r>g}(H'c5/SB?WPp=dO7{!>8 7= Dyzo~U?;BM;9a}(1\Nm}q^ƿЗiq%=C)_Jn77e5/ }OՏ|,}'~+*wޞ~x;p}?I%IٟSrGN_W?џ୹~^VGK{|?/yx[p_dr}?~_ud_տx3O)?W#}|?4O/U)<IS}=j5o}x~kA^/_4Kkx[o:x^wWǿHDD%Z(Eǭ>MkKDN2*MfeD%**D;L"J>Ws~z{=~رOEx?CE^g'8"ў]~6g'ص'\vN.?m|6 o%\!x@©/iU|CL48JqQgGKHބ#m2S ~c_8,#5WDrֿ?_n|'~ Gj~D|%> wx ^~OpI_//`WX1a~ڿh/`׀ץ}9JI?pN_W_ſ^?n? w>{'؍^7} %}>kǁ)bC˫ǻ}$UXXHAo^?gƧ$Xe' T7SRwe1#7i}y+?MڏGo恿N}Nk ?_/|7]_ \_u |W} ,g#>,i_?_߀?%COJ~'__&"'?bMOC @?O$'9N><Sn}]|7#=+c%}׉ϵ==i|j~W-j$>H#Ŀ^_g|8I _*kuF_~?|iF?p?wKR?}G}G^?~glGO>z~+-7п9_0i<C]{wFVZ/U2לO{Kz*WZ5{J}=$> /_HtK~z} u%e.9ߑ_%3?.~O?{w_i_d . 𽠿 폊o]eKW~į}a|fcg>&73g1~-~?_3^O~зM}k7[~y~Wx˓-Xo.sѾ>ۡCĿ~>[ }]-\ׯ-[UځZ?5g)wm ?|įwD>guw>Hb7H}lԛ9~ʹh߼V꫟}{7_| 7.~oq1/_~vYKwQr_ j鯾3O/;ڏ烕_r;?+v~9 eOW _J}N%9_Ln?{/F/o> _}Zׇ>O_/kG|x-<_:/~isc]\O f f>oT,g&O$>~)׿?|Wng2`߯O1cV7u4/ ~G>E|0p} wM}߯E7>72>__%7H~:{_5K4>"^>GCx]c'K}Xg~1ǃ?M?O9q?i hH'x^eDBqז.eY`q]Xqwwww-Zݽ=s/~)w3l6IFkh]jڭƨdp| ^hC8 ?ԟ_7Z/ϳ.ϵV$`?9fm^23ϰ/؏?<+?ܿF+S`W᧔㷒?\+9oZr;?/8`_]=<g+o~gcM.H>_Gu':Əpv~}i7Rhg}\׏?_pA_ l׿lf}qqn+߫b~%Q7׏ݭVV]̿w73.ߩ3~{s_~|&חl}m+A)O[[{|K[_[[~>~s8?8_ǩo['MIdORqSF6n?M}&?o߳aĹeYد|~۟?3oׯt>-oft֟/od{[}#߫¿ }m*ktIb?wl|_7o3Ohg|gOj| %t~ŧ)?O]OƝ_3}ҎO3)'=* p9dIߌ?y[ĸد'XVߟMٟr{||3㘇3]ml۟}c^m1+|t(O7>Շ1XxՇH79~~~b_,A{,O'Νž,OB{,ODb_?9YG\3ݿ)bV][>%}E_TN>ߟ5 Y?&ibӆ+ΝŹ,>O{,΍n@;dqxg-La~7FBdYb_?*Y RAdq w.9d^3dq+7O dP/>?8Y_?mG+|A!Ӆ$/~~Źy#}>[{bd%b?F_ ,Yo68w|n%Y[b}Md_߲Hm-[,7 <>,_K{_b?JUdqn~U+[5k5|89_:kqF|~Y}mRo^B/u"r~{oZV7,G`Ͽ>,7ŹžE?,sk?7ebd??7 3b[৓Ź?,oId ?lLO"a]pb;zGr~OwƏ#6d]?,+~49na}b?Qd#?,AG'F%B{?O`Ad @د`O>UK!&G{a۟I~]jq㻓Źwcߕ,B =ߙ,9?HdCoOߎ,3<\̷Xdİb'[ŹK|~2[)qVz?ߜ,oFOŹ۴Ϡ~rk|ߐ?d~dאּϮs byw=yۘ||]_>?됫~umr|kža~qn5b_,0:9~~૑ž~(*Y?B|r|?r2Y;+U[Ob_B dKɅ&ߟgb_9YvĹ5LgbWO_?—$ϫ%b^'#%㋐bo&o"f|Ar|>y P??Yǿ,~[\_,Ν}b?<5޻`^xu'>7Y"ߍI{'Ox/>Y;~Q?Y۟Yb_/|,3!|&0>#Y<?ŧ'stӒžiOM~*8w{5>E?=bO^_1),|>Y[w 3vxޝ,"n}/žP/ ލ,㿊K{ ,zocx3ԋob;^ .㿇Iߏ7_#/t9t3 uT2014-11-25 23:06:55,982 ONT Sequencing Workflow (version 1.6.3). 2014-11-25 23:06:55,984 Workflow is Basecall_2D. 2014-11-25 23:06:55,984 Starting for read LomanLabz_PC_Ecoli_K12_R7.3_2549_1_ch8_file30_strand. 2014-11-25 23:06:56,040 Splitting hairpin by abasic marker. 2014-11-25 23:06:56,051 Selected model: "/opt/chimaera/model/r7.3/template_median68pA.model". 2014-11-25 23:06:56,065 Basecalling template data. 2014-11-25 23:07:26,296 Selected model: "/opt/chimaera/model/r7.3/complement_median68pA_pop2.model". 2014-11-25 23:07:26,304 Basecalling complement data. 2014-11-25 23:08:02,450 Aligning hairpin data for 2D basecall. 2014-11-25 23:08:04,151 Post processing template data. 2014-11-25 23:08:09,086 Post processing complement data. 2014-11-25 23:08:15,407 Performing full 2D basecall. 2014-11-25 23:09:39,176 Workflow completed successfully. 2014-11-25 23:09:39,186 Done.