diff --git a/CHANGES b/CHANGES new file mode 100644 index 0000000..80d5049 --- /dev/null +++ b/CHANGES @@ -0,0 +1,7 @@ +Revision history for MinCED + +0.1.0 15-Mar-2011 + Initial fork from CRT + More robust parsing of FASTA files and support for multiFASTA files + Support for finding CRISPRs in datasets with more than one sequence + Fixed some compilation warnings diff --git a/CRISPR.java b/CRISPR.java new file mode 100755 index 0000000..2494af5 --- /dev/null +++ b/CRISPR.java @@ -0,0 +1,194 @@ +import java.util.*; + +public class CRISPR +{ + private Vector repeats; + private int repeatLength; + + public CRISPR() + { + repeats = new Vector(); + repeatLength = 0; + } + + public CRISPR(Vector positions, int length) + { + repeats = positions; + repeatLength = length; + } + + public Vector repeats() + { + return repeats; + } + + public int repeatLength() + { + return repeatLength; + } + + public void setRepeats(Vector _repeats) + { + repeats = _repeats; + } + + public void setRepeatLength(int length) + { + repeatLength = length; + } + + public int repeatSpacing(int pos1, int pos2) + { + return Math.abs(repeatAt(pos2) - repeatAt(pos1)); + } + + public void addRepeat(int val) + { + repeats.addElement(new Integer(val)); + } + + public void insertRepeatAt(int val, int pos) + { + repeats.insertElementAt(new Integer(val), pos); + } + + public void setRepeatAt(int val, int pos) + { + repeats.setElementAt(new Integer(val), pos); + } + + public void removeRepeat(int val) + { + repeats.removeElement(new Integer(val)); + } + + public int repeatAt(int i) + { + return ((Integer)repeats.elementAt(i)).intValue(); + } + + public int start() + { + return ((Integer)repeats.firstElement()).intValue(); + } + + public int end() + { + int lastRepeatBegin = ((Integer)repeats.lastElement()).intValue(); + return lastRepeatBegin + repeatLength - 1; + } + + public int firstRepeat() + { + return ((Integer)repeats.elementAt(0)).intValue(); + } + + public int lastRepeat() + { + return ((Integer)repeats.lastElement()).intValue(); + } + + public int numRepeats() + { + return repeats.size(); + } + + public int numSpacers() + { + return numRepeats() - 1; + } + + public String repeatStringAt(int i) + { + int currRepeatStartIndex = ((Integer)repeats.elementAt(i)).intValue(); + int currRepeatEndIndex = currRepeatStartIndex + repeatLength - 1; + return DNASequence.seq.substring(currRepeatStartIndex, currRepeatEndIndex + 1); + } + + public String spacerStringAt(int i) + { + int currRepeatEndIndex = ((Integer)repeats.elementAt(i)).intValue() + repeatLength - 1; + int nextRepeatStartIndex = ((Integer)repeats.elementAt(i + 1)).intValue(); + int currSpacerStartIndex = currRepeatEndIndex + 1; + int currSpacerEndIndex = nextRepeatStartIndex - 1; + + return DNASequence.seq.substring(currSpacerStartIndex, currSpacerEndIndex + 1); + } + + public int averageSpacerLength() + { + int sum = 0; + for (int i = 0; i < numSpacers(); i++) + { + sum = sum + spacerStringAt(i).length(); + } + return sum/numSpacers(); + } + + public int averageRepeatLength() + { + int sum = 0; + for (int i = 0; i < numRepeats(); i++) + { + sum = sum + repeatStringAt(i).length(); + } + return sum/numRepeats(); + } + + public String toString() + { + String str = ""; + + String repeat, spacer, prevSpacer; + repeat = spacer = prevSpacer = ""; + + str += "POSITION\tREPEAT\t\t\t\tSPACER\n"; + + str +="--------\t"; + + for (int y = 0; y < this.repeatLength(); y++) + str +="-"; + str +="\t"; + + for (int z = 0; z < this.averageSpacerLength(); z++) + str += "-"; + str +="\n"; + + + //add 1 to each position, to offset programming languagues that begin at 0 rather than 1 + for (int m = 0; m < numRepeats(); m++) + { + //repeat = getRepeat(m); + str += (repeatAt(m) + 1) + "\t\t" + repeatStringAt(m) + "\t"; + + // print spacer + // because there are no spacers after the last repeat, we stop early (m < crisprIndexVector.size() - 1) + if (m < numSpacers()) + { + prevSpacer = spacer; + spacer = spacerStringAt(m); + str += spacer; + + str +="\t[ " + repeatStringAt(m).length() + ", " + spacerStringAt(m).length() + " ]"; + //str +="--[" + DNASequence.getSimilarity(repeatStringAt(m), spacerStringAt(m)) + "]"; + //str +="--[" + DNASequence.getSimilarity(spacer, prevSpacer) + "]"; + str += "\n"; + } + } + + + str +="\n--------\t"; + + for (int x = 0; x < this.repeatLength(); x++) + str += "-"; + str +="\t"; + + for (int z = 0; z < this.averageSpacerLength(); z++) + str += "-"; + str +="\n"; + + return str; + } + +} + diff --git a/CRISPRFinder.java b/CRISPRFinder.java new file mode 100755 index 0000000..a3db122 --- /dev/null +++ b/CRISPRFinder.java @@ -0,0 +1,243 @@ +import java.io.*; +import java.io.File; +import java.util.Vector; + +public class CRISPRFinder +{ + private String inputFileName; + private String outputFileName; + + private int screenDisplay; + private int minNumRepeats; + private int minRepeatLength; + private int maxRepeatLength; + private int minSpacerLength; + private int maxSpacerLength; + private int searchWindowLength; + + DNASequence sequence = null; + int sequenceLength = 0; + + + public CRISPRFinder(String _inputFileName, String _outputFileName, int _screenDisplay, int _minNumRepeats, int _minRepeatLength, int _maxRepeatLength, int _minSpacerLength, int _maxSpacerLength, int _searchWindowLength) + { + inputFileName = _inputFileName; + outputFileName = _outputFileName; + + screenDisplay = _screenDisplay; + minNumRepeats = _minNumRepeats; + minRepeatLength = _minRepeatLength; + maxRepeatLength = _maxRepeatLength; + minSpacerLength = _minSpacerLength; + maxSpacerLength = _maxSpacerLength; + searchWindowLength = _searchWindowLength; + } + + + public boolean goCRISPRFinder() + { + File inputFile = new File(inputFileName); + if (! inputFile.exists()) + { + System.out.println("File name does not exist: " + inputFile.getPath()); + return false; + } + System.out.println("\n\nReading file '" + inputFile.getPath() + "'"); + FASTAReader fastaReader = new FASTAReader(inputFile.getPath()); + if (! fastaReader.isFASTA()) + { + System.out.println("File '" + inputFile.getPath() + "' does not seem to be FASTA-formatted."); + return false; + } + + while ( fastaReader.read() ) + { + sequence = new DNASequence(fastaReader.getSequence(), fastaReader.getName(), fastaReader.getDesc()); + System.out.println("Sequence '" + sequence.getName() + "' (" + sequence.length() + " bp)"); + + /* + // Check that sequence is a valid DNA sequence + if ( ! sequence.isDNASequence() ) + { + System.out.println(sequence.getErrorLog() + "Skipping this sequence!"); + System.out.println(""); + continue; + } + */ + + try + { + findRepeats(sequence, fastaReader.getNum()); + } + catch (Exception e) + { + System.out.println ("Error processing input file '" + inputFile.getPath() + "'. Please, check contents.\n"); + } + + } + + System.out.println("Done!"); + return true; + } + + + private boolean findRepeats( DNASequence sequence, int readNum ) + { + + Vector CRISPRVector = new Vector(); + sequenceLength = sequence.length(); + int actualRepeatLength; + boolean repeatsFound = false; + + CRISPR candidateCRISPR; + String pattern; + + if ((searchWindowLength < 6) || (searchWindowLength > 9)) + { + // Change window length + int oldSearchWindowlength = searchWindowLength; + searchWindowLength = 8; + System.out.println("Changing window length to " + searchWindowLength + " instead of " + oldSearchWindowlength); + } + + double spacerToSpacerMaxSimilarity = 0.62; + int spacerToSpacerLengthDiff = 12; + int spacerToRepeatLengthDiff = 30; + + //the mumber of bases that can be skipped while we still guarantee that the entire search + //window will at some point in its iteration thru the sequence will not miss a any repeat + int skips = minRepeatLength - (2 * searchWindowLength - 1); + if (skips < 1) + skips = 1; + + System.out.println("Searching for repeats..."); + long repeatSearchStart = System.currentTimeMillis(); + + SearchUtil searchUtil = new SearchUtil(); + + int searchEnd = sequenceLength - maxRepeatLength - maxSpacerLength - searchWindowLength; + for (int j = 0; j <= searchEnd; j = j + skips) + { + candidateCRISPR = new CRISPR(); + + int beginSearch = j + minRepeatLength + minSpacerLength; + int endSearch = j + maxRepeatLength + maxSpacerLength + searchWindowLength; + + if (endSearch > sequenceLength) + endSearch = sequenceLength; + + if (endSearch < beginSearch) //should never occur + endSearch = beginSearch; + + String text = sequence.substring(beginSearch, endSearch); + pattern = sequence.substring(j, j + searchWindowLength); + + //if pattern is found, add it to candidate list and scan right for additional similarly spaced repeats + int patternInTextIndex = searchUtil.boyer_mooreSearch(text, pattern); + if (patternInTextIndex >= 0) + { + candidateCRISPR.addRepeat(j); + candidateCRISPR.addRepeat(beginSearch + patternInTextIndex); + candidateCRISPR = CRISPRUtil.scanRight(candidateCRISPR, pattern, minSpacerLength, 24, searchUtil); + } + + if ( (candidateCRISPR.numRepeats() >= minNumRepeats) ) //make sure minNumRepeats is always at least 2 + { + candidateCRISPR = CRISPRUtil.getActualRepeatLength(candidateCRISPR, searchWindowLength, minSpacerLength); + actualRepeatLength = candidateCRISPR.repeatLength(); + + if ( (actualRepeatLength >= minRepeatLength) && (actualRepeatLength <= maxRepeatLength) ) + { if (CRISPRUtil.hasNonRepeatingSpacers(candidateCRISPR, spacerToSpacerMaxSimilarity)) + { + if (CRISPRUtil.hasSimilarlySizedSpacers(candidateCRISPR, spacerToSpacerLengthDiff, spacerToRepeatLengthDiff)) + { + candidateCRISPR = CRISPRUtil.checkFlank("left", candidateCRISPR, minSpacerLength, 30, spacerToSpacerMaxSimilarity, .70); + candidateCRISPR = CRISPRUtil.checkFlank("right", candidateCRISPR, minSpacerLength, 30, spacerToSpacerMaxSimilarity, .70); + + candidateCRISPR = CRISPRUtil.trim(candidateCRISPR, minRepeatLength); + + CRISPRVector.addElement(candidateCRISPR); + repeatsFound = true; + + //we may skip current CRISPR (assuming CRISPRs are not interleaved) + j = candidateCRISPR.end() + 1; + } + + } + } + } + } + + long repeatSearchEnd = System.currentTimeMillis(); + System.out.println("Time to search for repeats: " + (repeatSearchEnd - repeatSearchStart) + " ms"); + System.out.println(CRISPRVector.size() + " possible CRISPR(s) found" + "\n"); + + + // ********************** Display CRISPR elements ********************** // + // ********************************************************************* // + try + { + + FileOutputStream outputFileStream; + PrintStream out; + + if (screenDisplay == 1) + out = System.out; + else + { + if ( outputFileName.equals("") ) + outputFileName = "a.out"; + + System.out.println("Writing results in file '" + outputFileName + "'"); + System.out.println(""); + + File outputFile = new File(outputFileName); + if ( readNum == 1 && outputFile.exists() ) + { + boolean success = outputFile.delete(); + if (!success) + throw new IllegalArgumentException("Error: Could not delete file '" + outputFile + "'"); + } + + outputFileStream = new FileOutputStream(outputFile, true); + out = new PrintStream(outputFileStream); + } + + out.print("Sequence '" + sequence.getName() + "' (" + sequence.length() + " bp)\n"); + out.print("\n"); + + if (repeatsFound) + { + int repeatLength, numRepeats, numSpacers; + CRISPR currCRISPR; + + String repeat, spacer, prevSpacer; + repeat = spacer = prevSpacer = ""; + + //add 1 to each position, to offset programming languagues that begin at 0 rather than 1 + for (int k = 0; k < CRISPRVector.size(); k++) + { + currCRISPR = (CRISPR)CRISPRVector.elementAt(k); + out.print("CRISPR " + (k + 1) + " Range: " + (currCRISPR.start() + 1) + " - " + (currCRISPR.end() + 1) + "\n"); + out.print(currCRISPR.toString()); + out.print("Repeats: " + currCRISPR.numRepeats() + "\t" + "Average Length: " + currCRISPR.averageRepeatLength() + "\t\t"); + out.print("Average Length: " + currCRISPR.averageSpacerLength() + "\n\n"); + out.print("\n\n"); + } + //out.print("Time to find repeats: " + (repeatSearchEnd - repeatSearchStart) + " ms\n\n"); + } + + out.print("\n"); + + if (!repeatsFound) + out.print("No CRISPR elements were found.\n\n"); + + if (screenDisplay == 0) + out.close(); + + } + catch (Exception e) { System.err.println ("--Error writing to file-- \n"); } + + return true; + } +} diff --git a/CRISPRUtil.java b/CRISPRUtil.java new file mode 100755 index 0000000..a9e7e6d --- /dev/null +++ b/CRISPRUtil.java @@ -0,0 +1,500 @@ +import java.util.*; + +public class CRISPRUtil +{ + //identified repeats may represent only a subset of a larger repeat. this method extends these + //repeats as long as they continue to match within some range. assumes there are at least two repeats + public static CRISPR getActualRepeatLength(CRISPR candidateCRISPR, int searchWindowLength, int minSpacerLength) + { + int numRepeats = candidateCRISPR.numRepeats(); + int firstRepeatStartIndex = candidateCRISPR.repeatAt(0); + int lastRepeatStartIndex = candidateCRISPR.repeatAt(numRepeats-1); + + int shortestRepeatSpacing = candidateCRISPR.repeatAt(1) - candidateCRISPR.repeatAt(0); + for (int i = 0; i < candidateCRISPR.numRepeats() - 1; i++) + { + int currRepeatIndex = candidateCRISPR.repeatAt(i); + int nextRepeatIndex = candidateCRISPR.repeatAt(i + 1); + int currRepeatSpacing = nextRepeatIndex - currRepeatIndex; + if (currRepeatSpacing < shortestRepeatSpacing) + shortestRepeatSpacing = currRepeatSpacing; + } + + int sequenceLength = DNASequence.seq.length(); + + int rightExtensionLength = searchWindowLength; + int maxRightExtensionLength = shortestRepeatSpacing - minSpacerLength; + + + int currRepeatStartIndex; + String currRepeat; + int charCountA, charCountC, charCountT, charCountG; + charCountA = charCountC = charCountT = charCountG = 0; + double threshold; + boolean done = false; + + threshold = .75; + + //(from the right side) extend the length of the repeat to the right as long as the last base of all repeats are at least threshold + while (!done && (rightExtensionLength <= maxRightExtensionLength) && (lastRepeatStartIndex + rightExtensionLength < sequenceLength)) + { + for (int k = 0; k < candidateCRISPR.numRepeats(); k++ ) + { + currRepeatStartIndex = candidateCRISPR.repeatAt(k); + currRepeat = DNASequence.seq.substring(currRepeatStartIndex, currRepeatStartIndex + rightExtensionLength); + char lastChar = currRepeat.charAt(currRepeat.length() - 1); + + if (lastChar == 'A') charCountA++; + if (lastChar == 'C') charCountC++; + if (lastChar == 'T') charCountT++; + if (lastChar == 'G') charCountG++; + } + + double percentA = (double)charCountA/candidateCRISPR.numRepeats(); + double percentC = (double)charCountC/candidateCRISPR.numRepeats(); + double percentT = (double)charCountT/candidateCRISPR.numRepeats(); + double percentG = (double)charCountG/candidateCRISPR.numRepeats(); + + if ( (percentA >= threshold) || (percentC >= threshold) || (percentT >= threshold) || (percentG >= threshold) ) + { + rightExtensionLength++; + charCountA = charCountC = charCountT = charCountG = 0; + } + else + { + done = true; + } + } + rightExtensionLength--; + + + int leftExtensionLength = 0; + charCountA = charCountC = charCountT = charCountG = 0; + done = false; + + int maxLeftExtensionLength = shortestRepeatSpacing - minSpacerLength - rightExtensionLength; + + //(from the left side) extends the length of the repeat to the left as long as the first base of all repeats is at least threshold + while (!done && (leftExtensionLength <= maxLeftExtensionLength) && (firstRepeatStartIndex - leftExtensionLength >= 0) ) + { + for (int k = 0; k < candidateCRISPR.numRepeats(); k++ ) + { + currRepeatStartIndex = candidateCRISPR.repeatAt(k); + char firstChar = DNASequence.seq.charAt(currRepeatStartIndex - leftExtensionLength); + + if (firstChar == 'A') charCountA++; + if (firstChar == 'C') charCountC++; + if (firstChar == 'T') charCountT++; + if (firstChar == 'G') charCountG++; + } + + double percentA = (double)charCountA/candidateCRISPR.numRepeats(); + double percentC = (double)charCountC/candidateCRISPR.numRepeats(); + double percentT = (double)charCountT/candidateCRISPR.numRepeats(); + double percentG = (double)charCountG/candidateCRISPR.numRepeats(); + + if ( (percentA >= threshold) || (percentC >= threshold) || (percentT >= threshold) || (percentG >= threshold) ) + { + leftExtensionLength++; + charCountA = charCountC = charCountT = charCountG = 0; + } + else + { + done = true; + } + } + leftExtensionLength--; + + // Ok to suppress warnings since we know that we are casting integers + @SuppressWarnings("unchecked") + Vector newPositions = (Vector)(candidateCRISPR.repeats()).clone(); + + for (int m = 0; m < newPositions.size(); m++) + { + int newValue = candidateCRISPR.repeatAt(m) - leftExtensionLength; + newPositions.setElementAt(new Integer(newValue), m); + } + + int actualPatternLength = rightExtensionLength + leftExtensionLength; + + + return new CRISPR(newPositions, actualPatternLength); + + } + + + public static CRISPR trim(CRISPR candidateCRISPR, int minRepeatLength) + { + int numRepeats = candidateCRISPR.numRepeats(); + int left = candidateCRISPR.start(); + int right = candidateCRISPR.end(); + + String currRepeat; + int charCountA, charCountC, charCountT, charCountG; + charCountA = charCountC = charCountT = charCountG = 0; + boolean done = false; + + //trim from right + while (!done && (candidateCRISPR.repeatLength() > minRepeatLength) ) + { + for (int k = 0; k < candidateCRISPR.numRepeats(); k++ ) + { + currRepeat = candidateCRISPR.repeatStringAt(k); + char lastChar = currRepeat.charAt(currRepeat.length() - 1); + + if (lastChar == 'A') charCountA++; + if (lastChar == 'C') charCountC++; + if (lastChar == 'T') charCountT++; + if (lastChar == 'G') charCountG++; + } + + double percentA = (double)charCountA/candidateCRISPR.numRepeats(); + double percentC = (double)charCountC/candidateCRISPR.numRepeats(); + double percentT = (double)charCountT/candidateCRISPR.numRepeats(); + double percentG = (double)charCountG/candidateCRISPR.numRepeats(); + + if ( (percentA < .75) && (percentC < .75) && (percentT < .75) && (percentG < .75) ) + { + candidateCRISPR.setRepeatLength(candidateCRISPR.repeatLength() - 1); + charCountA = charCountC = charCountT = charCountG = 0; + } + else + { + done = true; + } + } + + + + charCountA = charCountC = charCountT = charCountG = 0; + done = false; + + //trim from left + while (!done && (candidateCRISPR.repeatLength() > minRepeatLength) ) + { + for (int k = 0; k < candidateCRISPR.numRepeats(); k++ ) + { + currRepeat = candidateCRISPR.repeatStringAt(k); + char firstChar = currRepeat.charAt(0); + + if (firstChar == 'A') charCountA++; + if (firstChar == 'C') charCountC++; + if (firstChar == 'T') charCountT++; + if (firstChar == 'G') charCountG++; + } + + double percentA = (double)charCountA/candidateCRISPR.numRepeats(); + double percentC = (double)charCountC/candidateCRISPR.numRepeats(); + double percentT = (double)charCountT/candidateCRISPR.numRepeats(); + double percentG = (double)charCountG/candidateCRISPR.numRepeats(); + + if ( (percentA < .75) && (percentC < .75) && (percentT < .75) && (percentG < .75) ) + { + for (int m = 0; m < candidateCRISPR.numRepeats(); m++ ) + { + int newValue = candidateCRISPR.repeatAt(m) + 1; + candidateCRISPR.setRepeatAt(newValue, m); + } + candidateCRISPR.setRepeatLength(candidateCRISPR.repeatLength() - 1); + charCountA = charCountC = charCountT = charCountG = 0; + } + else + { + done = true; + } + } + + return candidateCRISPR; + } + + + public static boolean hasSimilarlySizedSpacers(CRISPR candidateCRISPR, int spacerToSpacerLengthOffset, int spacerToRepeatLengthOffset) + { + int initialSpacerLength = candidateCRISPR.spacerStringAt(0).length(); + int repeatLength = candidateCRISPR.repeatLength(); + + for (int i = 0 ; i < candidateCRISPR.numSpacers(); i++) + { + int currSpacerLength = candidateCRISPR.spacerStringAt(i).length(); + + //checks that each spacer is of similar size to other spacers + if ( Math.abs(currSpacerLength - initialSpacerLength) > spacerToSpacerLengthOffset ) + { + return false; + } + + //checks that each spacer is of similar size to the repeats + if ( Math.abs(currSpacerLength - repeatLength) > spacerToRepeatLengthOffset) + { + return false; + } + + } + return true; + } + + + //checks first five spacers + public static boolean hasNonRepeatingSpacers(CRISPR candidateCRISPR, double maxSimilarity) + { + //assumes at least two elements + String firstRepeat = candidateCRISPR.repeatStringAt(0); + String firstSpacer = candidateCRISPR.spacerStringAt(0); + + if (candidateCRISPR.numRepeats() >= 3) + { + int i = 0; + while ( (i < candidateCRISPR.numSpacers() - 1) ) + { + if (i == 4) //only check first 5 spacers + return true; + + String currSpacer = candidateCRISPR.spacerStringAt(i); + String nextSpacer = candidateCRISPR.spacerStringAt(i + 1); + String currRepeat = candidateCRISPR.repeatStringAt(i); + + //spacers should be different + if ( DNASequence.getSimilarity(currSpacer, nextSpacer) > maxSimilarity ) + return false; + + //repeats should also be different from spacers, otherwise may be tandem repeat + if ( DNASequence.getSimilarity(currRepeat, currSpacer) > maxSimilarity ) + return false; + + i++; + } + + //checks last repeat/spacer + if ( DNASequence.getSimilarity(candidateCRISPR.repeatStringAt(i), candidateCRISPR.spacerStringAt(i)) > maxSimilarity ) + return false; + + return true; + } + + //we check that the spacer is different from the repeat + else if (candidateCRISPR.numRepeats() == 2) + { + if (firstSpacer.equals("")) + return false; + else + return ( DNASequence.getSimilarity(firstSpacer, firstRepeat) < maxSimilarity ); + } + + else + { + return false; + } + + } + + + public static CRISPR checkFlank(String side, CRISPR candidateCRISPR, int minSpacerLength, int scanRange, double spacerToSpacerMaxSimilarity, double confidence) + { + boolean moreToSearch = true; + + while (moreToSearch) + { + int result = scan(side, candidateCRISPR, minSpacerLength, scanRange, confidence); + if (result > 0) //if another repeat found on flank + { + if (side.equals("left")) + candidateCRISPR.insertRepeatAt(result, 0); + else if (side.equals("right")) + candidateCRISPR.addRepeat(result); + } + else + moreToSearch = false; + } + + return candidateCRISPR; + } + + /* + scan to the right and left of the first and last repeat to see if there is a region + that is similar to the repeats. necessary in case we missed a repeat because of + inexact matches or a result of one of the filters + */ + private static int scan(String side, CRISPR candidateCRISPR, int minSpacerLength, int scanRange, double confidence) + { + int repeatSpacing1, repeatSpacing2, avgRepeatSpacing; + int firstRepeatIndex, lastRepeatIndex, candidateRepeatIndex; + String repeatString, candidateRepeatString, newCandidateRepeatString; + + int repeatLength = candidateCRISPR.repeatLength(); + int numRepeats = candidateCRISPR.numRepeats(); + int sequenceLength = DNASequence.seq.length(); + + firstRepeatIndex = candidateCRISPR.repeatAt(0); + lastRepeatIndex = candidateCRISPR.repeatAt(numRepeats-1); + + if (side.equals("left")) + { + repeatString = candidateCRISPR.repeatStringAt(0); + repeatSpacing1 = candidateCRISPR.repeatSpacing(0, 1); + if (numRepeats >= 3) + { + repeatSpacing2 = candidateCRISPR.repeatSpacing(1, 2); + avgRepeatSpacing = (repeatSpacing1 + repeatSpacing2)/2; + } + else + avgRepeatSpacing = repeatSpacing1; + + candidateRepeatIndex = firstRepeatIndex - avgRepeatSpacing; + } + + else //if (side.equals("right")) + { + repeatString = candidateCRISPR.repeatStringAt(numRepeats-1); + repeatSpacing1 = candidateCRISPR.repeatSpacing(numRepeats-2, numRepeats-1); + if (numRepeats >= 3) + { + repeatSpacing2 = candidateCRISPR.repeatSpacing(numRepeats-3, numRepeats-2); + avgRepeatSpacing = (repeatSpacing1 + repeatSpacing2)/2; + } + else + avgRepeatSpacing = repeatSpacing1; + + candidateRepeatIndex = lastRepeatIndex + avgRepeatSpacing; + } + + int begin = candidateRepeatIndex - scanRange; + int end = candidateRepeatIndex + scanRange; + + /******************** range checks ********************/ + //check that we do not search too far within an existing repeat when scanning right and left + int scanLeftMaxEnd = firstRepeatIndex - repeatLength - minSpacerLength; + int scanRightMinBegin = lastRepeatIndex + repeatLength + minSpacerLength; + + if (side.equals("left")) + { + if (end > scanLeftMaxEnd) + end = scanLeftMaxEnd; + } + + if (side.equals("right")) + { + if (begin < scanRightMinBegin) + begin = scanRightMinBegin; + } + + //out of bounds check for scanning left + if ( (begin) < 0) + return 0; + + //out of bounds check for scanning right + if ( (begin + repeatLength) > sequenceLength) + return 0; + if ( (end + repeatLength) > sequenceLength) + end = sequenceLength - repeatLength; + + if ( begin >= end) + return 0; + /******************** end range checks ********************/ + + int[] array = new int[end - begin + 1]; + + int index = 0; + for (int i = begin; i <= end; i++) + { + candidateRepeatString = DNASequence.seq.substring(i, i + repeatLength); + array[index] = DNASequence.getHammingDistance(repeatString, candidateRepeatString); + index++; + } + + //min(array) returns the index of the smallest value in array in this case, it refers to + //the candidate string theat is closest to the repeatString. uses hamming distance as levenshteinDistance is not useful for this particular task + int newCandidateRepeatIndex = begin + min(array); + newCandidateRepeatString = DNASequence.seq.substring(newCandidateRepeatIndex, newCandidateRepeatIndex + repeatLength); + + boolean match = patternMatches(repeatString, newCandidateRepeatString, confidence); + + if (match) + return newCandidateRepeatIndex; + else + return 0; + + } + + public static CRISPR scanRight(CRISPR candidateCRISPR, String pattern, int minSpacerLength, int scanRange, SearchUtil searchUtil) + { + int numRepeats = candidateCRISPR.numRepeats(); + int patternLength = pattern.length(); + int sequenceLength = DNASequence.seq.length(); + + int lastRepeatIndex = candidateCRISPR.repeatAt(numRepeats-1); + int secondToLastRepeatIndex = candidateCRISPR.repeatAt(numRepeats-2); + int repeatSpacing = lastRepeatIndex - secondToLastRepeatIndex; + + int candidateRepeatIndex, beginSearch, endSearch, position; + String text = ""; + + boolean moreToSearch = true; + while (moreToSearch) + { + candidateRepeatIndex = lastRepeatIndex + repeatSpacing; + beginSearch = candidateRepeatIndex - scanRange; + endSearch = candidateRepeatIndex + patternLength + scanRange; + + /******************** range checks ********************/ + //check that we do not search too far within an existing repeat when scanning right + int scanRightMinBegin = lastRepeatIndex + patternLength + minSpacerLength; + + if (beginSearch < scanRightMinBegin) + beginSearch = scanRightMinBegin; + + //System.out.print("beginSearch " + beginSearch + " " + "endSearch" + endSearch); + if (beginSearch > sequenceLength - 1) + return candidateCRISPR; + if (endSearch > sequenceLength) + endSearch = sequenceLength; + + if ( beginSearch >= endSearch) + return candidateCRISPR; + /******************** end range checks ********************/ + + text = DNASequence.seq.substring(beginSearch, endSearch); + position = searchUtil.boyer_mooreSearch(text, pattern); + + if (position >= 0) + { + candidateCRISPR.addRepeat(beginSearch + position); + secondToLastRepeatIndex = lastRepeatIndex; + lastRepeatIndex = beginSearch + position; + repeatSpacing = lastRepeatIndex - secondToLastRepeatIndex; + if (repeatSpacing < (minSpacerLength + patternLength)) + moreToSearch = false; + } + else + moreToSearch = false; + } + + return candidateCRISPR; + } + + + private static boolean patternMatches(String pattern1, String pattern2, double confidence) + { + double patternSimilarity = DNASequence.getSimilarity(pattern1, pattern2); + if (patternSimilarity >= confidence) + return true; + else + return false; + } + + private static int min (int[] array) + { + int min = array[0]; + int minIndex = 0; + + for (int i = 0; i < array.length; i++) + { + if (array[i] < min) + { + min = array[i]; + minIndex = i; + } + } + return minIndex; + } +} + diff --git a/DNASequence.java b/DNASequence.java new file mode 100755 index 0000000..6b80541 --- /dev/null +++ b/DNASequence.java @@ -0,0 +1,367 @@ +import java.io.*; +import java.util.*; +import java.util.regex.*; + +public class DNASequence +{ + public static String seq; + private String name; + private String desc; + private String errorLog = ""; + private Pattern notDnaRe = Pattern.compile("([^ACGT])"); + + public DNASequence(String sequence) + { + seq = sequence.toUpperCase(); + name = ""; + desc = ""; + } + + public DNASequence(String sequence, String _name) + { + seq = sequence.toUpperCase(); + name = _name; + desc = ""; + } + + public DNASequence(String sequence, String _name, String _desc) + { + seq = sequence.toUpperCase(); + name = _name; + desc = _desc; + } + + public int length() + { + return seq.length(); + } + + public String getName() + { + return name; + } + + public String getDesc() + { + return desc; + } + + public String toString() + { + return seq; + } + + public boolean isDNASequence() + { + int length = seq.length(); + + if (length == 0) + { + errorLog = "Not a valid DNA sequence. Sequence contains no characters."; + return false; + } + + Matcher m = notDnaRe.matcher(seq); + boolean isNotDNA = m.find(); + if ( isNotDNA ) + { + errorLog = "Not a valid DNA sequence. Invalid character '" + m.group() + "' found at position " + m.start() + ". "; + return false; + } + else + { + return true; + } + } + + /* + //method has not been tested + //may contain alphabetic characters other than acgt + public boolean isSequence() + { + int i = 0; + int length = seq.length(); + + if (length == 0) + { errorLog = "Not a valid sequence. Sequence contains no characters."; + return false; + } + + while (i < length) + { + if (Character.isLetter(seq.charAt(i))) + { System.out.println(seq.charAt(i) + " " + Character.isLetter(seq.charAt(i))); + i++; + } + else + { errorLog = "Not a valid sequence. Error found at position " + i + " scanning a non-alphabetic character " + seq.charAt(i); + return false; + } + } + return true; + } + */ + + public String getErrorLog() + { return errorLog; + } + + + public String substring(int beginIndex, int endIndex) + { + return seq.substring(beginIndex, endIndex); + } + + public void toUpperCase() + { + seq = seq.toUpperCase(); + } + + public static int getHammingDistance(String seq1, String seq2) + { + int length = seq1.length(); + int hammingDistance = 0; + + if (seq1.length() != seq2.length()) + { + length = min(seq1.length(), seq2.length()); + hammingDistance = Math.abs(seq1.length() - seq2.length()); + } + + for (int i =0; i < length; i++) + { + if ( seq1.charAt(i) != seq2.charAt(i)) + { + hammingDistance++; + } + } + + return hammingDistance; + } + + + //***************************** + // Compute Levenshtein distance Michael Gilleland, Merriam Park Software www.merriampark.com/ld.htm + //***************************** + public static int getLevenshteinDistance1 (String s, String t) + { + int d[][]; // matrix + int n; // length of s + int m; // length of t + int i; // iterates through s + int j; // iterates through t + char s_i; // ith character of s + char t_j; // jth character of t + int cost; // cost + + // Step 1 + n = s.length (); + m = t.length (); + if (n == 0) { + return m; + } + if (m == 0) { + return n; + } + d = new int[n+1][m+1]; + + // Step 2 + for (i = 0; i <= n; i++) { + d[i][0] = i; + } + + for (j = 0; j <= m; j++) { + d[0][j] = j; + } + + // Step 3 + for (i = 1; i <= n; i++) { + + s_i = s.charAt (i - 1); + + // Step 4 + for (j = 1; j <= m; j++) { + + t_j = t.charAt (j - 1); + + // Step 5 + if (s_i == t_j) { + cost = 0; + } + else { + cost = 1; + } + + // Step 6 + d[i][j] = Minimum (d[i-1][j]+1, d[i][j-1]+1, d[i-1][j-1] + cost); + + } + + } + + // Step 7 + return d[n][m]; + + } + + + //Chas Emerick http://www.merriampark.com/ldjava.htm + public static int getLevenshteinDistance2 (String s, String t) { + if (s == null || t == null) + { + throw new IllegalArgumentException("Strings must not be null"); + } + + /* + The difference between this impl. and the previous is that, rather + than creating and retaining a matrix of size s.length()+1 by t.length()+1, + we maintain two single-dimensional arrays of length s.length()+1. The first, d, + is the 'current working' distance array that maintains the newest distance cost + counts as we iterate through the characters of String s. Each time we increment + the index of String t we are comparing, d is copied to p, the second int[]. Doing so + allows us to retain the previous cost counts as required by the algorithm (taking + the minimum of the cost count to the left, up one, and diagonally up and to the left + of the current cost count being calculated). (Note that the arrays aren't really + copied anymore, just switched...this is clearly much better than cloning an array + or doing a System.arraycopy() each time through the outer loop.) + + Effectively, the difference between the two implementations is this one does not + cause an out of memory condition when calculating the LD over two very large strings. + */ + + int n = s.length(); // length of s + int m = t.length(); // length of t + + if (n == 0) { + return m; + } else if (m == 0) { + return n; + } + + int p[] = new int[n+1]; //'previous' cost array, horizontally + int d[] = new int[n+1]; // cost array, horizontally + int _d[]; //placeholder to assist in swapping p and d + + // indexes into strings s and t + int i; // iterates through s + int j; // iterates through t + + char t_j; // jth character of t + + int cost; // cost + + for (i = 0; i<=n; i++) { + p[i] = i; + } + + for (j = 1; j<=m; j++) { + t_j = t.charAt(j-1); + d[0] = j; + + for (i=1; i<=n; i++) { + cost = s.charAt(i-1)==t_j ? 0 : 1; + // minimum of cell to the left+1, to the top+1, diagonally left and up +cost + d[i] = Math.min(Math.min(d[i-1]+1, p[i]+1), p[i-1]+cost); + } + + // copy current distance counts to 'previous row' distance counts + _d = p; + p = d; + d = _d; + } + + // our last action in the above loop was to switch d and p, so p now + // actually has the most recent cost counts + return p[n]; + } + + public static double getSimilarity(String s1, String s2) + { int maxLength = max(s1.length(), s2.length()); + double similarity = 1.0 - (double)getLevenshteinDistance1(s1, s2)/maxLength; + return similarity; + } + + private static boolean patternMatches(String pattern1, String pattern2, double confidence) + { double patternSimilarity = getSimilarity(pattern1, pattern2); + if (patternSimilarity >= confidence) + return true; + else + return false; + } + + + private static int min (int[] array) + { int min = array[0]; + int minIndex = 0; + + for (int i = 0; i < array.length; i++) + { if (array[i] < min) + { min = array[i]; + minIndex = i; + } + } + return minIndex; + } + + private static int max (int[] array) + { int max = array[0]; + int maxIndex = 0; + + for (int i = 0; i < array.length; i++) + { if (array[i] > max) + { max = array[i]; + maxIndex = i; + } + } + return maxIndex; + } + + private static int min(int n1, int n2) + { if (n1 < n2) + return n1; + else + return n2; + } + + private static int max(int n1, int n2) + { if (n1 < n2) + return n2; + else + return n1; + } + + private static int Minimum (int a, int b, int c) + { + int mi; + + mi = a; + if (b < mi) + mi = b; + + if (c < mi) + mi = c; + + return mi; + + } + + + +} + + + + + + + + + + + + + + + + + diff --git a/FASTAReader.java b/FASTAReader.java new file mode 100755 index 0000000..b92b9dd --- /dev/null +++ b/FASTAReader.java @@ -0,0 +1,160 @@ +import java.io.*; +import java.util.*; + +public class FASTAReader +{ + private String fileName; + private String sequence; + private String name; + private String desc; + private String newHeader; + private int readNum; + private BufferedReader inputFile; + + public FASTAReader(String f) + { + fileName = f; + readNum = 0; + sequence = ""; + name = ""; + desc = ""; + newHeader = ""; + } + + //does not check that all characters are ACGT + public boolean isFASTA() + { + try + { + BufferedReader testFile = new BufferedReader(new FileReader(fileName)); + + String firstLine = testFile.readLine(); + while (firstLine.length() == 0) + { + firstLine = testFile.readLine(); + } + + if (firstLine == null) + { + testFile.close(); + return false; + } + if (firstLine.charAt(0) != '>') + { + testFile.close(); + return false; + } + + String secondLine = testFile.readLine(); + if (secondLine == null) + { + testFile.close(); + return false; + } + + testFile.close(); + } catch (Exception e) { e.printStackTrace(); } + + return true; + } + + public boolean read() + { + try + { + if ( readNum == 0 ) + inputFile = new BufferedReader(new FileReader(fileName)); + + readNum++; + sequence = ""; + + StringBuffer sb = new StringBuffer(); + + while( true ) + { + String currLine = inputFile.readLine(); + + // Process informative line + if ( currLine == null ) + { + if ( sb.toString().length() > 0 ) + { + // Last sequence + sequence = sb.toString(); + return true; + } + else + { + // No more sequences + inputFile.close(); + return false; + } + } + else + { + // Remove leading and trailing spaces + currLine = currLine.trim(); + + if ( currLine.length() == 0 ) + { + // Skip empty lines + continue; + } + else if ( currLine.charAt(0) == '>' ) + { + // Prepare new sequence + newHeader = currLine; + // Finish previous sequence + if ( sb.toString().length() > 0 ) + { + sequence = sb.toString(); + return true; + } + } + else + { + // Continuation of a sequence + sb.append(currLine); + if ( newHeader.length() > 0 ) + { + String[] array = newHeader.substring(1, newHeader.length()).split("\\s", 2); + if ( array.length >= 1 ) + name = array[0]; + if ( array.length >= 2 ) + desc = array[1]; + newHeader = ""; + } + } + } + } + } catch (Exception e) { e.printStackTrace(); } + + return true; + } + + public String getSequence() + { + return sequence; + } + + public String getHeader() + { + return name + ' ' + desc; + } + + public String getName() + { + return name; + } + + public String getDesc() + { + return desc; + } + + public int getNum() + { + return readNum; + } + +} diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..94a9ed0 --- /dev/null +++ b/LICENSE @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. diff --git a/README b/README new file mode 100644 index 0000000..c9852bd --- /dev/null +++ b/README @@ -0,0 +1,65 @@ +MinCED - Mining CRISPRs in Environmental Datasets + + +MinCED is a program to find Clustered Regularly Interspaced Short Palindromic +Repeats (CRISPRs) in full genomes or environmental datasets such as metagenomes, +in which sequence size can be anywhere from 100 to 800 bp. MinCED runs from the +command-line and was derived from CRT (http://www.room220.com/crt/): + Charles Bland et al., CRISPR Recognition Tool (CRT): a tool for automatic + detection of clustered regularly interspaced palindromic repeats, BMC + Bioinformatics 8, no. 1 (2007): 209. + + +INSTALLATION + +You need to install these dependencies first: + * Java (http://www.java.com/en/download/) + +In the MinCED folder, compile the source files: + * javac *.java + +To run MinCED, in the same folder: + * java minced [options] inputFile [outputFile] + +The help page can be obtained by typing: + * java minced --help + +You can get the MinCED version this way: + * java minced --version + + +EXAMPLES + +Finding CRISPRs in the E. coli genome: + java minced ecoli.fna + +To find repeats in short sequences, we need to decrease the minimum number of +repeats to find. For example, in 100 bp reads, we could not possibly find more +than 2 repeats: + java minced -minNR 2 metagenome.fna + +The output can be large, so save it in a file: + java minced -minNR 2 metagenome.fna metagenome.crisprs + +COPYRIGHT AND LICENSE + +Copyright 2011 Florent ANGLY + +MinCED is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. +MinCED is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. +You should have received a copy of the GNU General Public License +along with MinCED. If not, see . + + +BUGS + +All complex software has bugs lurking in it, and this program is no exception. +If you find a bug please email me at so that I can +make MinCED better. + diff --git a/SearchUtil.java b/SearchUtil.java new file mode 100755 index 0000000..201e8ff --- /dev/null +++ b/SearchUtil.java @@ -0,0 +1,168 @@ +class SearchUtil +{ + // Boyer Moore algorithm copyright by Michael Lecuyer 1998. Slight modification below. + + private static final int MAXCHAR = 256; // Maximum chars in character set. + private byte pat[]; // Byte representation of pattern + private int patLen; + private int partial; // Bytes of a partial match found at the end of a text buffer + + private int skip[]; // Internal BM table + private int d[]; // Internal BM table + + SearchUtil() + { + skip = new int[MAXCHAR]; + d = null; + } + + public int boyer_mooreSearch(String text, String pattern) + { + byte[] byteText = text.getBytes(); + compile(pattern); + + return search(byteText, 0, text.length()); + } + + public int linearSsearch(String text, String pattern) + { + int textLength = text.length(); + int patternLength = pattern.length(); + + for(int i = 0; i <= textLength - patternLength; i++) + { String subPattern = text.substring(i, i + patternLength); + if (pattern.equals(subPattern)) + { return i; + } + } + + return -1; + } + + public void compile(String pattern) + { + pat = pattern.getBytes(); + patLen = pat.length; + + int j, k, m, t, t1, q, q1; + int f[] = new int[patLen]; + d = new int[patLen]; + + m = patLen; + for (k = 0; k < MAXCHAR; k++) + skip[k] = m; + + for (k = 1; k <= m; k++) + { + d[k-1] = (m << 1) - k; + skip[pat[k-1]] = m - k; + } + + t = m + 1; + for (j = m; j > 0; j--) + { + f[j-1] = t; + while (t <= m && pat[j-1] != pat[t-1]) + { + d[t-1] = (d[t-1] < m - j) ? d[t-1] : m - j; + t = f[t-1]; + } + t--; + } + q = t; + t = m + 1 - q; + q1 = 1; + t1 = 0; + + for (j = 1; j <= t; j++) + { + f[j-1] = t1; + while (t1 >= 1 && pat[j-1] != pat[t1-1]) + t1 = f[t1-1]; + t1++; + } + + while (q < m) + { + for (k = q1; k <= q; k++) + d[k-1] = (d[k-1] < m + q - k) ? d[k-1] : m + q - k; + q1 = q + 1; + q = q + t - f[t-1]; + t = f[t-1]; + } + } + + + /** + * Search for the compiled pattern in the given text. + * A side effect of the search is the notion of a partial + * match at the end of the searched buffer. + * This partial match is helpful in searching text files when + * the entire file doesn't fit into memory. + * + * @param text Buffer containing the text + * @param start Start position for search + * @param length Length of text in the buffer to be searched. + * + * @return position in buffer where the pattern was found. + * @see patialMatch + */ + public int search(byte text[], int start, int length) + { + int textLen = length + start; + partial = -1; // assume no partial match + + if (d == null) + return -1; // no pattern compiled, nothing matches. + + int m = patLen; + if (m == 0) + return 0; + + int k, j = 0; + int max = 0; // used in calculation of partial match. Max distand we jumped. + + for (k = start + m - 1; k < textLen;) + { + for (j = m - 1; j >= 0 && text[k] == pat[j]; j--) + k--; + + if (j == -1) + return k + 1; + + int z = skip[text[k]]; + max = (z > d[j]) ? z : d[j]; + k += max; + } + + if (k >= textLen && j > 0) // if we're near end of buffer -- + { + partial = k - max - 1; + + return -1; // not a real match + } + + return -1; // No match + } + + + /** + * Returns the position at the end of the text buffer where a partial match was found. + *

+ * In many case where a full text search of a large amount of data + * precludes access to the entire file or stream the search algorithm + * will note where the final partial match occurs. + * After an entire buffer has been searched for full matches calling + * this method will reveal if a potential match appeared at the end. + * This information can be used to patch together the partial match + * with the next buffer of data to determine if a real match occurred. + * + * @return -1 the number of bytes that formed a partial match, -1 if no + * partial match + */ + public int partialMatch() + { + return partial; + } + +} diff --git a/minced.java b/minced.java new file mode 100755 index 0000000..6848474 --- /dev/null +++ b/minced.java @@ -0,0 +1,249 @@ +import java.io.*; + +public class minced +{ + public static void main(String[] args) + { + //default values + int screenDisplay = 1; + int minNumRepeats = 3; + int minRepeatLength = 19; + int maxRepeatLength = 38; + int minSpacerLength = 19; + int maxSpacerLength = 48; + int searchWindowLength = 8; + + int numOptions = 0; + + if (args.length == 0) + { + printUsage(); + //System.out.println("No arguments specified."); + //System.out.println("Try 'minced --help' for more information."); + System.exit(1); + } + + if (args[0].equals("--help")) + { + printUsage(); + System.exit(1); + } + + if (args[0].equals("--version")) + { + printVersion(); + System.exit(1); + } + + int i = 0; + while (args[i].charAt(0) == '-') + { + try + { + if (args[i].endsWith("minNR")) + { + i++; + if (i >= args.length) + { + System.out.println("Missing option value for " + args[i - 1] + "."); + System.out.println("Try 'minced --help' for more information."); + System.exit(1); + } + minNumRepeats = Integer.parseInt(args[i]); + numOptions++; + } + else if (args[i].endsWith("minRL")) + { + i++; + if (i >= args.length) + { + System.out.println("Missing option value for " + args[i - 1] + "."); + System.out.println("Try 'minced --help' for more information."); + System.exit(1); + } + minRepeatLength = Integer.parseInt(args[i]); + numOptions++; + } + else if (args[i].endsWith("maxRL")) + { + i++; + if (i >= args.length) + { + System.out.println("Missing option value for " + args[i - 1] + "."); + System.out.println("Try 'minced --help' for more information."); + System.exit(1); + } + maxRepeatLength = Integer.parseInt(args[i]); + numOptions++; + } + else if (args[i].endsWith("minSL")) + { + i++; + if (i >= args.length) + { + System.out.println("Missing option value for " + args[i - 1] + "."); + System.out.println("Try 'minced --help' for more information."); + System.exit(1); + } + minSpacerLength = Integer.parseInt(args[i]); + numOptions++; + } + else if (args[i].endsWith("maxSL")) + { + i++; + if (i >= args.length) + { + System.out.println("Missing option value for " + args[i - 1] + "."); + System.out.println("Try 'minced --help' for more information."); + System.exit(1); + } + maxSpacerLength = Integer.parseInt(args[i]); + numOptions++; + } + else if (args[i].endsWith("searchWL")) + { + i++; + if (i >= args.length) + { + System.out.println("Missing option value for " + args[i - 1] + "."); + System.out.println("Try 'minced --help' for more information."); + System.exit(1); + } + searchWindowLength = Integer.parseInt(args[i]); + numOptions++; + if ( (searchWindowLength < 6) || (searchWindowLength > 9) ) + { + searchWindowLength = 8; + System.out.println("--Reseting search window length to " + searchWindowLength + "--"); + } + } + /* + else if (args[i].endsWith("screen")) + { + i++; + if (i >= args.length) + { + System.out.println("Missing option value for " + args[i - 1] + "."); + System.out.println("Try 'minced --help' for more information."); + System.exit(1); + } + screenDisplay = Integer.parseInt(args[i]); + numOptions++; + if ( screenDisplay != 1 ) + screenDisplay = 0; + } + */ + else + { + System.out.println("Invalid option: " + args[i]); + System.out.println("Try 'minced --help' for more information."); + System.exit(1); + } + i++; //--------// + if (i >= args.length) + { + System.out.println("No input file specified."); + System.out.println("Try 'minced --help' for more information."); + System.exit(1); + } + } //end try + catch (NumberFormatException e) // exception will be caught if user does not specify an integer after each option + { + System.out.println("Invalid argument type. Please, specify an option followed by an integer. For example: -minNR 3"); + System.out.println("Try 'minced --help' for more information."); + System.exit(1); + } + } // end while + + + // Last options should be an input file and optional output file + String inputFileName = ""; + String outputFileName = ""; + boolean outputFileSpecified = false; + int numArgsRemaining = args.length - (2 * numOptions); + + if (numArgsRemaining == 1) + inputFileName = args[i]; + else if (numArgsRemaining == 2) + { + inputFileName = args[i]; + outputFileSpecified = true; + outputFileName = args[i + 1]; + screenDisplay = 0; + } + else + { + System.out.println("Improper usage."); + System.out.println("Try 'minced --help' for more information."); + System.exit(1); + } + + + File inputFile = new File(inputFileName); + if (!inputFile.exists()) + { + System.out.println("Input file " + inputFile.getPath() + " does not exist."); + System.exit(1); + } + + if (inputFile.isDirectory()) + { + System.out.println("You have entered a directory name. An input file name is required: " + inputFile.getPath()); + System.exit(1); + } + + + + File outputFile; + if (outputFileSpecified) + { + outputFile = new File(outputFileName); + + if (outputFile.isDirectory()) + { + System.out.println("You have entered an existing directory name. An output file name is required: " + outputFile.getAbsolutePath()); + System.exit(1); + } + + if (!outputFile.getAbsoluteFile().getParentFile().isDirectory()) + { + System.out.println("You did not enter a valid file output path: " + outputFile.getAbsolutePath()); + System.exit(1); + } + } + + + CRISPRFinder client = new CRISPRFinder(inputFileName, outputFileName, screenDisplay, minNumRepeats, minRepeatLength, maxRepeatLength, minSpacerLength, maxSpacerLength, searchWindowLength); + client.goCRISPRFinder(); + + } + + public static void printUsage() + { + System.out.println("MinCED, a program to find CRISPRs in shotgun DNA sequences or full genomes"); + System.out.println(); + System.out.println("Usage: java minced [options] inputMultiFastaFile [outputFile]"); + System.out.println(); + System.out.println("Options: -searchWL Length of search window used to discover CRISPRs (range: 6-9). Default: 8"); + System.out.println(" -minNR Minimum number of repeats a CRISPR must contain. Default: 3"); + System.out.println(" -minRL Minimum length of the CRISPR repeats. Default: 19"); + System.out.println(" -maxRL Maximum length of the CRISPR repeats. Default: 38"); + System.out.println(" -minSL Minimum length of the CRISPR spacers. Default: 19"); + System.out.println(" -maxSL Maximum length of the CRISPR spacers. Default: 48"); + //System.out.println(" -screen Print results to the screen, instead of a file; (range: 0-1); default 0"); + System.out.println(); + System.out.println("Examples: java minced ecoli.fna"); + System.out.println(" java minced -minNR 2 metagenome.fna"); + System.out.println(" java minced -minNR 2 metagenome.fna metagenome.crisprs"); + System.out.println(); + } + + public static void printVersion() + { + System.out.println("MinCED - Mining CRISPRs in Environmental Datasets (version 0.1)"); + System.out.println("Copyright 2011 Florent ANGLY "); + System.out.println("Distributed under the GNU General Public License version 3"); + System.out.println(); + } + +} diff --git a/t/1crisper.fa b/t/1crisper.fa new file mode 100644 index 0000000..e69de29 diff --git a/t/Aquifex_aeolicus_VF5.fna b/t/Aquifex_aeolicus_VF5.fna new file mode 100644 index 0000000..ad17d56 --- /dev/null +++ b/t/Aquifex_aeolicus_VF5.fna @@ -0,0 +1,22164 @@ +>gi|15282445|ref|NC_000918.1| Aquifex aeolicus VF5, complete genome +ATGGCGAGAGAGGTGCCTATAGAGAAATTGAGAAACATAGGTATAGTTGCTCACATTGACGCGGGTAAAA +CTACGACTACCGAGAGAATTCTCTATTACACGGGTAAGACTTACAAGATAGGTGAAGTTCACGAAGGTGC +TGCAACGATGGACTGGATGCCCCAGGAAAAGGAAAGAGGTATAACCATAACCGTTGCAACGACCGCATGT +TATTGGACGAGAAACGGGGAGAGGTATCAAATAAACATAATTGACACACCCGGACACGTTGACTTCTCCG +TTGAAGTTGTACGTTCCATGAAAGTTCTCGACGGAATAGTTTTCATATTCTCCGCGGTTGAAGGTGTGCA +ACCTCAGTCCGAAGCAAACTGGAGATGGGCGGACAGGTTCCAAGTTCCGAGGATAGCCTTCATAAACAAG +ATGGACCGTCTGGGTGCGGATTTTTACAGAGTGTTTAAGGAAATAGAAGAAAAGCTAACCATAAAGCCCG +TTGCCATTCAAATACCCCTGGGAGCGGAGGACCAGTTTGAAGGTGTTATAGATCTAATGGAAATGAAGGC +AATAAGGTGGCTCGAAGAAACCCTCGGAGCTAAATACGAAGTAGTAGACATTCCTCCAGAATACCAGGAA +AAGGCTCAAGAATGGCGCGAAAAGATGATAGAAACCATCGTAGAAACCGACGACGAGTTAATGGAAAAGT +ACTTAGAAGGACAGGAAATATCTATAGATGAACTAAGAAAAGCTTTAAGAAAGGCAACAATAGAGAGAAA +GCTCGTTCCCGTTCTTTGCGGTTCTGCATTCAAGAACAAAGGTGTTCAACCCCTTCTTGACGCAGTTATA +GATTACCTGCCTTCTCCTATAGACCTTCCTCCCGTTAAGGGGACAAATCCCAAGACCGGGGAAGAAGAGG +TCAGACACCCCTCTGACGACGAACCCTTCTGCGCTTACGCCTTTAAGGTTATGTCCGACCCGTATGCCGG +ACAACTTACCTACATCAGAGTGTTCTCAGGAACGCTAAAAGCGGGTTCTTACGTCTACAACGCAACCAAG +GACGAAAAGCAAAGGGCTGGAAGACTTCTTCTCATGCACGCGAACTCCAGAGAGGAAATACAGCAGGTTT +CCGCGGGTGAAATTTGTGCAGTTGTAGGACTAGACGCCGCAACGGGTGATACTCTCTGTGATGAAAAGCA +CCCCATAATCCTTGAAAAGCTTGAATTCCCTGACCCCGTTATATCTATGGCTATAGAGCCAAAGACCAAG +AAGGACCAAGAAAAACTCTCACAAGTTCTCAACAAGTTCATGAAAGAGGATCCAACCTTCAGGGCAACAA +CCGATCCCGAAACTGGTCAGATACTCATACACGGAATGGGTGAGCTCCACCTCGAAATAATGGTTGACAG +AATGAAGAGGGAATACGGAATTGAAGTGAACGTCGGTAAACCGCAGGTTGCTTACAAGGAAACCATCAGG +AAAAAGGCAATTGGTGAGGGTAAGTTCATCAAGCAAACTGGTGGTAGAGGGCAGTACGGTCACGCGATAA +TCGAAATCGAACCCCTCCCCAGAGGTGCGGGATTTGAATTCATAGACGACATTCACGGAGGAGTTATCCC +CAAAGAATTCATACCCTCCGTTGAGAAGGGTGTAAAGGAAGCTATGCAAAACGGAATTCTCGCAGGATAC +CCCGTTGTTGACGTTAGAGTTAGACTCTTTGACGGTTCTTACCACGAAGTTGACTCTTCGGACATAGCAT +TCCAGGTTGCGGGTTCCTTGGCATTCAAAGATGCAGCCAAAAAGGCAGATCCCGTTCTTCTGGAACCCAT +AATGGAAGTTGAAGTGGAAACTCCCGAAAAGTACGTGGGTGACGTTATAGGTGACCTTAACTCCAGAAGA +GGAAAGATTATGGGAATGGAAAACAAGGGAGTTATAACAGTCATAAAGGCTCACGTTCCCCTCGCAGAGA +TGTTCGGATACGCTACGACGCTCAGGAGCTTGACACAAGGTAGGGGAACCTTTATAATGAAATTTTCCCA +CTACGACGAAGTTCCGCAGCAAATTGCGGAAAAGATTATCGGCGAAAGAATGGCCGGTAAGAGCTCTTAA +TTAGGAGGTAATAGATATGGCAAAGGAGAAATTTGAAAGGACAAAAGAACACGTAAACGTGGGAACAATA +GGACACGTTGACCACGGCAAAAGCACTCTCACTTCCGCTATAACATGCGTTCTCGCTGCAGGCCTCGTTG +AAGGCGGTAAAGCTAAGTGCTTCAAATACGAAGAAATCGACAAGGCTCCAGAAGAAAAAGAAAGAGGAAT +CACGATAAACATCACCCACGTTGAGTACGAAACCGCCAAACGCCACTACGCTCACGTTGACTGCCCCGGT +CACGCTGACTACATCAAGAATATGATCACCGGCGCAGCTCAAATGGACGGTGCAATACTCGTTGTTTCCG +CAGCAGACGGCCCCATGCCCCAAACAAGAGAACACGTGCTTCTCGCAAGACAGGTTAACGTTCCTTACAT +AGTCGTTTTCATGAACAAGTGTGATATGGTTGACGACGAAGAACTTTTAGAACTCGTTGAGCTCGAAGTT +AGAGAACTTCTCTCCAAGTACGAGTATCCCGGAGACGAAGTTCCCGTTATCAGAGGATCGGCACTTGGAG +CACTTCAAGAACTCGAACAAAACTCTCCCGGCAAGTGGGTTGAGTCCATAAAAGAGCTTCTCAACGCGAT +GGACGAGTACATACCGACACCACAAAGGGAAGTGGACAAGCCCTTCCTTATGCCAATAGAAGACGTGTTT +AGCATATCCGGAAGAGGAACGGTTGTAACCGGAAGAGTAGAGAGAGGAGTTCTGAGGCCCGGAGACGAAG +TAGAGATAGTAGGACTCAGGGAAGAGCCCCTCAAGACAGTTGCAACGTCTATAGAGATGTTCAGGAAGGT +GCTTGACGAGGCACTGCCCGGAGACAACATAGGAGTGCTGCTGAGGGGAGTAGGAAAGGACGACGTAGAA +AGGGGACAGGTATTGGCGCAACCTGGGAGTGTAAAGGCTCACAAGAGGTTCAGGGCACAGGTATATGTAC +TTAGCAAGGAGGAAGGAGGAAGACACACTCCGTTCTTTGTGAACTACAGACCGCAGTTTTACTTCAGGAC +GGCTGACGTGACGGGAACTGTAGTGAAGCTTCCAGAAGGAGTGGAAATGGTAATGCCCGGGGACAACGTA +GAGCTTGAAGTAGAGCTCATAGCACCCGTGGCGTTGGAAGAAGGGCTCAGGTTTGCGATAAGGGAAGGTG +GTAGAACAGTAGGTGCAGGTGTCGTTACTAAAATACTGGATTGAGGGGATAAATCATGGAACAGGAAAAA +ATAAGGATAAAACTAAGAGCATACGACCACAGGTTGCTGGATCAATCGGTTAAACAGATCATAGAAACCG +TAAAGAGAACGGGCGGGGTTGTGAAGGGACCGATTCCCCTTCCCACGCGTAAGCGTAAGTGGTGCGTTCT +CCGTTCTCCCCACAAATTTGACCAGTCAAGAGAACACTTCGAGATAAGAGAGTTTTCAAGGATTCTGGAC +ATTATAAGGTTCACTCCCCAAACAATAGAAGCACTCATGGAAATCAGCCTTCCCGCGGGTGTTGACGTAG +AAGTGAAGATGAGAGGTTAGTGAGATGCCGCTGGGATTAATCGGTGAAAAGGTTGGAATGACAAGGGTCC +TTCTCAAGGACGGAACAGCCATACCCGTTACCGTTATAAAGTTCCCTGTAAACTACGTGGTTCAAGTGAA +GTCTCAAAATACAAAAGACGGGTATAACGCCCTGCAGATAGGCGCTTATGAAGCTAAGGAAAAGCACTTA +ACAAAGCCCCTGATTGGACACTTCAAGAAACACGGAGTTCCCCTTCTCAGGAGGCTGTGGGAATTCAGGG +TGGATAACCCCGAAGAGTTCCAGTCAGGTCAACAGCTCAAAGTGGAAGACGTTTTCAAACCCGGGGACCT +TGTGGACGTCTGGGGAATTTCTAAAGGTAGGGGCTTTGCAGGTGCTATGAAGAGATGGGACTTTGCGGGA +TTTCCCAAGTCCCACGGTCACAGGTATCACAGGGCAGTAGGTGCAATAGGACAGAGAACTGACCCAGGTA +GGGTATGGAAAGGCAAAAGGATGCCCGGTCACTACGGTGCAAAACCTGTGAGAGTTCAGGGACTTTTTGT +GGTTGACGTACTTCCGGAAGAAAACGCCATACTCGTGAAAGGTTCCGTCCCCGGACACAACAAGGGTATC +GTTGTAGTTGAGCAGTCCACTATAGCTTACAGAAAGAGCCAGAAGTTAAAGCAAAAGAGGTACCAGTTCA +TAATTGAAAACCTTGCAAAAGAAGAAAGCCAAGAGGTGGCTGAATCATGAAGATAGGAGATGTTGAAGTA +AGGGATGATGTTTTTAACGTCAAGGTAAAGAAACACGTTCTCTGGGAAGTAGTAAAGTGGCAACTTGCAA +AAAGGAGGCAAGGGACACACTCCACAAAGACGAGAGGTGAAGTAGCTTATTCAGGAAGGAAGATACTCCC +CCAAAAGGGAACAGGTAACGCAAGACACGGGGAAAGAGGTGTTAACATCTTCGTCGGCGGTGGTGTAGCG +CACGGTCCAAAGCCGAGAGACTACGAATACCCTCTCCCTAAAAGGGTGAGGAAACTCGGACTTAAGATGG +CTTTATCTGACAAGGCAAGAAATAACGCAATTATTTTCGTTGATAACATAGACCTCGGGAAAAAACCAAA +AACCAAAAAAGCTATTGAATTTTTAAAGAACTTGGGTGTAGAAAAGGAAAAGGTTTTAGTTGTAATTCCC +GAAAAGGCGGATGTCCTTTACAAGTCCTTCAGAAATCTCCCCAACGTGAGAGTTCTCCTTCCAGAAGGTT +TAAACGTTTACGACGTTCTCTGGGCGAATAAACTCGTCATTCAAAAGGACTGTCTTGACAGGATATACAA +GAAGGTGGAGGCGTAAGCCATGAGCCAGAGAAAGCCCTGGGAAATAATCATAAGGCCTATAATCACCGAA +AAGAGCAACAGACTCATGGAGGATTACAACAAGTACACCTTTGAGGTTGCCCTTGACGCTTCCAAACCTG +AGATAAAGTACGCGGTTGAGAAACTCTTCAACGTAAAGGTAAAGAAGGTAAACACGATGATAGTAAAACC +AAAGAAGAAGAGGGTGTGGAACAAGTTCAGACAGTACGGAACTACGAAGAAGTGGAAAAAGGCTATAGTT +ACCCTAGAGAAGGGGCATAAAATAGATATCCTTGAGTTTGCTCAAAAGTGAGGTAAGTAGTTATGGGTGT +TAGAAAGTTAAAACCTGTAACAAACGGGACGAGGCACGCAGTTCTTTACGACTTTGAAGAAATAGAAAAA +TTAGTAAGAAAAGGAAAAGAATGGGTTCTACTAAAGAAAAACCAAGTAGAACCTGAAAAATCCCTCCTCA +AGTGGTGGCACAGGGCAAAAGGACGCTCTAGACAGAGGGGGAACATCACCGCAAGACACAGGGGAGGAGG +ACACAAGAAACTTTACAGAATTATAGACTTCAAGAGGGACAAGAGCTTAGTTCCCGCGAAGGTAGTTTCA +ATAGAATATGACCCCTTCAGGAGTGCCAGGATTTGTCTCCTTCACTACGCTGACGGTGAGAAGAGGTACA +TAATCTGGCCAGAAGGGTTGAAGGTGGGAGACACCGTAATGTCCATAAGCTGGGAAGACGCGGAAGCCGG +AAAGCCCCTTCCCGAGATAAAACCCGGAAACGCAATGCCCCTCAAGTACATACCCGAAGGTACCATAGTC +CATAACATAGAGTTCATTCCTGGAAAGGGAGGACAGATAGCAAGGGCTGCCGGAACATGGGCTCAGGTTC +TCGGGCGTTCCACGAGGAAGGGATACGTCCTCGTCAGAATGCCTTCTGGTGAAGTTCGTATGATACACGA +GAGGTGTATGGCTACGGTCGGAAGAGTTGGACTTGCGGAACACGAACTCGTTAAACTTGGAAAGGCGGGA +AGAGCAAGGTGGCTCGGATGGAGACCTCACACGAGGGGAACCGCTATGAACCCAGTTGACCACCCGCACG +GTGGTGGTGAAGGAAGAACGAGAGGTAAACACCCCGAATCCCCTTGGGGATGGAAGACCAAAGGATACAA +GACTAGAAGAGGTAAGAAGTACTCCGATCAATTTATCGTAACGAGAAGGGACGGAAGACCCTTATAAAGG +AGGAGAGTAAATGGGATTTAAAGGAGCTTGGAACAAGAGAAACAGACTCATCGAGAACCCTGAGGAGTAT +TACAGACTCTACAAAAAACTCCAGAGGGCTTACAAGCTCGTGAGAGAAGCCATAAAGAGGTACGGTTCCT +TTGAACTCCTGAAAGGAAAGAACACACTTCCCGAACTTGAGGCACTTCTTGAGGAGAGGAAACTCGTCCT +TGAAAATCTCAAAAAGCAATTGAAAGAAGCCCACAAAGGAAAGCCCAAGATAGAGGCGGAAGGAGATGAA +AAACTAAAAGAACTTATCAGAGAAGTCAATAAAGCTCAAGCTGAAGTAAGGGCTCTCGAGATAATAGTGA +ACAGGGTAAGGAAGTATGAAGAACTCTACGCCCAGTACAAACAGATGACGGAAAAGAAGGCGTACGTAGA +TCCCAAACTCTGGGTCAGAATAAGGAAGATGAACGAAACGGGAGAGAGAAAGGTTGTGAGAACCTACTCC +AGAGCTACGACGATAATACCCGAGTTCGTAGGACACACAATAGCGGTTCACAACGGGAAAACTTTTGTTC +CCGTTTACATCACACAAGACATGGTGGGACATAAACTCGGAGAGTTCGCTCCCACGAGAACCTTCAAGGG +TCACCCCGAAAAGACCGCAAAGGTAGTTAAGAAGAAGTGAGGTGTGAAAGATGGGACAGTTAAGGATTAA +GGACAAATCTCAGAGGGACGGATATAAACCTAATCAATCAATAGCCATACTCAGGTACGCCCACATATTC +TCCCCTAAAGGCAAGACTTGTTCTCAGGGAAATTCAGGGAAAAGACGTGGGAGACGCCCTTTACCTGCTT +CGCGGTTATTCCCAAAAAAGCGGCAAGGATAGCGGAAAAGGTTTTAAAGAGTGTTATAGCAAACGCAGAG +CAAAAGGGCCTTGACCTTGACAGACTCTACATTAAAAAGGCTGTGGCGGACGACGGCCCTATACTGAAGA +AGTGGATTCCCAGGGCTCACGGAAGGGCTACTATGGTGAGGAAGAGGCTTTCCCATATTACAATAGTTTT +AGAGGAAAAACCTGAAGGCAAGGAGGAAGAATAAGGATGGGTCAGAAAACGCACCCGATAGGCTTTAGAC +TCGGAGTAATAAAGGAATGGCCTTCCAAGTGGTACGCTCCGAAAAAGGAATACTCTAAACTCCTTCACGA +GGACCTCAAGATAAAGAACTACATAAAGGAGAGGTACAAAGTTGCCGGAGTTTCAAAGGTAGAAATAGAG +AGAATCGTTGATAAGGTAAGGGTCAAGATCCACACCGCGAGACCTGCGATAGTTATCGGAAGAAGGGGGC +AGGAAGTAGAGAACTTAAAGAAAACCTTGGAAAAGATGCTTCCCGGAAAGGAGATAACCATTTCCGTGGT +TGAAGTCAGAGTTCCCGAACTGGACGCCCAGCTCGTGGCTCAGGACATAGCAACCCAGATAGAGAGAAGG +GTATCCCACAGAAGGGCAATGAAGAGGGCGATAGACAACGCTCTTAAGGCTGGAGCTAAAGGAGTAAAGG +TACAGGTCAAGGGAAGGATAGGAGGAGCGGAACTCGCGAGAAAAGAGTGGTTCCTCGTAGGAAGAATGCC +CCTTCAAACTCTAAGGGCTGACATAGATTACGGATTTGCAACCGCTTACACCAAGTATGGTATCCTCAGC +GTTAAGGTCTGGATTTACAAGGGTGATGTTCTGAACGGGCGGTAAAGAAGAAATCCTCAAGAAAATTGAA +GAAGAAATTATGCAGGCTGCAAAGGAGGGCTAAGAGATGTATCTCCAGCCGAAAAAGGTAAGATGGAGAA +AGCAAAGGAGAGGAACACTTAAAGGAAAGGCTTTCAGGGGAAATAAACTGGCCTTTGGCGAGTACGGGAT +ACAGGCCCTCGACAGGGCGTGGATTACCCAGCAACAAATAGAAGCCGTGAGAGTGGCACTCGTGAGGAGT +CTCAAAAAAGGTGCAAAGGTCTGGATAAGGATATTCCCTGACAAACCCTACACCAAAAAGCCCAACGAAG +TGAGAATGGGTGGTGGAAAAGGTGACCCTGAAGGCTTTGTAGCGGTGGTAAAGCCCGGTAGGATACTCTT +TGAATTTACGGGGGTTCCAGAGGAAGTTGCTCAGGAAGCCTTCACGATAGCGGCCTCAAAGCTCCCCATA +CCAGTCAGACTCGTTAAGTACGGCGAGTTCACCTTCAAGTACTGAGGTGGTGAAAGATGTGGGAAAGAGA +GAGAAAGAAGTTCTTAGAAGATATTAGAAAAAAGAGCTTACAGGAACTTGAAAAGCTATTGGACGAACTT +AAACTTGAATTGACAAGACTCAGGTTTAAAAAACAAGTTCAGGGTCTTGAGAACCCCATGGAAATGAGGA +AGGTAAAGAGGAACATAGCTAGAGTTTTGACGGTTATAAGGGAAAAACAGTTGAGAGGTGAAGGGTAATG +ACTGAGCAAAAACAGCAGAAGAAGTGGCACGAGAAGAGAAAACACCTCGTTGGAGTTGTAGTTAGCGATA +AGATGGATAAAACGGTCGTTGTTAAAGTTGACAGAAAAGTTCCCCACCCCATATACGGCAAGCACATCAT +AAAGAGCAAGAAGTACCACGCCCACGACGAACACAACGAGTGCAGGGTGGGAGATATAGTCATGATAAGA +GAAACAAGGCCCCTCTCCAAAACAAAGAGGTGGGTTGTAGTAAAGATACTCCAGAGGGCCAGAAGACCTG +AGGAAGAAATACAAAAACAACAGGAAGGACAAGAACAGTAATGCTCATCGCCGTTCCCCTTGATGATACA +AACTTTTCCGAAAACTTAAAAAAGGCTAAGGAAAAGGGTGCGGATATTGTAGAACTCCGTGTGGACCAGT +TCTCAGACACTTCCTTAAATTACGTAAAGGAAAAACTGGAAGAAGTACATTCGCAAGGTTTGAAAACGAT +ACTGACTATACGCTCTCCCGAGGAGGGAGGAAGGGAAGTTAAAAACAGGGAAGAGCTCTTTGAAGAACTT +TCTCCCCTCAGCGATTACACGGATATAGAACTCTCTTCCAGAGGGCTTTTGGTAAAACTTTACAATATAA +CGAAAGAAGCGGGAAAAAAGTTGATAATCTCCTACCACAACTTTGAGCTCACACCCCCTAACTGGATAAT +AAGGGAAGTTTTAAGGGAGGGATACAGGTACGGAGGAATACCGAAGATAGCGGTAAAGGCAAACTCCTAC +GAAGATGTTGCAAGGCTTTTATGTATTTCCAGACAGGTTGAGGGAGAAAAGATATTAATTTCCATGGGTG +ATTACGGAAAGATTTCAAGGCTCGCGGGATACGTTTTTGGGTCCGTAATAACCTACTGCTCCTTAGAAAA +GGCTTTCGCTCCTGGTCAAATTCCTTTAGAAGAGATGGTTGAGCTCAGAAAGAAGTTCTACAGGCTTTAA +ATTAAACTCCTCTGAAGTAATTCTCCTAACTCCGGAAATCTTTCAATAAAGAAGAAGTAGAACATATTTG +CGGAAAAGTGGGCAAAGGCTGGAGCGATTACGGAGTCCGTTTTTCTGTAGAGCCAGCCGAAAAACAGGGA +AGGGAAGAAGGTAAGAAGTGCGTTTAAGTTTGCCCAATATGCAAGATGTGCACTGGTGGACATCAGAGAA +ACAGTAAAGTTTGAAAACTTCTGCATCAGAAATCCCCTGAAAAAGATTTCTTCTGCCAAGGCAATACCGA +GCTGGTTTAAAACCAAGGCGTAGCACTGGGCACTTAGAAGGTAGGGAACGCTAAAGGGTAAAAATAGACT +CCCGTAAGTTAGTCCTTTTTTGAAGTTTTTAAAGCCCAGAGATTTTTCGTCCTGAAAGAGGAGCGGAGAA +AGCAGTATAAGCTGAGGAATTATACTCAAGTTGTAAAACCTCTGAAGATAAAGGGAAATAACGAGCAGAG +CGTACAAACCGAGGTGTATCAAAGTATTTCCCTCAAAACAGATATAGCCCTGTCAATGTGTTCCTTCTGA +ATTATCAAGGGCGGTAAGAACCTGAGAACTTTTCCGGCGGTGCAGTTTATGAGAAGTCCCTTTTCAAGAG +CCTTGAGAACGTAATCTTTACACTCTCTTTCAAGTTCAAGACCGAGCATCAATCCTCTTCCCTTTACCTT +TCCTTTGCCGAGTTCCTTCAGTTTTTCTTTGAAGTAATTCCCCACTTCCCTTACGTGAGGCAGGAGTTTT +TCAACTTCATCTACTACCACTGTTCCCGCCCTGCAGGCTAAGGGGTTTCCTCCGAAGGTAGAGCCGTGGG +AGCCGGGAGTAAAGCTCTGGGCCACTTCTTCCCTTGCAAGGATGGCACCTATTGGCACACCTCCTCCGAG +TCCCTTCGCAAGCGCAATTACGTCCGGTTTTAGATTGAAGTGTTGATATGCGTAGAATTCCCCGGTCCTT +CCTATTCCCGTTTGCACTTCGTCTATAATTAAGAGCACATCTTTTTCTTTACAAATTTCCTGGAGTTTAC +TTAGAAAATCCTCACTCGCCTCGTTTACTCCGCCCTCTCCTTGTATAACTTCAATAATTATCCCCGCGGT +TTCCTCGTCTAGGAGTTTGTAAACGCTGTCTATATCGTTCAGCTTTGCGTAAGAAAATCCAGGAACTAGA +GGTTCAAAGCCTTTGTGGAACTTTGGCTGTCCCGTTGCGGAGAGGCTACCGTAGGTTCTCCCGTGGAAAG +AGTTTTCAAAGGATATAAACTTCCACTTGTTCTTTCCTTTATCCCTCCAGTACTTCCTTGCGAGCTTTAT +AGCCGCCTCTACACTTTCCGTTCCGCTGTTTGCGAAAAATACCTTCCCTTCTGTCCAGAAGTGTTTTACA +AGTTTGTGAGCCAGTTCTTCCTGCCACGGGTTTTCGTAAAGATTTGAAACGTGGAGGAGTTTCTCAACCT +GTTCTTTTAGAGCTTCTGTGAGTTTTGGGTAAGCGTGACCGAGGGAGTTGACGCCTATACCGGAGACAAA +GTCAAGATACTCCTTTCCTTCCTCATCGTACAGGTAAACACCTTTTCCCCTTACAAACTTTACGGGCAAC +CTTGCGTAATTGTTCATTAAGTATGTCATGGTCTTCCCATGCTGTAATACTCAAAGCCTAAGTTTCTAAC +CTCTTGAGGATCGTATATATTCCTTCCGTCTATTATTATTGGAAGTTCCATCAATCTTTTTACTCTTTCG +AGGTTTGCCCTCTTGAACTCGTCCCACTCGGTCAGGATTAGCAGAGCTTCTGCTCCCTCAACAGCCTTGT +ACTTGTCATCAAAATACCTGAGATCCTCCCCTTCAATAAATACCCTTTTGAAGTTTTCAGTAGCTTTAGG +GTCGTAAGCCCTTATTTTTGCCCCTTCCCTTAAGAGTCTTTCAACAACTTTGAGCGAGGGAGCTTCCCTT +ATGTCGTCCGTGTTCGGCTTGAAGGAAAGTCCCCAGATCGCAATTGTCTTGCCTTTGAGTATCCAGAGTG +CATCTTTTAACTTTTGAAGTAATCTGTCCACTCTGCTTTCGTTTATACCGAGTGCACCCTTGAGGATTGT +AGCATCTACTCCCAATTCTTCAAGTATCCTTATAAAGGCTTTTGTGTCTTTCGGGAGGCAACTTCCTCCC +CATCCCAAGCCCGCTCTTAGGAATTCTTTACCTATCCTCTTGTCGTAACCCATTCCCTGGGCCACTTCCT +CTACGTTTGCCCCCACCTTTTCACACAGGTCAGAAATCATGTTTATGAAGGATATCTTCGTTGCCAAGAA +TGTATTAGAAGCGTACTTTATTATTTCCGCTGTGGGCGGGTTTGTAATGAGGATGGGAAAGCCTTTATCG +GTTATAGGTTTGTAAATCTCCAGTAATACTTCCTTTGCCCTTTCGCTCTCAACGCCTACTACTATTCTGT +CGGGTTCTAAGAAGTCTTTTACGGCGTGACCCTCCCTTAAAAATTCCGGATTTGAAGCTACGTCAAATTC +CAGTTCTTTGTTTTTCAAGTATAGTCTTACGGTTCTCTTAACCTTTCTTTGCGTCCCTACGGGAACGGTG +GACTTATTTACGAGGAGTTTGTAGCTATCCATATACTTTGCCGTGAACCTTGCAACTTCTTCAACCTGAG +AGAGATCCGCTGAACCGTCCGGGTTAGACGGAGTTCCTACGCATATAAATATCACCTCCGAAAACTCAAT +CCCCTCCTTTATATCCGTGGTAAAGCTAAGTCTTCCTTCATTTATCCCTTCCCTCAGGAGCTCTTCCAGT +CCTGGTTCGTATATGGGGCTCTTTCCCCTTCTTAGGAGTTCTACCTTTTCGGGTATCTTTTCGACTACGA +GTACTTCGTGTCCGAGGTGGGAAAAACAAGCTGCCGTAACTAATCCTACGTATCCGCCGCCTATTACGGA +GAGTTTCATTTAGGTTTTAATTTTAACAGAAAGTATATTAAGGATTTTTTTGTTTTTCTCTGAAAAGTTC +GGAAAAAGCTTTCCCTGAGAGGATATCTTCAGCGGGCGGAGTAATCCTTACCAGGAATTCTACTAAAGTA +TCGCTCTTAAATTTTTCCCTCGTTCTTGTTCTTCTAAACTTAATGGGGTAGCCTTTTTTAAACCTTTCAA +TCCTTGCATTCTTGTATTCCTCATCTATTTTCTCAAGGCTTAAGACGATTTCCTTTTTCATTATTATTCT +AAAAATCTATTCGTAAATACCGTCCTTTTCCAGTTTCATATAAGGGTAGCGGTACTTCTTATATATGTAC +TGAGTAACACCTATCATTGCACTGAAGGTTATGGTGGCACTTCCTCCTACACTTACAAAAGGGAGAGGTA +TCCCGACAACGGGAAACATTCCCATGGTCATCAGCGTGTTTACCGTAAACTGGAACAGGATAAGGGAAAA +GGTTCCGGCTATGAAGAGTTTCTCCGAGAGTCTTTGAGCCATTTCGTGGTACTGAATGAGTCTCAAAAAG +AGCAGTAAAAACAGAGAACATAGTATGAAAGTGCCTATAAATCCGAGTTCTTCGCCTATCACCGCAAATA +TAAAGTCCGTGTGCTTTTCAGGAAGGAAAAATAGGTGAGTTTGAGTCCCACTCAGGAGTCCTTTTCCCGT +TAGCATACCAGAACCTATGGCTATCTTTGACTGTATTAACTGGTATCCGCTTCCGTAGTAATCGCTCATC +GGGTCTATAACTGCGAGAATTCTCTTCTTCTGATAGGGTTTTAAGAAGTACTTCCAAGCAAGGGGTAAAA +ACGCAAGGAATGCCATTCCGGCAAGGATAAAGTACCTTAAAGGTACGCCTCTCACGAAAAGCATGAAAAC +AAGTGGAACGTAGTAAGACACAGTAGTGCCGAGGTCGGGCTGTTTGAGTGTTACCAGAGAGGGTATGGCG +TAAATGAGAAATAATAGAAAAACTTTCCTGTCCTTAATACTCTTTATTGCGGGAAGCAGGTAAGCGCTAA +CGAGTATCAGGGAAAACTTCATGAGTTCCGAAGGCTGGACGTTGAAAAAGCCGAGGTGAAGCCACCTCTT +TGCCCCGTAAACCTCTTTTCCGTAGAGTAAAACCGCCATGAGGAGGAGGAGGTTAAAAAGGTAGATGTAA +AAGGATAAATCCAGCAGGTTTTCAAACTTTTCAAAGGAGAGGAAAATTATCAAAAGCCAGCCAAGGATTA +CGTAAGTAAGGTGCTTATAAAAAAACGGAGAGGTTCCTCCGTCGTAGGTAGCGCTGTAAACGGCAACGAG +ACCAAATCCCTGAATGCATAAAAGGATTAATAAAAGGAAGAAATCAAGCTCTCTTAACTCCTCCAGAAAT +CGCATTAATTACCCTTACCTCGTCTCCTTCTTCCACGTATTCGTCCTCGGATATAACCTCACCGTTCTTA +ACGACTAAAGAGGAAATAGGGGAAAGACCGAGCTTCTTTAAGAGCTCTTTAGCCTTTAACTTCTTTTCGG +GAAATTCGTACTCTTTCCCCCGGTAAAGCACTTTTATGGGCATCTTGAAGTATCCGCCTCCACTTCGTCT +ATTTTATCAAGGAATGCCTCAAAAGGCCCCATGTTCTTCATGGCGACAAAACGAGGTCCTTCAAACTTCA +GCCTTCCGAAGAGCATTGCCTTCATAGGACCGTACTCTTTCCTTCCCATTTCAAGCCACCTTTTTGTGTC +CGCGTACATTAAAAAGTCGTTATCCGTTTTCTCGTCCTTCTTCCATCCTCCGTAAACACAAACCGCCCTT +CCGTTTTCGTTCTTTATGGTGAGCTGAATTTGTTTTTCCGGACCGCAGTCTTTTCTGTAAAGGAAGAGTT +TTCTTTCGGGAACTTCCGTCCAGCTTTCGCTTTTTCCGAGTTTTTCAACGAGTTCTGGTGTGTTGTTCCA +GACTTCGCAAAATTGTTTTGCCCATTCTGCATCCATGAACACAGGCTTTGCAAAGGCTATCGCAGAAACG +AGAACCCCTGCTAAGAGCTTTTTCATATCTTCACCTCCCTTAGAGTTATTTAATTAAATTTTGTCTTTCG +TTTTCCACGAATTCTATAAGTTTTTTGAATGGGAGGGGTGGCGAAAAGTAATAACCCTGAGCCTCATCAC +AGAGGAGTTTTTTTAGTTCCCTTATCTGTTCTTCATTTTCAACACCCTCTGCAAGGGCAAGGGCGTTTAA +ATTGTGCGTAAGTTCAATTATGTTTCTCACAACCTGCCAGGCGTTTACGTTTTCAAGCATCTTATCAATA +AAACTCTTGTCTATCTTTATTTCGTCTACGTCGAACTCAACGAGGTAATGCATGGAGGAGTAACCTGTCC +CGAAATCGTCTATCGCGATCTTTACACCTAATTTCTTTAGTTCACTCAGGATTTCTACTGCTTTTTCAGA +CTTTGCCATTAAAGCCCTTTCCGTTAGTTCCAGAATTACGTTTCTTAATGGAAACTTAAACTTTTCCTCG +AACTCAATTAATTTCTGTATCAACTCTACGCTGTAGAACTGTTCCGCGTTCACGTTTATAGAGAGATAAA +ACTCCCTTTCTTTGACAAAGTCCGAAAGCTCTCTGAAAGCTTTTTCCATGACGATGTAGTTTATTTGTGA +AACCAGTCCGTACTTTTCGGCTACGGGGACAAAGATACTCGGAGGCACTTCTCCGAGTTCAGGGTGATAC +CACCGCACCAAGGCTTCTGCACCGACTGGTCTGAAGTCCTTCAGGCTAACTATAGGTTGATAAACCACTC +CGAATTCTTTCTTTTCTATGCTCTCTTCTAAAAATTCCTTTATCCGTAGTTCCTTTTTGAGCTTCTCTTC +GTACTCTTTTTTGTAGAAGTTGACCGTATTTTTCGCGAAAAGTAATGCCAGCTCCGCCTTCTCTAAAAGT +TCCTTTGGATTTTCTCCGTCTTGAGGATAAGAGGATATTCCCGCTTTTATGTTTAAATCTACGGAGTCTA +CTTTTTCCTTAGAAAGTTTTTCTACTAACTCAACAACTTCTTCTCTTTCCTTGTTTCTAAGAGCTATCCC +GAAAGCCTTTCCAGATAGCCGGGCTGCCGCTCCTTCCTTAACAAGCGTTCTCAAACGGTTTGCTATTTCT +TTAAGTATTTCATCTCCCTTATCGAACCCAAAGAGGAAGTTAATCTCACCAAAGTTTTTTAAATTGAGCA +TGCACACATGGAGGTTATTAGTCTCTTCATCGTGAATGAATCTTTGAAGGAGCATAATAAACAGGTGTCT +GTTAGGAAGTCCCGTGAGTTGATCGAAAAAGGCGAGGTAGTACACCTTTTTCCTTAAAAGAATTTCATTC +GTTACATCGGTGAATAAAATTAGTACTATACATTCTTCATCTTTTTTAAAGCTTATAATGTACAACCTTA +CGTATTTATCCTCACCTTTCTTGGTTTTCAACTTTAAGGTGTATTCCTTGGGTTTTTCTATACACGTTCC +CGCTTCATTGAGAACCTTCTGTGCCCTTTTTCTGTAATGGAAAGGTAAGAATTCGAAGGGAGATTTGTTC +ATAACTTCGTGTCTTGTGTAGCCGAAAAGCTTTAAAGTGTAATCGTTTACGAAGATTATCTTTCCGCCTT +TCAAAAGTAGCAGTCCCGCGGGGAGGTTTTGAGCCAGGGTTTCAAAGAGCTTTTTTTCTTCCTTTAGTTT +TTCCTCGAGTTCTTTGAGGTTCGTTATGTCAACCCAGTATCCGGCAACCCTGTAAAGGTTTCCCTCCTTG +CTTACCACCTTGGCATTGGCGTATATCCAGACGTAAGAGCCGTCCTTTTTCCTTAACCTGTAAACGGTTT +GCACGAAGTTCTTTTCCTTGAGCTCTTCTACGGCTTTCAGAGCTTTTTCCCTGTCCTTGGGGTGTAGATT +TTCAACTCACCAGTCTTTAGATATTTCTTCAGGCTTCCATCCCAGCCACTTTTCAAGACTCGGAGTGACG +TAGAGTATCTTTTGTGGGTAAGGGGGCTCGGCTTCAACGAGGTAGGCTACAAAGGGGTATGAGTCCAGAA +GCGTTTTGTATATAGTGTAAGAAGTGATCTTTTCCGCGATTCTTTCGGAGACTTCCTTTACGAATTTAAG +GAATTCCTCTTCTACTTTACTCAGTTTCCTTCCTTTTTTCAAAGGAAAGTAAAGGTTTACTTTTGCATAA +GTGTTTATCCTGATTTCAAGTACTACTTCATTTCCTTTTGCACTACCTCTGCCGTCCCACTCTATCCTGT +AGCCTTCCGAACCCAGAAATTCCGATACAGCTTTTCCGACTACGGAAATAAATTCATAATGGGTGTTCGC +TCGGGAAGCTTCTTGAAAAATGGTTTTTAAAGTTTCTAACTCTCTTTCTATAATCTTTGAGTACATCCTA +TTTAAAATTTAATTTTAGATTTTTTCAGGAGGTAAAAAAATCATGAAAAATTTGACACCCTTGGAAGAAG +CCCTGAAGATCGTCTTGGAGAACGTAAAACCTCTGGAAAGTGAAAGGGTTTTTATACACGAAGCTCTCGG +AAGGGTTTTAGCGGAAGACGTAGTTTCCGATACGGATAAACCCTTGTTTGACAACTCCGCCATGGACGGG +TATGCGGTGCGCTGGGAGGATATAAAGGAAGTGCCCGCCAAGTTAAAGGTAATAGGTGAGTACGCAGCGG +GAACCGGGGAAAACTTAAAAGTGGAAAAGGGAACCGCGGTAAAGATATTCACGGGAGCTCCAATACCAGA +GGGTGCGGATACGGTGGTACCCGTGGAGTATACGGAAACTCAGGACGGATACGTAATCGTTAAGAAGAGT +TTCAAACAGGGAGCAAACGTAAGGAGAAGGGGCGAAGACGTAAAAAAAGGAGAAGTGGTAATACCTAAAG +GAAAGGAGATAAGACCTTATGAAATGGGAATGCTCGCTTCAGTAAACAGGGCTGTGGTGAGTGTTTACAG +AAAACCGCACGTGGGAATACTCTCCACGGGAGATGAGATACTGGACGTGTGTGAAGAACAAACCAAACCT +TCGCAGATAAGGACTTCTAACAACTACACCGTTTACGGGCAGGTTTTACAGGCGGGAGGTATTCCTCACA +ACCTCGGCATAGCCCCCGACGAGCCTCAAAAACTGAAGGAAATTATGAGGAGTATACACAAGTACGACAT +CTTCATAACCACGGGCGGTGTGTCCATGGGCGAAAAAGACTACGTCCAGTACCTCGTGGAAGACTTAGGT +ATAGACGTAAAGTTTCACAAACTCAGGATTAAACCGGCCAAACCCGTCCTTTTCGGCGTTTACGGAGAGA +ATAAACTCTTCTTCGGACTTCCCGGAAATCCCGTCTCAGCAGCCGTAGCCTTTGACCTTCTCGTTTACCC +TGCCATAAAAGCCATGCAAGGGCACAGGGAAGTGTTTAAACAAAAGGTAACCGCTATCCTTGAGGGCGAT +TACAGGAGGAAGAACGCGGACAGGAGGGAGTTCGCAAGGTGCAGGGTGTGGTTTGAGAACGGAAGGTACC +ACTGCGAACCTTATCCAAAACAGGACAGCCATATGCTCACCTCCCTTGTTAACTCAAACGCCTACATGGT +AGTTTACGAAGGCGTGAACGAGCTGAAGAAGGGGCAGGAGGTGGAAGTTATACTTTTCTAAGGGAGGGCA +AAAGATGAATAAAAACGTATTTCTCGTTTTAGCCATTTTAGTTTTCTTCGGTGTCTTAATAACCTCCCCT +TTCGAAGGGAACGTCAACAAAGGCATAGCAATTCTCCTGCTCGCCGCAATTCTTTGGATTACCGAGGCTC +TTCCCCTTCCCGTTACGGCACTCCTCATTCCCGTGAGCGGTGTTCTCTTAGGAGTTTTTGACGTAAAGAC +CGCACTTTCCTACTTTGCTCACCCGCTTATATTCCTCTTTTTCGGAGGATTCGTTCTCGCTGTAGCCCTT +TCAAAGTACCAGATAGACGAGTACATAGCCCATAAAATAGTCTCCGTAGCTCAAGGAAAGTTCCTGCCTT +CAGTTTTCCTGCTAATGCTTGCAACTTCCCTTATTTCCATGTGGATCAGTAACACCTCAACTACAGCGAT +GATGCTTCCCCTCGCCCTCGGGATACTGGCGGGAGTAAGGGAAACGGAAAGGGAAAAGGTATTTCCCTTC +GTACTTCTTGGTATAGCCTACTCTGCGAGCGTAGGAGGGATAGGAACGCTTGTGGGAAGTCCACCAAACG +GTATAGCGGCGGGGATACTCGGACTGTCTTTCCCCGACTGGCTCAAGTTCGGAATTCCCGTATTTTTAAT +ACTCTTTCCCTTGCTCTTCGCAATACTGTTTTTAGTCTTCAGACCTACCTCTGACCTGAAAGTTGAAAGA +GTTCAGGAAATTAAGTTTGAGTTCACTCCGCAAAGAGTTCTGGTTCTTCTCATCTTCCTCTTTACCGCCC +TTGCGTGGATTTTCAGCAAGAAAATAGCCCCTATTTTTGAAGTGAAAAAGTACTTTGACACGGTTGTGGC +ACTCCTCGCGGTAGTAGCACTATTTATTTTCAGGCTCCTTGACTGGAGGGACGTAAAAGAGGGTGTATCC +TGGGGAACGCTTCTTCTCTTTGGTGGTGGTATAGCCCTGAGTGGTATTATGAAGAAAACAGGAACAGCCA +AGTTTATTTCTCAGGAACTCGTAGACGTCCTGCACGGACTCCCTACATTTCTGTTTCTCCTCACTATAGT +TCTTTTCGTTATATTCCTCACGGAACTAATGAGTAACACAGCAACAACCGCACTTATCGCCCCTATACTC +TTTTCAACGGCTCAGATGATAGGTAAACCCCCCGAAATGCTCGTGATTCCCGCCGCGGTTGCCGCATCTT +GTGCTTTCATGCTTCCCGTTGCAACACCTCCGAACGCAATCGTTTACGGAACGGGTTACATAAAACAATC +CCAAATGATGAGGGTAGGTCTTATCTTGAATATCGTATTTAGTATTGTTTTAGCCGCTTTCTTTACAGTG +TACGTGGGAGGTTGAGAAAATGGGACTGAAGGAAAAACTTATCAGAAAAGGTAAATACATATGGGAACTG +CCAAAAGAAACGATAGAAGGTCAAAGAGTACCCGTAATTCTTTACCTGAGCGACGCCCTCTTTGAACTCC +TTGAAGAAGATGCCCTAAGACAGGCTGCAAACGCCGCAACTCTTCCGGGAGTGGAAAAGGCTATTTACGT +GATGCCGGACGTTCACGTGGGGTACGGCTTTCCCGTGGGAGGGGTAATGGCCACGAATACGGAAACAGGT +ATAATAAGTCCCGGTTCAATCGGTTATGACATCAACTGCGGTGTCCGTCTAATAGCGACAAACTTAAAAG +CGGTGGATGTAGCACCCAGAATAAAGGAAATAATGAACAACATGCTAAAAAACGTTCCCGCAGGTGTTGG +CTCCACGAGCGAGATAAAACTCTCTAAATCCCAGATGAAGGAAGTGCTCGTAAAGGGAGCAGGCTGGGCG +GTTGAACACGGCTTTGGTTTTCCCGAGGATCTTCAGCACATAGAGGGCTTCGGTGCTCTTCCGAACGCAG +ATCCCGAAAAGGCTTCTCACGAGGCCTACGAGAGGGGTTCGGACGAACTCGGAACTGTCGGAAGCGGGAA +CCACTTTGTGGAAGTTCAGGCGGTAGAACAGATATACGAGCCTGAAATTGCGGAAAAGCTCGGTATATGG +GAAGGACAGGTAATGGTTATGGTTCACTCTGGTTCGAGGGGTTTCGGTCATCAGGTCTGCACGGATTACC +TCAGGGTAGCCTTGAAAGTGAGGGATAAGTACAAAATCAAACTCCCTGATCCCCAACTTGCGTGTATGCC +CTTCAACTCTCCCGAAGGACAGGCTTACTTCAAGGCTATGAACGCCGCGGCAAATTACGCCTTTGCAAAC +AGACAGATCCTCGGTTTTAAAGCTGCGAACACGGTCAGGAAAACTCTCGGCATTTCGTGGGAAGAGTTCG +GCTACAGGCTCATATACGATCACGCTCACAATATAGGAAAGGTGGAAAAACACGAAGTAGACGGAAAAAA +GGTCGAAGTAATAGTTCACAGGAAAGGGGCAACGAGAGCTTTTCCTCCTTACAACCCCGAAGTTCCCCCC +GCTTACAGGGAAGTAGGACAACCCGTGATAATTCCGGGAGACATGGGAAGGGCTTCCTTCCTGCTCGTGG +GACAGACCAACTCTATGAAGATGTCCTTCGGGACTGCGTGCCACGGCGCGGGAAGAGTTATGTCAAGAAG +ACAGGCAAAGAAGTACGTAAAAGAAGTAGGACTTGAAAAGGTAATAGGTAACCTCGTAGTAGTTGCAAGG +GGTAAAGGAACAATAATGGAAGAAATCCCCCAGGCGTACAAGGACGTGACGGAAGTCGTAAGGGTTATAG +ATGAACTGGGAATAGCCAAAGCGGTGGCTAGGTTAAAACCCCTCGGAACGCTAAAGGGTTAAGCTTTCCC +TGAACACTTCCACCCTGTTCTTTCCCTTTCTCTTCGCCTCGTACAGTGCCTGATCCGCTTCCTTTATCAA +CTCTTCCAAGCTCTCGTGCCCTCTGTAAGTGCTCACCCCTATACTTACTGTTACTCTTAGTTTTTCACCG +TTTGGCAATTCTATGGGCGTTTGTTCTATCATACGCCTCAGTTGTTCCGCTTTCTTTACAGCTCCGTTCA +AGTTTGTGTTTGAAAGCATAACTATAAACTCCTCTCCTCCGAAGCGTGCCACGAGATCCGCTCCTCTCAC +GTTCCTTTTCAAGATTTCTGAAATCTTTTTGAGAACGAGGTCTCCGACGTCGTGTCCGTAGGTGTCGTTT +ATTTTCTTAAAGTTATCTATGTCAATCATAAGAATTGAGAAGTTGTATCCGTACCGTTTAGCCTTCGCCA +GTTCCTTTTCAGCCATCTCGGTGAAAACCCTTCTGTTGTATAGACCCGTGAGAGGGTCCGTCAAAGCCAT +TCTCTCGTAAAGTGTCTTTTCCTTTGAAGTTTCAATAAGTATCTTCTTTAAAGTTTCAATCATCTTTATT +ACCGCTACTTTAAGTTCGTAAATTTCGCTATCTTTGTCTTTGCTCCTCATAGCGTTTTCACGAAGTAAAT +CCGTCTTAGAAAACTCCTTCTTTGCAACTCCCTTTATTATCCCGCTCAAAAACTTTAAATCTTTAGATAT +TGAACTCAAATAACGTGATATAACCAGAACGTAAACAAGGAAGAATACAAGACTTGTCCCAAAAATACCA +AAAACGGTAAAGTTTAAGTTATTAAATTCTTTCCAAGTTATTAAGTATCCGAAGACTTTTCCCTCCCAGA +GAAGAGGATACCTCGCCACGAATACGGGATTTATAACGCTCCCCACATTCCCGTATGGTTCCACGGGAAA +AATTTTCTCTAAAAAATCGGGCTTAATATTACCAATGACTACAAAATCTCCGTAAATTAAAGAAACTTTG +TGAAGGTTTTGATTAAACTTCCCGTACTTGCTGTTGTCGTACAGAATTACTCCCTCGGAACGCAAAATTT +TTAAAACGATGTTTGAAAATTTATAAAAAAACACGAGAGGATTTTCTTCTTTTCCGTACATCAATTTCTT +TATTTCAGTACATGTAACCACGAGATTTTCGTAAAACTCCCTTGACTTTTTGTTGTTTAACGCTTTAAAA +TCTAAATACACAACCACTGATACGAAAATTATGTAGAGCACGAAAAAAATAACGGAGTAAGAAGTAATTT +TTTTCTTTATGCTCATATACCTTATAAAGTATATATACTACATTCCCTATGAGAATAGTCTTCGGAGGAA +GTTTTGATCCTGTACACGTAGGTCACATAATACTCGCGAGGGACGTCTGTGAACACTTTAATGCAAAAGA +AGTTATATTCGTCCCCACCTATCAGGCACCCCTCAAAGAAAAACACAAAGCAAGCGCTCAGGACAGGTTA +AACATGTTAAAGCTTGCACTTGAAAGGGAAGAGAAGTTCACAATAGAAGACTACGAAATAAGACGAAAGG +GAATTTCATACACCGTGTACACACTCAAGTACTTAAAGGAGAAGTACGGAGGGGAGGAGCTCTACCTCCT +CCTCGGAAGTGACAGTTTTTTGAAGTTCCATAAATGGAAAGAACCGCGTGAAATACTAAAGCTTGCAAAA +ATTATTGTGGTCGAGAGGGAAGGGATGTTGGAAAAGGTGAAGGAATACATAAAGGAGTACTTCCCGGAAC +TGAGGAAAAATGAAGATATCTTTTTCTACAAAGGCAGAAGGATAGACATCTCTTCAACCGAATAAGGAAG +AGAGTTTCGGAGGGTAAGAGTATTTACTGCATGGTGCCCGAAAAGGTAGAGGAATACATAAGGGAAAAGA +AACTCTACATTAAATCTCCGGACCTATAATCAGATTTATGAAGCTTAAAAGTAAACTCTCTTACGAAGAT +ATAAGAAGACTTCCTGAGGGAAGTTACGAAGTAATCAACGGGGAGGTGGTTGAACTGGTACCTACGGGAT +TTGAACACGGAGAGTACGAACTCGACTTGGGGGCTTTTTTAAGGGAAAAATTGAAGAATAAAGGATACGT +TGCAGTGGGAGAGGTAGGAGTTTTAATATCAAAGGAACCACTCAGGATACGCTCGGCGGATGTAGTTTAT +ATAAGCAAGAAACGTACTCCCGAAAGACCAAAGGGAATACTTGATGTTCCGCCTGAAATCGTTATAGAGA +TAGTTTCTCCTAATAACACATACTCGGAAATTGAGGAAAAGGTTTTTGATTACCTGAGCGCTGGTGTAGA +CAGGGTTTTAATCGTAGATCCGAAGGTAAGGAAGGCAACTTTATTCGAAAAGGGAAAAAGGGAAGCGAAG +ATATACGATTTTGACGAAGAGTTCGAACTTTTAGAAGGTCTCAAATTAAGGCTTTCCGAAGTCCTGTCTT +CATAAAGTAAAATTTTCCCTATGAAGGTAGGTTTTATAGGTTTAGGACATCTTGGAAGAGCCATAGCAAA +AAGATTGATAGAACAAGGTGTAGAATTAATAGTCTGGAACAGAACGCTTTCAAAAGCTCATGAATTTGCC +AAAGAAACGGGTGCGGAGGTTACAAGCTCCCCCGCGGATTTAATAAACAAGGTGGACAGAGTTTTCGTTA +TAGTTTTTGACTCTCAGGCTTCAGAAGAAGTGATATTCGGAGAAAAGGGACTCGTAAAAGGAGACATAAA +GGGAAAAACCGTTATAGACATGACTACGAACCACTACCTTTACGCACAGAAGGCTTACGAAGAACTTAAA +AAACTTGGAGCTTTCTATCTGGACGCTCCCGTCCTCGGAAGTGTTATACCAGCCCTTAAAGGGGAACTCA +CTATAGTCGTGGGAGGGGATAAGGAAAAGTTTGAAGAGAATAAACCTCTTTTTGAAAAGTTTTGCAGGGC +GATTTACTACCTAGGCGAGGCGGGAATGGGAAGTAAGATGAAACTCGTAAACAACATAGTTCTGGGCGGG +ATAATGGAAGTCCTGGCTGAAGCCATAGCCATAGGTGAAAAGGCGGGAATTGACAAGGAAACATTAATAA +ACGTCCTCAACGACGGAGCGGGGAAATCCTACATCTTGGACGTTAAGAAGAAAAAACTCCTCGAGGAAGA +CTTCTCAACGCACTTTTCCGTTAACCTCATATACAAGGATCTCCACTACGCTCAGGATTTAATAAAAGAC +TTGGGACTCTTCTCCTTTACAACCGCTGCGGTAAAAGAAACATACGGACTCGCAAGGAAGGAAGGGTTTG +GAAATCTGGACTTTTCAGCAGTTTACAAGCTCTTCAAAGAAGACTAAATAACGCCTTTCGTTGAGGGCAC +TCCGCTTCCCTCTACTTTTACCGCTTCTTTTAAAGTAATCGCAAAGGACTTAAAGCAAGCTTCCGCCACG +TGGTGGAGTATTTTCCCGTCAAGGACCTTTATATGTAGCGTGCTCCTGCTCTCAAGGGCAAAACCTTTAA +AGAATTCCCATATAAGCTCAAAATCAAACTCCGTTATCTTTCCCCTTAAGTCCTTGTCTTCGTAAAAGAA +TAGCGGTCTTCCCGAGATGTCTATAGAAGAGAGTACCAGAGCCTCGTCCATGGGAATTATGGAGTATCCG +TACCTCCTTATTCCTTTTTTATCTCCGAGGGCTTTTAGTACCGCCTGACCGAGAACTATACCGCAGTCCT +CCACTGTGTGGTGGTGGGAAACGTGAACGTCTCCCTCGGCCTCAACCTTCAGGTCAAACCTTCCGTGTTT +TGCAAAGGACTCAAGCATATGGGTTAAAAATCCCACAGGTGTGTTCACTTCGTAATTCCCGCTTCCGTCT +AGGTTTATGTATAGCTTTATCTTTGTCTCTCTCGTTTCCCTGAAGACTTCCGCTTCCCGCATAGGAATAC +TTTAACCTACCTTCGTTTCCTGGGTGTCTCCTTTATGAGTTTGTGTATCTCTTTGAAGTTTATGTCTCCC +GCAAGGACGTAAACCTTTCCCTCGTATTGGAACTTCTTAGAGACCGTAATACAGAAGTCATCTGTAGCCT +TTGAAAGGTAAATGTCGGAAATGTATTCTCCTTTTTCCATTGCCTCTTTGAAGTAAGGTTTCTCACTCCT +GTCCGTTCCCTTCTTGCCCTGAGCTATGAAGTAACTCGCATTCGGGTTTATCACGTTGTTAGAAATCTGG +AGTCCGCTGGAACTCATTATGTAGAAGAGTTCAAAGTAAGGGTACTTCTTGAAAGCGTCGTAAAGGGTAA +ATTCCCATAACTCCTTTGGTGCGTTTACGACTTCATTGAGAACCTTTTCAAAGTCCGACATAATTTTTTC +CTTTATATTCTTTAAGACCTTCTTCCTTCTGGGGTCGTAGAGGATAAGTTTGGGTTGGAGTCCCTGAACT +ATGAATATGTAACCGCTTACGTTCTTCGCTCTTTCTCTGAGTTCCTTAATCTTCTCGTTCAGTTTATCCA +AGCTTTCAAATAACTTGAGGTTTATGGACATCCCGTAAAGGGCTATGTGAGGGTAATCCGCAAATAGAAC +TGTATACTCCCTGAAGAACTCTTCAAACAAGTGCTTTATACGTTCCTTTTCAGGAGGCTCTTTGGAAACA +GCCCATATTTCTTCTTTCTCTTCTATTTCTTCAACTTCACCGCTTATACTTTCCTGTATATCTTCTTTGA +GGATTTTGAGAAGCCCCTTTGCCTTTTCGTATCCGAATTTATCCCTGAAGCCTTTGAAGTTCTTAATCCC +GAATATGTAAAGGTATTGGTCAGTTCCCAAAGACTCTCTGATGTGTTGAATTAAAGGGATGACGAACTCT +TTGTACTTGGTTATGTAGTGAAGTAGGACGTCGTAAGTAAGTACTCCTAAGTAGTTTCCCTTTTTGTCGG +TTATTATTATCGGCTCTTTTACTATAGGGAGAAGTTCCATAATGCCTATTAATCCCTCTTTACTCAGGTT +CAGATCCTTTACTTTTACCGCAAGCCTGCTCAGCTCTCCCGTAAGCAAATCCTTTCTGGTTATCCCTTCA +ACGTCCTTTCTGAAAACTATTCCTATGGGTTTTCCCTTCTTTAAAACCGTTAAGTACTCGTAAATCTTAA +GTTCGGAAAAGATTTCCTTCAGTTCCTGAACGCTCAAATCGTAAGAAACGGTAGGGACGCTGATACAAAT +ACTACCTAGATCAAATGACTCCTTCATAACTCCAGCCCTAAATCTTTATAATGGTAAACTTTTCCCCTGT +AGACAACCACTACCTCAATAGAAAAGGGTTCTTCTCCGAGGACTTCGTAAGCGGTTCTTATTATTTTGCT +AAGTTTATGAGGGGTTACCTTTTCCGCCGGGAAGAAGGTTTCACTTCCCTTTACTTCAACGATAACTTTC +CTTCCCTCGAACTCTGCCAGAATATCTATTTCACCGTAGGGACTTCTTAAGTTTCTTCCGAGGATTTGAT +AACCTTTACTTTTTAAGTACCGAGCCGCTAAGTCTTCGTACTCCCTTCCCTTCATAAAAAGTTTTTAAAA +AGCCCCAAAGGGGCGGATTAATGATATCCGAGTCTCTTGAGGAGGTTTTCTCTGTACTTCCAGAGAAGGA +GTCCCATAACGATGAAGTAGGCTATAACGATTACTCCCATAACTGTTCTCTTTGCGGATTCCTTAGGAGG +AGGAGTATTTACGGACTTCATGTAAGCCACGATTTTTGCAACCTTTTCCTTCGCCTGAGGGTCAAACTGA +GGGTTAAAAAGCTGAGGCATTGTCGTTCCGGGAAGAACTTTTTGAGGGTTGAGAATAAACTGGTAGAGAT +ATCCTTCTCCCCTTGCAAGGTACATGGAAGAAAGGTCGGGCGGTACTTGCCCGAGGGAAGCTTTCAGTCC +CTGAATGTCGTCGTGGGCAAAAGCTTCGTAAACGTCCTTGGGAACGAAGAACCTGTCTTTATACAGAGTT +CCGAACCTGTATACAGGTCTTCCAGATGTCTTTTCTATATTTTTCCACTTGGGATTTGCAGCAACGCTCA +TTATGTATATCCCGTCGTACCTGAGTGAGTGACAGGAAGAACAACTGGCTATAAAGAGTTCTCTTCCTTC +TTCAGCTATAGTCTTTCCGCTTTCAGTCTTTTTCCACGGGTTGTCTATTATCGCCTTTACTTCTTCGTCA +ACCTCGTAGTGTTCAACGTGCTTAAAAGGATTGTAAAACCAGAGGAGGAAGAAAAAGACGAGGGTTGAAC +CTGCAAAAAATATAGTTTTTATTAAGCCCCACGTGTTCATTCTTGCTGACCTCCCTTTGCTTTATACCAA +CCGTACTCGATGAACGAAATTATTGGCAGAGATATGAAGAAGGCAAATACAAGTGCGGCAAATATGAGTC +CGAGTTTTGCGTTCTGGGGTGTGGGAGGCATAGTTCCGAGTATCGTGAGAGCCATTGAGGAAATCATGAA +TATTACGAACATTACGAAGAATAGAGGTCTTCTCCTTGCACTCTTGAGCGGAGAGAAGTCGAGGAATGGC +AGTAGTAAGAGGAGTAACAGTAGTGCGTTAAATGCAACAAATCCCCAGAACTTGGAGGGTATTGACCTAA +AGACTTCGTAGTATCCGAGCAGGTACCACTCAGGCGCTATGTGAGCGGGGGTCTTAAGGGGGTTTGCGGG +TTCAAAGTTCTCAGGCGGTAGGAAGTGGCTTATATGGAAGAACACGAAGAAGAAGAATACTGCGAGATAC +CACATTACGTAAGCGCCTTCCTTGAGGGTCATGTAAGGGTGGAAAGGTACGAACTTATCGGGATTTTTCT +TCTTGTCGTACTCAATACCTTCAGGGTTGGATATTCCTGCGGCTCTCACGAGGTATAGGTGTATTCCTAC +AAGTGCAAGGAGTATGAGCGGGTATATGAGAACGTGAGAACCGAAAACTCTACCGAGGGTAACGTCCGTG +ACGACGTATCCTCCCTTCATCCAGAGAACTATAGTTTCAGCTATGGCTTTGAAGATAGGCTTCAGTATAG +GTGCATCTGCAAGAGAACCGGGAATTTCGGTAGTAACGATGAATCCCCAGTAAGAGAGCTGTCCCCACGG +AAGGAGGTATCCCGAGAGTGCGGTGAGTATTAAAACAAAGTATATGAGCCATCCCACTATCCAGACGAGT +TCTCTTGGTCTTTTGTAAGCGTTGTAGTAAATTCCCGTGAACATGTGGAGGTAAACGATAGCCATAAAGA +AGTTAGCACCGGTGCGTGTATGTGCCTGAAGAGCCATCCGAAGGGAATTTCTCCCATTATCGAGTAGGTG +CACTGTCAAAAGCGTCTGCGATTGAAGGTTGTAGTAGAGTATGAGAACCATTCCAGAGATTATTTGGATT +GCAAATGTGACGAGTGCGAGTATACCGAAAACATATGGGAAGGTGAGGTTCTTGGCAACTTTGTATTCAA +CCATCTGGGTTCTGTAAATCTCCCTTACGTGAGCCCTTTCATCAATCCAGTCAACTATCTTTTCTATTAA +TCCCATATTCCCACCTCCTTTATATGAGTTCCTTTACAAATCCCTCAACACCGACGATAAGTTTATTGCC +CTCTAACTTTTGAGGAGGTATAAATAGAGGTCTCGGTGGTGGTCCTCCTATTACGTCTCCGTAGGGTGTG +TATAACCCTCCGTGACAAGGACAGTGGAAGACAGGCTTATTAATACCCCCCTCTCCTTGAGGCTTCCACA +GGGGAATACATCCGAGGTGCGTGCAAACTCCCACGAGAGCAAAGACATCGTGACCTTTGAGTATTTCGTA +ATTAGTCGTCCCCTTAGAGTTTAGTGCTCCTTTTTTGAGGGTGTACCCTTCGGGTTTGAAGTCCTTAGGC +AGTCTTATTGCGAAGAGCGTTTTACCTTTCCAGGACGTGACTCTCACCTGCATCGGCTGGATTTTTGAAA +CGTCGATTTCCGTTTTGGCTCCAAGAGCGGCTATTTCTGAGGGTTCGAGCATTACCCTTACGAGGGCGTA +GAGGGCTCCCAGTCCCCCTACAGCCCCGAGAGCCCCAATTCCTATACTTATAAAATCCCTTCTCGAGGCT +TCCATAATACCACCTCCTGAAATTTAAGTAAACCAAACTATATTTTACTACTCGGCGGTGAAAATTTTTA +TAAAAATTTCGTTATATATACATAAAGTTAATTAAAGGTTAGGAAGTTAAAATAAACTTGATGGACCTGA +GCGTGGAACTCTTCGGCATACGCTTTAAGAATCCCGTCTGGGTTGCAAGCGGGACCTTTGGCTACGGCGT +GGAAGCTGCGGAAATCTACGATATATCAAAACTCGGAGCAGTAGTCACAAAAGGTCTCTCACTCAAGGAA +AGGCTCGGGAACGAAACCCCGAGAATTGTGGAAACCCCCTGTGGCATGCTCAACTCCATAGGTCTTCAAA +ATCCGGGAGTGGAAAAGTTCCTAAAAGAGATTTACCCCAAGATAAAAGACGTGGACACTCACTTCATAGC +TAACGTCTTCGGTGAAACGGAAGAGGAGTACGTGGAAGTTTGTATGGCTCTGGAAGATGCTGACAAGATT +GTGGCTTACGAGCTGAATGTTTCCTGTCCCAACGTGAAGAAGGGAGGAATCCTCTTCGGACACGACCCTG +TAATCCTCGGAAATCTCGTTGACAGAATAAAGGCGAAAATAAAAAAACCCCTCCTTGTAAAACTCTCTCC +AAATGTGACCGACGTTACCGAGTTTGCGAAGGTATGTATAGAAAACGGAGCTGATGGACTCGTTTTGATA +AACACATTAATGGGAATGAAGATAAACATATGGAAGAGGAAACCAGACCTTGCCACCAAAACGGGAGGAC +TATCCGGACCTGCGATACTGCCCATAGCGGTGAGGATGATTTATCAGGTTTACGAGAAGTTCGGCGACAG +AATTCCCATAATAGGAGTGGGAGGGATAACCACATGGGAAGACGCCATGGAACACGTAATGGCGGGGGCA +AGTGCAGTTCAGGTGGGAACCGCAAACTTCTACGAGCCCTTAGCACCCTTAAAGGTCATAGAAGGGATTG +AAAACTTTATGAAATCTCAGAATATCAAAGACTTCAAAGAATTAATCGGGATTGCCCACAGAGTAGAATA +AAGACATTATGGTTAGGAAGCTGAGCGAAGAAGAAGTAAAGAGGGAACTTGAAAATCTGGAAGGCTGGGA +ATTCTGTAAAGATTACATACAGAAGGAGTTTTCCACAAAGAACTGGAAGACCACCATATTCGTGGTGAAC +GCCATAGCCTCTCTGGCGGAAGCCCAGTGGCACCACCCAGATTTAGAAGTCAGCTTTAAAAAGGTAAAGG +TTAAACTCACCACTCACGAAGCTGGCGGGATAACGGAAAGAGATATTAAATTAGCAAAATCCATAGACGA +GTTGGTGAAAGAAATACTAAAGCATTGATATTTTTCCTTTTTCTCATATTTTCTCTATCCTTTGGCTTTG +AAGTTTATATAAAGTCTAACTATCCATTAAAAAAGGACAATCTGCGTCATGTAATAAACGAGAAGAATTA +CGCGAAAATCCTGGAAATGCTTAAGCAAATTCCCGAAATAAGGGAAGTAAGGTATGAAAAACGAAAGGAC +AAGCTCTTAATTTACGTGGAAAGGTATCCCATAATCAAAGAGATAAAAATAAAGGGGAACGTTTTTCTGA +GAGATGAAGATGTGAAAAACGTTCTTGGAATAGAAGAGGGCATTCCGTTAATAGAGGATAATCCAAAAAC +TTACGAGGAAATTCTTGAAAAGTATTATAAAGAAATCGGTTTTTTAAATGCAGATACCAAAGTGAACATA +AGTTTAGACGATAAAGGAAACGCTATTTTCTACATAAATATTCGCGAGGGGAACCTTTATTTTCTCGAAG +ATATCCAGTTTGAAGGTGTTAAAAAGCTACAAAAAAAAGAACTGATAAAAGCCTCTGGACTTGTAATAGG +GAGTATTTTTGATATAGATAAAGTAGAAGACGCAGAGGAGAATTTAGAAAACTTCTACAGAAAAAAAGGT +TTTTTTGAGAGTTTCGTTTATCTGAAAGGTATAAAAAAAGAAAAATTAAAGAGAAAGTTTAGGGAAGCAC +TTTTCCCCGAAACGGATTCATTTTTAAAAAGCCTTTCAATCGGTTTAAAAAATCTCGTGAACCACCCGCT +GGCTACGCTTAAGGCTTTAATCGGAAAAGGTAAGGTAGGCATTCCCGTTTATGAGGTATACGAAGGAGAA +AGGTATGAACTGAAGTTCCTTGGAAATAAGTTTTTTTCGGATGAATACCTGTATTCTCTCTTTGATATAA +ATACCGTGGGTGTAGACATACTGGTTCTTGAAGGTTTTAAAGATAAAATAGAGGAAGAGTACAGGAAAAA +GGGCTTCTTTGACGTAAATGTAGAGTACGAACTTGAAGATCACAGGATTTTGATAAAGATAAAAGAAGGA +GAAAGGTATAAAGCTAAGGTTTACATAAACGGGAAAAAAATAGAAATTCCTTACGATGAAGAGAAAATTC +AAGACTTAATAAGTAAAGAAATCCAATACTTGGAAAAAATGGGTTACGTTACGGCAACATATGAACTTAA +AAAGAAAATAAACAAAGATAAAAAAGAAGTGAACGTTCACGTAAAAATCAACAAAGGAATGCGCTACATT +GTTTGGAGCTTTAAAATAGAAAGTGAACTTTTCGAGGATTTAAATGAAAAAATTTCACTTAAATTCCCGA +AAGCCTTGGATTACGAAACTTTAGACGAGATTTACAAGGAAATAAATAAAAGGTTACGGGAAAAAGGATA +CTTTGACGCTAAGGTTTTCACAGATATAAGAATGCAAAAGGTAAAAGATGCTCTTTTGATGTTTTATAAA +GTAAAAGTAATTCCAGGAGAAAGATACGAGTACGGAGATACACTAATTTACGGTCTTGAGAAGACAAGGT +TAAAGGAAGCTGAGTACGTTCTGGAGAAAGAAAAGTACTTCTCAAAGGAAGTTGAAGAGAGAAGTGTATG +GAACGCCATAGAAAGCGAAATCTTTAAAAGTTTAAGACTTGAAGATTACGTAGACAGGGAGAGTAAGAAA +GTTCACAGACTTGCCTACTTTCAGGAGAAAAAGAGAGGGGTAATCGGACTTTCTGCGGGCTTTAACACCT +TTGAAGGTTTTAAACTTTCAGCAGAACTAAGTCTGAGAAACCTCTTGGGAATAGGGCTTATAAACACAAA +TACCTTTTCCATAAGTGAGAAGTACGAACTCTACAGGGTAAGCTTCAAAGACAATTTTCTCTTTTCAAGG +AGATTTTTCGGGGAAACGTCACTATTTAAGGATTACGAAGAGCATGACACGTACGAATTATTTACGGAAG +GCTTTGCCTTCTCTCTGGGATACAGGTTAAAACCCTTTACCTTTGTGGGTATTTCCTTCTCAAACTTTGA +GGCAAAGACCACAGGTGCGGAAAGGGACAAGGGAACTTACAGGAAATTGGGGCTGAGTTTTTCGGTAAAG +GAAAGGTTTAGACTGGTACTTTTTAGGGGATACGGACACAGGAATTATTCAAAGATAGAACTTGAAGGAA +AAATAAAGAAAGAATTTTTTGAAAAATTCGGTTCAAGGCTGAAATTTTCTTACGGATATGCTACGAAAAA +AGCACCAATATTTGAAAGATTTTTCCTCGGAGGATATAAGAGAATGAAGGGTTACACCTACGAGAGTATA +GGTTCTCCCTTGGGCGGGAGACAAATGCTTTATATTTCTCCCGAGATTTACTACCTTCTCAACAGAAACT +TGGAACTCATAACATTCCTTGAGCTCGGAAAGGTAGAGAATAAATTTCCGAGTCTTTACAAAAATATGAA +AAAGGACATAGGCTTTTCCGCAGGTTTTAGAACGCCCGTGGGCCTTATAAGGGGTGATATAGCCTATCCC +TTGGAAGATTTTAAGGTAAAGCCCTCGAGGCTTAAGTTTTACCTCTCGGTAGAGTTTTTCTTCTAAAGGT +AGTAATCAATAAGCACCACAATAAAGAAAATTACACTTATCCAGCCGTTTACCGTAAAGAAGGCTTTGTT +TATTTTTGACAAATCCCATGGTTTTATCAAACTATGTTCGTAAACTAGAAAGCCCGCTATCAAAAATAGC +CCCAAAAAGTAGATAAATCCGAGCTCCTTGTGGGTAAAGCCAAGAATAAGTAGTGATACAAAGGTTATTG +AATGGAAAAGCCTCGCTATCTTTATTGCTTTTTCTACTCCATATTTTACTGGTATGGATTTTAAGCCCAC +TTCCTTGTCAAATTCGTAATCCTGAAGGGCGTAAAGGACGTCAAATCCCGCAACCCAGAAAGCCATAGCT +ATCCCGAGAATTACAGCGGTAAGGGAAATCCTCTCGTTCAGGGCCACGTCCACGGCAACCGGTATGAGGA +AGTAAACGAGTCCGAGGACGAGGTGAGGGTAGTAAGTAATTCTTTTAGCTTGCGGATAAAACCATAGTAA +AAACAAAACCACGGGGGAGAGTAAAAAAGCTAAAAAGTTGAGCATAAGGGAGGCAAAAACGAAGAGAATA +CTCCCTACTAGGATTATTTTCCTTACTTCTTCTTTTGACACTTCTCCTTTAACGAGGGGCCAGTTTTTGG +TTCTCGGGTTTAGTCTGTCGTAGGGTTCGTCTATGAGTCTGTTAAAAGCCATACCAACGGTTCTGGCGCT +CACAAGGGCTACCAGAATCCAGAAAATTTTCCAGAGTGAAGGGAATTCTTCGGCAAGGAGCAGGACACTT +GCAAGGGCGAAGGGAAGGGCGAATATCGTGTGTTCAAATTTTACGAGCTCCGCGTAAGCCCTTACCTTTT +TCATCATCTTAACTTTAGCATTGATATGGCAATGATAGCAAGCAAGATGGATATAATCCACATCCTAACG +ACAATTTTGGGTTCGGGAAGTCCGTTTAATTCCAAGTGGTGGTGAAAAGGAGCCCTCTTAAAGAGCCTCT +TTCCTCCGGTCCACCTGAAGTAGATTATCTGAAGGATAACGCTTATAGTTTCAAATACAAAAACGCCTGC +TGCAACCGCAAATATAAACTCCGATTTCGTCAGAAGTGCAACGGTTGCAAGGGAAGCTCCGATACTGAGT +GAGCCCACGTCTCCCATAAACATCTGGGCCGGGAAGGAGTTAAACCATAAAAATCCAAGTCCTGCTCCAA +CAAGAGCAAAACAAAAAACCGTGAGCTCTCCCGCGTAAGGGACGTAAGGAATGTTTAGATACTGGGCTAT +TTTAGAGTGCCCCACCGCGTAGGCTACAACTCCGAGGGCTGTTGCCGTGGTCATCGCAGGTCCAATCGCA +AGACCGTCCAGTCCGTCGGTAAGATTCACGGCGTTCGCACTCCCCACTATCACAAACACCGCAAAGGGAA +GGTAAAGAACTCCTAAATCAACGTAAAGTTCTTTAAAGAAGGGAAAGTAAAGAATCGTGTCTATATCCGC +CCAGTAGTAAATAAGAACTGAGATTAAAGAAGCGCTGAGGACTTGAAGTAGGAACTTAGTTTTTATAGAT +ATACCCTTTTTGTTTTTGAGTTTTACATAGTCATCCCAGAAACCTATAGTTCCGAAACTCAAAAAGGACA +GAAGAACGACCCACGTGTACTTTATATCCCATCGCATTAAAAGGAGCGTGGAGAGCGTAACGACTATGAG +TATAACTATCCCGCCCATAGTAGGCGTGTACTTCTTCACCTCGTGGCTTTCGGGTGTGTACTCCCTCACG +TATCCACCAAAAAGTCTCTGTATTTTCCTCAAGCGATTTATGAAGGAAGGGGAAAGTACAAGCGTCAAAA +AGAAGGCAATGAGAACCGCGGTAAAGGAACGGAAGGTTATATATTTCAAGACGTTGAAGGCAAACCAGTA +ATCTTTAAGAAGCAATGCCAATTGGTATAGCATCAGTCACACCTGTTTCTGCTAAAGAGTCTGTCAAGGA +TTATAGCAACAGCATTTCTGACCGAGAGGTGATTCCAGTCTCCCGCACCGTATATCGGCTCTAAAATGTA +GTCAAAGGTGTTCATGAGATCGGGAGGTATCCCGTGTCCCGTTCCAAAAACTATGAGCCAGTCCCTGTCC +CTCTTTTGAATCTCATTCCTGAGCCATGAATACTTTACGGTGTTTGGATAGGTTCTCGCGTCCGTTCCCA +CGAGAAGAGGTCTCCTTCCTCTTTCTTTTTCTATGTCTTCTATTACTTCGTCCAGGGTGTAGGCGAGTCT +AACGAGCTGGACTATCTCATAACGCGTGGGATTTGCCTTCCTTCCTTCCTCGGATAACCAGTAATTAATC +TGCCTCTGAATTACTATCCTCTGGGCGTCTATGGGCTGGACTATGTAATACTTGTTTATCTCGTAAGCCC +TCGCGGGTCTTGCTATGTCGTGTAAATCCATAGTGGTAAAGGATGTAACTATTATCTTTCCGTCCTTGTC +CATTGCGGGGTAATGGAGGAGGGCTATAAAGACGTTTTCATTTATCATAATAAAATGAATTATAAATAAA +ACTATGATCTCGGTATTCATATCACTTCTGGCTTACATCTTCGCATTTTTCTCCTTCCTCCTCAAGAACT +TTTCAAAGAAGGAGATAAAATTCCTGCCGAACTTTTTCCTTACCCTGGGTTTTATATTCTACATACTTAC +ACTCCTTGAAAGGTTTGTACAGACTAAAACCTTTCCCGTGGGTGATGTTTACGGGATGATTTCGCTTGTT +GGAAACCTCTCCGTTTTACTCTTCTTAACCTTTTCGAGGAAGTATGAGTTTTCACCCTTCGGAGCTTTCG +TGTCCTTTTTCGCGTTTTTGAGTACTCTTCTGTTGATCCCTTCGAAGGAACTCGGTTTTTCAAACCCCCT +TTACGCCCTTCACATAACGAGTGCGGGATTTTCGTATGCCTTTTTGATTTTTGCGGGTTTTACTTCAACC +GCGAGGCTTTTAATCGAGAGAAAACTCCGCGAGAAAAAGGTGGACTTTAGCTTTGCTCCTTTGAAAATCC +TAAAGAAACTTGAAAGGGTTTTCATAATAGCGGGCTTTGTGGGACTTACTCTTACGCTTATTTTTGGAAG +TCTCTGGGCTAAGGTTTACTTGGGCACTCACTGGGTAAACGACCCTAAACTCCTCGTTACACTAATACTC +TGGCTTTATTACGGATTTCTCGCACACATGTTTATATTCAAACATTTCAAACCTTCTCAGATTTCCTACC +TTTCTATCCTCGGTATGTTTTTAAGCTTGATAGCCCTTTTATTCTTCAGGCATTCCTTTTAATGTCTTCA +AGTTTTCTCGCGGCTGCCATCAGCGTAGCCTGTGCCACAACTTCCCCGTCCACCTTTGCAACCCCCTTCA +TCTTTGAAAGTGCCTTTTTAAGAGATATAACTTCAAGCTCGAGTATAAGCTGGTCTCCCGGGTAAACGGG +TTTTTTAAACCTCGCGTCGTCTATACCTGCAAAAACAACTGCGTACTTTCCAATTTCAAGGTTAAGGGAC +TTTATCATTAAAATCCCCCCCACCTGAGCCATAGCCTCCAGTATGTAAACCCCCGGAAAGAGGGGAAAGC +CGGGAAAGTGCCCCTGAAAAACCGGCTCGTTAACGCTCACGTTCTTTAAACCAATGATCCTTTTTCCTTC +TTCTATTTCAAGGATTTTATCTACTAAGAGAATGGGATACCTGTGCGGAAGTATTTCCATTATCTCTTGA +ATATCCATAACGCTATTTTAACATTTTCAGGATGAAGCTTCCTCCTCTGATGCCCGCCATTTTCGTAAAA +AGACTAAATAGATTTGTGGGAAAGGTTTTTTTAAATGGGAAAATAGAAAGAGCTCTAATCAGGAACACGG +GAAGACTTTCTGAGCTCTTAAAATTCGGAAACACTGTTTTTGTTAGGGAAAAAGAGGGTGGAAAGTACAG +GTACGAAATCATACTCGCAAGGGCGGAGAAGAGTCTCGTATGCGTTGAGTCCCACTACGCCAACAAGATT +TTTGAGGAATACATTCGCAGAAATTGGAAATTTAAGGAGCTAAAGAGAGAAGTAAAGCTGGAGAATGAAC +GGTTTGATTTCCTTATAGACAACACACTGGTAGAGGTAAAGTCCGTTAACCTGGTAAAAAATGGTGTTGC +CATGTTCCCGGACGCTCCTACAAAAAGGGGAACGGGACACATAAGGACTTTGATAAAGCTTTCCGATAAG +TTCAAACCTCTACTTGTTTTCGTGGTTCAAAGAAGTGATTTTTTAAGTTTTGAGCCCAACTGCGAAACTG +ACCCCGAGTTCTGTAAAGCTTACTACGAATACGTATCTAAGGGGTTTGAAGTTTTAGTACTGAAGTGTAG +AGTTTCTTTGGAAGAGATAAATGTAGTAGAAGTATTTTTCACTTAACTCCGTGGCGTTTTTCTTTTAGCG +TTTTTGAACCTAAAAAAAGCATTACACTTCCAACGATTATTCCAACTATAAGAAGGACAATAAATGCCTC +TTTCATTTTTTACCTCCATCAATTTCTGAAGATAAAATGAGAGCGTTTTCCTGACATAAATCATATTTTA +TTTTCGTGTATTGTGATAGTCTTGATTTTCAAGGGCTTAAAGAAAAGCCCGTTTTGGCTCCTTGGCAATT +GAATAGAGAAAGTGGCTCCCGACCTTGAAACTCAAGGGTCAGAAAGTAATCCCTTACATTTTCAAGGCTT +TCCGAGACACAGGTCAACAAAGGGCATTTCCAAAGAATGAATTTATTGATTTTCAAGGGGTTTAAAAGTA +GGGTTGAAACGCCCTAAGTAAAGAAGGGATGCGGACAATCCTATTAAAGACCTTTCCGGTGAGGCAATAC +CTGTAGCTTAATTTTCTGGAAATTCCAAAAATCTTGAATATCGTTTATCTTAATGGGAGACGTAAACTTC +CTCGAGCAGATGCTTTTAAAGAGCACGATGAAAGAGATAGAGGAGAGGTACGACGACGTAATAACGATAT +ACAAGTACGACTACGAAATAAGGGGGATTGCGGAAAAACTCTACAGACTCTCAAAAATAGTGGAAGAAGT +TTTCAAAGAAATACCGAACCCGGAGAAAAAACTGGACGAAAGCCTCTACACAACTCTTTACAGTGTACTC +AAAGACATAAATTCAATACTCTACGACCTTTCCATAGCAACCAATGAACAGATAAGCTACGTCCTCATGC +AGGCTTACAGAAAACTTGACAATATAGACAACCTTTTGAGTAAATTAAAGTGATGTTCAGAGACAGGGAA +GAGGCGGGAGAATTATTAGCCGAAGCTCTGGAGGGAATTATTGACGGAGAGAAGAACCCTGTAATTCTCG +CAATACCGAGGGGAGAATTCCGGTAGCATACAAAGTGGCCGAACGCTTCAATATTCCCATGTCCGTTGTA +CTTGTGAGAAAGCTGGGACTTCCCTGGAACGAGGAGGCTGGTTTTGGTGCGATAGACCCAGACGGGACTC +CTTACTACGATAAGAGCGTCTTATCCTACCTTTCGGAAGAAGATATTAAACAGGTAGTTGAAAAGGAATT +AAAGGAACTGAGGGAAAGGGAGAGGAAATTCGTCCCAAGGGGTTATCCGGATTTGAGGGGAAGGCAGGTG +ATAATCGTTGACGACGGGGTAGCCACGGGCTACACGGCAATAGCCGCGGCAAACTGGGCAAAGAAAAAGG +GAGCATCTGAGGTGATAATAGCGGTTCCCGTTTGTCCTTCGGACGCAAAGGAGAGACTGGAAAGGTACGC +GGACAAGTTCGTGTGTTACTACTCCTCCGACGCACCTTCTTTCGCGGTGGGTATGTTTTATCGGGACTTC +CACCAGCTTTCAGACGAGGAGGCAAAAGAGTACTTAAGGAGGGCGGAAGAAAAAGGGCTTTTAGAACCTT +AATTACTTTTTAGGTCTGAAGGCTTTTACTTTATTCGGATCAGTGTCTATATATGCCCCGCCTATAAGGT +CTATACAGTAGGGAATTGCAGGCATTACGGCGTCCAGGCATACTTTTATGGATTGAGGCTTTCCGGGAAG +GTTTACTATTAAGCAACTCCCCCTTATACCCGCGGTTTGTCTTGAGAGTATGGCGGTGGGAACCTGTTTT +AACGAAACCTGTCTCATAAGTTCTCCGAATCCTGGAAGCATTTTCTCGCATACCGCTTCCGTGGCTTCCG +GCGTCACGTCTCTGGGAGCGGGACCCGTTCCGCCTGTTGTTAAAATCAGACTGCATCCCTTTTCGTCTGC +AAGTTCTATTAAGGTTTTTTCTATCAAATCCCTTTCATCGGGAATTACCCTGTACTCAACCTCAAAGGGC +GTTATTATCACGTCCTTAAGGTAATCTATAATAGCTTTACCGCTTATGTCTTCGTAAATACCTTTGCTCG +CCCTGTCGGAAATCGTCACAACTCCTATAACCGCCTTCTTTTCGCTCATGGGAATACATTTTAACGTTTA +GGTTAGAATAGTGATATGAGGGACATTGTTTTCATAGAAAGGGATCCTTACGCTCCGATAAGACACTGCT +ACACCGTTTCAAAAATACTCTACCAAGGAAAGAGTCCCTACCAGGAAATACAGGTAATTGAAAGTCCTGA +GTTCGGGAGAATGCTTATCCTCGACGGAGTGGTTCAGCTGGACGAGAAGTACGAATTTCTCTACCACGAG +TACCTCGCACACGTTCCACTCCACGCACACCCAAACCCCAGAAACGTGCTCATAATCGGAGGAGGAGACG +GGGGAACATTGAGGGAAGTTCTTAAACACGATATCGTAGAAAGAGCCGTCCTCGTTGACATAGATAAAGA +AGTAATAGAAGTTTCCAAGAAGTACCTCCCCACGCTATCGGTTGGTTTTCAGGACCCGAGAGCCATAGTC +GTGAACGAAGACGGCTACAAGTATGTCCAAGATTACGAGAACGAGTTTGATGTAATCATCGTAGACTCAA +CGGATCCCGTCGGATTTGCCCACGTCCTCACCACAGAGGACTTCTTCAGACACGTCTACAAGGCGCTAAA +GGAAGACGGAATATTCGTGGCTCAAACGGAGTCCATCCACTACCACCTTGAAATGGTGAGTAACATACAA +CAAAGACTAAAGAAAGTGTTTCCTATTGTTGACCTGTACACTTCCGTAATTCCCATATACGCCGGTTACT +GGTGGACCTTCTCAATAGCTTCCAAGAAGTATCCTGTGAGGACTCCCGCTAGGGAGGTAAAGGTCCAAAC +GAAGATTTACGACGCGGACATGCACGAGTACGCCTTCCTTCCCGAGAGCTTTTACAACAAGATTGTAAAC +GGAGAGTACAAGTATTAAAATAAATCTTTCAACCTCGTTTCCCCGCCCTGCGGGGAGACCTTAAAAAGGC +CAGGAGGTGAAGTATGCCGAGGTTGAGGCACTACAAAACCTTAAGGTATTACGAGACAGTTTTTGCTGTG +AAGCCCACTCTCAGCGAAGAGGAGATGAAGAAGAAGTTTGAACAGGTCAAGGAGTTTATCAAACAAAAGG +GCGGTGAGATACTCTACGAAGAGGACTGGGGTATGAGACAACTCGCCTACCCCATACAGAAGTTCAACAA +CGCCAGATACTTCCTTGTGCAGTTCAAGACCGAAAACCCCCAACTCCCCAACGAGCTTGACTTCCAGCTG +AAGATTGACGAAGACGTGATAAGGTGGTTAAATTTTCAAATTAAGGAGAGTGAAGTAAAGAAAAATGCTC +AATAAGGTTTTTATAATAGGAAGACTTACGGGTGACCCCGTTATAACTTATCTACCGAGCGGAACGCCCG +TAGTAGAGTTTACTCTGGCTTACAACAGAAGGTATAAAAACCAGAACGGTGAATTTCAGGAGGAAAGTCA +CTTCTTTGACGTAAAGGCGTACGGAAAAATGGCTGAAGACTGGGCTACACGCTTCTCGAAAGGATACCTC +GTACTCGTAGAGGGAAGACTCTCCCAGGAAAAGTGGGAGAAAGAAGGAAAGAAGTTCTCAAAGGTCAGGA +TAATAGCGGAAAACGTAAGATTAATAAACAGGCCGAAAGGTGCTGAACTTCAAGCAGAAGAAGAGGAGGA +AGTTCCTCCCATTGAGGAGGAAATTGAAAAACTCGGTAAAGAGGAAGAGAAGCCTTTTACCGATGAAGAG +GACGAAATACCTTTTTAATTTTGAGGAGGTTAAAGTATGGTAGTGAGAGCTCCTAAGAAGAAAGTTTGTA +TGTACTGTGAACAAAAGAGAGAGCCAGATTATAAAAACTACGAAGAACTCAGGAACTTTTTAACCGAAAG +GGGAAGGATTAAAGATAGAAAGCAAACCGGACTTTGTGCAAAGCACCAGAGGAGACTAGCTGTTCAAATA +AAGAGGGCGAGACAGCTCGGACTACTTCCCTACGTTGTTTACTAAAAACTTGTCCCTTCCTCCCTTTTCC +CTTAAATTATTCTCTAAGGAGGCGATTTAATGCACTTTCCTCTGCCGTGGCAATTAATACTGATACTCTT +GGTTATCCTCGTAATCTTCGGTGCTTCAAAACTCCCCGAAGTGGGTAAAGGTTTGGGAGAGGGGATAAGG +AACTTTAAGAAAGCGCTCTCAGGTGAAGAAGAGGAAAAGGGGAAGGAAGTTAAAAAGGAGGGTGAATAAA +TGTTTCCCGGCGGAATATCTATGACAGAGTTAATCATAATCCTTGCGGTTATCCTGCTACTCTTCGGTGC +TGGAAGACTACCGGAAGCCGGAAGAGCGCTTGGTGAAGGTATAAGGAATTTCAGGAAGGCACTTTCAGGG +GAGACGGAAGTAAAGGAAGTGAAGGCTGAAGACGTAAAGACGGAGGAGAGGAAAGAAGAAAAGAAGGAAG +AGAAGGAAAAGGTAGAGGCTTAACTCAGCAATTGAGCCACCGTTTGAATTGAACGCTGAAGGTTTCTCGT +ACGCAGTACCTCACTGTAAGGGGAAACGTCTATTACGTAACCGTCCTCTTTCCTCTTAATCTGGATAAAG +AACTTTTGAAGGTATCCCTTTTCCGAAAGTAAACACTCCACTAAAAAGTCCTTATCCCTTTGCCAAACTT +TAAAGGTTTTGAAGTAAACTTCTTCATCCAGTTTAATTTCTCGGCTTTCAATTTTCTTAGGATCTACGCT +TTCCACTTTTACCTTTACCGGAAACAATTCCCGTACCTCCTCAACCTCTGGATGTTCTACAAACTTCGGT +TCCTTAACCTTTCTCAAAATTAACTTGTAAAGTGTTTTTCCCATGGAAAGCCACTTTTGTTCATACTTGG +TCAAAGGCTCTTTTACGTTTAAAGTTCCCTCTTCTACCTCAAAGCAGTCTAATACCTTTGCACTTTCTTT +TGTAAATTCCAGAAACTCGTAGTTGTCGGTCCTTATCCTTATCTCTCCGCCGAGTTTTAATTTCTTCGCA +AACATGTAAAGTCTTTCGGGCTTTGTTAACCTCCTCTTGTGGTGCCTCTTCTTAAACCACGGATCCGGGT +AATTCATGTAGATGTTCTCAACGTAGTTATCTCTAAAGAGAAAGTAAAAGCCCCAGTAGGCGTCAACGTT +TGTGCAGTAAACGTTCTTTAATCCTTTTTTCCCTACTCTTTTCATCAGTTTTTCAATAGAAATCTGGGAT +ATCTCTATGCCGAAGAAATTCTTATCGGGATTTTCCTTCGCAAGCTTTACTATAAAGTCTCCTCTTCCGA +AACCTATTTCTACCTCAAGATTGGGAATTTCTACAGGTCTTTTTACCCTTTTGTAATTTACGTAACAGAG +CATCAATTATAATCTTAAACTGAAATGCTTACGGACTTAGGGCTACTGACACTCGGGTTTTTCTTACTGG +TAAAAGGAGCTGATATGCTCATAGAAGGAGCTGGAGGGCTTGCGAGGCGCTTCGGGATACCCGAATTCGT +AATAGGTCTGACGCTCGTGGCTTTCGGAACATCCCTTCCCGAGTTTACCGTGAACGTAAGTGCAGCACTC +AAAGACGCTTCGGGTATTTCTCTCGGAAACGTTATAGGTTCAAATATAGCAAACATTCTTCTTATCCTCG +GTGTAGCTTCATTGATAAAGCCCCTTACTGTTCACGCCACATTCGTAAAAAAGGAAATTCCAGTGAACTT +TTTTCTTACGTTAACGCTCATAGTCATGGCAAACGACGTTATCTTAAATCACGCTCCAGTTTCTTTGATA +TCCCGTGGGGACGGACTTGTCCTGATAATAACTTTTCTGGGATACATGTACTTCCTCGTGGCTTACTTGG +AAAGGGACAGCATTCTTGAAGGAGAGATGAAAGAAAGCATTTCTCCTTTTAAGGGCTTTATCTACTTCAT +TCTCGGACTTACAGGTCTTTCTCTGGGAGCAGACTGGACGGTAGACGGCGCAGTCGGACTCGCTAAAGCT +CTCGGAGTTAGTGAAGCTGTAATCGGGCTGTTTGTCGTTGCAATAGGAACATCTCTTCCGGAACTCTTTG +CCTCCGCGGTATCAGCCTATAAAGGAAACCCGGATATCGCTCTCGGGAACGTTGCGGGTTCAAACATTTT +CAACGCGACTCTAGTCCTTGGAACGAGCTCCGTTATAAGGGACATTCCCGTTCCAGAAAGGGCTAACGTG +GATTTGGGAGTTTTGTTCATTGCCACACTCTTACTTCTGATATCCTCCATCTGGGGTAAAAGGAAGTACA +CGCTCGACAGAATGGAAGGAGGAATATTTTTACTGGCTTACTTTATTTACGTTATAGCTTCTTGGTACAG +GGAACTCAGCTGAAGATTTCCTCGTAAAGTTTCTCGTCTATCCTCTTTAATTTGTGTCTTTCTTTTGGAA +CTTCGTCTACCTCAACGAAGTATAAACAGTTCGTTACACACTTCTCAACGCAGGAGGGAAGCAGTCCTTT +ATCAACCCTTTTGTAGCAGTAATCGCACTTTTCTACTTTTTGTGTAGCGGGATTGAAAGTTATAGCTCCG +TAGGGGCAGGCTATTATGCACGCTTTACAGCCTATGCACAGAGTTTGTTCCACGTAAACTATACCGTCCT +TCTCCCTCTTTCTCATTGCGGATGTAGGGCATGCAACCACACAGGGAGCTGGGTCGCAGTGAAAGCAGTT +CATGGGGTAGTAAAAAGCTCCCGGTTCTTCAGATATACCTTCTACCCTGAAAACTTTCATGGGTCTTATA +TACAGGCTCTCCAGTCCCTTCTCCTGAACGCAGGCTACTTCACAGGAAAGGCAGCCTATGCACCTGTCCA +GGTCTATGAGCATTATAGGACGCTTCATCTGAGTATCCTCAGGAGGATAGAGAGTATAAGGATAAGTATT +AAGGGGGAAAAGTCAATGCCGTTAATCGGTTTTACGACTTTCCTTATCGGCTCTAAAAAGGGAGACACTA +TCCAGTCTATGTACCAGTAAATTTTACTTCTCCTTACCTCGGGAAACCAAGACCCGAGTGCGTGAATGAA +AGTAAGAAGGATGAGGAGCTGAATGAAGACTTTAACGAGTTTTATTATCACTACTCAACCCATTCTATGA +TGGCCATTTCAGCTCCGTCTCCTCTTCTCCTGTAGGGGAGTTTTATTATCCTTACGTATCCGCCGTTCCT +TCCTTCAAATCTGGGAGCTATATCCTCAAAGAGTTTCTTTATAGCTGGTTTGTCGGGAAGTCTGCTGAGT +GCCTGTCTTCTTGCGTGGAGCGTTCCTTCTTTTGCGAGCTCAACGAGGGGTTCTATGAAACTCCTGAGAG +CCTTTGCCCTTTCGACGGTTGTCTCTATTCTCTCGTCAAAGATTAACGCCCTTGCAAGGGATCGGTAAAG +TGCAAGCCTTTGTTCCTTAGTTCTGTCAAAGTGCTTCTTCTTAACCCTGTGCCTCATCTCACCTACCTCT +GAGTTTCAATATTCATACCGAGCTCAAGCCCAAGCTTATGAAGTGCTTCCTTTATTTCAGCAAGTGCCTT +CCTTCCTATGTTTTTAGTGCTTTTTAGCTCATCTTCCGTCATCCTGACAAGGTCCCCTATTGTGGTTATA +CCTATTCTCTTGAGGGAGTTAAGTGCTCTTTGGGATATGTCGAGTTCTTCTATGGAGAGGGAGAGTTTTT +CCGCAAGTTCGTCCACCGCTACCTTTTGAGGAACTGTCGGTTTTTCCGTAAATATGTTCTCAAGGAGTTC +GTAGTGCTTCTTGAGTATTTCTATTGCTTCCTGCATGCACTGGTCGGGAGTTTTTATACCGTTCGTGAAT +ATTTCAAGTGTAAGCCTTTCGTAAGTGGATTTTTTCCCTACCCTTACGTTATCTACCCTGAAACCTACCT +TCTTTACAGGAGAAAAATCAGCGTCCACGAGAATCCAGCCCACTTCCCCTATAGCTTCCATTTCCTCTAC +GGGAACGTATCCTCTTCCCCTTTCCACACGAATTTCTATGTTAAGCTCCTTGTTCGGATCCGTTATAGTT +GCTATGTACTGGTCGGGATTGAGTATTTCAACGTTTGGAGGAGTTTTTATATCGGACGCCTTTACCTCCC +CTTCTCCCTTTTTCTGGAGATAAAGTATTTCAACGTCACTGTCTCCCTTCATTAAAAACTTAATTTTTTT +AAGGTTTGCTATGAGTTCTATTGCGTCCTCCTGAACGCCTTCAATCGCAGAAAACTCGTGGTAAATACCG +TAAATCTTTACCGCAGTAATGGCAGTTCCGCTAATGGAAGAGAGGAGAACCCTTCTCAGAGAATTTCCAA +CGGTAGTGCCAAATCCCCTTTCAAGCGGTTCTACTACGAGTCTCCCGTAAGTGTCCGTTTTTTCTTCCCA +GAATATCTTGTCGGGGTATATAAACTCGTTTAACATTCAATACCTCCGTTATACCTTAGAGTAGAACTCA +ACGATGTACTGAAGGTTTATGGGTATCTCGAGGTACTCCTGCACGTTTTCGGGAAGTCTTACAACTCTTC +CCCTGAAGTTATCCTTGTCGAGTTCGAGCCAGCTCGGTATAGATCTCGGGTCTACGTTTTCAAGGTTTTC +CTTTATGAAGGGAATGTCTCTGGACTTTTCCTTAATTTCTATAACGTCTCCGGGCTCTACAAGGTAAGAG +GGAATGTTCACCTTTTTTCCGTTTACGAGAACGTGCCCGTGTGCTACAAGTTGCCTTGCCTGTCTCCTCG +TGGAGGCAAATCCCAGTCTGTAAACTACGTTATCGAGCCTCCTCTCAAGGTACTGAAGGAGCATTTCACC +GGTATTTTCCTTTGACTTGGAAGCCATATCGAAGTACTTCTTAAATTGCTTTTCTCTGAGTCCTCCGTAG +AGGAATTTAAGTTTTTGTTTTTCCATTAAACGCAGACCGTACTCGGTTAACTTCTTTCTCCTTCCGTACT +TTCTTCCGTGTTGTCCGGGCGGATAATTTCTCCTGGCAAGGATTTTGGGAGCGGACTTCTTACCGGAAAC +TACTACACCAAACCTTCTGTCAAGTTTTACCCAAGGACCTATATACCTACCCATTTACACTCTCCTCCTC +GCAGGTGGTCTGCAACCGTTGTGGGGAATAGGCGTAACATCCCTTATGGCGGTTACCTTTACCCCCGAAG +CGAATACAGCCCTTACCGCTGACTCCCTTCCTGCTCCGGGGCCTTTGACCCATATCTCAACTTCCTGAAC +TCCGTGTTCCTTTGCCTCTTTCATAGCCTTTTGAGCTGCAAGCTGTGCTGCGTAAGGGGTTGATTTTCTC +GTGCCCTTAAACCCTACAGTTCCACCGCTAGCCCATGCGATGGTATTTCCCTGAGTGTCTGTTACGTTAA +CTATCGTGTTGTTAAAGGTTGTGTGTATGTGAACTATGGCTTTTGTTACCTGTCTTTTCTGTTTCTTTTT +CTTTTTCGCCATTTATGTCAACCTCCTTTACTTGGCCTTAGCTTTCTTTGTTCCTCCAACAGTTTTCCTC +TTACCCTTTCTGGTTCTCGCGTTTGTTCTCGTTTGTTGACCCCTTACGGGTAGTCCCCTTGCGTGTCTGA +TACCTCTGTAGCATCCCATATCCTTGAGTTTCTTAATGTTTAGCTGAACTTCCCTTCTCAGGTCACCCTC +TACCTTATAGTTTTCATCTATGAACTTTCTAAGAGTGTTTAGCTCGTCGGGGGTTAATTCTCCGACCCTT +TTGGTACAGGGAATTCCCGTCTTTTCACATATCTCCCTTGCCCTAGACCATCCTATTCCGTAAATGTAGG +TGAGTGCGACCTCCAGTCTCTTGTTGTTAGGCAAATCAACGCCCGCTATTCTCGCCATTTCTAACCTCCG +TTACCCCTGTCTTTTGCTTGTGACTGGGTATTTCGCAAATTACCATAACTCTTCCCTTTCTCCTTATTAT +CTTGCACTTAGCACACCTTTTCTTCACGGAAGACCTAACTTTCATACCGAACCTCCACAATAGCGGAATA +TCTTAGTATAACCTAAGTCCTTGCCTTTTTCAACTTTACAATCTGTAAACTATCCTTCCGCGGGTGAGGT +CGTAGGGAGAGAGTTCCACCTTAACTTTGTCTCCGGGCAGGATTCTTATGAAGTTAACCCTGAGTTTCCC +GGCTATGTGGGCAAGCACTTCCTGCCCGGTTTCAAGCTTTACCCTGAACATTCCGTTTGGAAGGGCTTCA +ACAACTTCTCCTTCGAGAAGTATGCCCCTCTCCTTTTCGTGCTCTTGCTTTCTCTTCTTCTTTCCCATCC +TTACAACTCCGTTAAAATTACTGGTCCTTTCTTAGTTATGGCCACTGTATGCTCAAAGTGAGCTGCCAAG +CTGCCGTCCTTAGTCTTTACGGTCCAGCCGTCTCCGTCTTCTACGGTTTCCTCCGTGCCTATTGATAACA +TGGGTTCGATGGCTATTACCATTCCCTGCCTGAGCCGTGGGTTCTTCTTTCCTATGTCTTTTACGTTGTT +GGGAACAAAGGGCTCCTGATGAACTTTCCTTCCTACTCCATGCCCGCCATACCTGAGTATGGTCTTAAAT +CCGTACTTCTCGGCGGTTTCGTGTATGGCTTTTGTTATGTCCCCCACCTTCTTTCCAGGAAGTGCCTTTT +CTATTGCGTTGTAAAGGGCTTCCTTGGTAGCTTCAAGGAGTTTTTGGGCTTCAGGGCTCCCCTTTCCCGC +TATAACTGTAATCGCGGAGTCTCCCGCGTACCCGTCGTATATAGCTCCGAAGTCTATGCTAACCACGTCT +CCTTCTTTTATCACTTTTTCTTTCTTTGGAAGTCCGTGAACTACTTCGTCGTTTATTGATATACAGAGAG +CCGCTGGGTATCTTACATCGGAAAAGGGCGGTTTATAACCTAAAAAGGCAGGCTTTGCCCCTCTCTTTTC +GGTTTCCTTTCTCGCTATCATCTCGAGATCCCACGTGGAGACCCCGGGCTTTACGTTTTCAGCCACTATA +TGCAGAACTTCCGCAACTATCTGCGAAGCCTTGCGTATCTTTTCTATCTCCCTCTGAGAGTACAGTTCAA +TTGCCATCTCCTATAACCTCTAAAACTTGCCTGTAAACCTCCTCAACAGGTTTACTTGCGTCTATTATTC +TTAATATACCTTTCTTCTTGTAATATTCAATGAGGGGAGCGGTTTGCTCTCTGTAAACCTCGAGTCTCTT +TTTAATGACTTCGGGTTTGTCGTCTTCCCTTTGAATAACCTTCACACCGGGAGGCGGTGGGTTGTACTTC +ACGTGGTAAACCTCTCCCGTTTCGGGATTTATCCTTCTTCCTGAAAGCCTTTCTATTACCACCTCGTCGG +GAACTTCAAAGAGGAGAACATGGTCAACTTTAAGTCCTTTCTTTTCAAGCATCTCGTCAAGGGCCTCTGC +CTGTTTTACGGTTCTGGGAAAGCCGTCAAATATGACGTTTCCGTGCTTCGGAAATACTTCCTCTATTAAA +GCTATTATTAAGTCATCGGGAACGAGTTCCCCCCTTTCCATGTATTCTTTGGCTTTTTTACCGAGGGGTG +TTCCCTTCTGAACGGCTTCCCTTAAGATATCTCCTGTGGATATGTGGACAAAGCCCTTCTCTTTTGCGAG +TCTCTTAGCCTGAGTTCCCTTTCCTGCACCGGGAGGTCCTAGGAAAACCAGTATCATTCTTTTACCTCCT +TACATAACTCTTGTACTTCTTCTGTATCAGGTAAGTTTCTATCTGCCTGAAGGTATCAAGGGCAACACCT +ACAACTATGAGGGCTGTGGTTCCTCCAAAGTAGAAGGGAATGTTAAACCAGACGCTTATAAGTATGGGGA +TGAGGGCTATTACGGAAAGGAAAAGTGCTCCAAAGAATATGAGCCTGTTTATTATCCTTTCCAGATACTT +TACCGTGTCCTGCCCGGGTCTGACTCCGGGAATGAAAGCTCCAGCCTTGTGGAGGTTCTCCGCAAGCTCA +ACGGGGTTTATTAAAACCGCTGTGTAGAAGTAAGTAAAGAAGACTATGAAGGTCACGTAGAGGAAGTTAT +AAAATATGGCTCCGGGCTGGAACATGTCCGCTATTACCTTAATAAAGGGATTCTGCACGAAGTTGAGAAG +AGTAGAAGGTATTAAAAGTAGTGCTTGGGCGAATATTATTGGTATAACACCTGCTGGGTTTATCTTTATG +GGCAGGTAAGTTTTCCTTCCGGCGTAGAGTTGTCTTCCCACCTGCCTTCCGGGGTACTGAATGGGAATTC +TCCTTTCTGCTTCCTGGACGTAAACTATTCCTACAATAATGGCAATTATTAAGGCGATTATTAAGAGAAG +CGTAAGGGGACCTATGTCTCCAGTCTTCACCTTCTCATAAAACTGGATTACGGCGTTCGGAAAGTTCGCA +ACTATACCCGCAAATATAATGAGGGATGCTCCGTTTCCTATGCCCTTTTCCGTAATCCTGTCCGCTATCC +AGACCAAGAACATAGTTCCCGCAACGAGGGTGAGTACCGTTATGAGGATGAAGCTTATGCCGGGATTTTC +AACCACCGGAATACCCTTAGGAGATACCTGCCCCCTTATCCAGAAGGCTATACCTAGGGACTGAACTGTA +GCCACGAAAAGTGTTAAGTACTTTGTGTACTCGTTTATCTTGTACCTCCCGTAATCCCCTTCCTCTTTTG +CGAGCCTCTGGAGCGAGGGAATGGCAACGGTGAGGAGTTGCATCATTATGGATGCGGATATGTAGGGCAT +AACACCGAGGGCAAATACCGTGAGTCTTCCCAGATTACCACCTGAGAAGATATCGTAAAGTGCGAAAACA +GAGCCTTCAAAAGCCTTTAAGAAGTCCCTCAAAGCTTCCGGGTTTATACCAGGTATCGGTATGTGACTGC +CGAGTCTGTATATTACGAACATGAGTAGAGTGAATATGAACTTCTGTCTTAGTTCTTTTAATTCAAAGAG +GGCTTTTAAGTACTCGGACATGTTAAAAGATTTTAATATAATAAAGTTCTCTCGGAGGTAGAAGAATGGC +TGATAGTGAGATTTGTGGAAAGAGACCTGTTGTCGGAAGGAGAGTCACCTTATCGGGTGAGAGGAACAGA +AGGATTTTTAAACCGAACGTCCATAAGATGAGGGTAATGCTCCCGGATGGAACGGTAAAGAGGATGTACG +TGTGCACCAAGTGCCTCAAGGCGGGTAAGGTAATGAAAGCACCCAGAATTCCCAAGGAAGGTTAATGTCT +TTAAGGTATTTGAGATTTCTGACAGCCGGAGAGTCCCACGGTAAGGGTTTGACCGCAATACTGGAGGGTA +TACCCGCAAACTTACCCCTTTCCGAAGAGGAAATAAACCACGAACTCAGGAGAAGGCAAAGGGGATACGG +GCGCGGCGGTCGTATGAAGATAGAAAAGGACACCGCGGAAATACTCTCGGGTGTCAGGTTCGGAAAAACC +CTCGGCTCTCCCATAGCCCTCTTTATAAGGAACAGGGACTGGGAAAACTGGAAGGAAAAGATGGCGATAG +AGGGGGAACCCTCCCCTTCCGTTGTTCCCTTCACGAGACCCCGCCCGGGGCACGCTGACCTCTCCGGAGG +GATTAAGTACAACCAGAGGGATTTGAGGAACATTTTAGAGAGGGCTTCTGCAAGAGAGACAGCTGCAAGA +GTTGCGGTAGGAGCTGTTTGTAAAAAGTTCCTCTCTGAATTTGGTATAAAGATCGGGAGTTTCGTTGTAA +GCATAGGCCAAAAGGAAGTGGAGGAGTTAAAAGACAAAAGCTACTTTGCCAATCCTGAAAAACTCCTTTC +TTACCACGAGAAAGCGGAAGATTCGGAACTCAGGATTCCCTTCCCGGAGAAGGACGAGGAGTTTAAAACC +TACATAGACGAGGTGAAGGAAAAGGGAGAGAGTTTAGGAGGAGTTTTCGAAGTTTTTGCCCTGAACGTCC +CTCCGGGACTCGGTTCTCACATCCAGTGGGACAGAAGGATTGACGGAAGGATAGCTCAGGCGATGATGAG +CATTCAGGCCATTAAAGGCGTTGAGATAGGACTTGGTTTTGAAGCCGCGAGGAGGTTCGGCTCTCAGGTT +CACGACGAGATAGGCTGGAGTGAAGGGAAGGGCTACTTCAGGCATTCTAACAACCTCGGAGGAACGGAAG +GAGGGATCACAAACGGCATGCCGATAGTTGTGAGAGTCGCGATGAAACCCATACCGACTTTAAAGAACCC +TTTAAGGAGTGTTGATATAGAAACAAAGGAAGAGATGAAAGCAGGAAAGGAGAGGACGGATATAGTAGCA +GTTCCCGCGGCATCTGTCGTGGGAGAAGCTATGCTCGCCATAGTTCTCGCGGATGCACTCCTTGAAAAAC +TCGGCGGAGACTTTATGGAAGAAGTAAAAAAGAGGTTTGAGGATTACGTGAACCACGTTAAGAGTTTCTA +AGATGAAGATACTCTCGATAGACACATCTTTTTCCTTTATAAACTTCAGCGTAATAGAAGAGGAAAAAGT +AACTTTTTTACATTATTTAAAGAGTAATAAAAAAACCCTGGAACTTTTGCCGAAAATCTTTGAAGAACTG +TGTATAAGACCTGAAAACTTTGACGCTTTTGCAGTTTCAGTAGGAGTGGGTTACTTAACCTCCCTGAGGA +TAGGCGTAACTTTTGTAAAAACCTGGGCCTATACCTTAGGAAAACCCGTAGTTTCCTACAAAAATTTAGA +ACTTCTTGCTAAAAAAACTCCCGTTCCTTTTCCCAAAATCCCATACCTTAAGGTGGGAAGTAACGTCTTT +TATCAGATTTTTGAGGAAAGTTCTTCAAGCGAGGTTAAGGTTTTCAAAGGAGAAGAGTTAAGAGGCTACG +GTATAAGCTTAAAAGAATTTGAAGATATAAAACTGGGAGAAAAGCAGTTCTTTCACGATATCTTCCCTTT +TTCAGCATACGGAGGAATTTACGCTTATGAATTTTTAAAAGAAAATCCCGAAGGTGAAAACGTTTTTGAA +ATAGAGCCTATATACGTAAAGCCACCCTATCACGTCAAAGATTGAGAGATTATCTTTTCAATTTTCTCGT +TCAATTCCTCTAAATTCGGGTTTTCAAGAGGTTTAGAAAATATAAATCCCTGCACAAAGTCCGTTCCCAT +GTAAAGCACCGTTTTTAACTCCTCCAAGGTCTCAACACCTTCTGAAACGACTTTTATGTTGTTCTCGTGG +GCGAGCCTTATGAGGTAATTCACTATAACTTTCTTCATACTGTGCTTGTGAATATCCCTTATCAACTCCA +TGTCTATCTTTATGATGTCGGGTCCTAGTTCCGAAAGGTAGAATAGCCCGGAATATCCCGAACCTACGTC +GTCAAGTGCAATCTTCACCCCTTCGCTCTTCAGAAAGGAAATCAGACTCTTTACAGCACTTATTTCAAGC +TCTTCGTACTCTGTTAATTCCACTACTACCTGCCTTGGACTTACGTCGTGCATGTAAAGGGTAGAGATAA +AATCTCCAAAGACCTTCAAGGGTTCCCTCAAGAACCGCGGGTGGAAGTTCAAGAAAAGCCACATGTCTTC +TTTTAGAAACTTTCTGGCATTTTTTAAAGCCATGTACCTGCAGAAGTTTTCGGAAAATTCGGAGGTGCTC +TTCCCCATGTTTATCAGGTCAACGATCTTTATAGGCGGTCTGCAGAGTGCTTCAAAAGCTTTAACTCTTT +TTTCTTTAACGTCAACGATAGGATGAAACAGGGTTTTAGTGTCTATAAATATGTTCCCGAGGCTGTGGTA +TATGACCTTGTCTATTAAGTTCGTAACGGGTTCTGCCTTGGAAATCGCCTTCACTATATTTTCGCAATCG +TTACCAACTTCCCCCTGATAAACTTTTAGGTCCTTTAATGTGTTTTCGTCCATTTCAGAAAGGAGGTAGA +GAATTTCCTCGTCTTTTAAACCTGCGGTTATTACGGCTGTGCCTGTGCGTCTTGTTTTTGCACCTGTGCT +ATGTAGACTTTCCTCAAACTCCCTTGCCTTCTCTTCATCTTTGAAAAGAAAAAGTATTTCTTCCATGTTA +TCCTTTCCAGAAATGGAACGTCCAGCAATATGTATTATAGGCTTTTTAAGCGGTTTCCTTTACAACGAAA +GCATATACAGAAGAGCCAAAAAAGGGAAAAATCCCATAGTAACCTTTCCCGTGAGGTTTTTCCTCCTCAG +CGTTCTTGTTTTCTTTATCGTTTACTTTTACAAGGCTGAAGGGGCTATTCTCTTTACGATTTCCCACCTT +CTCGGGCGTTTCTTCCAGCTCTTTTTTAGAGTAAGGTTAAATTAGTAGTTATGGAAAAGTTTTTAGTGAT +AGCTGGACCCTGCGCGATAGAGAGCGAGGAACTTCTCCTAAAGGTAGGGGAGGAGATAAAGCGTTTATCG +GAGAAGTTCAAAGAAGTTGAGTTCGTATTTAAGTCTTCCTTTGATAAAGCGAACCGCTCCTCAATACATT +CCTTCAGGGGGCACGGTCTTGAATACGGGGTAAAGGCTCTGAGGAAGGTAAAGGAAGAGTTCGGACTGAA +GATTACCACGGATATTCACGAGAGCTGGCAAGCTGAACCAGTTGCAGAAGTTGCGGACATAATCCAGATA +CCTGCCTTTTTATGCAGGCAGACTGACCTCCTCCTTGCGGCTGCAAAAACGGGAAGGGCTGTAAACGTGA +AGAAGGGTCAGTTTTTAGCCCCTTGGGACACGAAGAACGTGGTTGAAAAATTAAAGTTCGGCGGTGCTAA +GGAGATATACCTCACGGAGAGAGGAACTACCTTCGGATACAACAACCTCGTTGTAGATTTCAGGAGCCTA +CCCATAATGAAACAGTGGGCAAAGGTTATATACGACGCCACCCACAGCGTCCAGCTCCCCGGAGGTCTCG +GGGACAAATCAGGAGGAATGAGGGAGTTTATATTCCCCTTAATCCGTGCTGCGGTTGCGGTAGGTTGTGA +CGGTGTGTTTATGGAAACACACCCAGAACCAGAAAAGGCACTCTCGGACGCATCAACTCAGCTTCCCCTC +TCCCAGCTGGAAGGGATAATAGAGGCTATCCTTGAGATAAGGGAAGTGGCTTCAAAGTATTACGAAACAA +TTCCCGTTAAATGAAAGAAGCACTTTTCTTAAGCCTGAAACTCTCCTTTTTCACAACTTTAATCCTGCTT +TTAATATCTTTAGTCCTTTCTCCACTCCTGGCCTTTAAGGAATTCAAAGGAAAGAGTTTAGTTGTGGCAC +TCGTAACACTTCCCTTGGTCCTCCCCCCAACGGTTTTGGGATTTTACTTAATACTTTTATTCTCTCCTGA +AAGTCCTTTTGGCAAATTAGTGCAAAGTATTCTCGGGAAAACCCTTCTCTTTTCCTTTGAGGGACTCGTT +GTTGCTTCCGTAATTTACTCCCTTCCCCTTGCGGTACTCCCTCTCACTTCTGCAATGGAAAAAATCCCGA +AGGAGCTCATATACACTTCCTACGTCTTCGGTTACGGGAAAGTAGAAACCTTTTTTAGGGTAATCCTTCC +CCTCTCTTTAAACGGTCTTATAACTTCCGTAGTTATGAGTTTTGCAAACACTATGGGGGAGTTTGGAGTT +GTTTTAATGGTCGGAGGGAACATCCCCGGAGAGACACAAACCCTTTCCATATTTATCTATGACGCCGTTC +AGGCACTGGATTACAAAACCGCTCACAGGGCGAGTGTGTTGCTCGTTGGTGTTTCACTCCTCGTTATGTT +CATAGTTCTCAAGGTAAGGGGGAGGGTGCGCGTAGACGTTTGACGTTGCAACAGTGTTGCAACACTGCAA +CACCTTCCTGAAACGCCCTTGTTGAAAATCAAAGGGAAAAGTTTGGCACGGAGTTTGCAATTAAAAAATG +TGAAAACCAAAAGGAGGTGTGAAGCATGGCAACACTTAGCAAGTTAAAGGAACTTATGTCAATACCCGGT +GCAGTTGCCGCGGGTGAGTTTAGCGACGATGGAAGGCTTCTAGCCTACTACGGCGACATAGACGAGAAGT +CCGCGGAGATAGCCGCCATGATGTGTGCAGCTAACAAGATGATGGGTAACATGCAGGCAAAGGGCTGGAG +TGCTTACACGGGCAAGGACGGCTTTTACCCGGTTATAGGTTTTGCGGTTGCGGGAGGCAAGTACGCAGCC +TGCATAATGGGAAACGTAGGTGTTTTCGTAGAGCTTGATAAAGCTGACTTTGACAAAATTTTTGAAACCC +TTTCCAAGTTCATTTAAAAGGAGGTGGAGCGATGGCAAACTTAGACAAACTTTTACAAATTAAGGGAGTT +TTCGCAGCAGGCGAGTTCTCAGATGACGGAAAGCTCGTGGCTTACAAGGGTGATATAACCGAAGAAGAAG +CCGCTATGGCTGCGGAAATGTGTGCAGCAAACAACGCCATGGCCAAGATGCAGGCTGATGGCTACACAGC +CTTTTCCGGAAAAGAGTGGACTCCCCTTGTAGGATGGGCACTCACGGGACCAAAGTACTCGGTTTGCGTT +GTTGGAAACGTAGGAGTCTTTGTAAAGAACGATGAAGTTTCCTTTAACGAAGTATTCAAAGCTTTGAGGG +AGGAGGCGGGCAAGTAATCTCTTTTCCTTTCTCTTTACCACTTTTTGGAGGATAGAATGGCTTACAAGTT +TCTTTCAGAAGACTGGATAAAGGCGTACGCAGAGGAGTGGAACAAAAACGAAAAGTTAATGAACGACCTC +AAAAACTTCTCGGCGAGTATAAAGTACTACGTGGAAGGTAAAGAAAATGACGCAGTGGAGCTGATAATTG +AAAAGGGAAAGGCTGTTTCCGCAGGAAAGGCTGACCCTAATAAAAGGTACGACTTTGAACTCTGGGCAAG +TCTTGAGAACTGGAAAAAGCTCGCAACGGGGGAGATGGGCCCCAGAGCCGCGATGCTCACAAAGAGGTTA +AAGTTTAAGGGTTCTATGATTACAGCTATGAAGTACATGGGAGCCTTTGAAGAGAGCTTAAAGATGATGG +GCAGAGTTCCGACGGTCTGGGATGTTTAAATTTATAAACAAGGTGGATTTTAAAACATTTGACGAAATTT +TTGACGGTGTTCTCGTAATAGATAAAAACAGGAGGATAGTTTTTGCTAACAAAAAGGCAAAAGAAATACT +GGGGGAGGTAAAGGAGGGAGAGTCCTGCAGGGGGCTTTTTTCCATTTGTGAACACTGCCCTATGGAACTT +GTTGAGGACTCAGAGCAAGGAGTTCAGGTTTACGACGTCCTGACGAAAAGGAAAAATCACGTGTGCCTCA +GTATGAGTCCCCTCTTTGAGGGAGGGGAATTTACAGGAGTCCTTGAAGTTTTCAGGGATGTGAGCAAGGT +AATCCACTACATGGAAGAGGTTAAAAGACAAAAGGAGTTTGTAGAAGTCGTACTTGACTCTATCGTGGAG +GCTGTTCTCGTTCTGGACGAAAAAGGGAACGTTATAAACCACAACGGGAACGCAAGCAAAGTTCTTTGTT +CCAGGTTTGAAAGCATCACAGGAAAAAATCTGAAGGAAATAACTTCTCTGAGTCTGGAAGACCTCCCGCC +GGAAGGAGAAAGGGCGGACATTTACATAGAAACTCCCTGCGGTAGGCAAAAAGCCTCCGTTCTCCTCTCA +AAACTGAAGCAGGGAAAGGGCTGGGTTCTTTCTCTATACATAGTTCCCGAGATATTCGCAGGTGAGGGAA +ACAAGTTAAAAATCGTTACAAAGAGTCCAAAGTTTCTGAAGGTTCTGGAAAAGGTAAAAACGATTTCCGA +GATGAATGTAAACGTTTTGATCACTGGAGAGACGGGAACGGGAAAGAGCCTGCTCGCCAGATATATACAC +TACCTCTCTCCCAGGAGGGACAAGCCCTTCGTGAAGATAAACTGCGGTGCTATTCCTGAAAACTTACTTG +AGGCGTAGCTCTTTGGCTACAACAAGGGAGCTTTTACAGGAGCAATTGCGAGTAAACCCGGAAAGGTAGA +AATGGCAAACGGCGGAACACTTTTTCTGGATGAGATAGGAGAACTTCCGCTACACCTTCAGGTAAAGCTC +CTCGGATTGATTCAGGACAAGGAGTTTGAAAGGATAGGAGATCTAAAACCGAGAAAGGCGGACGTTAGGA +TTATCGCGGCTACTAATAAAAACCTCAAAAAACTGGTAGAAGAAGGGAAATTCAGGGAGGACCTTTATTA +CAGGTTGAACGTCGTGAACGTGGAATTACCACCACTCAGGGAGAGGAAGGAGGATATACCTCACCTTGTG +AGTTACTTCCTCGAGAAATTTTCAAAGATCCACGGGAAGAAGGTTAAGGGAGTATCTCCCGAAGCCATGA +AACTGCTCTTAGAGTACGATTATCCGGGAAACGTGAGGGAACTTGAAAACGCAATTGAACACGCTGTTGT +GGTCTCAAGCACGAGTTTAATAGGACCCGACGACCTGCCTGAAGAGATAAGAATCGGAAGCAAAGTTAAG +AAGAAGTTCAGGGAGAACGAGGAACTGGAGAAGATAAAAGAAGCCTTGGAAAGGGCTGGGGGAAACAAAA +GCCTTGCGGCAAAGCTCTTGGGTATCCACAGGACCACTCTGTGGAGGAAGTTAAAGGAATACGGGCTTGC +TTAGACACTGCACGCCTCGCATTCCTCAATATCCATAGCCGAACGGCTCCTGAGGTAGTATATCGTCTTT +AGTCCGAGTTCCCAGGCAAGTTCGTAGAGTCTGGAAAGCCTCGGCCCGTCTATGTTTTGAGGATCCACAA +ATAGGTTCAGGCTCTGAGCCTGGTCTATCCACTTCTGCCTTACCGCCGCCGCCCTTATGGTCCACTCGTG +GTCTATAGTGTAGGCGGTTTTGTAGTGCCAGTAGAACCTGTCTACCTCAGGAGGTACCTGAGGGAGTATC +CCGGACATGTTCTCCTCTTTGTAGAACCTTGCGAATATCGGGTCTATTGAAGGAGTTGCCCCGAGTATCA +GGGAAGTTGAACCAGTAGGCATAAGAGCGAGGAGGTACGCGTTCCTTATTCCATACTTCTTTATCTCCTC +CGCGAGTTCCCTCCAAGGCAGGTTATTTCCGTTCTGTCTTGAGTTTTCCTCTATTTCCTCAACACTTCTT +CCGAAGAGTATCCCCTTGCTCCAGTTTGAACCATCAAAGAGCTTGTACCTGCCCCTTTCCTTTGCAAGCT +CCAGAGAACCTTTCAGTGCATAGAAGGCTATTAGTTCAAAGAGCTTGTCCGCAAACTTAAGGTGTTCTTC +ACTTTCCCACTTTATCCCGTTCTTAACTAAACAGTAGTGGTAATTAGAAACTCCTATTCCTATGGCTCTG +TAGCGCTTGTTAGTGTACTCAGCTTCGGGTATGGCGTAGAAGTTCATCTCTATTACGTTGTCAAGCATTC +TCACAAGGAGTGGAAGAACTTCTTTTATCTCTTCTTCCGTATGAACTTTACCGAGGTTTACGGAACCGAG +GTTGCAGACTGGAAGATCTCCCGCCTCCTTTTTGTAAGTTATCTCTCCGGTTTCTGGATCTAATACGGGC +TTTTCGTGTTTAGAGGGAGACATTGTTTGTACTATTTCATGGCATAAGTTACTACTGTAAACCATTCCCG +TGTGTTTATTTGGATTCTTCCTGTTTGCCTCATCCCTGAAGAAGATGTAAGGTTCTCCCGTCTCAAAGGC +TACCGTGAGAAGTCTCTTCCACAGTTCGAAGCTGTTTACCTTCTTCTTCGCATAAGAAGGTAGGTTTTCC +TCAAGTTCAAGATACCACTTCTCAAATTCCTCTCCGTAGAAATCCTCAAGCCCTTTAGGTTCTAAGATAT +CCTGAGTTCCGTCTTCCTTTATGCCTACGTAGTAGTGACTTCCGGGAAGGGGTTTTACTTCCTTGTACTT +TCCGTCGTAAATCTTTCTCGTTATGTACTGCCTTGCCCAATATGGGTCTATCAAGGTCCAGTCTTCCCTG +TTTTTGAGTCTTTTCATAAAGAGGTCAGGGATTGATACTGCGGGGTGTATGTCGTGGGCTTTCTTTCTCT +CGTCTCCAACGTTTGTCTTTACTTCCAGAAAGTCAAGTATGTCCTTGTGCCAGATGTCCAGAGTGATGGA +AGCGGAACCCTTCCTCATTCCGAGTTGGTCCACGTAGGTCATCGTGTCGTTTATGAGCTTTACTACGGGG +ATTACTCCCGAAGAAGCTCCCTTGAACTTCCTTATGGGTGCTCCCGTTGCCCTTATCTTTCCGAGGTATA +CCCCGAGTCCCCCCGCAAACTTGGATATCATTCCCGCTTTCTTTACGTTGTCAAATATGTCAAAGAGGTC +ATCGTCCACTGTAAGCACGAAGCAGGAGGAAAGTTGTGTGAAGGGTCTTCTCGCGTTCATTAGGGTAGGC +GTTGCAACGGTTACTTTGTGCTCAGAAAGGACGTCGTAAAATTTTTTCGCCCACTTTAGTCTTTCTTCCG +GTTTTTCAGGAACTGCAAGTGTCATGGCAATGAGCATGTACATTTCTTGGGGAAGTTCTATTACTCTCCC +CTCTTCGTCCCTTACCAGATATCTGTCGTAGAGTATCTTTATCCCTGTGTAGGTGAAGTAAAGGTCTCTT +TCCGGCTTTATGTAGTTGGCGAGCTTATTGAAGTCCTCTTCGGAATAATTCTCAAGGAGGTACTCCCCGT +ATATTCCCTTCTCAACGTATTCTTTAACAAAACTGTAAAAGTTCTTTCTGTTATAGGGCTTGTACTTCCC +GAGGTCGTCCCTAAGAGAATAACCTCTCAGGTGTGCAACGTCCTTGTAGAGATCGTAGAGAAGAAGTCTC +GCCGCGGTGTACGTCCAGTCCGGCCTTTCGGCGGAAACTTTCTCCGCTGCAGTCTTTATTAAAAGCTGTT +GTATTTCTTTCGTAGTTATGCCGTCCCTGAACTGTATCTGGGCATCAGCTTCGAGTTCTAAGGGGTCAAC +GTTCAGCCCCTCGCACGCAAACTTAATGGCTATCCTTATCTTGTTGATATCTAATTTTTCTTTCCTCCCG +CTTCTCTTGATTACATACATTGTCATGATTTGAGAATTCTACCTCTCTTCAAGAAAATTTTTGATTGTCC +GTGTCATAGCCGGGCGAAAATTATTCATAAGACAGCATTTTTCACTCTACACTCTTTCCAAAGAGCACTA +TAAAGATAAGTACTGGGATAAGCAAGGTAAATACGAGAAATTGAAGCCGATCCTTCTTTTCGAAGGAGAC +GAGCCATGCTATAATCGTCTGGAGGAGATAGTAAAAGGCGAAGGCCTTGGAGGCGTATGCGATAATCTCA +AAGACGTTAGCGCTCCAAACTAGGGCAACTCCTACCAGTGTCGTGATTAAGTATCCGAATCGAGAGGAAA +CTCTGTGATTAGTTTCTTCGTATATTAGTCCCCCTGCGCCTATAGTGTCCGCAACTGCCGCACTAAATTG +ACTCATTAAGGGACCAAACCTGAGGAGGTATCCCAGAACGAGGGAAACTGCGGAAGCGAGGAATATAATT +TCCGTTTCATCTAGCTTCTTAGGCGGATTGTGGACGAACACGGAAGTTATCAAAAACATAAAGGAAACGT +AAATGAATCCCGAAATCCACTGGGCGAGTTTCATGCTCTTTACCCTCTCTTCTGGAGTGTACTCCTCGCC +GAGGTATTTGGAAGTTTCAAATCCCTGAACTATCAGGAGTATCCCTCCGAGCACCTCAAGGCTGTGAAGG +TCAAAGGGTTTTACCTCTCCCGCAAAGGAAAAGTTTTTGTAGTTATAGTAAAGTAGAGCTGTAAGGAAAG +AGAAGATAATTGAGAGCTTCAGTCCCACTGCATACTTTTCCATAAACTCCAGAAAGTGAAGTCTTCTTAT +GAAGCCCGAAATTCCGATGAATAAAAGTAAACCCGTTGTGAGCAGTCTCTCGTAAACCTCGTTTCTTTCA +AAAAATCCAGAAAAGACGAAAGAAGAGAGAAGTCTCAGGTAAAAGGCTATGGAAATCATGTACGCGAAGG +CAAGGGAAAGGTTTGAAAACCTCTCTACATCTAAGAGAAGGGCTTTTAGCTTGGAGCTTTCACTCCCGTA +AAGAATGGGTTCAGCCTTTATGATGTTGTACCTTATCGCTCCTCCGATGAGGTAGGCTAGAATAACAATT +CCTGCCATTCCCAGAATCGCATACTTTCCGAGAACGTAGTAAAGGAGAGGAGCGGAAACCAGATATCCGC +TTCCTATAATTGAGGCAAGAGGCGTGACTGCAACTGTCCATAGTCTCTTTCTTTCCAGAAATGGACTCAG +GAAAAACAGGAGGTATAGGATAAAAGAAGTAAAGACTATGTAGTCCGTAAGGGTTAAACGGTTAAGGATT +TCCATTCGTGTTAAATTATATTCTCATGTACTACGCTCTCCTTACACTATTCGTAATAATTGCAGTTGTA +CTCATTATCTCCACGCTCCTTCAAAAGGGAAGGGGAGACGTCGGTGCGGCTTTCGGCGGTGGTATGGGGC +AGTCCATATTCGGCGTCGGCGGAGTTGAGACTATCCTCACAAAAGCCACTTACTGGCTTGGAGCACTCTT +TTTAGTCCTTGCACTCCTTCTTTCGGTCATTCCAAAGGAAAAGGGTTCTGTAGTTGAGAAAAGTGTTCAA +ACTGAACAAAGTGAAGGTAAAGGAACTACTCAAGAAAGTGGAAAGTGAGTACAGGAGAGACGCGGAAATA +ATACTCTCCTACCTTTTGAAAGTTTCTCCCTCCCAGATTCCCCTGATGTATGCGAGAGAAATTCCTGAGG +AGATTGTAAAAAGATTCTTCAAACAAATGAAGGAAAGAAAAAAAGGTATTCCCACAGCCTACGTTATCGG +GGAGTGGGAGTGTATGGGAAGAGTTTTCAAAGTGAAAAAGGGCGTTCTCGTTCCAAGACCGGAAACGGAA +ATACTTATAGAAAGGACCTTAGAGTTGATTCCACAAGACAGAGAAATGGTGGGGTTTGAGCTTGGAAGCG +GAACGGGTTGTATATCCATTAATCTGTTAATTGAAAGGCCGAAGCTAGTAATGTACGCCACAGATGTAAA +CCCCGATGCGGTGGAGCTCACAAAGGAAAACGCCAAACTCCACAAAGTTGACGACAGGCTTTTCGTTTTC +TTGGGAAACGCCTTTGAACCCGTTAAAGGCATGAAGTTCGACTTCATAGTCTCAAATCCCCCATACATAC +CCGAAAACTTCTGGGAAATTCTTCCAGAAGAAGTAAAAAAGGAGGGCTACACTTCTCTCATAGGAGGCAA +AAAGGGGTGGGAGTTTTACGAACTGATTGCGGAAGAGGGAACTAAACACCTGAAAGAGAATGGGTTTATA +GCCCTTGAGATAGGACACGACCAGGGAAAAGTTGTTAAGGAACTCCTTGAAAAGAAATGTTTTAAAGTTA +ATATTTTTAAGGACTACGCTGGATTTGACAGGGTGGTGATAGCACAGAGATGGAGCTGATAGGTTTTCTA +ATAGGAGTTTTCTTCTTCATAATCCTTGAGGGATTTTTTGCAGGGTCAGAGATAGCTCTAGTGAACGCTG +ACAAAGGCTTTTTAAAGGCAGTTTACAAGAAGAAAAAGTACTCATTTCTGAAGCACTTCCTTGACAGTCC +TGAGGAGTACATCACCCTCACTATGCTCGGATACACCGTTTCCATAGTTTTCGCATCTGCCCTTTACACG +CTATTCCTAATGAACCTTTCAAAGTACGTTCCTGAGATAAAGGGAAAAGAAGTCCTCCTTGCGGAAACCT +TGGTGATATTCACAATAATCCTCGGTGAGATAATACCTAAAAGCCTATTTCAGCATTACGCGGATAAGGT +TGTAATACCGAGCCTCTATATCCTCGATAAACTCAGAATAGTTTTAAAGCCCTTTTTGGTTCTTGCAAAG +GCGGTAAGCAGGTTCATATCGAGCAGGTTCGCAAAAGGCGAAAGTAAGGTAAGGAGAGAAGACATAATTA +AACTACTCAGGGAGAAAAAGAGCTTCTCCGAGTCCTTAGGCTACGTAATTTCCAACATACTGTCTTTTAA +GGAAAGAAGGATAGGGGAGATTGTAAGACCGCTTTACGAAGTAGTTATGATTCCCGATACCGCCACAGTT +CTTCAGGCTATTGAGCAAATAAAGAAGAGCGGATACGCCAGGATACCAGTTTACAGAAAGCGGGTTGACG +ACATAATCGGATACGTGAGCGCTTACGATCTTATAGACAAACCCCTTGACGAACCCATTAAATCCTTTAT +AAGGAGAATCCTTATCTTCAGTGAATTCACACCACTTCCTAAGGTTCTGGAGGTTTTCAAGGAGAAGAAG +GAACACATAGCCCTTGTGGTAGACGAGAGAGGTGTAATCCTCGGCATAGTTACCCTTGAAGACATTTTCA +GGGAAATACTGGGAGACTTCATATCGGAAAAGGGAGAAGAGCCACTGGTGAGGGAAGTGAGTAAGGACAC +ATGGGTAGCGGACGGAAAGGTTGAAATAAACGAGCTCAGGAGAATTACAGGAATAAATATCCCGGACGGT +CCCTACAACACACTTTCAGGCTTTATAGCCTACCAGCTCGGAAGGATTCCCAAAAAGGGAGACGTAGTTT +CCTACGACGGATACAACTTTAAGGTAGTTGACGGAGACACGAGAAGGGTGAGGAAGGTTTTAATAGAGAG +GAAGGTTAAAAAGAAGGCTTTATCGGGAGCGTCCGCCTGACCTCTTCTATATAATCTTTGTCGTAATCTG +CGGCAAGTAAGGTATCCCCTTTCTCGGAAAAGGCAAGAACTTCTCCCCAAGGTGAGTAAATTCCCGAATG +CCCGGCAAACCTCGTTCCCAGGTACTCACCCCATGTGTTTGAGGCCAGAAGGTAAGCTTGTAGCTCTATC +GCCCTCGCCCTGCAGAGTGTCTCGAAGTGTTTTCTCCTGGCATATCCCCACTGAGCGGGAACGAGAACTA +CATCGGGTCTTTCCCTCCAGAAATTCATTATTAAATCCGTAAACCTTATCTCAAAACATATGAGAATTCC +AGCCTTTCCAAGCTTAGTTTCAAAAACTTTGTTCTCCTTTCCCGGAATAAAGTACTTATCTTCGTCGAAT +ATCGGAAAGAGCTTTATCTTTGAGCGTTTGCCGATAACTCTTCCGTCTTCTATTAAGAAAGCGGTGTTCA +GTATCCCTTCCGTACCTTTTTCGGGAAGAGTCCCGCAAAGGGTTAAAGATTTTTCCTTGGAAATTTTTTT +GAGTACTTCTAAAACTTCTGGAGTTTTTTGGGCGTGTTCTTCTAGGTTTTCGTAGTCAAATCCCGAATAC +CACATCTCAGGAAGGAGAACAAGGGAGTTTTCCTCTACTTTTTCAAGAAAATTTATTACCTTTTTCAGGT +TTTCTTCCGGAGTTGTTTGTCTTATTTGAATTGAGTAGAGTTTCATACTTAGGATTTTAAGGGATAAAGG +ATTAAGTTCTTTATAAAATCAAGCCAGCCTTTCTTGTACATTTCCTCATAAGTGGTATGTCCCTTTAAGA +ACTCCATGTACCTCTCAAGCGAGGTTCCACCTCCCATTTTGTAGGCAACTCTCTGAAATCTGTAAGCGAG +CTTCGCTATTTTTCCCGCGTAAGTGAATTCTTTTGCAAGTTCTTTCACCTTTTTCCTGTAAGTTTTCTCC +GGATTTTGGGGATTTTCCAGTATTGCATCTCCGGCAAGGAGTCCGCTCAGGTATCCGTAATAAATACCTT +CACCGAGGAGCGGGTCCACGAAGTTTCCCGCGTCTCCAACGAGGAGTATCCTTCCCCTTCCCGTGTGAAG +TTCCTCAGAACCTTCTGCAAAGGGTATAAACCAGCTCTTCGGTTTATAAATCTTTTTAACCTTCACTATT +TTTTGTCTCTTTATGTAATCCTTGAGAACTTCCAGTAAATTCTCCTTTTCGGTGGAAGCCACGCCTATGT +TCAGTTTATTCCCTTTTGGAAATACCCAGAGGTATCCCCTTTTTACCAATCCGAGTTCTATAACCACGGA +GTTAAAATCCATCTCACCTTCCGCAAGAACTTCAACCGAGCGGTAGTACTTCTCCTTTTTAAAACCCAAA +AACTTTGCAACTTTTGAGTGAAATCCGTCCGCGCCTATTAGAAAATCGCAGGAAACTTTCCCCTTTGTTG +TGTCAAGTATTATCTTTCCCTTTTCCTCCCAAAGGTCCAGAAGCTCCGTCTCCTCTCTAAGCTCGCATCC +CTTTTCCATAGCTTTTTGAGCGAGAAAGTGGTCAAAGTCAGCCCTGTCTATTATGTAGGCAACTTCCTCC +CTTTCCTTTAGCTTATGCTTGTCCCCTCTAAAACCTAAGTATCCCTTGTGTATCACGTTCAGTACTTTGC +TTTTAAAGTCCTGTGGAAGGTACTTTGAAAATCTTCCCGAAAGGGCTCCGCCGCAGAGTTTGAACCTTGG +TAGCTTTTTTCTCTCCATTAAGAGAACCCTTAAGCCTTTTTCGGATAAGTACCTCGCCGCGGAGCTTCCG +GAAGGTCCCGCACCTACTACTACTACGTCAAACCTCTCCATGTTCTTCCCAGAGTTTTTCCATAATCTTT +ATTTCTCTGTCCTCTTCAAACTCAAGGGAAGGTATTGTCTTTACTTTAAGTTTTTTGATTTTTGAAAGTA +ACACTCTTTTGTTTTCTTCAAGAAAATCCTTTACTCTTTCTGCATTTCCTTCGGGAAGAACTGTAAAGTA +CACTTTAGCTTTACTTCCGTCCTTGCTCAGTTCAACCCTCGTAATGCTCACAACTCCCAAATCAGTAGGA +GCGTTTTCAACTACGAAACTCGCAATTATCTCCTTTATTTGTTCACCCAGTCTCTCCTTCTTCCTGCTCA +TTCTCTATTTGCTCCAACACATCTTCGTACTTTTTAAACTCTTCGCTGTGGAGTACGTCCGTTATGAACT +CGTCTATTTCCTTTTTCTCGAGTATCGCACCCGCCAGCAGTCTTCCCGTGTACTTGTTGTTCTTTATCTC +CCAGAACATGAAAAATTCCGGAAATCTGTTCTTAATCTTTCTGTAAGCGTAACCATACTTGCTGTCCTTC +AGGGGATTTTGTTCTATGAAAAAGTGATCTTTACTGAGTTCTATGACGTGGAGTATAGCCCCCCTTCTAG +TTCTTACGAGTTTTAATTTAAAGTTCCACTCCTTTAAGGTTTCCATAATGAACCATTATAACTTGAGGAA +TTTCAGTGAACGGAAAAGCAAACTTTTTGTATCATTAAGATGTAAAAATTCTCGGAGGAGGTAGGAAAAT +GGCCGAATTCAAACACGTCTTCGTATGCGTTCAGGATAGACCGCCCGGACACCCGCAGGGTTCCTGTGCC +CAAAGGGGTTCAAGGGAAGTTTTCCAGGCCTTTATGGAAAAGATCCAGACAGACCTCAACTCTTCATGAC +TACTGTTATTACTCCCACCGGTTGCATGAACGCGTGTATGATGGGACCGGTTGTAGTCGTTTATCCGGAC +GGTGTGTGGTACGGACAGGTTAAACCCGAGGATGTTGACGAAATTGTTGAAAAGCACCTGAAAGGTGGTG +AACCTGTGGAAAGACTTGTAATTTCTAAAGGAAAACCGCCGGGGATGTTTTAACCTTGCCCCGGCACTCC +TGCTTCTTCAAACTCTATCTCTAACCTTTCGTGGGGAACTATCGTAGTTATAGCGTGTTTATAAACTAAG +GTTTGCTGTTTTCCATCCTCCAGAAGGATAGTAAATAAATCAAAGGATCTTATCCTTCCCTGAAGTCTTA +CACCGTTTACCAGGTATACTGAAACCTTTACCCTTTTCTTCCTCGCCGTGTTTAGAAAGCTCTCCTGCAA +CTTGTAAGGCATTTTTTACCTCCTTTTTATTGTTGGAATTTAAATAAACATTTTAGCTCAACTCAAGGAA +ATTAAGCTGATTTAGTACCTTTGTTCAATTGTAAACATGTTAACAAAATTGTAAACACGAAAAATTTCCA +TACCTTTGTAAAAGCGTATTCTGAAATTGGCACGGAAATTGCATAATAACTTACAAGGAGGAAGGAAGAT +GAAAAAGATCGAGGCGATTATTAAACCTTTTAAGCTCGACGAAGTGAAGGACGCCCTCGTTGAGATAGGC +ATAGGCGGTATGACCGTAACCGAGGTAAAGGGTTTTGGTCAGCAGAAGGGCCACACGGAGATTTACAGGG +GAACTGAGTACGTAATTGACTTTCTGCCAAAGGTAAAGATTGAAGTTGTCGTGAGAGACGAAGACGTGGA +AAAGGTGGTGGAAACCATTGTGAAAACTGCCCAGACGGGAAGGGTAGGGGACGGAAAGATATTCATAATT +CCTGTTGAGGATGTCATAAGGATCAGGACCGGTGAAAGAGGTGAACAAGCCATTTAAAAATAAAAGGAGG +TAGTAGTATGCCAAAGTACACACCAGAAGAAGTCTTAGACCTTATTCAGAAGGAAGGGGTTCAGTACGTT +GACCTGAGGTTTTCTGACCCCTTCGGTCAGTGGCAGCACTTAACGATCCCCGCCTACGAAATATCTAAGG +AAACTTTTGAAGTAGGCAGGGGATTTGACGGGTCTTCCATCAGGGGATGGCAGTCCATCAACGAGTCTGA +CATGCTCGCAAAACCTGACCCCAATACCGCGTTTATAGACCCATTTATAGAGCCAAAGACGCTCGTAATG +ATTTGTGATATCTACGATCCCGTTACGGGTGAAAGGTATGGAAGGGACACCAGGTACATAGCACAAAAAG +CTGAACAGTACCTCAAGCAAACTGGAATAGGAGATACCGCGTACTTTGGACCCGAAGCGGAGTTCTTCAT +ATTTGACAGTGTGGAGTTTGGCACCGCTGCTAATTACGCCTTCTGGAGAGTAGACTCAGAAGAAGGATGG +TGGAACAGAGAAGTACCCTCTTCCGGATATAAGATACCCCACAAGAGAGGATACTTCCCCGCACCGCCCG +TTGACAAGATGATGCAACTGAGAAACGAAATGGTTTCTATAATGTCGGACCTCGGTATAATAGTTGAGCT +CCACCACCACGAAGTTGCAACAGCTGGACAGGGCGAAATAGACATAAGGTACGACAGCCTTTTAAATCAG +GCGGATAAACTCTTCCTCTACAAGTACATAGTTAGAATGGTTGCCGCAAAACACGGAAAGTACGCAACCT +TTATGGCTAAGGTTCTTCCAAACGACAACGGTTCTGGAATGCACACCCACTTCTCCATATGGAAAAACGG +AGAAAACCTCTTTGCAGGAAGCGAGTACGCTGGACTTTCAAAGACAGCACTCTACGCCATAGGAGGTATA +CTCAAACACGGTCCCGCAATAGCGGCGTTTACAAACCCCACAGTTAACTCTTACCACAGGCTCGTACCCG +GATACGAAGCACCCGTAAGATTAGCCTACTCCGCTAGGAACAGATCTGCGGCTATAAGAATACCCATGTA +CTCTCAAAATCCGAAGGCAAAGAGGATAGAAGTAAGGTTCCCGGACGCTACATCCAACCCTTACCTTGCG +TTTGCGGCTATACTCATGGCTGCAATAGATGGAATTGAGAACGAAATAGACCCTGGTGAACCTTTTGACA +AGGACATATACTCCCTACCTCCCGAAGAGCTCGAAGGAATTCCTCAACTACCCGGTTCCCTTGAAGAAGC +CTTAAAGGCTCTGGAGGAAGATTACGAGTTCCTCTTAAAAGGAAACGTGTTCACAGAAGAGTTCATACAG +CTCTGGATAGAGTCCAAGAGAGCCGAAATAGACGAACTCAGGTTTATACCCCACCCCAAAGAATTTGAAC +TTTACTGGGACATTTAAACAAATTCTCGGGGGCGTTTCGCCCCTTTTATAAAAACTTTTTTAAAAAAGGA +GGGCAAAAATGAGAGCGCTAGGATTTATAGGGATTATTCTATCAATTTTTTCCTCTTTTGCGTATGCATC +TGAAGCCAAGTTAGACACTGGTAACACAGCTTGGATGCTCGTAGCTTCAGCCCTTGTGGTGTTTATGACA +GTTCCCGGGCTCGCTCTTTTCTATGGAGGTTTAGACAAATCAAAGAGCATCCTAAACACGATAGCGATGT +CCTTTTCAGCCTTTGCGGTTGTAACACTAACGTGGATATTCGTAGGTTACTCAGTAGCCTACGGAGACGA +TATTTTTGGTTTTATAGGAAATCCATTCCAGTACGTATTAGGTAAGGGTATAAGCGGGATAAATTCCGAT +ACCGGATACCCTGCACTTCTGGATCTGATGTTCCAGCTCACTTTCGCAACAATAACTACCGCTTTAATTT +CGGGTTCCTTCGTAGGAAGGATGAAGTTTTCAGCCTGGATATTGTTTGCAATACTCTGGAGCGTATTTGT +TTATCCGCCTGTAGCCCACTGGGTATGGGGAGGCGGATTTCTGGCTAACGACGGAGCCCTTGACTTTGCA +GGAGGAACGGTAGTCCACATTAACGCGGGTATAGCGGGTTTAGTAGGTGCGTTGATCCTCGGAAGAAGGA +AAGACACATCTCTTATTCCCAACAACGTTCCACTGGTAGCCCTCGGTGCGGGAATACTGTGGTTCGGGTG +GTTTGGATTCAACGCCGGTTCTGCTCTCGGAGCTAATGAGAGCGCAGCTTGGGCAATGATAAATACCACG +GTTGCAACTTCAACGGCAGCACTCGCATGGATGTTTACCGAATGGCTTCACGTCGGTAAACCTACAGTTG +TGGGAATATCTTCAGGTATCGTTGCAGGACTTGTCGCAATAACTCCCGCGGCAGGTTTTGTAAACCTTAT +CGGTTCAATTTTTATAGGAGCTATAGCATCCGTGTGTGCTTACTTTATGGTTGCTCTTGTAAAACCAAAA +TTCGGATACGACGATGCACTTGACGTGTTCGGAATTCACGGAGTACGCGGAATAGTGGGAGCAGTTTTAA +CGGGAGTATTTGCGGATCCGAACGTGGGAGGAACTCCTGGACTGCTCTACGGCAATCCAAAACAGGTTCT +TATACAAATAGAAGGCGTTATCGCTACTATACTCTACTCCGCTATCCTCACAGCCGTTATACTGCTGGTT +CTGAAAGCAGTAGTAGGTCTAAGAGTTTCCGAAGAAGAGGAGCTCGAACTGGACAGCTCCCTACACGGTG +AAAAGGCTTACAACCTATAAAGGAGGTTTAGTTATGAAAAAGTACGTTCTTCCTCTCTTGTTTTTAAGCT +CTCTTTCTCTCGCTGAGGAAAAAAGTCTTTACCTGAAGGTATCCCAACCGCTGGAGCTTTACGGCGGGAT +AAGTGCCGGGTACTTCTACACCACAAACGAGGACGGTAAAGACTCAAGCGATAAACTGCAGATAACGAAC +GCCATACTCGGACTGAAGGCTGAAGTTGGAGAAAAGATAAGGTTCGGCTTTGACCTTGCTGTAGGCGGTT +CTCTCTGGTCCACCGTATGGGACGGCGGACAGGGAGATTTTTCCTATTACGACCCAGATGAAAAGGAATT +GAAAGAAGGTGTAGGACTTCACTGGGGATACGCCTACCTGAAACCCTTCAAAGGCTTTGAAGTTTCTGCC +GGTGTACTTACAACAAACATAGGCTACGAACTTGCAGACACGTATAGCAATCCTAACGTAACTTTTGGAG +CGGTATGGTACGCACAGCCCTTCATATACCCCGGAGTCAGGCTCACGCTTGATTTTAGTGAAATAGCGGA +TTTACCGGTAAGTCTTTATGCCGAGTACAATCAGGAGTACGACCTTGACAATTACGCGGTTGGAATTCTC +GGGGAACTCGGCAACCTTTCTTACGCCCTGAGTTATTACGACTACAGAGCTTCAAAAAACCTCGTTGATT +TAGTTCTCGGATATACCATCTTCAACGTGGACCTCGGTCTGAACTTTGATTACCAATGGCTGGACGACAG +TGCAAAATCAGCAGGACAGGACGATTCTGCTTACGGAGTTGCCCTGTACGTAATACCAAAGTTTGAAACT +AAATACGGCGAGTTTTCCCTGCCTTTAAGACTGGAATACTTTGACGAAGGAAGTAGCGGGATTTACTTTG +GCGGGGCGGACAAGGGCTATACACTTACCGTTACGCCTACTTTCAGACCTACACCTAACACCTACGTAAG +GGCTGAAGTATCCTATGTAAATACGGATAATAAAGTGTTTAAAAACGGCACAAAAGACAACAAAACCACT +CTGGCAGTAGAACTCGGCTTCACCTTTTAGCCGCCCCTGCCCTTTTACCAGATTTTTGAGAAGTCTAAAG +AAATACTGCAATCCTCCAAGTTTATTTCTAAGGAATCATCTGTAACGTCTTTTAACTTCACATACTTACC +CTCGTGAAGTTTGTAGACCTTTGTTTTCTTCAGAGATAGGAAAGCTATAACGTAGTACTCTATTCCCTCT +CTCCGATAGAGTTCAAACTTTATCGTTTCGTCCTTTTGAGCAGTTCCTTCCGAGACTACTTCAAATATAA +CTTTCGGCGGTTTCAAGACTCTGTGTTTTATCTTTTCGCAAACCTCGTCTATTCAATACCTCTCCGTTAT +GTAGTCCGCTGCACAGGAGGCCGCTATGGCGTCAGGTTTCAAAACAGGAGTTAACCCTTGAGCAAGGACG +TATCCGACCGCTTCTTTCACTATTACGCTGGACGCAGTGTTTTCATCCGGGTTTATATCCAGATGAACCT +CAAAGTGCCTGCCGTCCACCGCGTCCATAAGCATAAGGGCGTGATAAACAGCACGGTTTACCTCTTCCAT +AAGCCTTTGCCTCAAAGAGTTTATCTTTGGAACCTTTTCCACATTCCAGAAAACTTTTGCCCCGTATTTT +GAACTTATGTGGACCACGATAACGGTAACGAATATCGTTTTATCCCTGAGCTGTCTGGAATCACAACCAA +CGTATATGGAAGTTTCTTTATCTGTAGTTTTTATAAACTCCTTTACCTCTTCAATGTCCCTGAACTTGGG +CATTACTTCTCAAAATCCACCTTTTGATACCAGGAAGGCTTGAAGAAAATCCAGTCTTTTAGGTTTTCAG +GACTTTTAGCGTAACAAACTTCGCATAAAACTCCTTCCTCCACTAGTTTGGAGTTGTCATCACAGCAATC +ACTCAAGTTCCAGAACTCGTAATTGTCGTGAAATATCAGCTTTCCGCATCCGAGACACTCGTAAAGAACA +CAGCCCTTTTCCTGCAAAAATTCCTTTAAATCTTTTTCCTCGGGGAGTTCTTCTAGTTCAAAGACGTTTT +TCAGGAATTCCTTCTGCTTCTCGGAAAGTTCCTTTACCTTCATACATTTAAATTTAGAACTTCAAGTTTA +AAAAACGGTTTTTTCATCAACCTTCCCACCCTGATACCCGGATCAAAGGGCTGAAACTCCTCAAAGGAGT +TCGGAACGAATACAACGTTATCAGCGAGGTTGTTGTTTACCTTTACTTTCAGCTTTACACCGTTTATTTC +TATAAGGTTCCCTATATTTAAACGTTCCTTCGTTTTCTGGTTTACGTAAGCAAACTGCTCCCTCTCAAGG +GCGTGGGTCCAGGGGTTCCAGTGTCCGAGTTCTTCCGCTAAGGTGTTGTCACAGATGAACCAGAGCTCTC +CGCTCTCTGATCTGTCTTCTTCGTTTATGTCAACCTCCGTAATGTCCTTCATACTTATGTCCACTCCCCC +TTCCTTTTCCTTTAATTCCTCAAGCTTAACTCCGCACTCCTTCAGAAAGTCTTCTACGTCAAAAGAACTT +TCAAAGTACTCGTACGGTTGGGGAAATGGTGCATTTAGGACCTGCGGTGAGTGTGCCAAAAAGCCAAAAC +CCTTTACTATAAACTCCCTTTCCGCGAAAGTGGTTCTGGGAATTATAAGAGTGCTGTGGTTTGCAGTTAT +AGTGGGGAAGTATGCAAAGTTAATGACGAATTTATCCTTTAACTTTTGAATTTGTTCATCAGAGAGGTAA +ATAAACGGATTTCCGAATAAAACGAGTGTGTCAAACTCTCCTAATCTTTCCAAAAATTCCTTTAAGCTTT +TTACAGGAAACGGCGTTATGTTTCCTACAATTGAGTAGTCCGCACCGTACTTTTCACTGATTTCTTTAAG +GGTTTTTAAAACTTTTCCTCTGAACGGTGAGCGAAGGAGTGTGTCTCCTACTATGACAACGCTCTCTTTT +CCGAAAAATTCAAGGAATTTTTGAGCTTTGCCTTCAAATCTTCCCTCAGAAAGTGCCTGTAAAATCTCGG +TTGTTTTTTCTGGTGTGGTCAGAACCTTTTCTTTTGATTTTTGAAAAACGGTCGTATACCTGCTTCCCGC +CGTAAAGATATATGCGTCCTTTTCAAAGGCGTCCACTATCCAGCGGGTGAGCATAACCTCCGAAAATGTG +GGCTCCGCCTCAAATATAAATAGGGCTTTTTTGTCCACCCAATCCTGAGCTCTGACGCTGGTTTGTTTAA +AGGGAAGGTAAAGGGAGTCCGAAAAGACTTCCTCGGTTAGGCTTCTTGCTATGAGGTATTCCTCAATTCC +CGCAAACCTGTCTAGGAAAAAGGCGACCTTTCCTTTTAAGTTTTCCTTTATTAGTTTCTTTGTCTCTTGA +AATTCAACTTCCCTAAAGTTGTTCCCTTCCCTTAAAAGGGGCTTTGTAATTCTTAGGGGGTTTTTCGGGA +TTTCCTGAATGTAAGTTATTCCCTTTGTGCAGAAGCTACCTATGCCGTTCGGGTCGTGGGGGTGTCCGTA +GAGGTCAACGAGCTCATCTTGCTTGAGGTAAGCTATGTAACCGCAGGCACTTGAACACCCGCCGCAAATA +CCGCACAGAGCTTTCTCAAATTCCTTTACCGTTAAGGGGACGGAAGTAGGGGAAAGGGGCATTTAAGCCT +CCTTGTCGTCAAGGTTAACGAGACAGGGCAGTTCTTTCCCCGCGAGAAGTTCCAGGAAAGCTCCTCCTCC +TGTGGAGACGAAGTCAAAGGCGTGATAAACTCCCGCCTTGTGAATGGCGTGGTCCGTATCTCCTCCGCCC +GCTATCGTGAGGGCTGAAGATTGGGCGAGTAATTTCGCGACCTCTATTGTTCCATGTTTGAACTTGTCTA +TTTCAAACACTCCCATGGGCCCGTTCCACACAATTGTCTGGGCATCGGAAATTATTTCCTTTACGAGTTC +AACGGAAACGGGTCCGATATCAAGCCCCATCCACCCGTCTGGTATCTCCTGCCAGGGTACTACTTTCGTG +GGAGTGTTTTCCGAGACTTCCTGCCCTATCACAAAGTCAACGGGAAGGTAGAGTTTAATCTCTAGCTTTT +TTGCAACATCTATTAAATCCCTTGCAACGTCCTGTAGGTCGTCCTCCACGAGGGAATTTCCAACCTTGTA +GCCCATAGCTTTGAGGAAGGTAAAGGCCATAGCGCCGCCTATAAATAGTTTGTCTACCCTCCTTATTAGG +TTCTTTATCACTTCGAGTTTGGAGGAAACTTTAGCACCTCCCAGGATAGCGACCACGGGTCTCTGGGGTG +CTACCATCGCCTTTTCAAAGTAAGTGATTTCCTTTTCCAGTAAAAATCCCATTACGGCGGGTTTTAAAAA +CTTGGGAACGAGGTACACGCTTGCGTGCTTTCTGTGACAGGTTCCGAAGGCGTCCGCAACGTAAACTTCT +CCCAGACTCGCAAGCTCTCTCGCAAAGTTCTCATCGCACTCCGTTTCTTCTTTATGGAACCTAAGGTTTT +CAAGGAGAACTACGTCTCCCTCTTTCATGGAGTTTACAATTCGCTTTACTTCTTCTCCCACGCAGTCCGG +GGCGAGTTTTACCTCCTTGTTTATATACCTTGAAAGTCTTTTGGCTACCGGTGCCAAACTGTACTTTGGA +TCCCTGTTTTTAGGTCTTCCTAGATGGGACATCAAAATTACCTTTGCGTTTGCGTCAAGGAGGTACTCAA +CTGTGGGAAGGGAAGCCCTTATACGCGTGTCGTCTACTATGTTTCCCTGTTCGTCTAGTGGAACGTTGTA +ATCAACCCTTACGAGAACTCTCTTCCCCTTTACGTCAACGTCCCTTAAGGTCTTTTTTCTAAGCATTTAT +CCCTCCATCAGAAGGGTTTTTCGGGAACCTTTTCCCAATCCTTCAGGAACCTCTCCAGCCCTATGTCAGT +TAAGGGGTGCTTGAAGAGTTGTTCCATAACTTTAAAGGGCATGGTACAGATGTCAGCACCGATTAGAGCG +GACTCGAGAACGTGCATAGGGTGCCTTACGCTTGCAACTATTATTTCCGTGTCAAACTCGTAATTGGAGA +AAATTGTTTTAATCTCTTCTATAAGTTTCATTCCTTCTCCGCTGATGTCGTCAAGTCTTCCCACGAAGGG +AGAAACGTAAGAAGCTCCTGCTTTTGCCGCAAGCAGTGCTTGGGTTGGTGAGAAGACGAGGGTTACGTTT +GTGGGTATCCCCTCGCTTTCAAGGGCTATCACAGCCTTGAGTCCTTCGGGAGTCATGGGTATCTTCACGA +CCACGTTTTCTCCGAGTTCCGCTAGCATCCTGCCTTCCCTTATCATTCCCTCTGCATCCAGAGAAACGGT +TTCTAGACTGACGGGTCCATCAACGAGTTCAAGTATTTCCTTTACAACTTCTTTGAAGGGTCTTCCCGTT +TTTGAGATGAGTGTAGGGTTTGTTGTAACGCCGTCCAGTATTCCCCACTCCATAGCCTTCTTAATCTCTT +CTACGTTTGCTGTATCTAAAAAGAACTTCATTTCCTTTACCTCCAAAAATGGGATTATATCACTTGTAAT +ACTCCTCGAAAGCTATCCACGTTCTCGGTATCCGCCACTCAAGGTTATCCCACTCCTTCATGAGTTTTTT +CCTCTTCTGTGCAGCCCTGTTTATAGAAGGACCTAAGGTATCCAGAGCTTCTTCTTCGAATTCTTCAAGG +TCTCCCTCAAGTATCGCCCTTGCAGCTATTGAGCCCGTAATCACCGCGTTCGCTATACCTCCGCCCGTAA +TGGGGTGGCAGAATCCTCCCGCATCTCCTACCAAAAGCACGTTTCCCCTGAAAGGATTCTTTATCCCCTC +GCCGGGAATAAAACCTCCGGTTCTTCCGTAAATAGGTTCGGGTTCTACAAAGTCCTTAACTTCTTTTACA +AACTTGTTTAGAACTTCTACCACGTTCACACCGTAAGAGAGGTCAACGCCGACGCCTACGTTTGCAAGTT +CCTGTTTCGGAAATATCCAGCCGTAACCTCCTGGTATGTAGTCCCTAAAGAATATGAGAAGGTCATTTAA +AGGCTTTTTCAGTTTAAGTGTGTACTGAGCAGTTATTAAAAATTCCTTAGTGTGTTCTCCCGTGAGTTTT +GCAACGAGCGAACGTGCCCCGTCCGCCCCGACCACGATATCCGCTTTTACCTTAAAAACTTCCCTTTTAT +TTAAATCTTTTAGGATTAAATACTTTCCCTCAAAACCGATAAACTTCGTTTTTGTTCTTAAGTGCGCACC +CTCCTTTTCTGCGAGCTTGGCTATTCCTTTGTCCCACTTTTCCCTGTGAAGGATGAAGCCTTCCGAGTAC +ATACTAACGATTTCCCCCCAGGGTGTGTAGTGAACCATGTCTTTTACCTTTTGTGCTATTGTCTCCTCGG +GAAAGAACTCGGGAAATTCGTAAGAGAGCTGGACGGGAACAAACTCGGCACACTGAACGGGATAGCCTAC +TTCCTTCCTTGAATCTATAAGCAGGACCCTAACTCCCTTTTTTGCAAGTACGTAGGCACAGGTGGAGCCT +CCGGGCCCCGCACCTACTATCGCAACGTCGTACTTCATAACTCCGATAATTTAACCCTCCTTTGCTCTCC +CGTTTCCATGTCCTTAATCGTCACTTCCTGGTTCTTCACCTCGTCTTCACCGATGATAACGGCGTATTTA +ACGCCGAGTTTGTCGGCAAACTCCAGTTGTTTTTTCAGCCCTCCTTTTCTGTAGGAATACTCAACTACCT +TTCCTTTCTTCCTTAAAATGTCCGCAACTCTGAGGGCGTACTCGTGAACGTCTCCGAAGGGAATGACGAA +GTAAACCTCTTCTTTTTCCTCCTCGTCTGGAAGAAGAAGCATTAACCTTTCAACTCCAAGGGCAAACCCG +AGGGCGGGAGTGGGAGGACCTCCGAGCTCCTCAACTAAGTAATCATACCTCCCGCCTGCGATTAGCGTGA +GTCCGAGCTCGTCGGAGACCGCCTCAAATACGGTCCTAGTGTAGTAATCAAGCCCCCTCACGAGGTTGTA +GTTTTCCCTGAAGGGAATGTCAAGGGCCTTTAAGTAATTCTTTAGTTTTTCGTAGTGTTCCCTGCATTCA +TCGCACAGAAAGTCTATCATTTTAGGAGCTTCTCTCACCGCGACTTTGCAGGTCTCTACTTTGCAGTCCA +GAACCCTCAAAGGGTTCCTGTCCATTCTGCTTATGCAATCACTGCAGAGTTCTTCTTTCACTCCTGTTAG +GTAGTTAAGTAATGCCTCCCTGTAAGCCTCCCTGTCTTTTTTACATCCAAGGGAATTTATCTCAACAACA +ACCCCCTTGATCCCGAGTGCCTGAAGTATGTCGTAAACGATCTTTATTATTTCTGCGTCCGCGTGAGGTT +CTGCAACGCCGAAGACTTCCGCACCTATCTGGTGGAATTGCCTATACCTTCCCGCCTGGGGTCTCTCGTA +CCTGAACATAGGTCCCTCGTAAAAGAGCTTCACATAAGGTCTCAGAGCGTAGAGTTTGTGTTGGATAAAG +GCTCTCACAGTTCCCGCGGTCCCTTCCGGTCTTAATGCAAGCTTTCTCCCTTTTCTGTCCTCAAATACGA +ACATCTCTTTCTGGACTATGTCAGTGGTTTCTCCCACACTCCTTTGGAAGAGTTCTGCGTACTCAACAAC +AGGAAGGATTATCTCCTCAAAGTTGTAAAGTTTTAGTATCTTCCTTGCGGTGTCCGAGATTTTTCTGAAC +TTCTTTGCGTCTTTTCCCAGTATGTCGTGAAATCCCCTTACGCTCTGTATGTTCATAAAGATAAATATTA +AAGGTTTTTTGTGGTAAACTTATTGTGTTAAAATTATTCGTCCGAAAATTTACGGAGGTACGGGAAATTG +GCGGTAAGGATAAGGCTCGCTAAATTCGGAAGGAAACACCACCCCATATACAGAATAGTGGTAATGGACG +CAAAGTCTCCAAGAGAAGGAAAGTACATAGACATTCTGGGGACTTACGACCCTAAGAGAAAGGTTCTCAT +TAACGTTTACCCTGAGAAGGTGAAGGAATGGGTTTTAAAGGGAGTTGAGCTATCTCATAGAGCTAAAGCT +ATTTTGTGGAATCATGGTATCTTAAAGGAAGTCGTTCCCGAAGGTTATGAGATGAAAAGGGTAGGTGATT +ATTACGTTTTTGAAAAGCGTGAATCCAAAAAATCCAAAGGAGGTGAAGCGGCATGAGCGCACTCAAGGAC +ATTGTTGAACTCACAGCAAAAGAATTAGTAGACAACAAGGACAAAGTGAGAGTTACCGAGATTGAAGGAG +AAAAGACCGTTGTAATTGAGCTCAGGGTTGACCCTGCTGAGCTCGGTAAGGTTATCGGAAAGCAGGGTAG +GATCGCAAGAGCTCTCAGAACCATCCTCACCGCAATCGGTAGAAAGATAGGAAAGAGGGTGGTTCTGGAA +ATACTTGAGTAATGAAAGAAAAATTAGCCTTAGCCCTGCTCTCTTTTTTTCTGGGGCTTGGTTCCTTCTT +CAGTTTTTACGTTGCACCTACCCTTTTTAAAGTTTTAGAAAGACAGCAGGCGGGAGCTGTAGTAGAAAAA +GTTTTTCCCGTTTACTTCGGACTTGGTATCATTTTAGTGGGCATTTCTCTCTTTCTTGGGAGAGACTCTG +GAAAACTCTTTTTATCTCTTGGAATTCTTAACCTTTTACTTTTATTACTTCAGGAATTTATCGTAATACC +TAAGCTTCACGGTTTGAAGGCTACCAATTATGAGCTTTTTTTAAAGTACCACGGAGTATCCATGGGAATA +AACCTCGCGATTTTACTTCTGACTTTAGGGAAAGTTCTTATACTAATTTTCAAGAGGTAATTAAATGAAT +GTGAAAGAAGGTGTAAAGGAGTTAATACTGAGCTACGGAAAAAACTTAGCGGAGCTTGAACCCATAAACA +CAAAGCTTATTGAGTACAAACTAAAACTGAAGGCTCAAATAATAAAGACCCTTTCTCTTGACGTGGACAA +ATCCACAAAAGAAGAGATGTTCAAAGACATGCTCGAAGGCGTAAACGAAGCGGTGGCGGAAATCGCAAAG +GAAATGGACACCCAGAACGAGAGAATGATAGAGAGGTACATGCTTTTCTTTGAATCCACGAGTGAAGTCC +TGAAAGAATTCATGGAAGGAGATTACATAGAGGACAAACACGAACTTTCCCAAACTTTAGGGAAAATCTC +CAAGATACTTGAAAAGCTAAGACTTGATTTAAAAGAAAAACAAAAGGGAATACTCAAGTTCATCAGAAGG +TTGATATTTAGAACTTAATGCTCCTTTCCTTTTTAGTTTACGTCCTCGCCTGGGCTTTTCAGGCCTTTAC +TGGTTTCGGTGCAGGTATTTTCATAGTCGGTATACTCTCCCTTTTTTACGAGCCGAAAACCGTTATAGTT +TCCTCAACGGTTGTCAACCTCCTCGGTATAATCTCCATGCTCCTTTTCCTCGGAAAAATCACGAGACCGA +ACTTTAAAATCCTATTCCCTTTAATCGCCGGTTCAGTTGCAGGCATAGGTGTAAGTGCAAAGCTCTTAAT +GGAAATAGACAGAGAAGTCCTGAAGGCTTTAATAGGAGGATTTGTTTTATTTCTGGGGATTTACGACTTT +TTAGTTCAGACTAATTCTTTGAAATTTAGGTTAAAGGCATCTCCTTTCGTAGGCGTCTTTACGGGATTTT +TGAGCGGTATCTTTGCGGGACTTATCGGAATGGGAGGACCCCCGCCGGTGGTTTACCTGAACCAGGTTTG +CAGAGATTTAAACACTTACAAAATCACCCTCTCCTTCTTTTTTGCCACTAACGTGGTTTTCAGGATAATC +TTTTATCTCCTCTACGGAGGAACTGAGTACTGGAGTTACGAACTCATACTTCCCGCCTTTCTGGGAGCAC +CTCTCGGCGTTTTTGCAGGTATCTACCTTTCACGTTACTTTACTCCTTACTTCGTCAAGAGGTTTATCTC +CCTCAGCGTCCTCTCCCTCGGGCTCTTCCTCCTTCTGGAAGGTCTGAAGGAGTTTTCCCACGACTTTTTT +AAACACAGTGTAATAGAAGAGAGCCCTTACGGCGGTCTCAAAAGTCATAAAACCCCAGGGAACTAAGGGA +GAGTGAATAACCTTAAGCAAAAAGTAAGAAGGGATTATCCTGAATAGCCAGAAGGAGCTTATGTTTACGA +AGAGGGGTATATGCGTCTTTCCCATACCCTTTAACGCCCCAGAGTATATGGACGCGTAAGCCATAGCGGG +CTGAGAAATTCCGACTATCTGAAGGTAGTAAGAGGCCCACTCGATTACTTCCGGATCCCTGCTGAAGGGA +TAAACGAGGTAGTGGGGAAAGAGTATGAGGATTAAACCCGTTAAGCTCATAACGAGGGCCGTAAAGTGGG +CGGAGGTGTTTACCGCGTGAACCATTCCGCGGTAGTTCCTTGCTCCGTAATTCTGACCCGCCAGCGTTGT +GCTCGCAATCATCACACCGAAGCCTATCATAAAGGAAATGCTCTCTATCCTGAGACCTATCTGGTGGGCT +GCGAGAACCTTGTCCCCGAATTTGGCAAGAAAACCTACGAAGACGTTAAAGGAAAGCGTGGTTATAGCCC +TCTCAAGAGCGGTAGGTGTCCCGAGTCTCACCATTTTAAAGAGCAGTTTCGGCTCAAGTCTGAGGTGCAG +GGGAAAGGGCTTTTTAAAAAAGATGAGGAGAAAGGTGTATATAAAAAAGGCGAGTATCTCCGAAATCGCT +ATTCCCCAACCAGCACCCTCCACTCCGAGTTTTGGAAGTCCGAACTTTCCGTTTATCAGGGTATAAGCGG +TGCCTATGTGCGTTAAGTTCATGATTATGGCGACCTTCATGGGTGTCTTTGTGTCCCCGGCTCCGTTGTA +AGCTCCGTAAAAGGTATTCGTTAAAAAGCCGATTGGTATGAACCAGAAAATGGGAGTGAGGTATTCCTTT +GCCAGACTCCTTACCGTTTCACTCGCCCCGAGAACTTTCATTAAAAACAGAACGAAATCCTTTCCGTAAA +AGAACAAAGGGAGGGAAATTAAGAAGGACAAGAATAAACCGTTTATGAGTATGGGAGATGGGTCCTTTTT +TGCCCCGACGAACTGGGCTATTAAAATGTTCGTTCCCGAGTAGGAGAGAGCCATCAGGGAGTAGATGAAC +CAGAGAAGCGAGAGGGAAAAACCCGTCGCCGCAACCGCGGAGGGAGAAATGGAGGAAACGAGAATCATGG +ATATCATGTTTTCCACAGTGTAGAGGAGGTTCACCACTATTATGGGTATGGAGAGTTTTACAACTTTCTT +TATAACGCTCAGATACGGCTCGTTGGGATTCACAATAATCCTTTGCATTAAAATTATTTTCCATGCAAAT +TTACGAAGGGAAACTAACCGCTGAAGGGCTGAGGTTCGGTATAGTGGCTTCCAGGTTCAACCACGCACTC +GTGGATAGACTAGTTGAGGGAGCTATAGACTGCATAGTAAGACACGGGGGAAGGGAAGAAGACATAACGC +TCGTTAGAGTGCCGGGCTCCTGGGAAATTCCCGTGGCTGCGGGAGAGCTTGCGAGAAAAGAGGACATAGA +CGCTGTGATAGCGATAGGAGTTCTAATAAGGGGGGCTACTCCCCACTTTGATTACATAGCCTCTGAAGTG +TCAAAAGGGCTTGCGAACCTTTCCTTAGAACTGAGAAAACCCATAACCTTCGGTGTTATAACTGCGGACA +CCTTGGAGCAGGCGATAGAAAGGGCGGGAACAAAGCACGGGAATAAGGGCTGGGAAGCTGCACTTTCCGC +AATAGAAATGGCAAACTTATTTAAGAGTCTGAGATGAGGTATCGGAAAGGTGCAAGGGACACCGCCTTCC +TGGTTTTATACAGGTGGGACTTAAGGGGTGAAAATCCAGGAGAACTCTTCAAAGAAGTTGTGGAGGAAAA +AAACATTAAAAACAAGGACGCCTACGAATACGCCAAAAAGCTTGTGGATACCGCGGTAAGGCACATAGAG +GAAATAGACTCTATAATAGAAAAACACCTGAAGGGCTGGAGTATAGACAGACTCGGCTACGTTGAGAGGA +ATGCCCTGAGGCTTGGAGTTGCCGAACTCATCTTTTTAAAGAGTAAGGAACCTGGAAGGGTGTTTATAGA +CATAGTGGATTTAGTAAAGAAGTACGCGGACGAAAAGGCAGGAAAGTTCGTAAACGGAGTGCTTTCCGCC +ATTTACAAGGCTTACATTACTTCTTCAAAAGAAGAAAAACCAAGTTTAAAATCAGAGTGAGCAGGAGGCT +GAGCAAAATCGCGGTAGTTATGGGAATGTAAACAACGAAGTTGTCCCTCTTTATGTATATATCACCGGGA +AGTTTCCCAAGTCCCAGGGGAAGTTTTTCAAAGAACAGGAGAAGGAGTCCGATTATAACAAGGACGATAC +CGAAGAAAATCAATACTTTCCCTATCTCTCCCATACCTTAAATTTTAGTGTATGAGACAGGTCTCCGTCA +TAGGCTCATCAAAGGCAAGCGAAGAGGAGTACGAATTTGCCTACAGGCTCGGAAAAGAATTAGCAAAGAG +GAACTTGGTGGTGGTTTGCGGAGGGAGGACAGGTGTGATGGAGGCAGTATGCAAAGGTGCAAAGGAAGAG +GGAGGACTCACAATAGGAATAATGCCCTCCTACGACGGACACGAAGCAAACCCTTACGTGGATATAAAGG +TAAACACGGGAATGAACTGGAACAGAAATCCCATAGTTGTTGCAAGCAGTGAAATGGTTCTGGCGGTAGG +AGGAAATTACGGAACACTCTCGGAAATAGCCTACGCCCTAATTCTGGGAAAGTATGTGGTAGGTTATAAA +ACGCACAAAGTGGAAGGTGTTGAACAAGTAGAGAGTTTAGAAGAAATGCTTAAAAAAGTCGATGAATTCT +TCGGAGGGAGGCTATGAAAGTATTCATAACCGGAGCGACTGGATTTGTTGGGAGGCACATCGTAAGGGAA +CTATTAAACAGAGGGTATGAGGTCCACGCTGGTGTAAGGAACTTAAGCAAACTCGAAAGACTCTTCGGAA +ATCAGGTAAAGGGCTACATAGTGAACTTTGACGAAAAGGACTCTATAAGGGAAGCATTAGGAAAAGTAAA +TCCCGACTTCGTAATTCACCTAATAGGCATACTCTATGAAGAAAAGAAAAAAGGAATAACTTTTGAAAGG +GTTCACTACGGCCACACGAAAAACCTTGTAGAAGTTTCAAAGGGGTTCAACGTAAAGAAGTTCCTATTCA +TGAGCGCCCTCGGAACCCACGACGAAGCACCCTCCCGTTACCACCAGACCAAAAGGTGGGCGGAAAGGGA +AGTCATAAACTCCGGTCTCAATTACACGATTTTCAGACCTTCTATAATCCTGGGGCCTGAACAAAAACTC +TTTTTTGATATGTACAAAATAACCAAATACATTCCCGTAGTAGCCCTTCCCGATTTCGGGAATTACCAGT +TCCAGCCCGTTGACGTGAGAGACGTGGCGTGTGCTTACGCGGAAGCCCTTAAAAATCCCGAAACCGACAG +GAAGATTTACGAGCTTTGTGGGACTAAGGTTGTAACCTTTAAAGAACTCCTTGCGGACATATTCTCCTAC +TGGGACAGAAAGGTTCTCATGATACCGATGCCCAAAAAGCTTATGTACTTCGCGGGCTTGATTGTGGAAA +AGATAATAGAACCCCCTCCCTTTTCTTCTGACCAGATAAAGATGATGTGGAAACCTAACGTGTGCGGAGT +GTTAAAAGATGAGGCTATTTCCAACGGAATTAAATCTATTTGCAAAAGAGAACCCATACCTTATGAAGAG +AGTTTAAAGTGGTCTCTCGAAAATTTTGATATAATAATTAAAGGAAAATAATTTTCAATTAGGAGGTGGA +AACATGAGAAAAGGTTTACTCCTAATGGCGGTATTCGCAGGCTTTGTGGTGGCAAAGGAAAAGATTGACG +ACAAGGAACTCCTTAAAATGGCAAGGCAGTACTTCAAACCCCTCCCCAAAGTTGCGGAAAATCCCCAAAA +TCCTGTTACCCCAGAGAAGGTAAAGCTCGGAAAGATGCTCTACTACGATCCCAGACTTTCAAAGAGCGGA +CTAATCAGCTGTAACACCTGTCACAACCTCGCGAGGTACGGAGTTGATAACCTCCCGACTTCCATAGGAC +ACAGGTGGGCTATTGGACCAAGAAACGCACCCACGGTTTACAACGCCGCAATCCACATAGCTCAGTTCTG +GGACGGAAGGGCTAAGGACGTTGAAGAGCAGGCTCTCGGACCCATAGTAAACCCAATAGAAATGGCAAAT +ACCGAAGAAAACGCCGTAAAGACTTTAAAATCCATACCCGAATACGTAGAACTCTTCAAAAAAGCGTTCC +CCAACGAAAAGGATCCCGTTAAGTACGAAAACATAGGAAAGGCAATAGGTGCCTTTGAAAGAACTCTTAT +GACTCCCTCAAGGTTTGACGAATTCCTGAAAGGAAACACGAAAGCTCTAACAGAACAAGAAAAGAGAGGA +CTCAAGACATTCATAGAAGTGGGGTGTGTGGCTTGCCACAACGGACCAGGTGTAGGCGGAAACATGTTTG +CTAAGTTCGGAATGATTACCGAGTACTGGAAAGTTACTTATCCTTACGTTCTCGTAGGAAAACCTGCGAT +AAAGGTTGACTTCGGTAGGTTCGGTGTGACGAAGAAAGAAGAAGACATGTTCGTATTCAAAGTTCCTTCC +CTCAGGAACATAGAACACACGTACCCCTACTTCCACGACGGAAGCGTGTGGAGCCTTGAAGACGCTGTAA +GGATAATGGCAAAAACTCAGCTAGGAAAAGAACTCACGGACCAGCAGGTTAAAGATATAGTTGCCTTCCT +CAAAGCCCTAACCGGTAAGATACCAAAGCACGCACTTGAAGTTCCCGAACTACCCCCGTCCACAGACAAA +ACCCCGAAACCCGAACTTTAATACCTTTTAAAGAAAATAACTAAATCCTCCCCCAAGTTTTCCACTTTTT +TCTTTCTCACTTTTAAACTTTCTTCTATACTTCTTATCCCGAGGTCACCTATACTCAAGCCCTCCCCCAT +AATTTTGGGTGCGATAAACACAACTATGCGGTCAAAGAAACCCTCCTTTAAGAAACTCGTCAGCGTTCTT +GGACCACCCTCCACCATGAGGTGCATAATTTCAAGCTCTTTGAGTTTTTTAAGGATATTTTTCAGGTTAA +AGCCTTTGAGGATTAAAACCTGAACTCCTTTTTCTTTGAGTTTTTCAGCTTTTTCATTCTCCTTTTTCGT +TATAACAATTGTTGGAGCTTCTTCCGTATTCAGAACTTTAGCACTCAGTGGAACTTCAAGTTCAGGGTCC +AGAATTATCCTTACAGGTTGTTTTTCCGTTGGAACAAACCTGACCGTTAAGTGTGGGTCGTCTTTTATGA +CTGTGTTTACACCTACCAGAACCGCAGTTGCCTCTCTCCTTAAGATGTGAGCTACCTTTCTGCTTTCCTT +TGAGGTTATCCACTTACTGCTTCCCGTGAGGGTCGCGAGTTTTCCGTCCAGGGTCTGGGCCCATTTTAGC +GTTATGTAAGGTCTTTCCTGAGTTATGTAAGTAAAAAAATCTTCGTTGAGTTCTCTGGCCTCCTCTTCGC +ATACACCGACATCCACTTCTATTCCCGCATTTCTCAGTTTTTCAACACCTTTTCCAGACATCAAAGGATT +TGGGTCAAGCGTTGCCACTACAACCCTTTTAATCCCGCTCCTTATTATCGCGTCCGTGCAGGGAGGAGTT +CTCCCGAAGTGAGTACACGGCTCAAGGGTAACGTAAAGGGTTGCCCCTTTTGCTTTTTCCCCCGCCTGAC +CGAGAGCCATAACTTCAGCGTGAGGCTTTCCTGCTTTTTCGTGATAACCTAATCCCACGATTTTTCCTTC +CTTTACGACAACCGCTCCCACCGTAGGATTTGGATGAGTGTAGCCTTTTCTCTTCTTAGCCAGAGAGAGT +GCCAACTTCATATAGTTTTTGTCTATTTCTCTTATCATTTACTTAACCCCTTTACTGCTTCTACATCTTT +CTTTATTTGCTGTATTAATTCTTCAACGGAGCTGAACTTCTTTTCCTCCCTTATGAACTTTAAAAACTCA +ACCTTTATCCTTTTTCCCCTTAAGTTCCCTTCAAAGTCAAGTATGTGAACTTCAAGAACCCTTTTCTTTT +TCCCGAAGGTAGGACGATATCCGTAATTAGCAACTCCGAGGTACTTGTCTTCTACTTTTACAGCGTAAAC +GCCTTCCTTTAAGCACAGATTTTCCGTGTTTTGCAGGTTTGCGGTAGGAAAACCGATTTTGGAGCCTCTC +TGGTCCCCCTTCACGACTTTCCTCTTAACCCAGTAGTTGTGTCCTAAGTACTCCCTTACTTCTTCTACCC +TTCCTTCCCTCAAAAGTCTCCTTATAAGTGTGCTGCTGACGATGTGTCCCTTTATCTTGAATGGTTTTGC +CTCTTCAACCTCAAAGCCGAGTTCACTCCCCACCTCTTTTGCGAGTTCTATCTCCCCTTCCCGTCTGTAG +CCGTATCTCCAGTCGTATCCAACGAGCAGGTACCTGCACTTCAATTTCTCGTAAATTATCTTTTCGAGAA +ACTCCCTCGCCCTTATTTTTGCAAATTCCTTATCAAACCTTATGAAACAAAGGTAATCAACTCCCAGTTC +CCGAAATATCTCTATCTTTTCGTTTATGTCCGTAAGTTCACAAGGAAGGAGTTGAGGTGCTAAAACTTTA +AGCGGATGAGGACAAAAGGTAAGAACGAGAGTTTTTAAGTTTTCGCTTTTTGCTTTCTTCTTTAAGTTTT +CTATTAAATACCTGTGGCCGAGGTGAACTCCGTCAAAGTTCCCTACAGTAATCGCCGTGTTTTCCGGAAC +TTCTTCTAAGGTTTTCAGCCTCTTATTGGGACAGTTTTTGGAGTCAAGTTTTAGAAGAAAAACTTCCATT +AAACATTAACCCGGGGGCCAGGACATTTCTCTTCCGCCTATCAGGTGAAGGTGGAGGTGAAAAACTGATT +GTCCCGCATCTTTGCCTACGTTAAAGACAAGTCTGTAACCTTTATTGAGGTTCTCATCAGGTGCGATACC +GAGGTCCTCTGCAATTTTCCTCGCCACGTAAAACATGTGTCCAACTAAACACTCGTCCTCGGGCTCAAGA +GTTTGTATCCCCATTATGTGTTTTTTGGGAATTATAAGTATGTGAACGGGAGCTACGGGATTTATGTCGT +GGAAAGCGAGAACCTTATCGTCCTCGTAAACCTTCTTTGCGGGAACTTCCCCCCTTACGATTTTACAGAA +AATACAGTCCTTCTCCTGCATGTAATGTTATTTTATCCTAGTATTCATGTCGTCTAAACATGTATGAAAA +GAAATTACATTCAAGAATAAGGAGTGGAAGATGGAGCTGTTATTAAAAATACCTCTCGAAAAGGAAAAGT +ATGAGATAAAGGAATATCCTGAAACGGGAACGATGTTAATAGTACATAAAGACTTGAGAGGAGAGCCAGA +TTACTCTATAGAAGGGGAAGGTTTAGTAATAGAATTTAAAAACGGGGAGATTTACACAATAGACGTTTAT +GATCCGGAAGTGGCAAGAAAAATTAAGCAGGAGCTTGTTCTAGTACTTTAAACTTTCCTTTATACTTAAT +AAAAATTCCCTATGGGAGGTAAGGCATGAGGAATAAAGTTCTGATAGTCCTCGCGGTGATCGCCGGAGCC +CTTATATTAAAGTCCTGCGGAGAACCCTACAGCGGAGCTAAGGAAACCGTGGGAGAGTTCATGGAAGAAA +TCGCCGAAGGCGAAGGAAGGGACGCCATAAAGTACCTCTATCCGGCTTACAGGGATGAACTTGCAAAGAA +CTTCAAGCTTCCCGTTCAGTTTACGGAAATGAAACCCTCCGAAGTGCTCGCATGTGTTCTGAGCACTATG +GGAAGAAACATAGACGAGGTTGAGATTAAGAAGGCTATAGCTGTCAATCCTAACACAGCCAATGTAGTGG +TTAAAGTGGAAGACAAGGAAGGAATAGAGAAGTTCTTCAGCTTTACGGTTGTAAAAGAAGGAGATAAGTG +GTACATAGCAAAGATTGAAAAATATATACCCCAAGTAGGAAGGTGAAAATACTTATCTGGCAGACTGCAT +ACCTCGGGGACGTGGTTCTCGCCACGCCCCTCATACAAACCCTTAAAAAAAACTTTCCGGACGCAAAAAT +AGGCTTTGTGGGAAGACCCTTTATTAAAGAACTTTTTAAAGACGAAGAAGTAGAATTAATTCCCTATTCA +AAAAAGTTCAAAGAAAGCTTTACGGTAATAAGGAAGATAAAAAATTACGACGTAGTGATCTCACCCCACC +GTTCCATGAGAACAGCCCTAATACTCTTTTTTTCAGGAATTAAAGAGAGGATAGGTTTTGACAGGTCAGA +TCTTCCCTTTTTGTACACAAAACTCGTGCCCCATCGCTGGGAACTCCACGAAGTAGACAGAAATTTAGAA +CTTTTAAAACCATTAGGAGTAAAGGAATTTATTAGAGAGACAAAACTCAAAATGAAAGAAGAAGAGTACA +GGAAAATCCTAAATAAATTCAACTTAAAGGAAAAAAAGTACATTGTTATTTCACCCTTTTCAAACTTCCC +GTTAAAGGAGTGGAGCTTAAAAAACTGGAAGGAGTTGGTAAGGAAACTAAACACTCCCGTCGTAATCACG +GGAACGAAAGAGGACGAAGAGAGGAGTAAAGAAATAGATGGAAAGAATGTAGTAAACCTCGTGGGGAAGA +CTTCTCTCAGGGAGTTTATGGGAGTTTTGAAAGGAGCAAAATTCGCGATTTCCAACGATTCCTCGGCAGT +TCACGTGGCAAACGCCTTCAGAGTTCCCGCACTCACGATTTACACGGCAACTTCACCCAAGTACGGTTTT +TACCCTTTAATAGGTGAATACATACAAAACCCCGCTCCCTGCTCACCCTGTTCTCCCAACCCTAAAAAGT +GCAAAACGGGAACTAAAGAGTGCCTTTACTTTCCTGAGCCCGATTACGTTCTGGAAAAGGCAATACCTTA +TATTAAAGACTTATGATTTCAGCGTTTGTTGTTACGGGATTTCTCGGAAGCGGTAAGACGAGTCTGATAA +TAAACTCCGTAAAGGAGCACCTTAAAGATAAAAAGGTCGCGATAGTTGTAAACGAGTTCGGAGAGGTAGG +AGTAGACGGAAAGATACTTAAAAACGTTTACTCCGAAGTTCTGGAGCTTTCCGAAGGCTGTATTTGTTGC +AAACTGAGTGCGGAATTTGAGAGTTCGGTCCGGAGGCTCATTCAGGACTACAACCCGGAAGTTCTTATCG +TAGAGACCTCCGGCGTAGCGGAGCCGTTTCCCATAGTGTTCAGTTTAAAGACTCTAGGGCTCTTCGTGGA +CGGAGTTATATGCGTTATTGACTCTAAAAACTTTCCGAAGTACAAAGAGGACGACACCGCAAAGTACCAG +CTCGCAACCTCAAACGTAGTCGTTTTAAACAAGACAGATTTAGTTTCAAAGGAAGAGCTGGAGAAAGTAA +AGGAAGAAGTGAAAAAGATAAAGGAAAAGTACAAAGTGGTGAACATGTTCTCCCCGGAAGAGAAGGAAAG +CTTTTACAAAATTTACGAAGCTACTTATGGAAAAGTTCCAGCGGAAGTATTCAAAGGTGTCGGAAAACCC +GTAGAGCTAAAGGAACACCTTCACTTTCACTCCCATGACAGCAGAAAGGAAGAAGTTGTAACCTTTGACA +GAGAACTTACGGAAGAAGAACTCGTGAACTTCCTGAAAAACCTGCCAAAGGAAGTTATACGTGCAAAGGG +AATTGTTAAGTTAAAGGACTACCCCTTTCCCGTATTCGTCCACTACGTCTTCGGAGATTACGACTACGGA +ATGCCCGCGGAAAATTACGAAGGAGAGTCTTTCTTGGTTCTAATAAGATGATTGATGTAAGGAAGTACAT +AGACAACGCAGCCCTGAAACCTCACCTCTCTGAAAAAGAAATCGAAGAATTCGTCCTAAAGTCTGAAGAA +CTCGGGATTTACGCTGTGTGTGTAAACCCGTACCATGTGAAGCTCGCAAGTTCAATAGCAAAGAAAGTAA +AAGTCTGCTGTGTGATAGGCTTTCCTTTAGGACTTAACAAAACTTCCGTTAAAGTAAAAGAAGCGGTAGA +AGCCGTAAGAGACGGTGCACAGGAACTCGATATCGTGTGGAACCTTTCGGCTTTCAAAAGCGAGAAGTAC +GATTTCGTGGTGGAAGAATTAAAGGAAATTTTTAGGGAAACTCCTTCAGCAGTTCACAAGGTAATCGTTG +AGACACCTTACTTAAACGAGGAAGAAATAAAGAAAGCGGTGGAAATCTGTATTGAAGCAGGAGCGGACTT +TATAAAGACCTCAACGGGCTTTGCACCGAGGGGAACAACACTCGAAGAGGTAAGACTGATTAAAAGTAGC +GCGAAAGGCAGGATTAAGGTAAAAGCTTCGGGAGGGATAAGGGATTTGGAAACGGCAATATCTATGATAG +AGGCGGGGGCGGACAGGATAGGCACGAGCAGCGGTATAAGCATAGCCGAAGAATTTTTAAAACGACATTT +GATATAATGTCCCTATGGCGGACAAGAAGTGGAAAACGGCAATATCTACCCACGTAAATCACGAGCCCTA +TGTAAGGGGATACAGACTCCTTGACCTTGTAGGAAACCTCACCTTCTCGGAAGCAATATATCTCCTCCTC +AAGGGAGAACTCCCCTCGGAAGCAGAAGCTAAAATGATGGACGCCATTTTTGTCTCCGTAATTGAACACA +GCATAGCACCCCCTTCCGTAATAGCCACGCGTGCGGTTATAAGCGGTGGAAACTCTCTGAACGTGGGAGT +CGGTGCTGGAGTTCTGGCTTTCGGTAGTGCCCACGGTGGAGCCCTTGAAGACGCAATGAAGTTCATGCAG +GAAGGAGTAAAGAGCAACAGACCTGTTGAAGAAATAGTAAAGGAGTACTTATCCCAGAAAAAGCCAATAC +CCGGTTACGGACACAGGTACTACAAGGAGTTTGACCCAAGAACGAAGAGATTATTTGAACTTGCGGAAAA +GTACGGTTTTTGCAAGGAACACTGCGAATTTGCAAAGAAAGTAGAAGAAGAGATATACAAACAGAAAGGA +AAGAGAATAGTCCTGAACGTTGACGGTGCCATAGCAGCTATAACTTCCGATATGGGCTTCGACTGGAGGC +TCGGTAAAGGATTTTTCATAATCGGAAGAGTGCCCGGACTCGTGGCCCACGCTTACGAAGAATTAACGCA +GGAGAAACCCTTCTCCAAGAGACTTTCCGAAGAGGAGTATGAATACACCGGAGTTGAACCGAGGGAACTC +CCGCCCGAAAGGAAGAAGGTATGAAAAGGCTTCTCCCCGTCTTCCTCGCCCTTATACTCTTCGGTTTGTT +AGTTTACATAGGACTAAATCAGGATAAACACGATCACTACACAATCACAACCCAGAAAGGTCAGAAAATC +CCAAACGTTACCTTAACAACACCTGACGGAAAGAAGGTAAGTATAGAGGAATTTAAAGGGAAGGTTTTGC +TCATAAACTTTTGGGCCACTTGGTGTCCTCCCTGTAAAGAAGAAATCCCGATGTTTAAAGAGATATACGA +AAAGTACAGGGACAGAGGTTTTGAAATACTCGCCATAAACATGGATCCCGAAAACCTCACAGGCTTCCTG +AAAAATAACCCCCTTCCATTCCCGGTATTCGTGATAAACGAGAAGTGGAAAGAGCCTTTAACATTCCAGG +GCTTCCAACGTCGTACTTGGTTGACAGAGGAGGAACTATAGTAAAGGTTCGCTTGGGAATTTACAGGGAG +CTGGAAAAGGATTTGAACGATCTTCTGGAAAAGTAATTAGGTCTTTATAATTTAAAAAGGTTATGAGCAG +TACTGCGAAGAAAATTGTAGTAGCCTTATAGTTTTGAGTATAGCCTTCCTTTCCGCATTCTTTACCGTTT +ACAACTACTTAAAACATCCAGAAAACAGGGAGTACTTTTTAAAGAGGCTTGAACGTGCAAGGGAAACAAA +TCCCATAAAAGAGTCCGTTGAAATGTTAAAAGAAAGATTAAAAGGAGGAGAGCATGAACACCAACCTCAA +AAGTAGTCCCCTGAAGACGTTAGTTCTCGCCTCGGTTGTCTTGACTTACGTTATAATTTAAAAAGGTTAT +GAGCAGTACTGCGAAGAAAATTGTAGTAGCCCTTATAGTTTTGAGTATAGCCTTCCTTTCCGCATTCTTT +ACCGTTTACAACTACTTAAAACATCCAGAAAACAGGGAGTACTTTTTAAAGAGGCTTGAACGTGCAAGGG +AAACAAATCCCATAAAAGAGTCCGTTGAAATGTTAAAAGAAAGATTAAAAGGAGGAGAGCATGAACACCA +ACCTCAAAAGTAGTCCCCTGAAGACGTTAGTTCTCGCCTCGGTTGTCTTGACTTACGTTTTGATGGTATT +CGGAGGTATAGTTACCTCTACGGGTTCAGGGCTCGGATGTCCCGACTGGCCCCTGTGTCACGGACAACTC +CTTCCTTTTCAGTTAAAGGAACAAATTCCCACACCTCCCGCACCCGTGGTAGCTCCAACTCCCCTCCAGC +CCTGGATTGAACAAACACACAGGATACTCGGAGGAATAACTGGCATAGTTCTGCTCGCAACACTCTTTTA +CGCCTTCAAAAGGGGAACTTCTTTCGTTAAAAAAGCCCTCGTTTTTATATTCATAGCTCTGATACTGGAA +GCCCTTCTCGGCATGAGGGTTGTAATAACGGAGGCACCGCTTCTCAGAGAACTACTCCACTATGTCTACA +CGAGCGCTCACCTCATACTTTCGGTGTTTATACTTTCAACGATAACCATAACTTACTACTACGTTAAGTT +TTTTGGGGAAAGGCCTAAGGAGTACATCCCTTATGCAGATGCCCTCTACGTTGCAACTATGTTCCAGATA +CTGCTCGGTATATTCGTGAGGTACGTAAAAGCCCTTGAGTACAATCAGTTTGTTTACTACCTTCACATAA +CTTACGCGGGTTTCCTCGTTATACTCTCCCTCTTCATAATGTTTAAGGAGTTCAACAAGTACTCTTTAAT +AACGTTTCTCTTAATGACCGCTCAGATACTCGCAGGTGTCGCCACCGTGATTTCAGGGTTCTTTTTACCG +TACCTCTTTCTTCACATAGCAATAGGATTCTTTATAGTCCTTTGGGTATCCTACCTTGTAGCACCTTCCG +TTTTAAAGACTTATACTGAGTTTAGAGGAGAGCTGGCATGAGTGAAAGGGTAGAGGCGGGACAGAACGTG +ATAAAGGAGTATTTGGTTCTCACAAAACCGGGAATAGTTTCCTTAGTTCTTATTACCACTCTCGGCGGAA +TGTATTTAGGTTCAAGGGGTGAGCTTCAGCCCGAACTCGTTTTCTGGACCTTGCTCGGTACGGGACTTGC +CGCGGCAGGTTCCGCGGTTCTCAATATGGTAATTGATAAAGACATAGATAAATTGATGGTAAGAACTTCC +GAGAGACCGCTTCCAAAGGGAACGGTTGACCCTACAAAAGCTTTCATCTTCGGTATAACTCTTCAGGTTT +TCTCACTCGTTATAATGCTCACTTTTGTGGGAGTCCTTCCAGCGCTGCTCGTAGCGCTCGCTTCCTTTTC +TTACGTGATACTTTACTCTTTGCTTCTCAAGAGAAAGAGTCCCGTTGCAACTGAAATAGGCGGGATATCG +GGGGCACTTCCGCCCGTTATAGGTTATGTTGCGGCTTCAGGAAGCGTAGATATAAACGCCATAGCCCTCT +TCCTTTTAATGTTCATGTGGCAACCTCCTCACTTCTGGGTTTTAGCCCTCAAGTACGCGGACGACTATAA +GAGGGCGGGAATTCCGACACTTCCCGTAGCCAGAGGTGTATTCATCACCAAACTAAAGACACTCCTTTAC +ACAGCTTCACTCTTTCCCGTATCCTTAATCCCTTACCTGACGGGACTTGTAGAAAACCTTTACTTTGTCG +TTGCGGTTGTTATGAATCTGATTTATCTGGGGCTCACTTTAAAGTTCTTCTTCTCAAAGAAAGAGGAAAG +TATGAAACTCTTTTTCTTCTCAATCATTTACCTTGCGGTTCTTTTCGGAACAATGATAGTGGACATGGTG +AAGTGATATGCTCTGGTTTTCCCTCTTTATTTTATCCATAGCAATCGGTGGTTCTTTTGCCCTCCTCGTT +GCAATAGCAAGGACTCCGGGACTTGCGGATCTCTTTCCTCCAAAGTACTTCTACCACGCTCTTGTGGGAC +ACGTGGACAGCGCTCTGATAGTCGGACTTTACGCATTTTTGATATTTTTATGGCACAGGATTTTTGAAAA +GAAGGAAAACTTCGCAAGCTTCCTTCCCGCACTGCTCGGGTTTTTTATGATAGCGGGAAGTTCACTCTTT +GGTCTCGGACAGGCACTATGGAACAACTACGTTCCTACCATAATACACCCTGTATTCTTCGGCGGAGTAT +CTTTATTTTTCCTTGGTGTTTTCTTAAACTCTTTGAGGTTTTTGCCTCAAGCTGTTAAGAACTTCTACAT +CGGTGATACCCTGAAATCCATTCTTTCTACTACCGTGATTAATTCTTTCTTAATGCCCTTAACTTACCTC +ATCGCCTACTTCAACACTCCAAAAGGAGAAAATGTTTACGAGTACTTTGAGGCACTTTTCTGGTTCGGCG +GGCATACCCACCAGTTTGTAAACGCGGGACTCCTGATTTCATTGTGGCTACTCCTCCTGAGAAGGGAAGT +TCTAAACCTCTGGTTTTTAAACTTACTTCTCGTTGTATTTCCTATAACTTACTTCTTTGCCCAGATTTTC +CTGAACCCTCTATCTTCTACAGGAAAGAGCCTCACCACGTGGGGTTACATGGTCGGTATAGGTATTCCTA +CAATCGTTTACGGACTCATAACTCTTGTAAGGGCTGTTAAAGGATTGGACTTTTATAGAAGCATTCTTGT +GCTGTCCGTTTCCCTTTATCTCCTTGGGGCTTTAATGGGATACATGATAGTAGGTATGGATACGAGGGTT +CCAGCACATTACCACACGGTAATAGCGAGTATACTCGTGGGCGTTATAGCTCTTACCTTTATGTACCTTC +AGGAACTGGGATACATGGAAAAACTCGGGAAGTTTGAGAAGTTTATCCCTTTTTCTACGGTTTTGGTATG +CTTCTTTTTGTCCTCGGACTCTTCTGGGCGGGAGTCTTTGGAGCTCCAAGGAAAACTCCGGGAACGGATT +ACATACAAAACGCAAAGGTTTACTTATTCATGGCTCTCATGGGACTAGGTTCTGTACTATCCGTAGTAGG +AGGGGCTTCTTTCGTCTTTGTAGTGCTGAAAACAGTTTTGAGAGGTAGGAAGTATGGAAAGGAGACAGAA +GCAAATTAGGAGGTTTAATATAACTATTGCGATTATACTCGCAGTTCTCGCTCTTATAACTTACCTCATA +GTCTTCCTGGCTGCGTATCTGTTAAAATAAACAAACTATGTACGAACTGATAACCATTCTTAGTTTAGTA +ACGATAGGACTGAGTGGTTTGTTAATACTTACTGGAATAGTCCTCATAAAACTCGGAAAGAGGGAATGGC +ACAAAAGGGCTATGCTGACCGCTTCTTTCTTAGCCCTTATATTCGTTGTGCTTTACCTCATAAAGTCCAG +TCTCTATCCACCGAAACAATACACGGGAGAGTATAAAACCCTTTACTACTTTGTCCTCTGGAGTCATACA +ATCCTTGCGATAATAAACTTCCCCCTAGCTGTATACACGGTTTACTTGGGACTTAAAGGTCTCTACGATA +AACACAGAAAGATAGCACCTATAACCGCCGCGGTATGGATATACGTCGCCGTAACGGGATGGATGATATA +CTTTTTCTTAAACTGATGTGGAGGGGATTATGAAAAAGTTCTTTGCTCTCATGACCTTAATTGCGGGAAT +TTCCTTTTCCCTTGACTTTGCCTGCGTTGACACGAACAAAGTGATAAGGGAGTCTAAGTTCATAGCGAAG +GCTCAGACTGAACTGAGAAAAGAGCTCGAAAAGTATCAGAAGCTGATACAGGAAAAGCAAAAAAAGCTGG +AAGCGTTAAAAAAATCCTTGGAAAGCAAAGCACTTTCAGAAAAGGCTAAAGAAAAAAAGGCAAAGGAAAT +AGAACAACTGGAAGACGAACTCAGAAAACTTCAGGTGGAAGCCCAGTCTAAACTTTCAAGGAAGAAAGCT +GAGCTTGAAAAAATGGTTTTTGACAAAGTAATTAAGATAGTAGAAAGCACGGCTAAGAAGAAAAAGATAA +AGGCCGTTTTTGACTGCAACTCCATGCTCTACTGGGATAAGAAAATAGACATCACAAATGAAGTTCTGAA +AGAACTCGATAAATGAAGAAGGAGTTCTCCGCAGGGGGAGTGCTTTTCAAAGATGGAGAAGTGCTCCTCA +TAAAGACTCCCTCAAACGTATGGAGTTTTCCAAAGGGAAACATAGAGCCGGGAGAAAAACCTGAGGAAAC +GGCGGTAAGGGAAGTGTGGGAGGAAACAGGAGTAAAGGGAGAGATTCTGGATTACATAGGCGAAATCCAC +TACTGGTATACGCTAAAGGGGGAGCGGATTTTCAAAACCGTAAAGTACTACTTGATGAAGTATAAAGAGG +GAGAGCCGAGACCCTCATGGGAAGTGAAAGACGCCAAGTTTTTTCCAATTAAAGAGGCTAAAAAGTTATT +AAAGTACAAAGGAGACAAGGAAATCTTTGAAAAGGCTCTAAAACTCAAGGAAAAGTTCAAACTTTAACCG +TCCCTTTTTGTTCCTCTTCTATCCTCTCAAGTGTAGGATCATTTTTCTTTCCAGTAAGGATGTCCAGTAG +TTCCTTTACGTGTATTATTCCCTGATACTTGAGCCAGTGTCCGTTAGCACCGCTTATGAATATGCCCTCC +TCGTAGTCTCCGAGCCACGCAAGGCCTAACCTGTCCGCTATGCAAAATCCCACTTTCTTAGCTTCTTCCC +CTTTGTTGCACGGAACCACGCAGTGAGAAACGCATCCCTTCCAGCCGTTGTACCCGCTCAAAAGTCTTTC +TATAAAGGGTGTTTTTATAACCCTCAAGGGATATCCTACGGGAGATTTGAAGAGCATAATATCCTCTTTG +TTCAGATTGGTAACGAGCTCTTTGTAAATTTGGGGAGCGTCACACTCGTGAGTTGCTATAAAACGGGTAG +CCATTTGAACGCCAGAAGCTCCCATGTCTATGAATTTCTTAATGTCGTAGTAACTCCAGACTCCGCCTGC +AACAATTACGGGTATATCTCCCCACTTCTTTGCCTCCTCCAGCACAGAGGGGAAAATGTTTTCCAGCTGG +TATTCGGGTTTAAAGCAGTCCTCGTACTTAAAGCCCTGGTGTCCTCCAGACTTTGGACCTTCAAGTATTA +CGGCGTCTGGAAGTCTATTGTACCTCTTCTTCCAAGTCCTGCAAATTAAGTTCAGCGCCCTTGCGGAAGA +AACTATGGGTACAAGTGCAACGTCATACCCTTTAACGTATTCGGGGAGTTTTAAAGGCAGTCCTGCACCT +GATATTATAAGATCCGCACCTGCTTCCGCCGCGTCCCTTGCTACCCTTCCGTAATCTGTTATAGCGGCGA +GTATGTTTACTCCTATAGCTCCCCTTCCGCCCGATATTTCCTTCGCGTCGCGAATGATCTTCTTGAGAGC +TTCGGGGTGGTGCGTGTTTACAGAACCTATCGGTCTTCCGAACTTGTCCCTCTTTACTAGATGGGGATAT +CTGTAGCCTGTTCCACAGCGGAAACGACACCAATAGCACCTTCTCTTGCAACGCTTCCGGCGAGCTTTTC +CCAGGATATACCAACACCCATTCCGCCTTGAATTATGGGTATATCTACTTCAATCCTTCCAATTTTTAGC +TTTGGTAAGTTCATACTAACCTCTCCTTAGAATATCTTAAAACAAATTTTAAGATAGAATTATTGAACGT +AAAGTCCAGTAAGCTTTATCAGGTGCAATAAAGGAAAGTTCAAGTATGGCTACAGTCTATTTAGGACTCG +GGAGCAACGTAGGAGATAGGATATCTTACATACTTAAAGCGATAGAAAAACTTGAGGAATTTTTGGAAAT +AGAAAAAATATCCACAGTCTACGAAAGCAAAGCCTGGGGTTTTGAAAACCAAGGAAACTTTCTAAATTTC +GTTTTAAAGGCAAAGACTTCTCTTCTCCCGCAGGAACTTCTTTTGAAGATAAAAAAAGTGGAAAAGGAAG +TTGGACGAAAGGAAAGGTTTAAGTGGGGCCCGAGGGAAATAGACATAGATATACTCCTGTACAAAGATGA +AGTCATCAGGACCAAACTCCTGAAAGTCCCCCATCCCTTTCTGGAAAAAAGGGATTTTTTCGTCTATCCA +CTACTTGAAATAGAACCGAATGTAATACATCCTATCTACAGAAAGCCTCTGAAGGAGTTTAAGCCCGAAA +ATACACTGAAACCTTTCTGCTGTATCTTAAAAGTATGAAGCGTGTTCTCGTTGTGGACGACGAAGAAAGT +ATTACTTCTTCTCTCTCCGCAATCCTTGAAGAAGAAGGATACCATCCAGATACGGCAAAGACGTTAAGGG +AAGCGGAAAAGAAGATAAAGGAACTGTTCTTTCCCGTTATAGTCCTTGACGTTTGGATGCCCGACGGGGA +CGGTGTAAACTTTATAGATTTCATAAAAGAAAACTCTCCCGACAGCGTTGTCATAGTAATCACGGGACAC +GGGAGCGTGGACACAGCGGTAAAAGCGATAAAAAAGGGAGCTTACGAGTTCTTGGAAAAACCTTTTTCCG +TTGAGAGATTTCTTCTTACGATAAAACACGCCTTTGAGGAGTACTCAAAGAAAGCCCCGCCTCAGGAGGA +AATAGAGTTTGTAGGGGAACACCCGAAAATTCTGGAGATAAAGAGGCTTATACCCAAAATAGCGAAGAGC +AAAGCTCCTGTCCTTATAACAGGAGAAAGCGGAACGGGAAAGGAAATAGTAGCGAGGTTAATACACAGGT +ACTCGGGAAGAAAGGGAGCTTTTGTAGACCTGAACTGTGCTTCAATTCCTCAGGAACTGGCGGAAAGTGA +ACTCTTTGGACACGAAAAGGGAGCCTTCACTGGAGCACTTACGAGAAAGAAGGGAAAATTAGAACTCGCC +GATCAGGGAACCCTCTTTCTGGACGAGGTGGGAGAGCTTGACCAAAGGGTTCAGGCAAAACTCTTGAGGG +TTCTGGAGACGGGAAGTTTTACAAGACTCGGAGGAAATCAAAAAATAGAAGTGGACATAAGGGTAATATC +CGCAACGAATAAAAATCTGGAAGAAGAAATCAAGAAAGGAAACTTCAGGGAAGATCTTTACTACAGACTT +TCTGTATTTCAAATATACCTCCCGCCACTCAGGGAAAGGGGAAAGGATGTTATCCTCCTCGCGGAGTACT +TTCTAAAGAAGTTCGCAAAAGAGTATAAAAAGAACTGCTTTGAACTTTCCGAAGAGACGAAGGAATACTT +AATGAAACAGGAGTGGAAAGGAAACGTAAGGGAATTAAAGAACTTAATAGAGAGGGCTGTTATTTTATGC +GAAGGTGAAGTCATAAAACCTGAAGATCTGGGACTGAAGGAGAAAAGCTGGAGGGACTTATCTTACCTTC +TTAAGATAAAAGAGCTAAAAGAAGCAAAAAAGGAATTTGAGAAGATATTTATCGAGGAAAAGTTAAGGGA +GTACGATTACGACCTGAAAAGAACCGCGGAAGAAATAGGTATAGATCTTTCAAACTTGTACAGAAAAATA +AAAAGTTTAAACATAAGAGTCAAAAGTTCATAAGAATAGACACTATACTCACGACCGCTGTTTCCGTCCT +CAGGGTGTATGGCTCTAAAAGAACGGATTTAAATCCTTTTTCCCTCAGTATTTGACTTTCCCTCTTAGAA +AATCCACCCTCTGGACCCACTACCACCGAGTAAGTTTTTGCCTCTAAATTCACGTCTTTGGGTTTTACAC +CTTCGTAGAAGTTGTCAAGGATTATATTCTCCTCAGATTCTGGGATTAAATCAGAGAGCCTTACGGGTTT +CTTTATTTCCATAGGGATAGGCCTTCTTGACTGCTTCATAGCTTCTATAACTATCCTCTTCCACTTTTCG +GTTTTCTTCAGTATGGCTTCTTCCTTTTGAAAACTCCTTTCAGAGATAATGGGGACAAAGGTTAGAACTC +CCAGCTCCGTTGCCTGCCTGACTATTGTATCCATAGTTTTCAAATCAACGGTAACACTCTGATACAGAGT +AATATCTTTTGGAGGCAGTTTTGTTTCCAGCTCTTCCACGATTTCACAGGAAATCTCCCTTTTGTCTTCT +CTCCGAACCTTGCATACGTATATTTTTCCCTCGTGTATTACTCCGAACTCTTCGTCTTTTTCAATCCTCC +TTACTCTAAAATGCTTTACTTCTCCTTCCCTCAAAATAAGGAGGTTTCCGCGCCTTTCTTCTGAGTAAAA +GACGTGCATGCTATTATCTTAACTATGCGCGTAGGGATAGTGGGTTTTGGGAATATGGGACAGGCTTTTG +CCTTGTGCTTTTCAAAAAAACTCGGTAAAGAAAACATAATAGTCACGGACAAGGTTCAGGAAAAGAGAAA +CCTCGCAACGGAGATGGGAATAGCTTTTGCAAGTGATGTAAAATTCTTGGCGGACAACTCAGACGTTGTT +CTCGTAGCGGTAAAGCCCAAGGACTCGCAGGAGGTTTTACAAAAACTAAAGGATTACAAAGGGATAATTC +TCAGCATAATGGCGGGAGTGAGTATTGAGAAAATGGAAAAAATCTTAGGAAAGGATAAAAAGATAGTAAG +GGTAATGCCAAACGTAAACGTGGCCGTGGGAAGCGGTGTTATGGCGATAACCGACAACGGGAACCTGAGC +GAAGAAGAAAGAAGTAAAGTAGAGGAACTTCTGCTTTCCTGCGGAACTCTTTACCGTATAGAGGAAAGAT +TATTTGACGCCTTTACCGCACTTGCAGGAAGCGGACCCGCTTTCGTTTTCTCCTTTATAGACGCTCTGGC +ACTTGCGGGAGTCCATCAAGGTTTTTCTTACGAACAAGCCCTCAGGATAGCCCTTGACACGGTTATGGGT +AGTGCAAAACTCTTGAAAGAGTTTCAGGTAAATCCTAACGAGCTCATAGCTAAGGTCACCTCTCCCGGCG +GAACGACTATTGAAGGGATAAAGTACCTTGAGGAAAAGGGATTTAAAGGCACGGTTATGGAATGTATAAA +CAGGACTTCCCAGAAGGCAAAGAAGCTTTGAATTTAGAGATAAGGCTGGGAAATAAACTCGTAAGATTCA +GGAAATTCACAGGAAAGGAAAAGATTTACCTTCCCATTCAAAGACACACCGATAAAGTTATAAAACTAAT +TGATAAAGACTCACCACCCCTTGAGGGAGATGCGGTAATAACGAACTTAAAGAACGTAGAAATTGGGGTA +AGAACAGCGGATTGCGTGCCGATAATACTTCTTGGAAAGGAATGGGTAGGCGCGGTTCACGCAGGCTGGA +GAGGGCTAAAAAAGGGGATAATAGCGAAAACCCTAAAAGCATTAAAAGAAGAAGGAGAAGACGACATTAC +GGCTTTAGTCTTTCCCTCCGCAAAGGGTTGTTGTTACGAAGTGGGAAAAGAGTTTAAAGAATTTTTCAGA +AGGAATTTAAAGGAAAGAAACGGAAAGCTTTTCTTTGATCCTCAGAGGGAAGCTGTAGAACAACTAAGGG +AGAACGGAATAAAGAGTATTCTTGTATGGGAAAAGTGCACTATATGTTCTCCGGAGCTACCCTCCTACAG +GAGGGATAAAACGAAAGAAAGAATGCTTACAAGCGTCGTTATACTGTTTTAATCTTCCCTGCAAAGTTCT +TTTATTTCTTCCAGATAAACCTTTATTATCTTCAAATAGCTTTTATACCTCTCACACGAAATTTCTCCGT +TCTTTACTGCTTCTTTTACAGCACAGCCCGGTTCGTTCGTATGCGTGCAGTCAGGGTACTTACACTGATA +CCTTAAAAACTCCCTGAAGTAATTTCTCACTTCTCTTGGTTTTACGAACATCGTAGCCTCAACCTTTGAA +AATCCGGGAGTGTCCCCTACAAAGGATCCCTTTCCGAAGGGAATTAACCTGACTCCCGTGGTGGTATGTC +TTCCTCTTTCCGTTTTTTCGCTTACTTCCTGCGTTCTCAACTCTTCTCCCGTGAGCCTTGAAAGGATTGA +GCTCTTACCTACACCCGAGGGTCCCGCCAAAATGCATATAAAACCTTCAAGGTAATCAACTAGTTCATCT +ATTCCCTCTCCCGTTTTAGCGCTTACCTTGAGAACGTCGTAGCCCGCATCCCTGTAAATGCTATCCATCT +TTCAAGTTCCTTCTTTTCCTCTTCGTTCAAAAGATCTATTTTGTTAAACACTATTACGGGTTCTACTTTG +AAGTATTCGTAAACGACTAGCATGTTGTCAAGCAGGTAGTTGTTGAATTCTGGCATTTTTAAAGTTTCAA +CTATTATTACTCTGTCAACGTTTGCGACTTTGGGTCTTATGAGGAGGTTTTTCCTTTCCTCTACCTCTTC +TATCGCAAAGGTATTCGGATCTACAACCTCTCCCCAGACGTAATCACCGGCGTTAATTTTTGTCTTCTTC +AGAACTTTTCCCCTCGGAATTCCCCTGTAAGTTTTGCCGTCCTCAAACAGGTAAACGCCTATCATCTGGG +CTTCCCTGTCTACGACGAGTCCCCTTTTCAATTCTTTCTTTCCCATAACTACACCTCTTTTTCAAGCTCT +TTAATTGCCCATTTAAGTGTATCAATAACGTAGTTCATTTCGTCTTCCTCTATTACAAGAGGCATCATCA +ATACCATAACGTCTCCGAGCGGTCTCAAAAACACCCCTTTTTCCCTGCACTTGTAAGCCACCTTAAATCC +CGTCCTTTCACCGTAAGGGAAAGGTTCTCCCTTTTCTTTGTCCTTCACCAGCTCTATTCCAGCCATAAAA +CCTAGCTGTCTAACATCTCCAACGTGCTTGAGTTCCCAGAACTCCTGAAGCCTTTCCTTTAAAAGCTTTA +TCTTTGGTTGGAGCTTCTCTAAAGTTCTTTCTTCCTCAAAAACTTCTAAGTTTGCGAGTGCAACGGAACA +GGCGAGGTTATTTCCAGTGTAGGTGTGCCCGTGGTAAAAGTGCTTTGCCTCCCCGAACTCACCTAAAAAG +GCATTGAACACCTCGTCCGTTGTGAGTGTCGCAGCAAGCGGGAGGTACCCTCCGGTTATACCCTTACCTA +GACACATAAAGTCCGGACTGACTCCTTCCTGCTCACAGTAAAACATCGTTCCCGTCCTGCCAAATCCCGT +GGCAACCTCGTCAACTATCATTAAAGTGTCGTATTTCTTCGTAAGCTCCCTTACGCCTTTCAAAAATCCC +GGAGGGAAGGGGAGCATTCCCGCGGCTGCCTGAATTCCCGCTTCCATAATGACCGCAACGATATCTTCCC +GCGACTTCAGGATATCTTCCAGTTGTTTTAATAAATCTGCCGTGCACTCAGGGCAGAGTTCCCCGTACTT +TTCCTTGCAGTACAGGTAAGGAGATGGGAGTTTTATAGTCTTGAAAAGGAGATCTTTATAAGTTCCGTGG +AAGAGTTCTATACCCCCTACGCTAACCGCTCCTACAGTATCCCCGTGGTAGGCTTCGGAAAGCGTTATGA +AAACGTTTTTCCCTTTAACTCCCTTGTTCTTCCAGTAGTGATAAGCCATCTTTATCGCTATCTCTACTGC +TTCCGCACCGTCTTCGGAGTAAAAGACCTTGTTTAATCCTTCAGGAGAAATTTCTACAAGCTTCTTTGCA +AGGAGTATGGCGGGAACGTTGGAACTTCCCAGAGTAGTTGTGTGAGCTACCTTACAGAGCTGTTTCATAA +CTGCGTTGTTCAGTTTAGGGTGGTTATGTCCGTGGACGTTGCACCAGAGGGAAGATATGGCATCTATATA +CTTCCTGCCGTATATGTCCCACAGGTAAACGCCTTCTCCGCGTTCAAATATCAGGTTTTCTTCTTCTCTG +TAGACTTTCATCTGGGTAAATGGATGCCAGAAGTACTCCTTGTCCCACTTTTCGAGCGTTTTAGGGTCTA +ATTCCCACATAGTAATATAGTATCTAAAGAAACACCACAAATACTTGAGTGTTTTTGTAAAAATAGTAAT +GATGCACGAGAAGCTGGAAAGGATTTGTTCCGTAATAGAACACTACCTCTCGGATATTTTGGGAAGGATA +AGGGTGTACAGGGATGAGGCAAACTTCCTTATACCTTGGGGTTCTACTGTAATAAACGTGAACGTGTTTG +GAGGAAGAAGAGGTATACATTGATGTAAACTCCCCTGTGGCTTTAAAGGTTCATCCGAGTAAAGACTTGA +TGAAGTTCCTATTATCGGAAAACGCAAACCTGAAGATGGCGTCTTTTTTTACGGAATTCGAAAAGGGTTT +TATGGATATAATCGTAGGCATAAAAATAAGGTATAAGGATTTATCAAGGGAATTATTAAAGTTTGTAGTA +CTCAACATAGGTAATTTGGCAAACGAATACGGAAAGGAAATAAGGGCTGTATTCGGTGGACTCTCCTTTA +AGGAATATCTGGAGAGAGAAAAGTACTCTTACCCTTATTCGGGAGAAAAGCTCTTTCAGGAGAAGATTTC +AATTAACGGAACGCTGCTTTTACTTGAAGTGTATGTGAAAGAAGAAAATTACACACTCATATGCCGAGAG +GAAGGTAGTTCCAATTACCTTATAAAGGCTATAAGAAAAGTTGAAGGCCCCTATGAGGCTTTAAAAATAC +TTGAAAAAGCAAAAGAAAGTATTAAGAACAGAGATTTTGTATCTTTGAGAAAACTCTTCAGTCCGTACGA +GGTAGACTTTTTTGAACTTTATTCCGTATTCCTTAAAGGAAAGGACACGACAAAACTGAAAAAACTTGAA +AAAGAAATTCACGAACTCCCGTATATGCTTATAAACGGAAAAATAACTTACGAGGAGTATAAGAAGAGGA +TAAGGGAAATAGAAAAGGAAATAGGGCTTTCGGAGTAGCAAGAATGAAATTAAAAAAACCTGCTAAAAAA +ACCTTAGAGGAAATAGGAAAACACTACCTGAATATCGGAGTAGCTATTATAGTTTTCGCAATAATACAAC +CTATTGTACAGGGGAAATTTAATATTAAAGTTGCTCTATATTTTGGATTAGCATATTTTATTGTTTTCTC +AATTGCAATAATATTATTAGTAATAGGAGGTTCCTGTGATGAATGATATGTTTTTATATTACTTAATTCT +TTTTTCTTTTGTATTACTCGCAGGAATATTTGGAATAGGAATAGTAATTCTGAGTTCTAAATATAGTGAT +ACTAAAAACAAGACTTAATACATTTCTCTCTCAGCGGACACTCTTCACATAGTGGCTTTTTCTTGCAAAA +CTCCTTTGCATGAATGTCTATAAGTGCGTGAAATTCTCTGTAAATTTCTAAATCTTTTGGCAAATTTTTC +TCAAAAAGTCTTTTTATTTCTTCGTAAGAACCTTTTATATTCCACAATCTTTCGAGGAGTCTTTTGGTGT +AGGCGTCTACAACGAACTCCAGTCTGTCGAGAGCGTAAAGTAGAATAGCATCAGCGGTTTCTTTTCCTAT +TCCTTTAACTTTTAAGAGGTCTTCCCTCTTCACATTTTTTAGATGGGAAATACTCGGAAACTTGTTCGCA +AACTCCTTAAGGTATAGGCTCTTCTGTCTGTAAAATCCCGCAGGTTTTATTAATTCCATTAATTTTTCAG +TAGGAATTTCCTTTATCGCCTTCAAGTTCAGGGCTTTTTCCCGTTTTAAGTTTTCCAGAGCTTTTTCAAC +GTTTTTCCACGAAGTGTTTTGAGTCAGAATTGCACCGATGATTACCTCTTCTCTGGGATCGGAACCGTGA +GTTTTGTGGTATTCAAGATCTACAGGCCACCAGTTTTGCTTTCCGTAAAACTGAAGGAGTTTATCGTAAA +GTTCAATTAACTCTCTTTTACCAATTCCAGACATCCAAATCCCTGATAACGGCGGAAACCGAGTCCGTAC +TTGTACACTTCGTTTAAAACGTATGGGTCACCTTCTAAAGTAAAAACTCCTTGATAGGCTACTATCTTTA +TGACTTTTTCGTTTTCTCTGTTTCCTACGACGTGTTTTACAACGGACTTCTTCCCTTCTTGGTGTTCAAA +CTTTAGTTCCGGAAGACCGTTGAAAATACACTTCAAAGAATACCTGAGTTCCTGCGTAAAGGCTCCGTCG +TCGTATAAAATGAAATCGTCATTTCTATTTCCGAGCTTTGAAGGAAGAACAGGCTTTTTATCCCTGTTTA +TAACGACTATGGGGGAAAGCGTTCTAAAGGTTTGTCTTGGCTTTGTAATTTGTTCTTCCTCGCACATAAG +AACCTTCTTTACCTTAATGTTTCCGTTTGTGTATCTGCCGTTGTATTCCCTTAACTTTTTTAGTCCGTTG +TAGAACCTGTGGAAAAAGTCAGGACTTCCCGAAGACACGGTCATTATAGCCTTCCCGTTGTTTTCAAGGA +TTTCACCGTTTATCCTTATATTTTCGAAGAACACGCAAAAGGTAAAAGGTTTAAAGTTCTTCTTCTGGAA +GAGATCCTTTGCGTAATTCTCGTCTTCCTTCTCTAAAGCCTTTTTTATTAAGGAAAGGAAGGATCGTCTG +TAGAAGATCGATATCTCCTTGGGGACTTCCAGATAAGCTTTTACCCTCATTTTTTCTTACTCCCCCCTTT +TGATTTGTCTTTAAGGAGAACCTCTTTTATCAAATAGTTCTGAATAATATTGAATACGTTGTTCAGCGTC +CAGTAAAGAACCAGTCCCGCCGGGAAGTTTATAAAGAGTAATGTGAATGCCACCGAGGTTATGTATCCCA +CAAGGGCCTGCTTTGGATCGGGGGAAGGAGTCATCTTTTGCTGAAGTATCATGGTAAGTCCCATAATAAC +GGGAAGTATGTAATAGGGATCCTTGTCCGCAAGGCTGGGAATCCAGAGGAAACTGCTGACTTTCAGATCT +ACGGTTATTATGAGAACCTTGTATAGCGCAAAGAATATAGGTATCTGGAGGAGTATGGGAAGGCATCCTG +CCATAGGGTTGAATCCCGTTTCCGCGTAGAGTTTCATCATCTCTTCCTGCATCTTTACGGGATCGTCCTT +ATACTTCTGTTTAATCTTTTCCATTTTAGGGGCGAGTTCTTGAAGCTTTTGCATAGAAACTACGCTTTTG +TACCCCAGCGGGAAGAGGAAAATCCTGACTATAAACGTGAGAACGAGGATAGAGAGAACCCAGCTTCCCG +TGTGTTCGTATATCCAGTACAGGAAGAGAAAGAGCGGTTTTACTATTATCTTTAAAGTTCCCCAGTCTAA +GGTATCTACCAAACCAAGTTCTCTGAGCCTTGCATAGTCCTTCGCACCAAGGTATATGGTCTTCTCTCCA +TCGTAAAGGAAAGTGGAAAGTGATACAAATTTATCTCCTAGTTTTACTTTGTAAACTATGTGTTTCTGGT +AATCCTTTGCCCCTTTAAAGAAGTACCTGCTTTCCTCTCCTCCAAACTCAATATTCCCTTCAAACTCATT +TATACCCTTTAGATCATCCACATCAAGCCTTACAACTTCCCCGTTTATTTTCAGAACAGGTCCTACGTGT +GTATAAAATGCCTCATCATCGGGAGGAGAACCTACAAACACCCAGAAGGGTGGTTTTAATCCTTCAACGC +TTAAATGAATTGCTCCGTTTTTATAGGAAAGTATTTTCTTTACTTTCAGCTCCTTGTGGATTAATTCGAC +TGAGTTTTTACCTTCTTTAATTTCGTATTCTCCAAAGTTTAATTTCTGATCAAGGTCTGGATTTCCCGTG +AATATCTCCAGAGGGAATATTTTTAACTCTCTTTCAGCTTTCGATATTAAATCAAAGCCGTACTTCTGAT +CTATAAATCTTAAAATTTTCCCGCCTTTTTCAGACAATTCCAAGGAATAAATTCCTAGTTTTACAGTTTT +AGTGTTTTTATACTCCTGTTTTTCTCTGAAAGTTCCGAGCATTAACTGGGGAAGGTTTACGTTTTTAAAC +TCTTCTTTTTTTACTACTTCTTTTTTTTCTGTTTTTTGAGGTTGAGAGGGTTTAACGTAATAAATGTAAA +ATAGCTCGTAAGCGGTTATGAATAAAAACATTAAGATTGTGAATATTAAAAACCTTTTCCAGAACTGGTT +GTCGTTGTCCATCATGGGTAATCAACTCCTCCCTTAAAGAAAGGGTTGCACCTCAAGACTCTGAAGAAAG +CCTTAATAAGTCCCTTCAGCACTCCGTACTTTTCCACAGCCATTATAGCGTATGTAGAACAAGTAGGGTA +ATACCTACAGGAAGAAGGGTAAAGAGGAGATATAAACTTCTGCCAGAATTTTAAGAAAATTAAAACTATA +CTTTTCATAACTTAAGGAGCGAGTCTCTTCCTGCCTTTTCTCCTCCTTCTGGCTATGATCTTCCTTCCAG +ACTTCGTTCTCATTCTTGCGAGAAATCCGCTCTTTCTCTTCTTCTTTTTTATAGATATATGCGGTTTTAA +TCCTTCGGTTACCATTCCAATATCCTCCTAAATAAAAATTTAAAGGAGAGAGAAGGGCTTAAACCACGAA +GAGCAGTATGAAAGCTATGAGCAATCCGTAAAGAGCGATAGTTTCTATAAACGCAAGTCCTATGAACATA +AGGGTTTGAAGTCTTCCGCCTGCGTTGGGATTCCTCGCAACACCTTCCTGAGTTCCCCTAACGGCATGAC +CCATACCAACTCCGGCACCGAGTCCTGCAAGCCCTATAGCAAGTCCTGCTCCAAGGTACAGAAGTCCCTT +AGCTACGGAAGCCTCTCCTTCCGCTGCCATTGCTATAGCAGGCATTATAGCGGTTAAGATAGCCATTAAC +CTCTTCATCACCTACCTCCTTAAAGCTTATTTAACTATAAGAGAAGCCAAGTTTAGTCCGTCTATTACCT +TACAAAGGTACGCGGAAGGGTAACAAGCCCATACCACGAGCTCGTACCCTTTCCCTTCCACAAACTTCTT +CACTTCTTCACTCAGCGGTCCTATCCTGTACTCAACACCGGGAATTTCCGTACTTCCAGTTAATTTTTCC +CAAACTTCTCTCAATCTTCTCTCTATACGCTTCTTACTCTCTTCCTTTATCTCAGGTGGAAAGGGAAGAC +CGAAAGTTACATTAGCCCTCTCTAAGTTGTAAACGTCTTCCAGTACAGCCAGAATGTCTAGCTCCGCACC +AAGTTTTTCGGAGAAGTTCACGGCGTAAGTAATCGCCTTTTCGCAATCGCTGTAAGCGTCTGTTAAAACT +AGCAGTACCTTCATATCAGTGCTCCTCGTGTGCTACAGCTCCGGCTATGTAAACCACCGAGAGTATCATA +AAGATGTAAGTCTGTATGAATATGGCGAGGAACTTTATAGCTATAACGAATATAAGCACAACCGGTGATA +CTACCAGCGTGAATGGATTCTTGATAACCAGGCTTACTAAAGTAAGAAGTAGGAGTGCTCCCGCTTTCAT +GTTTGCGAATAACCTGAGGGAGAGGGTGATTGGTCTTGCTATGTGAGATATAACTTCAACCACGAAGAAA +AAGGGAGCCATTAGAGGTATGGGTCCCATAAAGTGTTTCAAATAAGCAAGACCGTTTTCCCTGAAGCCTT +CAAAGTGGTAATAAAAGAACACTAAAAGTGCTAAAGCTAGGTTGGTGTTTATGTTTGCGGTAGGAGCTTC +AAAGCCGGGAACCATTCCTAGTATGTTCCCGAAGAAAACGAAGAGTCCTATGGCTGCTATCAAGGGTACG +TATTTAAGTCCTCTTTCGCCTACGTTTTCCAGGAGCATATTCCTGACGAATCTCAGGTATCCTTCCAGTA +GAGCTTGATACTTTGTAGGTTTAAGGGAAGGTTTTCCTCCTTTGAGGACGAAAATTATCGCAAGTGCCAC +CGCTAAGAGTGCGTAAACTACGTGCGAGTACTCCATTTCCCTTACCTCTTTTGCAATTGGCTCAGAAAAT +TATAACATAAATTTGATGCTGGCAAAGAGAATAATTCCCTGCCTTGACGTGGATAAAGGGAGAGTTGTGA +AAGGTGTGAAGTTCCTAAACCTCAGGGACGCGGGAGACCCAGTGGAAGTGGCAAAAAGGTACGAAGAAGA +AGGAGCGGATGAACTGGTATTCCTGGACATAACAGCCTCGGCGGAAGACAGGGAAATAATGATAGACGTA +GTAAAGAAGGTTGCCGAAACCGTCTTCATGCCCTTCACAGTGGGAGGAGGGATAAGGAGCTTGGAGGATA +TGAGGAGACTCTTAGAAGCGGGAGCGGACAAGATATCTATAAACACGGCAGCGGTGAAGAATCCGAATCT +TATTTACGAGGGGGCAAAGAGGTTCGGATCTCAGTGTATAGTGGTTGCTATAGACGCAAAAAGGAAGGGA +AATTCGTGGGAGGTTTACATACACGGTGGAAGAACACCTACGGGACTTGACGCTGTTGAGTGGGCTAAAA +AAGTTGAAAGTTTGGGAGCTGGAGAGATTCTCTTGACTTCCATGGACAGAGACGGGACAAAGGACGGGTA +CGATATAGAACTAAACAGAGCCATCTCGGAAGCGGTGAACATACCCGTTATAGCTTCTGGGGGTGCGGGC +AAGAAGGAACACTTTTACGAAGTTTTTTCAAAGACAAAGGTAGAGGCTGCCCTTGCCGCTTCAGTATTCC +ACTTCAGGGAAATAAGTATTCCGGAGCTGAAGGAGTATCTTCTGGAAAGAGGTATTAACGTGAGACCTCT +TGACTGACGCATTTTAAAGCTTCCTTTCCCAATACTTCTTCCAAAACAAACAGAGCTCTTTTTTTTGCAA +TTTCTGCATTTCTTTCTGGATTTTTAGAGTTTGCATCAGCAAAACCTATAAATTCAACTTTCTGTAACAA +GCCGGATTTTTCTAATTTTGATATCAAGTCCTTTAAGTACTCCAGATTCTTGTCCTCTGTCTTTACTTTT +GCGTATCCGAAGTAGATGCTATAAGTGATTTTTAAGGATTCTTTTATCTCAGAATTTTTCATTTTCTCGA +AGTAAGGGTTTCCTATATCTTGAGTTTCCAGTATAACCTTAATTTGTTTTTCTTTCTTAAAGGAAGTGAT +AGGAAACTTCACATAATCTTTTCCGATATCTACCGGATAAGCTATATAATTTTTTTTAACATTACCTTCA +AGTTCTTCTATATTTGCAACTTCGGGTAGGTCGCTTTTCACGGGAATTACAAGCAAGATGTCTTCGTTTA +AATCCACTTTTGGAGTTATTTCTATAACCGCAGACTTTCCTTTAGTTACACGAATATCCGCCTCTACGTT +TTTCATTTTTTCTCCTTTTACCTTTATATTCGTGTAAAGAATAACGTCAGTTCTCCTGAAGTACTTTCCC +GATTTGTCCGATACTTTGTACTTTAAAAAAACTTGAGTGGGACACACTGAGAAGGATAAAGAGGTTAATA +GAACCAGAAGAAAGATCAATGTTTTATACATACTCCCTCCTTACTTTTTCATTATAAATTCCTCCGATAG +TACCTTGAGTTTTCCATCTTCCTTTACTACGTACATACGCTTTATACCTTCGTCAGAATAAGTGTCAGAT +CTATACTTCTGGTAGAACTCAATTACATAGTACCTAGGTTCATCATCCCCCAACTTTGAAAAGGCTAAAA +TGGATAAGTTTGAAATATCTACTTTTATGAATTTTTTACTCAAAATAGTCCTCTTCTTGTAATCCTTCCA +TTCTTTTAATCCGCCACCTTTCCACCTAAAGTGCTTTGAGTAAAAGGAGATAAACCTATTTAAATCTTTT +TTCTCCCATGCATTCTTCCAGGAGAGTATGAATTCTTTAACGTTTTCCACCTCAAGACTTTGAGGAATTA +CTTTGTATATACCTATAAGTGTATTTGAGAGGTTTATCTTCGGCACGATTTCCGTCTTTAACACATCGGT +CTGAGCTACCACGCACCCTCTCGTACTGAAAGGAAGTTTATCTCTGTCTTTTTCGTTGCTACCGTGGAGC +CATATGCCGCTTCCCGTCTTTCCAAGGAGTTTGTCATAGGGATTTGGGTAGTTAAGGGCTACCGCTATAC +CACCGTATATTTCTGATAACTGCTCCGGTGGTATAAAGCGAGTAAAGTAATAAACCCCTTCGGGCGTTTT +CCCGTCTCCTTCCCTTTCTTTGTCTCCAATGTTCATACCCGTAGTTACGGGATACATCCCTTCGAGCTTT +TTACCCTTGAATACAAACAAATACTGACTCATCTTCTCAACGAGGAAGACGTAGTGATTTTCCGGATTTT +CTACTAAAACGGGCGGTGCTTCTTTAAACCTTTTTTCAAGGATTTTCCTAATTTTTTCCCTGTAGATTTC +CTTATTTTCTACTTTCCTTATAAGGAAGTTGAACCTGTAGTAAGATGGATTGTAGTAGGGATTTAGCTCT +ATTGACTTGAGGTAAGCTTGTATAGCTTCCTTTAATTTCCCTTCTTTTTCAAGCAAGAGACCTTCGGTAT +AGAGTTTTACGTAATCCTCTACCGTAATATTTAAATTTTCGAAGTAGGATTTCAGAACTTTTAACTCTAA +ATCGTTCGTTTTTCCCTCGTAAAACTTTTTGAATAATTCTCTTATCTTTCCCTTTTCGAGTTCCTCGTAA +GAGAAGAGAAAAGAAATACTTAATAAAAGTAGAAAAAGTATCATTCTTCTTTACTTCCACTTTCTTCCTT +TTTCTTTATTATCTTTACCTTCCCTTCCGCAATATCTTCTATTGCTGCGAAGGTTTTTTTGTGAACCTCT +CCCCCTTCCTGGACAAAAAAGTCCTCTCCTTCCCTGAGGAGCTGAAGCGTTCTCCTTACGGCTGCGTGCA +CGAGTTCATAGCGGGACTCAACCCTTTTCATAGCTTCCTCTATCTTAGGTCTCCTTGACATAACACTCAC +CTCCTTTGAGTAAATCTACGATATCCTTATCGAGCCTGAACTTCTCTATCTCATCCAGGACTCTCTCCTT +CTTCACTCTGTAAGAGAGAATTATAGATTTTACCTTTTCTACCGCTTCGTTCAAGTAGTCGTTTATAACT +ATGTAATCGAAAAACCTTGCACAGGGAACCTCTCCTTTAGCTGTTTCAAGCCTCTTGCTTACGTTGGAAT +CTACGTAACCTCTTCCTTCAATCCTCCTCTTAAGTTCTTCAAAGGAGGGAGGGAGGAGGAAAATGGTAAC +GGCTTCGGGGAAGAACTTCTTCACTTTAAAGGCACCCTGGACGTCTATGATAAGGAGCGCGTCCTTTTTC +TCTACGTTTATGGTTTCCTCTATGTCCTTCTTCGGCGTCCCATAGTAATTTCCGTAAACGTTCGCGTACT +CGAGGAAGAAGCCTTCCTTTATCTTCTTCTCAAATTCTTCTACGGAAACGAATACGTAGTCTACTCGTTT +TGTTCGTAGGGGCGGGGACTTCTCGTGGTGTAGGTAACTATCCTCTTGAGGTCGGAGACTTCGGAGAGCA +ATTTCTGTGCTACCGTCGTTTTTCCAGTTCCCGAGGGTGCGGAAAGCACGAATAAATTTCCCATTTTAAA +AAATGATACTACTTGCCACAGTAAAGCTCCAAAACCTTTTGCACTATCTTACTCGTTGATATGTCGTACT +CAAAGGGAATCGTAAGAACTTTACCGCCGTAGCTCTCCACAAACTCCCTTCCCACAATCTTGTCAAGGGG +CCAATCTCCACCCTTTACTAGTACGTCCGGTTTTATAGCCTTTATGAGTTTTTCCGGAGTGTCCTCTTCA +AAGATGACCACGTAGTCCACAGGTTTCAGGGAAGAAAGCACCTTAGCACGCATCTCCTGAGGGATTATCG +GTCTTCTTTCTCCCTTTATTCGCCTCACGGAAGAGTCTGAGTTCATACCGACCACGAGAATGTCCCCCAG +TTTTTTAGCCTTCTCTAAGTAATCCACGTGCCCGGCGTGGATTATGTCAAAACACCCGTTGGTGAAAACA +ACCTTTTTGCCTTTTCTCTCCCTTTCCAGAACTTTTAAGAGTTCTTCCAGAGGGAGTATCATGTGAGGTC +AAATATCACGGTCTTTATCTCTGTGTAGTCTTCTATTGCGAACTTTGGTCCTTCCCTACCTATTCCAGAG +TACTTTACTCCGCCGTAGGGCATGTGATCCGCCCTGAAAGTGGGTCCCTCATTTATGAGTACTCCTCCCG +CCTCTATCTCCTTTATGCACTTCCAGGCGAGCTTCACGTCGTTCGTGAATACTCCCACCTGAAGACCGTA +ATCGGAGGAGTTTACCCACCTTATGGCTTCTTCTATGTCCTTGTAGGGATTTACCGCAACCACGGGGGCG +AAGGCTTCTTCTTTGAAGAGTTTAGAGTCTTCAGGAACCAAGGAAACTATCGTGGGAGAGAATATTGTCT +CATCCTCTGCACACCTGAGCCCGCCCGCTTCAATTTTCGCTCCTTTTTGAACAGCTTCCGATATCCACTC +CTGTATCCTTTCCAGCTCCGAGGGTGCTATCATGGGGCCTAAATCCGTGTCCTCGTTCATAGGATCACCG +ACTTTTAGTTTACTTACTCTTTCTTTTAGTCTTTTAATGAATTCATCGTAGAGGTCCTCGTGGACGAAAA +CCCTCTGAACGGATATGCAAACCTGTCCCGCTATCGCGTAACCACCTTGAACCGTCTTCTCAACAGCCTT +TTCGAGGTTTCCGTCCTTGTGGAGGATTATCGCAGAGTTAGAGCCGAGTTCAAGAACGAGCTTCTTTATA +CCCACCTGCCTCGCTATAATATCTCCAACTTTCCTGCTTCCCGTAAAGGAGACCACCCTGACGTCCGGGT +GCGTAGTCATAGCTTTTCCCACGTCCCCGTACCCGGGTATTACGGAAAGTGCCTTTGGTGGAACTCCCGC +TTCCAGGAGTATCTCTCCAAGCATTAAGGGAGTTAAAGGTGTCCTTTCGGAAGGCTTAAGGATTACAGCG +TTTCCCGCAGCCAAGGCGGGTGCTACCTTGTGCATGGAAAGGTTCAGGGGAAAGTTAAAGGGCGTTATTG +CAGAAACTATACCCACCGGCACTCTTATGTAAAAACCTAATTTTCCCTTTCCGTTAGGATGGGCGTCTAT +TGGAAAGGTCTCCCCGTTTACTCTCTTTGCCTCTTCAGCGGAAAATATAAGAGTCTGTATAGCCCTTTGA +ACCTCTGTTCTCGCTTCCCTGATGGTTTTCCCGACTTCCAGAACCAAGGTTTTTGCAAACTCTTCGGCCC +TCTCCTTCAGGAGCTGGGCAGCCCTCATTAATATCTCGTAGCGCTCGTAAGCGGTGAGGGAAAAAATCTC +TTTGAAACCTTCCTTTGCTCTCTCTATCGCCTTTTCTACGTCCTTTTCGTCTCCCTTCGGAACCCTACCT +ATCGGTTTTCTCGTGTAGGGATAAATTACTTCTATCTTTTCCTCTTTGTCTACCCACTCTCCGCCTATTA +ACATCTTTTTCTCTATCATCTTTCCCACCTCACAGTATGTACCTGCTCAGTTCTTCATCTTTTACGAGGT +TTTCAAGTTTAGCCTTTACAAATTTTGCGTCTATTATTATAGTCTGCCCGGCCATTTCCGGAGCGTTGAA +GGATATGTCTTCCAGGAGTTTCTCCATTACGGTGTGGAGTCTACGAGCCCCTATGTTTTCAGTCTTCGTG +TTAATTTCCTCCGCAATCCTCGCTATCTCTTCTATTGCATCATCTGTAAACTCAAGGTAAACGTTTTCGG +TTTTGAGGAGTTCTATATACTGCTTCGTGAGTGCGTTTTCTGGTTCTACGAGTATCCTCTTGAAGTCTTC +CTTTGTGAGGGGTTTTAGTTCAACTCTTATGGGAAACCTTCCCTGGAGCTCCGGAATTAGGTCCGAAGGC +TTTGCCATGTGAAAAGCTCCAGCCCCTATGAAGAGTATGTGATCCGTCTTTACAGGTCCGTACTTTGTGT +TTACAGTGGTTCCTTCAAGTATTGGTAGGAGATCCCTCTGCACCCCTTCCCTTGAGACTCCGGGACCTGC +TCCGGGTGTCTTTACCGCTATCTTGTCTATCTCATCTATAAAGATTATCCCGAAGTTCTCCGCCCTGTAT +ATGGCTTCCCTTGCGACTTCCTCCATATCTATGAGCTTTTCCGCCTCTTCCTGCTCAAGTATCTGAAGGG +CTTCCTTCACCTTTACCTTTCTCCTCCTCTTTGAGGGAATAAGCCCTGAGAGCATCTCCTTTATCTGGTT +CTCAAGTTCTTCGAGTCCGGGAGGTCCGGCTATTCCCACCATGGGCACGGTCTTTTCCTTTACCTCAATC +TCAACTATCCTGTCGTCCAGTTCCCCCTTTCTGAGCTTTTGCCTGAGCTCCTCTCTCTTTCCGGCGTCCC +TGCTTTCCCTTATTCCGAAGCTCGTGAACTGGTGGGGTACGAGGTAATCGAGGAGTCTCTCTTCGGCGAG +TCTTCTGGCCCTTTCCCTTACCTCTTTCATCTTTTCCTGTTTGACCATCTGGAAGGAGACTTCCACGAGT +TCTCTTACCATGCTTTCAACATCTCTTCCCACATACCCTATTTCCGTGTACTTCGTTGCCTCTACTTTCA +CAAAGGGTGCCTTTATGAGGTTTGCAAGCCTCCTCGCTATTTCCGTTTTTCCCACACCCGTTGGACCTAT +CATCAGTATGTTTTTCGGGATAACCTCATTCCTCAGGTTTTCTGGGAGTTTTTGCCTCCTCCAGCGGTTT +CTGAGGGCTATGGCAACGGCCTTTTTCGCCTCCTCCTGACCTACTACGTACTTGTTTAGCTCCTCTACTA +CCCTCTTAGGTGTTAATTCTTCAAGGAGCTCAGAAAGGGATTTCGTCGTCATCTTTTGACCTCTCGGTGG +TTTCTAAAGAAACTTCTTTAACTATCCTGTCAAGGAACGCGTCAAGGTCCTCGGGGAACTTTTCGAACTT +GAGTTCTTCGGGGTAAACCCTTTCCACCACTTCGGGCGGCGGATTTCCGAAACCTATTGCTGGAACGATG +TTCTTCGCTCCCCTTCTGACCGCTTCTCCGATTGCTATCCTGTAAGCTTCCCTCAGGGCCGTTTCAATAT +CCTTGAACCTGTCCACTTCGTCTCCTAGTTCGTACAGGGTTATGTCGTAGGCTTCTTCCTTGAACTTTTC +CCAGTCTCTGATACCTCTGATGTAGTACTTTCCCTGACTTCCTGTGAGTTCAACGCTAGAGAGGTCGTCG +AGCTTAAATGTAACGATGTAGTAATCTACAAGTTCCCTGTCCGCGTAAACGTCTATAAAGAAGAAAAACT +CCATCTTATTAATAATATTTCTACAAGCTTACTTTTTAAAGGCTATTATAAAAGTGTATGGAACTGGTAA +GGGAACTGCTAAGGAAAATAGCTGAATTTGAAAACCTAACTGCGGAAGAAATGTACAACTTGATGAAAGA +AGTGGCGGAGGGAAGGGCAACGGACGCCCAGATCGGAGCACTCGTAATGGGAACAAAGATGAAGGGGGAA +ACTCCTGAGGAAATAGAGGGTGCAGTAAAGCTCTTCAGGGAAAAAGTCGTAAGGGTTCCCGTAAAAGATC +CTGAAGAGCTCGTGGACGTAGTAGGAACGGGAGGAGATAAAAGTTCTACTTTTAACGTTTCCACTGTTAC +TGGGTTTGTTCTCGCTGGTGCAGGAGTAAAAGTGGCAAAACATGGGAACCGCTCCGTCTCTTCAAAAAGC +GGTAGTGCGGATTTTCTGGAAGCCCTCGGAGCAAAAGTAGAACTTCTCCCTGAAAAGGTGGCGAGACTTA +TTGAAGAAGTGGGATTCGGATTTATGTTCGCTCCGCTCTTCCACCCCGCCATGAAAAGGGTCGTTTCTCC +GAGAAGGGAGGTGGGAGTCCGATCCATTTTTAATTTGATAGGACCACTTACAAACCCCGCGGGTGTAAAG +AGGTATCTCCTCGGTGTTTTTTCAAAGGAATACGTTGATAAATTCGCAAAAGCCCTTAAAAACCTCGGCG +TTAAAAAGGCATTCGTCGTGCACGGGGAAGGTGGTATTGACGAGGTGAGCGTAGAAGGGGAAACCTACGT +TACGGAAGTTTCAGAAGAAGGGATAAGGAGTTTTACCTTTTCTCCTGAAGAACTCGGTGTAAAGAGAAAG +TCTCTGAGTGAAGTTAGGGTAAACTCCCCGGAAGAGAGCGTAAAAGTTGCACTTTCAGTTTTGAGAGGAG +AAGAGGGAACGCCGAGGGATATGGTTCTCCTGAACGCAAGCTTCGGAATTCTCGTATCTGAAAGGGCAGG +GGATATAAAGGAAGCCTTTGAAATGGCTAAGGAGTCCATAGACAGCGGAAAGGCTCTGGAGGTATTGGAG +AAGTATGTGGAACTCTCAAATAAAATCTGATGAAGGAAGCCCTTATCCTTTTCTTTCTTATAGTTTCCTA +TAACTACCTCCTTTACTACATAACCGCCAAAGATTTAGCACTAATTCCCCTCTTTCCCGAAAACCCGGAA +GAGATCATACTCGTCATAGCCTTCAACTCGGCCCTTTATATAGGCTGGTTCTTCGGGGAGAGGAGAAAAC +TCGTAACAATTCTGGGTTATTTATTTTTCTTTCAGACAGTTCTACTCTCTTTAGTGAAGAAAGATCCCTA +CACCTTCGTTTCTACCGCTTTTCCCGTGATCTTTACGCTTATGCTAGTTGCTCTATTCAAGAGCCCCTTT +GAAAGGGAACTCGAAAGGATACAGAAAGAGAAAGAAGCACTGCTGGAAGAGCTGGAGAAAAACGAAGAGG +TAAGACAAAAAGTAGAGGAAGAAAGAGAACGTCTAAAGAAGGAAATATCCCTCATAAAACTCCAGATAGA +ACAAAAAGAAAGAGAACTTGAAAGAGCTAAAGAGGCACAGGAGAAACTGGAAGAGGTTGAGAAAAAAGAA +AAAGAAGTTAATAAACTCAAAGAAAAACTAAGGGAACTCGAGAAAAACTTAAAAAAACAAAAGGAAAAGG +AAGAGAAACTCCTAGAATCCAACAGGAAACTATTTCAGTTGCTTGAACTGCTCGGAAGGAAGGAAGATAA +GAGGAGGGGAAGCAAAGAGGTAAGGGAGCTGAGAAAAGAGAGGAAGAAACTGGTCAAGGAAGTTTTAGAG +CTACAGGATCTTCTGGAGATATACTCAAGGGAAAATGAGGAGTTAAAAAAGGAGCTTGAAAAGTTAAAGA +GTGAACTAGAAGGGGCCAAAAAGGAAATCGCTAAACTCTTAACCGAAAAAGAGAATTTATCAAAAGCGGT +AAAGAAGAAGGAAGAGATTTACGAGGAAGTCTTAAGAGTTTTCCTTCCGAACGTGAAGTTTACACCGGAA +GCCCTTCAAGAATTCATGAGTTTATCCACTCAGGAGAAGAGGAGGTTTTTGAGGGAATTGGAAAAACTGG +AGGAAGGAACGAAGCTCGAGAGTTTAACAAACGTTCACGGAGTTTACAAGCTCAAGTTCGGAGGTGGAAG +GATTTACGTAAGGAAGGAAGGGGACAGGTGGGTAGTTATCGGTATACTGGATACGGAGCAGGACAAGGAA +AAAGAGCGCTACATAGAGTCTTTGAGGGATAGATTGTATTAATAGGAGTCTGGTAAAATTGATAAAGGAC +TTAGCAAAAACTTTGATAAAAACAAAGGAGGAAAGACATGGCAGAATTAAGGGAAACTCTCGAAAGACTC +GCATCCTTCAGACCTCAAAATTACTACGTTTCCACCCTTTATTTGAGATTAATGCCCGAAGACAGGCAGG +ACAACAAGTACCTGAGGGTTTACAAGGACCTAGTGAAAAAGAAGGAAAAGGATTTAGAAAACCTGAACCT +GGATAAAGAGGTTCTTGATTCTATAAGGGGGGACATTAAGAACATTCAGGACTTTTTATCCGATCCTAAA +AACCTTTACAACTGCAGGGGGATAGCGATATTTTCCTGCTCAAAGCTCGGACTGTTTGAGTACGTGAAAC +TTCCCTACGTTTACAGAAACAGGCTTATGTTCTCACCTGACCCTCTCGTGAGGGAAATAGCGGCGATAGA +CGAGGAGTTCGGAAGGGTTGCAGTTCTGCTTCTTGACAGAAAACACATAAGGTACTTCCTCATGGACATA +ACGGGAATAGAAGAAAAGCTGGACTTCTTAGAGCCCATGACCACGAGAGCCCACAGGTTCCACAGCGGAG +GAGCGCTTCTCAAAGGTGCGGAGGGAACGTTCCAGTACAGAATGCCCGCGAGGGGTGCAGCGCCAAACGT +AGTTCAGCACGGAATGGGTGAGTGGCGTTTCCACATGAGATTAAGGGAAGAGTGGCACAGGATACTCAAA +CTCGCATCGGACGCCCTCTTTGAAGAGTGGAAGAGAATACACTTTGACAAGTTAATAATCGGGGGATTTA +TAGAAGAAGGTCTGAGGGAAATAGAAAACTTCCTGCACCCATACGTTAAAGAAAAACTGGTGGGTTACAT +AGAGATAACGCCCGAAGAGGCAACTCCCCATCAAGTTTGGGAAAAAGCCCTTGACCTCCTTTGGCAAAAG +GACAGGGAGCAGGAAAAGGAAATAATTAAGGAGCTTGAAGAATTAAAGGGCTGGGGACTCGCGGTTAACG +GAACTTCGGAAGTTCTTGAAATGCTAGCCATAGGAAACGTAAGAACGCTAATTCTTCCAGAGGACTTTGA +AAAACCCGGATACCTCTGTCCGCAGAGTCACCTCGCATTCTTAAAGCCCGAGTGCCCCCTTCCCGAAGAA +AAGCCCATTCCCGTAAGCGACGTGGTTGACGAGGCATTAGAAGAGGCCCTGGATCAAAGGGCAACGATAG +AGGTTATAATAGATAAGGAACTCCAGAAGAAGGTGGACGGACTTGCGGCGTTCTTAAGGTTTAAGCTATG +AACGAGAGGTTAATGATATTCATCGACGGTTCTAATCTGTTTCACGGAATACGGTACTTGAACATAAAGG +TGGATTATTCAAAACTCGTGGAGTTCTTGAGGGAGGGGCGCTACCTCGTTCGCGCTTACTTTTACACCGC +CGTTCCTCAGGAAAAGGACATCAAGAAGGGAACGCCCGAGTGGGACAGTCTTCAGAGACAAAAGAGGTTC +CTTGACGAACTTTCCTTTATGGGCATAAAAGTGAAGACAGCTCACTTGAGGAAACTCCCGAGCGGTGAGT +ACCTGGAAAAGGAAGTTGACATAATGCTTGCCACGGATATGCTCTCCCTTGCTTACAGAAACGCTTACGA +TACGGCTGTTCTCGTTAGCGGGGATAGCGACTTTATACACACCGTGGAAGCGGTGCAGAGTCTGGGAAAG +AGGGTGGAAAACGCAACATTCAAGAAAACGAGTTCCTACAACCTGAGAAAGGTGTGCGACAGGTTCATAC +TTCTGGACGACCATCTTGACAAGATACTCATGGAGGAGAAGGGTAAAGAAATAGTTCCCGTGGAAGAGGA +GGAAAAAGGAACGGAAGAAAGGGAAGGCTTTTTGGAAAGGTTTAAAAAATTCTTCGGGCTATGAAACTGC +TGGTTGCCACCACAAACGAAGGAAAGTACAGGGAGATAAAAGAAATTCTTTCCGAGTATGGTATTGAAGT +ATTAAAACCCGAGGAAAAACTGGAAGTAGAGGAAACGGGTTGTACATTTTTAGAAAACGCATACCTGAAG +GCTAGAGCTTACTACGAAAGGTACAAAATCCCTGCGCTTGCGGACGACTCCGGTCTTATCGTTGAAGCCA +TAAGCCCATATCCGGGTGTGTATTCCAGCAGGTTTTACGACATAGACTTCGGCGGCAGGGAAGAAGTAAG +AACGAACAAGGACGAAGCAAACATAAGAAAACTTTTAAGGCTTTTGGAAAACACAGAAAACAGGAAGGCA +AAATTTGTAGCTTTTATAGTCGTATACGGGGGAAGTTGGGGAATTTTTGCAGAAGGAGAAGTCAGGGGAG +AGATAACGAAAGAGCCGAGGGGAGACAGAGGTTTTGGCTACGACCCCGTTTTCGTTCCGGAAGGTTATAA +CAAAACCATGGCTGAACTTTCTCCGGAAGAAAAGAACAAAATATCCCACAGGGGGAGAGCTTTAAGAAAG +CTCGTACATGTACTGAAAAATTGTGAAAAAGCTTTCTGAAAAGTTAAGAGCTTACGAAGTTCTAAGGGAA +GTCTTCAACGTAATTGCGGTTATCTCCCTGAACAGGTTTAAAAAAACGAGACACATAGTCTCTCAAGAGT +ATCCCTACTTTGAAAGGTTAAAGGAGGTTCTTGAGCATCTCTTTGCCCTTCATCCGACTCATCCGCTATT +CAAACCAAGAGAGGAAAAAAGAGTTTCGGTAGTAGTGTTTACCTCAGACCTTTCCTTTACGAGAGAGCTC +TGCAACAAGATTTTTAAAAGTGTCCCCGAATTTCGGGAGACGGAGTTTATAATCTTCGGAGGAAAGTGCA +GGAAGAAAGATTTATTTGAGAGACTTAAACCGAAGGTTATCTCAAACACTTTTACTAAGCTTGTAGACTA +CTCAAAGATTTTAAAAACTTTTGAAGAACTCTTTGAAAGGTTTGCATCAAAGGAACTGGATGCGGTCTAC +GTCGTAAGCGCACTTCCGTTTTTGGAAAGGGCTGAAGGAAAGGGAAAAAGGGAAACGGGAAAATCTATAA +AGGAAGAGGAAGTAAAGAGGGAAATACTGTACACAAGGGGAGCGAGGTACGTAAGGGCGGTAGAACTTGG +AGAGAGCGGGAGAATAGAGGTTTACGTTGAGAGGTTCTTACCTCCGAAGATAAAAGGGGTTTACAGGAAG +GACTTAATCCTAAACTTTGAAGGAAATGAAGAGGAAATAATAAGAACCGTTCTCAAACTGTACACGGAGT +TTCACGCAAAGTTCTTGAGTTTAGCACACTGGAATGCCTTGAACCTTCAGCGTTTCAGAACGGCAAAGAG +AATTCAGGACAATTTGGAAAGGAAGATAAAGAATTTAAAGAGGCTCATAAGTAAGGAAAGGCAAGAAAAG +ATTAACAGAGAACTACAGGACATAGCCCTTTCACTTCTGGCTTTAGAAGAGAAGAAGTTTAAAGACATTG +AACACAAAGATTATGTCCTCGAGATAGATAAAAATCTTGAAGAAAGTCTAAAGAAAAAGGTAATAGAAAT +ACTGAAAGAACACTTTCCCATTTTAGAAGTTAAGGAGGTGGAAGGATTGCTCGGTTTTTACTTGAGGGGA +GAGGGCAAGGTATACAACGCCAGTACCCTGAAACAACTGGAACTCTTTGTAAGAGAAATTATCTTAAGGG +TGGACCGATCTTGACGAGACCCGTTTCCGTAATTTCCATAAAGTGGGTTTTTGTGTCGTGCCCGCAGAGT +CTGCATCCGTCAATCCTGAAGAGTCGAACTATATCGCCTATCTCCTTTTTGTATATCTGTGCCTGATACT +TAGTCATTATTAATTCCTTTGCAAGAACCATCGTACAGTCAACTATGTGGCTTATGGCAAAACCGCCTGC +GGCTTCCGCGGAAAGTTCTTCGTGGGAACTCCTCTTTTGGGAAACAAAGAGAGCGGTCTGATACCACTTC +TTCATGAAGTTAAAGAGTTGTCTCACTATAGTCCTTGCGAGCATTTCCTTGGCTTCGTACAACCCTGTTA +CAGAGTCTATTATGGTGTGCTTCACCTTGTAAGTTTTTATTACGTGTGCTAGAGTGGCGAGCAGGTTCGG +GATGTTTTCCCTGAGCGTTGCGTGACTTGCGGCGTCTATGAGTATTATCTTATCCTTTATCTTGTCAAAG +TCTACGCCCATTGCGGTTGCCCTTTCTCTTAGTCCCATGGTAACGAAGGGTGCAGGGCTTTCAACGGTTA +TAAAGGCAACAGGTTCTCCCCTTTCCGCCTGCTTTACTGTGTACTGTTCCACCATCAAGGACTTTCCCGT +ATCTGAAACGCCGGTTATGTTCGTAACGGAATACCTTGGTATACCGCCTAAAGGTACTTTTACAACTTTC +CCTTCCCTGATTTCAGACTTGAAGAAGAGTTCATCCAGTCCCTCTACTCCCGTGGGAACACCTTCGAGTT +TAGGAGCTTTCTTGAGGGCCTCTTCCGCTACCCATATACCCTCTTCTACGACTCTGGGTTTTTCTTGATG +TTCTTCCTCGTAGTGTTTTTTGTAGTCCATAGGTTACCTCCCGTATACGTATAACTTTCATTTTACAACC +TCTGTAAGGACTTACAAAACATAACTACCCGGAACTTTTTGGCACGTTTTTTGCAAGAGTTTCCTCAGGA +GGAGTGAAAGATGAAAGTAGTTATCGTTGGAAACGGAATAGCCGGAACGGCTCTTGTAGAGGAAATACTA +CGATTAAGCAGTGGAAAAGATATAAGAATTCAAGTCTTTGGAGATGAAAAGTTTATAGGTTACAACAGGG +TTCTCATAACAGAAGTTCTGGCTGGCAGGAAAACACTCAGTGAGATATACATAAAGCGCTGGCAGTGGTA +CGAGGAAAAGGGAGTAAGGCTGGAAATCGGTAAGAAGGTGGAAAGACTATTTCCCAATAAGAAGATACTC +GTAACGAAAGACGGGGAATTTTACAGGTACGATAAAGCTATAATAGCAACGGGAAGTAAGCCCTTTATAC +CTCCTTCTATTAAAGGCGTAAATAAAAAAGGTGTATTCACTTACAGGACAGCAAAGGACGTTTTTGAAAT +TCTGGATTACGCCAGGGTTTCAAAAAGGGCGGTGGTAATCGGGGGAGGACTCCTCGGTATAGAAGTGACT +AAAGCCCTAAGGGACATAGGTCTCGAAGTTTTTCTGGTTCATATCCTTGACACCCTAATGGAACAGCAAC +TTGATAAAACGGCTTCTGAGCTCCTAAGAAAGGATTTAGAAGATATGGGAATAAAAGTATTGCTCAAAAA +AGTTACGGAAGAAATCTTAGGGGAGAAGAAAGCCGAGGGAGTACGTTTTTCAGATGGTGATGAACTCCTT +GCTGATTTTGTAATCATCGCTACGGGAATAAGACCGAACGTTGAAGTCGGTGTAAATTCAGGTCTAAAAG +TAAACAAGGGCATAGTGGTTAACGACTACTTGGAGACCTCTGCGAGTGATATCTACGCCGTTGGAGAGTG +TATAGAACACAGAGGAAAAACTTATGGTCTGGTAGCCCCAATAATGGAGCAAGTCAAGGTATGCGCTCAC +AACGTTGTTCACGGAAATGAAAAGAAGTACACGGGATCACTTACCTACGCTATGTTAAAGGTTGCGGGTG +TAAATCTGTTTTCTGCGGGGGAAATTAACGAAAAAGACGGAGACGAGGTTGTAGCTTTTCTAGATAACGG +AAGGTCACTGTATAGGAAAGCGGTAATCAGAAATAACAAAATTGTAGGAACAATTTTGTATGGAGATGTA +AGGGGAAACAATTACCTCCTCGACCTAATAAAAAGCGGTAAAGATATATCGGAAGAAAGACCGTATTTTC +TTATAAAACACATCCTTCCCAAGGGCACAACCGGGGTTGAAGAACTTAAGGATAATGACATAGTTTGCAA +CTGCAACGCAGTAACGAAAGGCGAGATAGTCAAGTGCATTAAAGAAGGGTGTAAAACTTTAGAGGAAATT +CAGGAAAGAACAAAAGCTTCTACTTCATGCGGTAGTTGTATAGAACTCGTTGAAGAAATACTGAAACACT +ACGTAAAAGAAAAACCAAAGCGTGTTAATAAAATTGAGGTTATAAAAAAGGAGCTTCATCCCTTTGACTT +AGAGTTTAAAAAACGTTTAGAGAAGTACTTTTCCGAAGGAGAGCTTGAAAACATTCCAGAAGAGGACAGG +GACGTAAGACTAAAGTGGTATGGCATCTTTTACAGAAAAGCTACTCCAGGATACTTCATGGTCAGAATTA +GGGTTCCTAACGGAAGGCTTTCCTACGAGCAGGCTAAGGTAGTTTCCCACATTTCGGAGAAGTTCTGCAG +GGGAGAAGTGGAAATAACTTCCCGTCAGCAACTTCAGATTAGGTGGATAAAGTTAAAAGATTTACCTGAA +ATCCTTGAAGCGTTAAACAGGGTAGGCCTTTCAACACTCCAGACGGGTATGGATAACGTGAGGAATGTAA +CAGGTGACCCTCTTACAGGTCTCGCAGAAGATTCTCTTATAGATACCCTGAGATTGTCTCAAGAGATAAC +AAATATCTTTTTAGGTAAAAAGAAGTACGCAGACCTTCCAAGAAAACTAAACGTAGCGGTTCTGGGTTCA +CAAACGGACTGTATAAACGCCCTGTTTAACGACGTTTGTTTTTACCTTTCGGAGAAGGATGGAAAGCTCG +GTTTTAACCTTTATCTGGGCGGAAAGATAGGTTCAGGTGGCCCTAAAAAAGCGATAGATATGGACATGTT +CGTAGAACCTTACGAAGTACCCGAGGTGTTCAAGGCAACACTTGATATTTATTCAACTTTTGGAAACAGG +GAAAACAGAAGTAAAAACAGACTGTATTTCCTTCTTCAAGAGTGGGGAGTTGAAAGGTTCAGAGAAGAAC +TGGAAAAGAGACTGTACAAAGCTATACCCTCAAAAGGGAAAGATTTGGTAAACAAAACGGGGGAAAGGGA +GGGGATTATAAACCTCAGGAATGGAACTTACGCAGTCTGTGTTGTAGTTCCGGCAGGAAAGATAAAGGCT +AAGGACTTTAGACAGATTGCAGAGCTTGCAAGGAAATACGGAAGCAGAGAGCTCAGGTTAAGTGTGTATC +AAAATATATACATCCCGAACATCCCGGAAGAGAACCTGAACCCACTTCTCGGAGAAGAAATCTTTGAAAA +GTTCAGCACGGTTAGCTCTCCTTTTACAATGCATCTTATAGCCTGTGCGGGAAGTGATACCTGTTCCTTT +GGTGTCATACCTAACAAGAGTGACGCTGTGAGGGTGGCCAAATACTTAAGCGAAAGACTCAAACTTGACA +TTCCTGTCAGGATGCACTGGTCCGCCTGTGCCAAAGGTTGCGGTCAACACGGGAGCGGAGATATAGGATT +TGTAGGGACTAAAACCAAGCTAAATGGAAAAGCTGTGCTGGCTGTAGACGTATTCGTCGGAGGTTCACCC +ACAAAGGAAGGTTTCAAAGTAATTCAAGGGCTTCCTTTAGATAAAGTGGAGGAAGCTTCTTACCTACTGC +TTAACTACTACCTTGAAAACAGACTAGAGGGGGAGAGCTTTGCGGATTTCGCCCACAGGGTAGGAGTGGA +TAAACTCAAGGTGGTTCTTACAAGTCTTTTACAGGAAGGGGAATGTAAGCTACTGAAACCCGAGAGTATA +AGCAAGTAAAGGAGGAAGTGGAGTATGGGAAAGGTTTACCTCATAGGAGCCGGTCCTGGAGACCCTGAGC +TTCTGACACTTAAAGCTTATCGTATTCTCAGGAAAGCTGACGTAGTTCTATACGATGCCTTGGTAAACAG +GGAAATACTTCACTTTGCCAGACAAGACAGCCTTAAGATATACGTGGGCAAGAGAGACGGAAAACACTCC +TTGCCTCAGGAGGAGATAAATGAACTTCTTCACAGGTTTGCACTTAGCTACAAAATTGTAGTTAGACTTA +AAGGCGGTGACCCTTTTGTGTTCGGAAGGGGCGGAGAAGAACTCCTTTACCTAAAAAGCAGGGGTGTGGA +AGTGGAAATAGTACCGGGTATAACTTCGGCGATTTCTGCACCCTCCTCCGCTTTCATTCCCGTAACACAT +AGGGGAATAGCCTCGTCGTTTGCGGTTGTTACAGGCCACCCCAACAGAGAAATAAAATGGGAGGATTTAG +TGAATATAGATACACTCGTTGTTCTTATGGGTGTTAAGAACAGAGAAAAGATAGCGAGAGAACTTATAGG +AGCAGGACGAAACCCGGACGAACCCGTTGCCTTTATAGAGAAGGCTACAACTCCGGAGCAGAGGGAAGTT +TTCAGCACATTGAAAGAAGTTGCTCAAAACCCGCCGGAGGTAAACCCGCCCGCTGTAATGGTTGTAGGAA +AGGTCGTAGAAATAGGAGCAAAAGTCCTATGTGAACGTATAATCGGCGTTACACTTTAAAGGAATGGACA +TTTTAGAAAGAACTTTCAAAAAATTAACGAGACTTAAGGATAACCTTCAGGACCTTTCTCAGGAAGAAGC +CTATGAAGTATTTAGGGCTATACTTGAAGGTAAACTCTCAGATATAAAGACAACTGCCTTCCTGACAGCC +ATGAGGATAAAGGGGGAAACTTCTGAGGAACTCCTCGGTGTAATTAAGGCAATTAAAGAGAGAATGAATT +TTCCGCAGAAGAAAGAGGACGCCTTAGACCTCGGTCTGAACTATGACGGGAAGAACAGGACCATTTATAT +CCTTCCCTCTGCCCTGTGGCTCTGTTCAAGACTCGGTGTAGAGTTCACAAACCACTACGCTCTTGGAGCT +CCAACGAAAGAAGGTGTTACCCTCTACGAAGTAGTTAAGGAACTTGGTGTAGATATGAACGTATCCTTTG +TAGACCAAAAGAATTACGCACCGGAGCTATACAAACTCATGCCTCTGAGAAGAGAACTCGGTTTCAGGAG +CTTGATAAACACGGTAGAAAAGTTTCTAAATCCCTTTCAGACTAAAAAGATTGTCGTTTCTATCTTTCAC +AAGCCGTACTTTGATAAGAACGCAGAGCTTCTTGAGCTCCTCGGGATTGAAGACTACACAATTATCAAGG +GGCTTGAGGGCGGGATTGAGCCTCTCCCTGATAGACCCACGCTCGTAAAGAAGAGAGGGAAGGACATAGA +AAGTATAGAACCTAAATCCCTCGGTCTTGAAATGCCCAAGGATGTTCATTCTGAAAACGTCCTGAGGGAT +TCGCTTGAGATAAACAGAAAGATAATTGATGGTAGAGAGAGGGGAGAGTTCTTCAACTGGGCGCTTTACA +CGGCGGGGGTATTGCTCTACGCGGCAGGGGAGTGCGAAAGTGTGGAAGAGGGGGTAGGAAGGGTAGAGAA +AGAATCCACCTGAAACAAAAATGTAGCTACAAAATTGTACGCAAAGCGTCTCCACAATCAGAGAAAAGTT +TCCAAGAACTGTTAAAACAGAACGGGGAGAATTTGGCACGCTTTTTGCAATTAGTTTGAGTGAAGGAGGT +GAAAAGATGTTGTCCGAGGAGACTATCAGGGTCATTAAGTCAACTGTCCCTCTTCTGAAAGAGCATGGTA +CGGAGATAACTGCTAGGATGTACGAATTGCTGTTTTCAAAGTATCCTAAAACTAAGGAGTTATTTGCAGG +GGCTTCGGAGGAACAACCAAAGAAGCTTGCAAACGCCATAATAGCCTACGCTACCTACATTGATAGGCTA +GAGGAGCTTGATAACGCTATCTCAACGATAGCCAGGAGTCATGTGCGAAGAAATGTAAAGCCGGAACATT +ATCCGCTGGTTAAAGAATGTCTCTTACAGGCAATTGAAGAGGTTTTAAATCCTGGGGAGGAAGTTCTCAA +AGCATGGGAAGAGGCGTACGATTTTCTTGCTAAAACGCTTATAACCCTAGAGAAAAAACTTTATAGCCAG +CCTTAGGGAGGTCTAATTATGAGGAGCGATATAGGAAGGCTCTCTAAGTACTTAATTGAAAGGAAAAAGA +ATCTTGGTCTTACGTGGGAAGATGTAAGCAGAAAGCTTGGGAAAAGCCCCGTTTATTGTGCAATGCTCTT +CTATGGATACGCTCAGGCCGACGATGAAGAGGTTAAAGCTGTAGCTGAGCTTTTGAATCTGGAAGAGAAG +GAGCTCGCGGAGCTGAAAGATGCCCCATACAGAGAACCTCAGCAACCCGTCCCGCCTACGGATCCCTTCG +TTTACAGGCTCTATGAAGTTGTTATTCTCTACGGACCGGCTTTAAAAGATGTAGCCCACGAAATGTTCGG +GGACGGGATAATGAGTGCTATAGATATGAGCGTTGAGCTTGAAAAAGTTGAGCAGGAGGGGGCTGAGCGT +ATGGTTTTAACCTTTAATGGCAAATGGCTGAAGTACAGGAAGTTTTAAAGGGAGGATTTAGAAATGGAAG +AGCTCTTGGCAATTGTCAGGAAGGAAAAGTCTTACGATGTGATGAAATCCTTATCTGAGGCTGAGATACC +TTACGTTTCCTGGACTGTGAAGGGGAGGGGGAAGGAGGGGGGACTCAGATATAAAGGTCTTATTAAAGAA +AAGGTCCTCATGCCTTTCCTGCCAAAAAGGGCTTTCTTGGTCTTTCCCGAGGAGGGCAAAGTAAATGAGG +CTGTGAACCTTATCGTTGAAAGTGCTCACACGGGTGCTTACGGAGATGGGAAGGTCTTTTTGATAAACCA +GGAGGTAGGCGTTATGAAACTTGTAAAGGCTGTTATAAGACCTGAGAAAGTCTACGAAGTAATTAAGGCT +CTCGAGAGCGAAGGATTTAAAGCTATGACCATGTGGGATGTGGTAGGAAGAGGAAAGGAGGGGGGGATCT +TGGTGGGAGGGACTCCTTACGACGAGCTCGCTAAGACGCTCATCATGGTCGCGGTAAAGGATGAGGACGT +TGACAAGGTTATACAGAGCATAACGAAAGCTGCGCACACGGGTGCTTACGGAGATGGGAAGGTGTTCGTT +TGCAGCATTTCAAAAGTTTGGACCATAAGGACTAAGGAGGAGGAGCTATGAATTTCCTGAAGGAGATAAT +TGAAGCAATTAAGAAGGGAAATCCAAAAGCTCTGTTTGCCAGTTTTATATACTTTGACCATTCATTCAGT +ATATGGCTACTCTTAGGAGCTCTTGGACCTTTTATAGCTGAGTCCTTCGGACTCTCAGGAGCCCAAAAAG +GTTTTATGGTTGCAATTCCCGTAATAGCCGCAGCCATATTCAGACTCAACTTCGGACATATGTTCCAGTA +TATAGACGGGAAGTACATAGCGATAATGGGCATAATCCTTTCCTCTATCCCTCACCTTTACATGATACTC +AGCGGATATCGTGTAACCTACGATGACCTTCTCTGGATGGGGGTTTTTCTCGGTATCGCAGGAGCAAGCT +TTGCGATAGCCCTCCCTATGGCGGGAAGTAACTACCCGAAAGAGGTTCAAGGACTCGTACTTGGACTTGC +CGCGGCGGGAAACATAGGAGCTGTTTTAGACGGTATACTCTTTCCTCCTATTGCAAGGTCCATCGGTTGG +GAAAATACCTTCGTTCTTTCGGGAATACTCCTTCTTATAGCCCTGTTTTTTGTCGTTATCTGGGCGCGGG +ACCTTACCAAGAAGAACGAAGGGAATAGGTTTTATCCCGTATTTGCATTCTTTGCCACTATAGCTTTTAT +GGTAATACTGGCTCTCGGTTTTCAAAAGGGATGGTTCGGTATAACCGGAAACGCTGGAAAACTCCTCATA +CCGGTACTTGGTTCTGTATTTGCTATACTCCTTATGCCTCTTGCCTTTAAAAAGGTGTTCCTGGAAAGGG +ACACGTGGGTACTTATGCTCGCTTACTCCATAACTTTCGGCGGTTTTGTAGGAATGTCCTCGTACGTGGC +TATGCTCCTTAGGGACATATACGGTATATCCAAAGTGGAGGCAGGAGCTCTTATGTCCCTTTTTGCCTTT +ACGGGTGCGATGATAAGACCTCTGGGGGGACATATCGCGGATAAAATAAGCGGAGCTACAGCACTTCTCT +TTTTCCTCGCGGGCATAGCGGGAGTTAACTTCATATTTTCCCTCGTAACACCGCCTCTGGCGGTAGGTAT +AGTTTTATTCCTTGCACTCTACTCCTTCTATGGACTTGGAAACGGTGCTGTATTTCAGCTCGTTCCTCAC +AGGTGGCCATATCAAACTGGACTTATGACGGGAATAATCGGAGCTGCCGGAGGTATCGGTGGTTTTTACC +TGCCCGTTGTAAACGGAATAGTCTTTGAGTCCACGGGAGCTTACAACCTGGCGTTTGCACTCTTCGGAGG +AATAGCCCTGCTGTGTCTCCTTATAGTTAAGCTTCTTCATGCTCGCTGGATGGAATGGGCCTACGTTCGC +TACGACTACGAAAAAGAAACGTTGGTTGGTATTGATCCTAAGAGTGGAAGGGTAATTATGGAGTTGGCAA +GATGAAGAGGTTTCAATGTCCTTACTGCGGTGTAGGATGCGGTCTTTACATAAACGAGAAGGGTAAGGTG +AAAGGGGATTTTGAACATCCCGCTAATCTCGGGGACATCTGTAAGAAGCCCTTGTATTTACCGAAGGTAC +TGAATAGGGGAAGGATAGCGAAGCCCATGTACAGGGAAAATAAGAGTCACAGCTTCAGGGAAATAAGTTG +GGAGGAAGCTTACGAGATACTAAAAGAGAAGCTCATCTCCTTTTCTCCCGACGAAACTTACTTTTATCTT +TCGGGACAACTTTTAACGGAGGATATATACGTAGCAAACAAGTTCGTTAAAGGTTTTCTCAGAACCAATA +ACGTTGACGCAAACTCAAGACTTTGTATGGCTTCTGCAGTTACCGCTTACAAACTCGCTTTTGGTTCCGA +CGGTGTTCCCTGTACGTACGAGGACGTGGACGATGCGGATGCCTTCCTTTTTATAGGTTCTAACGCTGCC +GTAGCTCATCCTGTTCTTTTTAAAAGGGTTCTGAAGAGGAGGAAGGAAGAAGAAAAAGTAATTATAGTAA +CCGTAGATCCGCTGGAAACGGAAACCGCCAAAAGGAGCGATGTTTTCATTCAAATAAAAGCTGGAACGGA +TACGGTTTTCCTCAACTCCGTTTTATACGTTCTGCATAAGGAGGGGTGGATAGATTACCGCTTTATTTAC +AACTACACGGAGGGATTTGAAGAGGCTCTGGAAGTTGCCATGAAATTCCCTCCAGATGTGGCCGCCAGCA +TTTGTAGCGTCAAACCGGAAGACGTATACCTCGTAGCGGAGCTCTTTGCCCACAGTAAAAAACTTATCTC +CTTCTGGTGTCAAGGGTTAAATCAGTCCTTAAATGGGACTATGAAAAATCTGGCTTTGATAAACCTCCAC +TTGGCCACCGGAAGGCTCAACGAAAAGGGATGTCCCTTTTCCTTAACCGGTCAACCGAACGCCATGGGAG +GTAGAGAAGTAGGTTATCTCACAAACGGTCTTCCCGGATACAGAGATGTCAGGAATAAGGCGGACAGAGC +ATTTATGGAGAAATTCTGGGGCGTTAAAGGTATAAAGAAAGAGCCGGGACCCACAATTACGGAAGCGATA +GACATGATTCTAAAAGACAGAATAAAGTTTCTCTGGGTGGTATGCACAAATCCCGCGGTGTCTTTACCCA +ACTTAGAAAAAGTTAAAAGGGCTCTTGAGAAGGTTTTCTTAGTAGTTCAGGACGCTTACTGGAATGACAC +CTGCGAGTTTGCAAATTTAATACTGCCCGCCGCACAACTGGGAGAAAAAGAAGGAGTTATGACTGGTTCC +GATAGAACTGTTACATTTTGTGAGCGTTTTTCCGAGCCTTTTGGTGAATCAAAGCCAGACTGGCTCATAT +TTACTGAGCTTGCAAGAAAGATGGGAGCCGAAGAGCTTTTCCCTTACTCTTCTCCAAAGGAAATATTTGA +GGAATTTAAAGCCTCAACCAAGGGGAGATTGTGCGACATGAGTAATTTATCCTACGAAAACCTTCCCGCA +AGGTGGGGCAAAAGATGGCTCTATGAAGACCTAAAATTCCCAACGGAAAGCGGAAAAGCAAGATTTCACC +CCGCACGGGTAGATGTGGCAGCTGAAGAAGGGATGTTTATACTTCTGACGGGAAGATTAAAGAACAACTG +GCACACTATGACGAGAACTGGAAAGAGCCCGGAACTGTTGAAAGGTGAAATTCCACCTTTTGTGATAATG +AATCCCAGAGACGCGGAGGAACTGGGAATAGAGGAAGGAGAGGAAGTGATACTGAGTGCAAAGGGAAAAG +AAATAACCAGAGTTGTCAGGTTCGGAAACGTAAAAAGAGGACACATATTCGCACCTTTCGGTTATCCTTC +CGAATACGGAGAGCCTACTAATTTGTTAACGTCCGACAGAACGGATCCTTACTCAAAGGAGCCGGATCTT +AAGTACTCAGGGGTAGATGTGTTTGTAAAAGTAAATAGGTGAATTTACCTTTTTTTGGGGAGTTTTATTC +CGTACTTTTGTATCCTGTAACTCACCTGTCTCGGCGTCATACCTAGTTTTTTGGCGGCTTCTTTTATGAC +AAATCCGCTTTCTTCCAAGGCTTTTTCTATTAATTGCTTTTCAAGATCCCAAATAGTTTCCCCGTTCAAG +GTTTGATTATAGATTCTACTTTCTTTTTTCACATCCCTTATTTCAGGAGGCAGATCCTCCTCACTAAGGA +CTCCATCCGTGTCTAAAATTACCATTCTTTCCAGCACGTTCTGGAGTTCTCTGACGTTTCCTTTCCACTC +GTATTTCATGAATGCATCCATTACTTCCTGCGTAATGGAAACTTCTTTGTTGTATTCTTTCGAAAACTTT +TCTAAAAAGTAGTGAACCAGAACCGGAATATCTTCTTTTCTCTCCCTCAAGGGCGGTATGAATATGGGAA +CTACGTTGAGACGGTAGTAGAGGTCCTCCCTGAACTTTCCTTCCCTTACCATGCTTTCTAAATCCCTGTT +AGTAGCGGCGATTATACGAACGTCAACCTTTATGGGTCTCGTCCCTCCTATGCGTTCTATTTCTTTCTCC +TGAATTGCCCTGAGCAGCTTCACCTGAAGGTGTAGAGGAAGTTCTCCTATCTCATCGAGAAAAAGTGTTC +CACCGTTTGCCAGTTCAAACTTTCCTTTCTTAGTTGAATAAGCTCCTGTAAAGGCTCCCTTTTCGTATCC +AAAGAGTTCAGCTTCCAGAAGCTCTCCGGGTATAGCTCCGCAATTTATCGCGACAAAAGGCTTATCAGCC +CTTGGGCTGAGGAAATGTATAGCCCTCGCGAAAACTTCTTTACCTACACCGCTTTCACCCCTCAGAAGAA +CCGTAGCATTAGTGGGGGCTACTCTGTGCACAATTTCCAAAACGTTTAATATCTCTTTGCTCCTGCCTAC +TATCCCCTCTACGTGGAGTTTCTCGTATACACGTTTTAATTCCGTCTCCAGAGCTCTTTTTTCCTCCTCA +AGACTTTTTCTTTCCGCCTGTACTTTTCTTTCAAGGGAAAAGCTGTTTGCAATCAGCGTAGCTATCATAC +TTAAGAACCGTGTGTATTCATCTAGAGAATCCTTCTCATTTATTTCCTTGTCCGCACTCAGAACGCCTAT +CACTTTTCCTCCGCTCTTAATGGGCACGGCTATAAAGGCTATCTTCTTTTTACTTTTTTTCCTTTTCCAA +ACTTTGTTAAGGAATTCTGGTTCTTGAGATATATCTGGGATAACTATTGGTACTCCGTGTTTCCACACCT +TGCCCGTTATACCTTCTCCCTTTTTAAAACCTTCTTTCGGAAATTTACCTGAGGATGTGGCTCTTACAAC +TATTTGATCCGTGGAAGGGTCGTATATTGTAAGCGTCAACCTTTCAAATCCCATTAATTTTTTAAGGAGT +CTAAATATATAGGGAACAGTAGTTTCAAGGTTTAAGGAACTAGAAAGTATTTTGCTTACCTCGTATAAAG +TTTCGATCTCTACCTTTAAATCCATCTAATAAAAAATTTAATTACTTGGTTCCCGTGCTCCCAAATCCTC +CCTCTCCCCTTTGGGTTTGACTCACTTCCTCCACCTCCACGACTTCCACCCTCTGAACTGGTGCGATAAC +GAGCTGGGCTATCCTCTCCCCTCTCTCTATCACCACCTCTTCATTTCCCAAGTTTACAAGTATCACCTTT +ACCTCCCCCCTGTAGTCCGCGTCTATAGTTCCCGGAGCGTTTAAAACTGTAAGTCCCTTTTTCCAGGCCA +GACCACTCCTTGGCCTCACCTGTCCCTCATAACCTTCGGGGATTTCCAATATTAAACCCGTGGGTATCAA +TACCCTTTCAAAGGGCTTTATTTTTAGGGGTTTTTCAATTGCAGCCCTCAGGTCGAGTCCCGAAGAGTGG +GGAGTTGCGTACGAAGGAAGAGGTAGGTCTTGAGCGTGGGGAAGGCGTTTTATTTTGAGTATTACTTTAG +ACATCGTCCGTGAACTTGGGTCTTCCCTGTTCGTCTATTTCAACAACTTTGACTTTTACTACGTCTCCTA +CCTTGTACTTTTGCCTTGCATCCTTTACCCTTTCCTTCATCTTTGAAACATGCAAGAGTCCCACCTTTCC +GGGGGCGTACTCTATGAAGGCACCGTATGGCTCTACTCTAACAACTTTACCTTCGTATACATCTCCTACT +TTAGGTTTTACCTCCTTCTTTTCGGTACCTACGTCTTCTATCCCTATTGTTGTAAACCTCGGTCTTCCAA +GTTCGTCGAGGTCTAGAACCTTAACTATTATTTCCTCTCCTACTTTGTACTTTTCGGTTGCGCTCCTTAC +GGGTTCTGCCATCTTGGAAACGTGGAGGAGTCCTATCTTTCCTGGCCAGAGTTCAACGAACACTCCGTAC +GGTTCTACCCTCGTTATGGTTCCCTTGTAAACGGCACCTACCTCAACTTCCCTTACTATGTCCTGAATCA +TTTGTTTGGCTTTTTCCACGTCACCGCCGGGAAATACAAAAAGGTAAACCTTTCCTTGTTCACCTACCCA +TACCTTAACGCCCGTCTCGTCGTAAATCTTCTTAACGGTTGAACCGCCCGGCCCTATTATGAGGGGAGCT +TTTTCTTCGGGAACGTCTACAACTTCAACCTTCGGCGTGTAGGGGTGAGGCTCTTTTCTCGGCTCGGGTA +TAGCTTCGTACATCTTCTCAAGTATGTAGAGCCTTCCTTCCCTTGCCTGTTTAAGAGCGTCGAGCATTAT +CTCTTTTGTAATTCCCTTTACCTTTATGTCCATTTGAACGGAAGTAATTCCGTCTTTAGTTCCCGCAACC +TTGAAGTCCATATCGCCGAGGTGGTCCTCGTCCCCCAGTATGTCAGAGAGTATAACGTATCTGTCCTTTT +CAAGGATAAGTCCCATGGCTATGCCGGCCACATGTTTGTTGTCCTTCATGGGAACGCCGGCGTCAAAGAG +AGCCAAGGATGCACCACAAACCGTGGCCATGGAAGTGGAGCCGTTAGACTCGAGTATGTCGGACACAACC +CTTATTATGAAGGGGTACTCCTCTTCGGGAGGAAGTAATGGTTCTATTGCCCTCTCCGCAAGGGCTCCGT +GTCCGATTTCCCTTCTCCTCGGAGGACCCCAGGGTTTTGCCTCACCAACGGAAAAGGGAGGCATACTGTA +GTGGAGCATGAATCTCTTGAAGACTTCCCCTTCCGCTATGGTTTCTATTATCAGGGCTTCGTCCGGTGTT +CCGAGGGTTACCGTAACGTAAGCCTGCGTCTGTCCTCTTGTAAATATGGCATTTCCGTGGGGTCTTTCGA +AGGGATGTACCTCTATCCATATAGGTCTTATCTCGTTGGGTTTCCTTCCGTCTATCCTTACGCCTTCTTT +TAGAACCTTTTCACGCATTAACCTGCTTTCGAGTTTCTTGTAGAAGTACTTAACCGCAAAGTGAAGTTCT +TCGGGGATTTGGTGAGCTTCTATAAATTCCTCAACTATCTTGTCTAAGGTTGAATACCTTTCTTTTTTAT +CTTTTATGTTAAAGGCCTCAAGGATTTTTGGAGTACACTCTTCTTCAAGGGCCTTGAGTATATCTTCGGG +AAGTTCAACCTTCTGATACTCAAACTTGGGTTTCCCTACCTTTTCCCTCAGTCTTTCCTGAGCTTCTATA +ACCTCCTTTATTGCGTCAAGTCCGAAGAACAGGGCGTCTGCGAGAACCTCTTCTGGTATCTCCTTTCCTC +CGCCTTCCACCATTACGATGGCGTCTTTTGTTCCCGCCATTACTATGTCGAGATCCGCTTCCTTCCTCTG +TTCGTAGGTGGGGTTAGCCACGAACTCCCCGTTTACCCTACAGACTCTGACTCCCGCGATGGGACCTTCG +AAGGGAATTCTGGATATGTGGAGGGCTGCGGAAGCACCGGTTATTGCAAGAACGTCCGGGTCGTACTTAT +CATCCGCGGATAAAGTGAGGGCGGTTATTATAACATCGTGGAAAAATCCTTCGGGAAAGAGAGGTCTTAT +TGGTCTGTCTATTACTCTGGAGACCAATATCTCCCTGTCGGTGGGTTTTCCTTCCCTCTTTGTGAAGCCT +CCGGGTATCCTACCGTACGCAGAAGCCCTTTCCCTGTAGTCTACCGCCAGGGGGGTAAAGTCAACGTCCG +TTATGGGCTCGTCCGACATAACCGCGGTCACGAGAACCGCGGTACCGCCCTGCCTGACTACTACGGAACC +GTCGGTGAGTTTTGCGTACTTTCCAGTCTCTATAATAATAGGCTCTTCGGAGTTTCCTATCCTCGCTTTT +TCCTCCACACTCATGTTCACTTAACCTTGAGGTTTAGTTTTTGAACTACTTCCAGATACTTTGCGTAATC +GGTTTCCCTCAAGTACTCAAGAAGCTTCCTTCTTTTGTTTACCATAGCAATCAATCCCCTTCTGGAGTGT +ATGTCTTTTTTATGCTTCTTCATGTGTTCTGTGAGCCTGTTTATACGCTCCGTTAGTATGGCTATCTGAA +CTTCGGGAGAACCTGTATCTTGCTCGTGTCTCTGGAACTGTCTTATCAAGTCCCACTTAACGTCCTTGGG +CAGAACCATCTTCCCATATACCTCCGTCTTTTCTTAGAATTGAGCAAATAAATATTATAAGGAATTTTTA +AGTAGTTTTGTAAAAAGGAAGCTCGTTTACCTTAATGCCGTAGCCCCAGAATAGTGCATTTGCCACCGCA +GGTGCTATGGGCGGAAGTCCCGGTTCTCCCACACCTCCCATGTGGGCATCGCTGTTCAGTATGTGCACTT +CTATTTCTTCGGGAGCCTCATCCATTCTCAGAATGGGATAAGTGTCGAAGTTGTCGTTTACGGGCTTTCC +GTCTCTGAACCTAACCCCTTCCTTTAAAAAGGCACTGAGTCCCATAATTATCGCGCTTTCCATCTGGGCT +CTTATGAGCTCAGGATTTACGGTTACGGGACCTATGTCTATAGTGCAAACTACCTTGTGTACCTTTATCT +TGTCCTCTTCGTAAGAGACTTCCGCAACTTGTGCCACATGACTTCCGAAAGAGTAGTGGTAAGCAAAACC +CATCGCTTTTCCGTATTTCGGCTCTTTGCCCCAGCCAGCTTTTTCGGCGGTGTACTCAACAACTCTCTGT +GCTCTCGGGTTTGTTTCCAAGAGTTCTAATCTCATCTCTACCGGGTCTCTGTTTGCGAGTTTTGCAAGTC +TATCTATGAAGGTTTCCAGGGTAAATGCGTTGTGAGTGCTTCCCACGGAGCGCCAGAAGAACACCGGAAC +GGGAAGGTCTACCTTTACCCACTCCACGTGGACGTTAGGGATTTCGTAAAACATGTTGTGAACTCCTTCA +ACGGCGGCTGGGTCTATAATCACCTTTCTTCCTGCCCATTCAAAAACGGAGGGTACGGCTATTTTAAAGA +AGAGGGCGTTTACTTTACCATTTTCGTCCACACTCCCTGCCATTTTTGTCGCGTTCATGGGTCTGTACCA +TCCCGACTTTACGTCGTCCTCCCTTGTGTATATCAATTTCACGGGTCTTTTTATCGCCTTTGATACTTCA +AGGGCTTCCCTTATAAATTCAACGTTTGCCTTTCGGCCAAAACCACCACCGAGGTAAGTGGTAATCACCT +TTATCTTCTCCTCCGGAAGCCCTGTTATTTCCTTCGCCACGTTCAGTGTGGCAGTCTGGGCTTGAGTGGG +TGCGAATATTAAACACTCGTCTTCTTTAACGTGCACGGTACAGTTCATAGGTTCCATGGTGGCGTGGTAG +AGGTAAGGAAGGACGTAGGTTTCCTCAATCTTTTTCTTTGAATTCTTGAGAACTTCTTCCGGCTTCCCGT +CTTTTCTGGCAACTATTCCCTTTTCTTGGAGCTTTTTCAAGTAATATTCCTTAAACTTCTCATCGTCCCA +GCCATCTATGGGTGATTCTTCCCACTCAACCTGAATCTTCTCCCTAGCCTCCAGGCAGTCTTCTAAACTT +TCACCGCAAATAGCAAGACCCGTTGATATGGGAACGAGTTTTACGTTATTGACCTCTCCCTTATATCCTT +TCAACTTAGCTCCGAAGGGTGCCCTCTCCACAACAGCGTAAACCATACCTTCCATAAAGGTGTCTATTCC +GAACTTCGCCCTCCCGTTTACTTTTTCGGGAACGTCTATTCTGGGGACACTTTTTCCTATGTATATGAAC +TCCTCTTTTGTCTTTAGTCTCGGATTGGTTGGTATCCTTTCCCTGAAGGCTTTTTCCGCAAAAGCACCAT +AAGGGTATTTTTCTCCTGTTTTCAGGTTTTCAATAAATCCCTGCTTAGCCCTTAAATACTTCTTCTCCAC +TCCGAGTTCTTTTGATGCTGCGGAAAGGAGCATTTCCTTCATAGACGCTCCTACGAACCTCAAAAAGTCG +TACATGTGTCTTACGCTCGTACTTCCTCCCGTGAGCTGCACTCCCCACTTTGGATCTACGTACTTTTTAC +CCGCGGGTGCGGGTTCTACCTTTACCCTTTCCCAAGGAAAGTCAAGTTCATCAGCGAGTATTTGGGGAAG +TCCCGTGTAAACTCCCTGTCCCATTTCAGATTTATTGACGAGAACGGTCAGGTAGTTGTCCTCCGAGAGT +TTTATCCAGAGTTCCGGAGCGTAATTTGGCAGCACTTCATCTGCTTTCAAAAGCCTGTAGCCGTCAGAGG +TGAGCACTACGGCAAGAGCCAGACCGCCTTTTATAAAATCTCTCCTGCTTATCATACTTTTACCTCCCTC +ATCATCTGGGCAGCCCTCTGAACAGCCCTTACAATCCTCAGGTAAGTCCCGCACCTGCACAGGTGTGAAG +ACATGACACTTACTATTTCCTCTTTTGAAGGGTTCGGATTTTTACTCAGAAGTGCATAGGCTTCCACTAT +TTGTCCGGGCTGGCAGTATCCGCACTGGGGAACCTGAAGTTCAATCCATGCCCTTTTAACAGGGTGTTCT +TCGGGAATTCCCTCGATGGTTATTATTTCTTTTCATTCCGCTTCCTTGACTGGGTACTGACAGCTCCTCA +CAGGATTTCCGTCTATTAAAACGGTGCAGGAACCGCATATTCCCTTACCGCATCCGAACTTCGTCCCGGT +AAGTCTCAACCTCTCCCTTATTACCCAGAGGAGAGGCGTATCAGGACTTACATTTACTTCGTACATTTTT +CCGTTTACTTTTAAAAGCATTCCTACCTCCATAAGTTTTAAATTTAATTGATAATGATTCTTTTGGTTGA +AGATGACGACAACTTAAGGGAACTCCTTAAGAAAAAACTCGAAGAACACTTCGTGGTAGAAACTGCAAAA +GACGGAAAGACGGCAAGGGAGAAGTTAAGTAAAAATAACTACGACGTTGTTCTCCTCGATATAAGACTTC +CCGACGTAGACGGAACAGAACTTTTGAAAGAGTTTTCAACGAGCGGGGTTAAGTTCATAGTGATTACCGG +CTACGGAGACGTAAAAACGGCCGTCCAATGTGTAAAACTGGGAGCCTACGACTTTATCCAAAAACCTTTT +AACTTTGAACTACTGGAAGTAACTATAAGAAGGGCACTTAAAGAGAAAAGACTGGAGGAGGAAAACAGGA +CGTTAAAGAGCTTCCTCTTTAAGGAAAAGGAAGAAGATTACCTGCTGGAAACCAGAAGTCCAAAGTTCAG +GGAAGTTTTAGAAATAGCGAGGAGGATTGCAAATACAGACCTTCCCGTGCTCATACGCGGAGAGACGGGA +GTGGGGAAGGAAGTTCTTGCTAAATATATACACACTATTTCAAATAGGAAGGACAAACCTTTCGTGGTAG +TGGATTGCACCTCTATACCCGAGCACCTCTTTGAGAGCGAACTCTTTGGATACGAAAAGGGAGCCTTTAC +GGGGGCAAATACTAGAAAACTAGGACTTGTTGAACTCGCAAATGGCGGAACGCTCTTTTTTGACGAAATA +GGAGAAATGCCTCTCTCAATTCAAGCAAAGCTCCTGAGATTTATAGAAACTAGAAAGTTTAGAAGGGTAG +GAGGTTTAAAGGATCTAGAAGTAGATGTCAAAATAATTTGCGCTACGAATAAGGATTTATACGAGAAGTC +AAAGAGAGGAGAGTTCAGAGAAGACCTCTATTTTCGTATAAACACAGTGGAAATCGAAATCCCTCCTCTC +AGGGAAAGAAAGGAAGACATACCCCTCCTCGTGGAGTTTTTCCTGAAGAAATATGGGAAGAAGATCAAAA +AAGAAACCTTAAACGAGCTTATAAATTACCCCTGGGAGGGAAACGTAAGGGAACTTAAGAACGTAATAGA +GAGGGCATGCATACTCTCAACGGGTGAGTATATTGACGAGGCGATATGTCTCAGTAAGAAAAGCGTGAGC +TGTGTGGAAAAAATGATGGAAAAACTCCCAAGTCTTGAAGAGCTTGAAGGGATGTACCTCAAGTTTCTTT +ACGAAAAACTGGAAGGTGATGTGGACAAAATTGCCGTTATTCTCGGCTGTAGCAGGAGAACCGTCTTCAG +AAAGTTAAAGAAGTTAAGAGAGGGGAAGGTGCACTTCAAAAATGCTTCCCTTTCCGGGGGCACTCCTTAA +GTTTATTTTTCCCCCGTAGCTCTTTACAATGTCGTTCACTATGGCAAGTCCCAGTCCACTCCCTTCCCTC +TTGTCTTTCCCGTGATAAAAGGGCAGGAATATCTTGTCCACTTCTTCGGGAGGTATGCCTTTCCCTTCAT +CCTCTACAATTAAAATCAACTCCTCACCTTCTTTTTTCAGGAAAACTCTCACTTTCTTCCCCCTGTCTGA +TGCCTGAATTGCGTTCAGAACCAAGTTTAGAACCACGTGTCTTATGTCCGTTTCGTTTCCAAACATGTAA +ACGCTTTCAAGTTCTTTTTCTATAATTACTCCTCTCTCTTTTGCGTAAACTCTTAAAAGTTCAAGTACGT +CTTCCACAGCCTTTTTAGTATCCACTAAATCCTTGTTGTTATCCTTCCTCGCAAAAAGCAGTAGCTTGTC +AACGGTGTTTTTACAGCTAATGAGTGCATTTTTTATAACCTCTATCTCTTCACAACTTCCGCACTTTTTT +TCCAGCTCCTCAAGTGCAAGGCTTATGGTCGCGAGAGGTGTGTTTAGTTGATGGGCAACTCCGAGGGCAA +GGTACCCCACAGAACTGAGCTTTTGAGAAAGGCTGAAGAGGTAAAACTTTTCCTTGTCGTTCTTTATGTT +TTTTATGAACTGAATTATTTTCCTGCCCTCTTCTATTGGGAAAGCACAGATTTCTACGTGAACTTCCTTG +TTATCGTGGGTGTAGTGGGTATGAACCACACTGACAGCTCCTTTCCTTTTCTGGATCTCTTTTAAGGGAC +AGGGATGACACTCACCGTCGCAGGGCTCGTCCCTCTTGTGAGAAACAAGATAGCAAGGCTTCCCCACGAC +CTCCTCTTTACTTCTGTACCCGTTTTCCTTCACGTAAGACTCGTTGGCGTAAACTATTTTGTAATCTTTG +TCTATCACCACAACCTGTTCTTTAAACTTTTCAAATACCTCAAACTCCCCCATGGGAAAAATTTCTTTCC +ACCGTAAGAATTTTTAAGTGTCAAGTTTGTCACTAAGGTGTCATTTTTGACACCTGATTCTTTTCAAGTT +CCTTAGAATTTCAGTGTCCAGAAATTGGCACGAAAATTGCAATAAATACAACGAACAAAAATGGAGGTAA +GAGTATGGGTGTAAATAGGAGAGACGTTTTTAAACTGGCGGGTTTGGGGGTAGCTCTGGGAGCACTTCAA +TTACCCTCTATTGCATGTGCTGCGAAAACGTCAAATAGCTTGCTCTCTCCTTCTAAGGGAAAGAGGATAG +TAATCGTGGGAGGAGGATGGGCCGGTGTTACGGCGGCAAAATATATAAGGAAGGAAATCCCCGACGCGGA +AGTGGTTCTCATAGAACAGAGAAAGATGTTTATGTCCTGTCCGATAAGTAACGTATGGCTGGGTGGGCTG +GTAGACCTGGAATTCCTTATACACGACTTCTTAACACCCGCTGCAAAGTACGGTTACACTTTCATTAACG +CAACCGTAACGGATATAGACAGGGATAAAAGAAGGGTATACACGGAAGACGGATACGTTGAGTACGACTA +CCTCATACTCGCACCAGGAATAAGGTACAACTACGACGCATGGTTTAACGGAGATAAGGACATGGCAAGG +TACGCTCAGACACACTACCCATCCGCTTTCATTCCCGGCTCTGAGCACTTGAGGCTGAAGAAGAAAGTGG +AAAACTTCGAAGAAGGGACGTTTGTACTGGTTGTTCCTCCACCTCCACACAGATGTCCTCCCGCACCTTA +CGAGAGGGCAGCTATGATAGCGCACGTTTTCAGGCAAAACGAAGCCAAGGCAAAATTGATAATCCTTGAT +CCAAAAGAAAAGATAGCTCCAAAGGGTCCCGGTTTCAGAATGGCTTACGAGCAGCTGTATCTTGACATAA +TAGAGTACGTTCCCAACGCAAAGATAAAGGAAGTTGACCCCGTTAAAAAGGTTATAAAGACTACCGCAGG +GGACTTTAAGTTTGACGACGCTAACCTGAACCCTCCCCATCAAGCGGCGGACATTGCCTGGAAAGCCGGA +CTCGTCAATCCAAAAACGGGCTGGTGTGATGTAGACCCTATAACGCTTCAGTCTAAGGTGGACAAGAGGA +TATTCATCCCCGGAGACGCAAACTCCGTAAAAGGTTTTCCAAAGAGCGGTGATATGGCGAACAACCAGAC +CAAGTTTATGCTCGTGAAAGCTATAAAGGCGATGATAGAAGGAAAGGATCCCCTTGAATACGTAAAGGCT +CCTACAAACACCTGTTACTCTATGGTAAACGGAGACCCGAAAGAAGCGATAGTCATTAACGTTGTTTACG +ACATAGACAAACAAAAGCGTATGCCCGTTAAGAAGAAGGTTAACGTAGAAAACGAGCGTTCTCAAAGACT +CGCAAGGGCTACATTTGAATGGGCTAAAGCCATGTACAGGGATATGTTCTCGTGAGGTAAGGAAATGGAC +AGAAGAACCTTCGTAAAAGCCTGCGGGTCAGTTGCCACACTTTCCCTTATCTCTTCCTCCTTTTTTACTC +AAACCTTAAGAGCACAAACCAACGAGTTCAAAAAGTACAAAAAGGCTATTCTGCTGAACAAAGATGGAAA +TCCGATAAAGCCGGAGGAGATAGAAGTCGGAAAGCAGTACTTGTTTTTCTACCCTTACCGCTCAACGCCT +GCCTTTTTGCTCAACCTCGGAAAGGAAGTAAAGCCTGTGGAAGTAAAGCTCTTAGACGGGAGTTCCTACC +TCTGGCCCGGAGGCGTAGGTCCTCAAAAAAGCATTATCGCTTTCTGTGCTATATGTCCACATCAACTCAG +TTATCCGACTCCCGATTATTCTTTCATTAATTACTATCCGCCCGACAAGCCCTCAAAAGCGGCAAAAAAA +GGAAACGTCATTCAGTGCTGTGCCCACATGTCCATCTTTGACCCCGAAAAGGGAGGAGTTGTACTGGACG +GTCCCGCGGAATACCCCTTACTTACGATAGTCCTTTCATACGAGGATGGAAAACTTTACGCGGTCGGGAC +GCTCGGTGTGGAGAAGTTTTCAGATTTCTTTGATGCCTACCGCTCTGAGCTTAAGAAAATGTACAAATCC +TTCAGAAAGGCAAAGAAGAAGGTGGATAAATCTGTTGTTATGAGGGTGGAGGAGTACGTAAATGAAGTCA +TTTACTGTTGACAGAAGGAATTTACTGCTTGCAGGTGGAATTGGACTTTTGGGTGTTTACGTTTCAAAGA +GTCTTGTCTTTGGAGAGACTAAGGGAAACAGGGTTGTGGTTCTCGGGGGAGGGTACGGGGGTGTTACAAC +TGCAAAGTACGTAAAGAAACTTTACCCCGATGCGGAAGTTGTTCTGGTAGAAAAGAACCCAATGTTCGTG +TCCTGTCCTCTGAGCAACCTCTACCTGGTTGGTTTAGTTCCTTACGAACAGCTCTGCTATCCATATAACA +ACCTAGTGACAAAGTACGGTGTGAACTTCGTAAACGACGAGGTTATAGGAATTGAGCTTGATAAGAGAGA +AGTAATTCTCGGAAACGGAAGACTGAAGTACGACTACCTAGTGATTTCACTCGGCATAGAGTACGATTAC +GAAGAAAATCCGGCGTTGAAGGAAGTTTACTGGAGTTATCCTCCCGCATTCAGACAGGGAAGCGAACACC +TTTACCTGAAGAGGATGCTCGAAGGCTTTGAAGGGGAGAGTATATTAATCAGCGTCCCGAAGATGCCATA +CCGCTGTCCTTCCGCACCTTACGAGAGAGCCGCACTTATACTCTCCTACGCCAAAAAGGAAGGACTTAAA +GTTCACCTTTACTTCGTAGATGAGAACGAAAGACCTCCCGTACTTACAAAAGGATTTTTGAAAGCTTACC +AAGACTTTTACAAAGACGACGCCACTTACCTTACCTCAACAAAAGTTCTGGAAGTTGACCCCGTCAAAAA +AGTGGCAAGAACCACGAAAGGCGACATAAAGTTCAGTATGGCAAACTTCATACCCCCCATGAGGGCTCCA +AAGCTTCTGGAAAAGGCAGGACTTTTGAAGAAAGGGGAAAAGTGGGTAAAAGTGGATCCCATGACTTTTG +AAACCTCAGTAAAAAACGTTTTCGTTATAGGGGACAGTGCCTTTACCTATCTGCCAAAGAGCGGTTACGC +TGCTCACTCACAGGGTAAAGTAGTCGCAAAGGTTATAGCTTCAAGACTCAGGAAAAAGCCCTGGGAGGGA +GAGCTTATACAGCAAGCGGTTTGCTACGCCATGGTAAACCTCAAGCAGGCGATAATGATGAACGTGGAGT +ACAAGTACAACCTAAAGACAAAAGAGATAAAGAAGGAGATTTACGAGGACGATACCTGGAAGGTTTCAAC +AGCAAAGAGGTATATAGAGTGGGCGAGGGGACTGTGGAGGGACATGTTTACGTGATTACTCCCACTCTAT +GGTAGAAGGGGGTTTTGAGGATATGTCGTAAACAACCCTGTTCACCCCTTCCACTTCGTTTATTATCCTT +CTCATAACCCTGTCCAGGAAGTCGTAGGGAAGTCTCGCCCAATCCGCTGTCATACCGTCCACACTCTCAA +CAGCCCTGAGGGCTACGACTTTCTCGTAAGTTCTAACATCTCCCATAACACCCACGGATTTCACGGGAAG +TAGAACAGCGAAAGCCTGCCAGACTCTGTCGTAAAGCCCTTCCTTTTTTAGTTCCTGTATGAATATGTAA +TCCGCCTTCCTCAGGATTTCTAAGTCCTTTTTATTCACCTCACCGATAATCCTTATGGCGAGTCCGGGAC +CTGGGAAGGGATGTCTCCTGAGGATTTCCTCGGGAACGCCGAGAAGTTTCCCGATTTTTCTCACCTCGTC +TTTAAAGAGTTCCCTGAAAGGTTCAAGTAGTTTTAAGTTCATTCGCTCGGGAAGCCCGCCCACGTTGTGG +TGAGTCTTTATCTTAGCACTTCCCTTTATTCCGGCACTTTCCACAACGTCAGGGTAAAGGGTTCCCTGAA +GTAAGAACTCCGCACCCTCTATCTTTTTAGCCTCCCTCTCAAAGACTTCTATAAAGGTTCTCCCTATTAT +CTTTCTCTTTTCTTCTGGATCCTCAACGCCTTTTAATTTTTCGAGGAACTCTTCCGAGGCGTCCACGACC +GTGAGAGGAAGGCCCAAGGACCTTAAGTTCTTCTCAACTTCTTCCCTCTCTTTGTACCTCAAGAGTCCGT +GGTCTATAAAGAAGCAGTGAAGTTTATCTCCTATAGCCCTGTGGGTTAAAACCGCGGCTACCGTAGAATC +CACCCCCCCTGAGAGCGCGGCTATCACCTTAGCGTCTCCCACGGTCTTCCTTATCTCCTCTATTTTCTCA +TGGATGAAGTCACCCATTTCCCAGTTCTTTTCCGCCTTGCATACGCCGTATATAAAGTTTGCGAGCATCT +CCTTTCCGAAGACTGTGTGCGTGACCTCAGGGTGGAATTGAAAGCCGTAAATTTTCTTCTCCCTGTTTGC +TATAACCGCGTAGGGGGAGTTTTCGGATACCGCCAGAACCTCAAAGCCCTCTGGAAGCTCTACAACCTTG +TCCGCGTGGGACATCCACACATCACTCTCCTTCGGTATACCCTCAAATATCACATCTTCCTTAATAATCC +TGAGTCTCGCCCTTCCGTACTCCTGCTTTTCAGAGCGAACTACTTTACCGCCAAGCTGGTGTGTAATCAC +TTGAAGCCCGTAACAAATCCCAAGTATGGGAACACCGAGCTCGTAAATCCTTTTGTCGGGTAGGGGAGCA +CCCTCGGCGTAAACGGATGCGGGACCTCCCGAGAATATAATCCCGTAGGGATTTTTCTTCTTAATTTCTT +CCACAGGGGTGTCCCAGTGGACAATTTCACTGTAAACACCAAGCTCCCTTACCCTTCTTGCGATGAGCTG +AACGTATTGAGAACCGAAATTAACGACGAGTATAGGTCTTCTCTGCATAAGGATAAATAATATATAGATG +GATGAATAAAGGGAGGTGAAACCATGAAAAAGTTAAGTGGTGTTTTAGCGGGAAGCCTTTTACTCATTTC +CGCTTCCTTTTCTCAGGACCTGAAAGCTCACGCGGAGCTTATAAATACAGAGGGAGAGGTCATAGGAAAG +GCTGAGCTCATAGAAACTAACTCCGGAGTTCTTATAAAGCTAAATGCAAAAGGTCTACCACCTAATGCGG +AGCTTGCTTTCCACATACATGAAAGGGGAGAGTGCAAACCGCCGACTTTCAAAAGTGCGAAGGGACACTT +TAACCCTTATGGAAAGAAACACGGCCTTTTAAACCCTGAAGGTCCCCACGCTGGAGACATGCCCAATATT +TACACCGATGACAAGGGAAACGTAAGGGTTCAGGTTTTAAATCCCTTCGTAACATTGAAGAAAGGGGAGA +AAAACAGTTTATTTAAAGAGGGAGGAACGGCACTCGTAATTCACAGCGGACCCGATGATTATAAATCGGA +TCCTGCGGGGAACGCGGGTAAAAGAATAGCCTGCGGGGTGATAAGGTAATTTCCTTTCCTCTTTATCTTT +TAAACTTTTGTATGACCCAAATTCTCAAACTTCTTTTCCCGAAAATTTAAAATTTTCCTATGGCTATCGA +TAAGGAAAAGATCAAGCAGGCTGTAAGACTGTTTTTGGAAGGAATAGGAGAAGATCCCGACAGGGAAGGA +CTGAAAGAGACCCCCGAACGCGTTGCGAGAATGTGGGAAGAGTTTGAGAGGATGAGAAACTTTGACATGA +AGTTATTTGAGGAGTTCGGGGGATACAACGAAATGGTTCTCGTAAAAGACATAAAGTTTTACAGTCTATG +TGAGCACCATCTTTTACCTTTCTTCGGTAAAGTTCACATAGCGTACATTCCCGATAAAAAAATCTCCGGA +CTTTCCAAACTCGTGAGAACGGTGAGAGCTTTTGCCCTGAGACCGCAGGTTCAAGAGAGGCTAACCGAAG +AGATAGCGGACTTTCTGGAAAAGGAACTAGAACCCAAAGGTGTGGGAGTAGTTATAGAGGCAGAACACCT +CTGTATGTCCATGAGAGGGGTTATGTCTCCCGGACACCTCACGGTCACCTCAGCCCTGAGGGGTGTGTTT +TTAAAGGACATAAAAACGAGGGAAGAGTTTTTAAAGCTCGTTAAAGGCGTTTAAGGTATTGGAACCCTGC +TTATGACTTCCTTTAAGACCGCTTCCGCCTTCACTCCTTCCCTTACCTTTATCCTGTGGGGAATTACGTA +CTTAAGTAAGTCCAGAACGTCTTCCGGGACGACAAAGTCCCTTTCCCTGAAGTAAGCCAGAGCCCTTGAG +GCGTTCGCAAGGTGTATAAGACCCCTCGTGGAAACACCCAGAATAACCGAAGGGTGATTCCTGACCTCGT +TTCCTATGTTTACAATAAACCTTGCGACTTCCGGGGAAACGTATATTTCCTTTACTTCGTTTACAGTCCT +TATAACTTCTTCGGGGGAACTTAAAACATTTAGAGAACTTACCTTTTCCATGGGGTTTATCCCCTGAACT +ATCTGAACTTCGTCCTCTTCCGAAGGGTATCCCATACTGATTTTCATAGTAAACCTGTCGAGCTGAGCTT +CGGGAAGGGGGTAAGTACCGTAATACTCAATCGGGTTCTGAGTAGCTATGACGAAGAAGGGTTCGGGGAG +TTTGTAAGTATTTCCGTCCACGCTCACCTGTTTTTCCGCCATAGCCTCAAGGAGGGCACTCTGAACCTTC +GGCGTTCCCCTGTTTATCTCATCAGCCAGAACTACGTTACTGAAAATAGGCCCCTTTTTGAACTCGAATT +CCCTTGTTTTCTGATTGAACACGCTGACTCCGGTTATGTCCGAGGGAAGGAGATCACTCGTGAACTGTAT +CCTGCTGAACGAAAGTCCAAGAACCCTTGCCAGAGCCAGAGCTAATGTTGTCTTACCCGTTCCGGGAACG +TCCTCTATAAGGAGGTGTCCGCCCGATAGGAGACAGACGAGAGAGTTTTTTATAACTTCTTCCTTCCCCT +TTATTACTTTCGAGACCTCAGAAATTATGAGGTTTATGTCCATTGGTATAATTTTAAAAACAAGGAGGAG +AAAAGGTGAACGAACTATTTCAAACCCCTCAGGTAGAAGCGGGAATTAAAGAATACCCCTTAATGCCTTT +AAGGGACATAGTTATCTTCCCCACAATGGTTCAGCCTCTCTTTGTAGGAAGGCGTTTCTCAATAAGAGCT +ATTGAGGAGGCGAACAAAAAGGACAAACTTATATTCTTAGTTCTTCAAAAGGACAAAGATGTAGAAGAAC +CTAAGGAAGAGGACATATACAAAGTCGGTGTGGTTGCCTACATATTAAGAACAGTTCCCATAGAGGACGC +AAGAGTAAAGGTTCTCGTTCAGGGATTAAAGAGAGGGGTTATAAAGAAGCTCGAGTGGAAAGAAGACCAC +TACGTAGCCCAGGTAGACGTTATAGAGGAAAGGGACATCCCGCCCGAAAGCCAAACGATAGAGGACAAAG +CCCTCATAAAGGCCGTAAAGGAATCCATAGACAAACTCGTCAGCCTTGGAAAACAGATAATTCCCGACCT +CGTAGTTCTCATAAAGGAACTCGAAGAACCCGGAAAGCTCGCGGATATGGTAGCCTCCATCCTTGATATA +AAATCCTCACAGGCTCAGGAGATACTGGAAACTTTCGACCCCAGAGAAAGACTTAAGAAGGTTTACAAAT +TCCTACAGGACGAAATAGGACTCCTAGAAGTAAAACAAAGGATAAGCGAGATAGCAAGGGAGAGAATGGA +AAAGGAACAGAGGGAGTACTACCTCAGACAGCAACTCAAAGCCATACAGGAGGAACTCGGAGAAGCAGGC +GGAATAAAGGCTGAAATAGAGGAGTACACAAAGAAGTTTGAAGAAGTCAAAGAGTGTATGCCTGAAGAAG +GGGTAAAGGAAGTAGAAAAGAACATAAAGAGACTAGAGAGACTGCACCCCGAGTCCGCGGAAGCTGGAGT +TATAAGAACGTGGCTCGACTGGGTTCTGGACCTTCCCTGGTGTACGAGGACTGAGGACAATTACGACCTT +GAAAGGGCAAGGGAAATTTTAGACAGAGATCACTACGACCTTGAAAAGGTAAAGGACAGGATAATAGAGT +ACCTCGCCATAAGGAAGTTAACTCAAGGTAAAGAAGCCCCAACTCAGATACTTGCCTTTGTAGGACCTCC +GGGTGTAGGTAAGACTTCCCTAGGACGCTCAATAGCGGAGGCCCTCGGAAGGAAGTTCGTAAGGATAGCT +TTGGGAGGTATAAGGGACGAGGCGGAAATCAGGGGACACAGGAGAACTTACGTCGGGGCAATGCCCGGAA +GGATTATTCAAGCCATAAAACAGGCCGGAACGAAAAACCCTGTAATAATGCTGGATGAGATAGACAAGCT +CGCCATATCCTTCCAGGGAGACCCCGCGGCTGCACTCCTCGAAGTCCTTGATCCGGAGCAAAATAAGAAG +TTCACGGACCTCTACATAGGGATTCCCTTTGACCTCTCAGAAGTGATATTCATTTGTACGGGAAACAGGG +CGGATACTATTCCCACACCGCTCCTCGACAGGATGGAACTCATAATGCTTTCAGGATACTCCGAAGAGGA +GAAACTCTTCATAGCAAAGAAACACTTGATTCCCAAGTTAATTCCCCTCCACGGCTTTAGCCCGGAAGAG +ATCGAGTTTACGGACGAGGCTATTCTGGAGATAATAAGGGGCTACACGAGAGAGGCGGGAGTGAGAAACC +TTCAAAGGCAGATTTCCGCAGTCCTGAGAAAAATAGCTGTAAAGAAACTACAGGGTGAGAAAGGTCCGTT +TAATATAACCCCTGAGCTCGTCAGAAAACTCCTCGGAGTTCCGAGGTACAGACCTGAAAGGGAAAAGAAA +CCTCTCGTTGGGGTTGCCACAGGACTCGCATGGACCGAAGTAGGCGGAGAGATAATGTTCATAGAAGCCA +CGAAGATGAAGGGGAAAGGCTCGCTTGTTCTCACAGGTTCACTGGGAGACATAATGAAAGAAAGTGCTCA +GGCAGCTCTCTCTTACATCCGCTCAAAGGCGGAAGACTACGGCATAGATCCGGATATATTCTCACAGGTT +GACGTTCACGTGCACGTTCCCGAGGGAGCGGTTCCGAAGGACGGACCATCCGCGGGTGTTGCGATAGCGA +CCGCACTCCTATCTCTGTTTACGGACATTCCCGTGAGGATGGACGTTGCCATGACGGGAGAAATTACCTT +AAGGGGAAGAGTGCTCCCCGTAGGTGGTCTGAAGGAAAAGATACTCGCGGCAAAGAGAGCGGAAATCTAC +GAGGTAATCCTGCCCGCTAAAAACAAAGACGAGGTTATGGAAGAACTCCCAGAGTACGTAAGGGAAAAGA +TGACTCTACACTTTGTAGATAACTTAGAAGAAGTGTTCAAGATAGCATTAGTGAGAGAGCCAAAGCCCCT +CAAAGAGGCGTGATCTCTATAAGGTAAACCTCTCCCCTGTTCTGTATGGGGATCGTTCCCTTGCTCCCCG +TTATTACAAATATCCTTCCTTCGCTATCCCTTACTATAGCCTGAATGGCTTCTTCAAACTTTCTTCCTTT +GAGTTTAATCGCCTCGTAAACCTTTTCCTTTTTCCTTACAACGGTCCAGAGTTCCCCTTCCGTAAACTTT +GTAAAGCCCACAAGCTGGAATATGTTACTCGCCCTGTTTTTTGCTATTAGAGGTAAAACGTCCTTGTAAA +CTTTTGTGAAGTTCGGTCTAACGTAGAAGCCGTACTTGTCTCCTTCCGCATACTCGTAAACTCCGGGAAC +CTCCGCGGTTGTGTAGGAAAGTCCGAACCCGTCCTCCGTTAAAACCTCCTCATCGTTTACGTAAACCCTG +AGCTGTCCGTCGTTGTCCACAAAAACGAGAACGTTGTTCCAGGCATTCGCACCGTCTACTCTAAAGTCTT +CAGGAAGATTAAGGGCGTCTTTCCTTACAAGTTTATCACCTCGGAGCTCAAACCTGTAAACCTTTCCCCA +GCTTCCTTTAAACTCCTGCCCTATGAGAACTTTCTTTCCGTTTTGATAGAAAAATCCAAAGAGGTATGGA +ACGTTTTTATCGGTAAGCATTAGGGAGTTTCCTACGGGACTAAGAACGGCGGAACTCGCCTCCCCGTTCG +ATATCATGTTTACGAGAACGGCAGACCTTCCTTTATTTTCGTAGCACACAACACCAACAGGATAACCTGT +AGGAATGGCGTAAGATAGTACTTCAACAAAGTCGGTTTTTAGTACTTCGTAAACTTTTACTTTGTCGGAA +AAGAGAACTACAAGGTAATCTTTCTTTCCGAAGAGTTTACAGATATCCGCAGATAGCGGAAGGCTCTCCA +GACTTCTCACAAACTTAGCCTTTAGGGCAAAGTCTTCAAAAACACCACCTCTTTTTGCAAAGCCCACACC +GGAGTACTGGAAGAATGCAAGAGGTTTTCCTTTGTAAGAAACACCGTAACCGTTTTCAAGTTCCTTTACC +ACGTAATCGCAGTTTTCAGAGTTCCTTTTTACATTTTGAACTACTTGACTGAGGGCGTAATACCCTTCGT +CTCCTCCAATATAACACACACTACCAATTTTTAGCTTTACCCTATCACCGGGCTTTATTCCGTTGTTTTC +TAAGGTTTTTGCCTCCGAAAAATTCTCTCTCGGCTTTATAACCTCTACTTCTCCTACCTTTTCTTCCTTG +TATCCGAGAACTTTTTTCGTAACGGGGTGAATTATGGGCTTTTTACTCTGGAAAACTTCAAAGATCTCTC +CGGGAAAGGCTTTTCCCCTCGGAAGGTCTATCAATACTTTTTCCCCTTCCTTTTCAACCACGTATCCGCT +TCTCTGAAAGAATTCCAGAAGTTCTTTTGGAACTTGAGCAAAGAGAAAGGTACTTAAAAACAATATTAAT +AGACTAAGTGTACGCATCTTTTAACCTCTCTAAGTTTTCTAAAATCTTGTCAGTTATTTCCTTCGTGCCG +ACTTTTATGCAACCCTCAGAGTATATATCCGGCGTTCTGTAGCCCTGATTTAGTGTTTCCTCTATTGCCT +TCTCTATCAGGTCGTGGGCCTTGTCCATGTTAAAGGAGTACTTGAGCATCATGGCGGCGGAAAGTATAGT +GGCTATCGGATTTGCTATACCTTTACCCGCTATGTCGGGAGCAGAGCCGTGAACCGGCTCGTAAAGTGCG +TACCTGTCCCCTATGCTCGCAGAAGGAAGCATTCCGAGGCTTCCCACAACAACTCCCGCTTCGTCGGATA +GGATATCACCGAAGATATTTCCCGTGACTATAACGTCAAAGCTTGTTGGTCTCCTTACGAGTTGCATAGC +ACAGTTGTCAATGTAGAGGTGTTCCAGTTCAACGTCCGGGTAGTTTTCTTTTTCTTCCTCTACAATCTGT +CTCCAAAGGGCACTTACTTCAAGGACGTTTGCCTTATCCACGCTCGTTAACTTCTTTCTCCTTTTCCTTG +CAATTTCAAATCCTTTTCTAACTATCCTCCTTATTTCGTCTTCTGTGTACTTCATAGTGTTTATCGCGTA +CCTCTTTCCGTTTTCTTCAAAAATCCCCCTCGGCTCTCCATAGTATATTCCAGAGGTAAGTTCCCTTATA +ACGATCATGTCCGTTCCTTTTACGACTTCTTCTTTTAAAGGAGAAGAGGATATCAGTGCGTCCCAGACTT +TTGCAGGTCTGAGATTTGCGTAAAGGTCGAGTTCCTTTCTAATCCTTAAAAGTCCCTTCTCCGGTCTTTT +ATCGGTAGGAAGGTTGTCCCACTTCGGTCCCCCGACTGCACCAAGGAGTATAGCGTCCGATTCTTTGCAT +ATCTTCAGAGTTTCTTCGGGAAGAGGATCTCCCGTTTTGTCTATCGCCTCACCGCCTATTAGCCCCTCTC +TATACTCAAACTCAACGCCGTAAATCTCACCTATTTTGTCAAGAACTCTGAGGGCTTGTTCCACTATTTC +TGGACCTATCCCGTCTCCTTTGAGTACTGCTATCTTGTATTTTTTCATATGATGTATTTTAGCAATAAAA +ACTTAGACGAATTTATTATAATTATGTTTAAGGGCTACAAAGCCCCTCCTGGCTCCTTGGCAATTGAATA +TGGTTTATGGGTCTCAATGAGTGATGCTTTGATGACGTGATGAAATGAAATCATGATGCAATAGGGCTGA +AGGGATTGAAAATCAAGGGTAAAAATTTTATAAAGGTATACTCAAGTTTGCAGAACCTCAGGTTAGCGGA +AATTAACGTTCGTTTCGTGAGGGTCAGAAGTTTAATAAGTTATTGATAAAGCGTTATTTTTTAGACACAG +GCGTGCAGGGTTCCTAATGTACCGTGTGGAGTTGAAACCCAGTCAGATTGAAGTTATCGTCAACTTCAAA +ATACGGTTCCTAATGTACCGTGTGGAGTTGAAACCTTGCTTTATCAGAGAATAGTATTCTTTCTATGTCT +TCATAGTTTGTTCCTAATGTACCGTGTGGAGTTGAAACCTCTTGATAGTATCTGTTTTCCGCGTATTCCA +CGATTCTTTTGTTCCTAATGTACCGTAGTGGAGTTGAAACTTCGGTGATAAAGGAGCATTTTTCACAAAA +GAAATCAGTTTCTAATGTACCGTGTGGATAAAAATGATTATTTGTGTTTAAAATTCTTTAGAAATGCTTA +CCGTGGGTATCCTCGGAGGTGGACAGCTCGGATGGATGACTATACTGGAAGGGAGAAAACTCGGGTTTAA +ATTTCACGTCCTTGAAGACAAAGAAAACGCTCCTGCCTGCAGGGTTGCTGACAGGTGTTTCAGAACAGGA +CAAATAAGTGAATTCGTAGACTCCTGTGACATTATTACTTACGAATTTGAACACATTAAAGATGAAGTTT +TGGAAAAGTGCGAGAGTAAATTAATTCCCAACCCTCAAGCTCTTTACGTTAAAAAAAGCAGAATCAGGGA +AAAGCTTTTTCTGAAAAAGCACGGTTTTCCCGTGCCGGAGTTTTTAGTAATCAAAAGGGACGAGATAATA +GATGCTTTAAAGAGTTTTAAACTTCCTGTGGTGATAAAGGCGGAAAAGCTTGGCTACGACGGAAAAGGAC +AGTACAGGATAAAAAAACTCGAGGATGCAAACCAGGTTGTCAAAAACCACGACAAAGAAGAAAGTTTCAT +AATTGAGGAATTCGTAAAGTTTGAAGCGGAAATTTCCTGTATAGGTGTAAGGGACAGGGAAGGTAAAACG +TACTTTTACCCTCAGCCATTCAATAAACACGAAGAGGGTATACTTATTTACAACTACGTGCCCTATGCAA +AGTTAAAAGAAGCTGAAGAAATAACTAAGAGGCTAATGGAGCTTTTAGATATAGTGGGTGTGTTCACGGT +TGAATTTTTCCTGCTAAAAGACGGGAGAGTTTTAATAAACGAATTTGCTCCGAGGGTTCACAACACGGGA +CACTGGACCTTGGATGGAGCGTACACCTCCCAGTTTGAAAACCTCCTTAGGGCTATAACGGAAATGCCTC +TTGGTTCTACGGAGTTAAAACTACCGAGCGGTATGGTGAATATACTCGGGAAATCTTATGAGGAAATCCC +TCTGAAAGAAATCCTTTCCGTTGAAGGTGCAAAACTATACTGGTATGGCAAAGAGAAGAAACCAAGAAGG +AAGGTAGGACACGTTAACGTGGTGGGAAGGTCAAAGGAAGAAGTAGTTGAAAAAGTAGAAAGAGTCTTCA +CACTTCTCAAAGGCTCAAGAGAAAAACTCCCAGCACCATGATTATACTCGCCTTAAAAGCGTTCTTAACT +TTTTCGCCGAAGAAGACCTTTCCGTAAAGGACGTCAAGGAGTATGGCCAGCCTTTCGGTGGCGGCAACAA +ATGAAGCGTAAGTGTAAATGTACGCCCACGTGTAGAATACCATCCCAAGGGAAAAGAACAGCCCTACAAT +TCCGAAGAACTTCCAGTCCGAAGAGAAGTCTTTAACCTCAAATCTCTTCACGAAAGGGATTAGAGCCAAG +CTCATGACGAGGCAGTAATACCACGAAAAGAAAAACTGGTTACTGCTGACAACTGCAATTTTCCCTATTA +CGACGTTCACGCCGAATAAGAAGGAAGAAAACAGGGCGTAAAGGACCCCTTTATTTAAGGTAAAGAAACT +TTTAATGTTCTTTCCTGCGAGTAGTGTGGTTCCGTAAACTATGAGCAGTATTCCGAGCCAGTTTCTTAAG +GAAAGAACTTCTCCTAAAACTATCCAGCCTGCGAGGGCGGAAAAAGCGGGCATTGTGGCGTAAAAAGGCA +TCGCAAGGGATAGGGGTGCGTACTTTAAAGACTTTATGAAGAAAATAGAGGCTAAAATTTCCGAGGGAAG +CCATAAAAAAGTGGTTTTAATCACGGTTTCGTTCAAATCCCAGTAAACTAAACCGAAAGGCAACAGCAGC +AAAGCCCCGAGGGGAAATCTTATCCAGAGGACGAAGTTCTCTTCATAGCCTTTCAGAATGAGTTTTTTAT +TAAAAATGTCGTTGGTGGCCCAGAAGAAGGCAGAAAACAGAGAAAAGGTTATACCGAGTAGGTGATTGTA +TTCCATTAAGTGAGAGGTATTTTTTCGTAGTGTTTAAACTTCTGTTCCCATAAGTAGGAAATCTGAAGCA +GGGTAGTTTCGTCCCAGTGCTTTCCTATGAGCTGCCCGCCTACGGGAAGCCCGTCTTTCCATGCTATCGG +TATGGATATAGCGGGTAGTCCTGCGAGGTTTGCGGGAACGGTAAGTATGTCCGAGAGATACATCTCTATG +GGGTTTTCAAGTCTTTCACCGAACTTGAAAGGTAGCGTCGGCGTAGTGGGGGAAGCTATAACGTCAACTT +CCTCAAACGCCTTTAAGAAGTCATTCGTTATAAGTCTTCTAACTTTCTGAGCTTTGAGGTAGTAAGCGTC +GTAGTATCCCGCTGAAAGGGCAAAGGTACCGAGCATTATCCTCCTCTTTACCTCAGGTCCAAAGCCTTCG +TCCCTCGTCCTTGCGTACATCTCAAATATGTCTTTGTACTCCTTAGCCCTGTATCCGTATCTAACTCCGT +CGTATCTTGCGAGGTTTGAAGAAGCTTCAGAAGGAGCTATTATGTAGTAGGTGGGTATAGAGTACTTAAC +GTGGGGAAGGGAAACTTCCTTTATTTCAAAGCCTTCTTTCTCAAGCTCCTTTATAAAGTTTTCAAAGGCT +TCTTTTACCTGAGGCTGGAGCTCGTACTCAAAGAATTCCTTTGGAAGACCTATTTTCAGACCTTTTACTT +CCTTCTTTACCTCTTCGCTCCACTCGGGAACGGGGACTTTTGCGCTTGTGCTGTCCTTTTCGTCCCAACC +GCTTATTACCTCAAGCACGAGGGCTACGTCTTCCGTTCTCCTTCCGAACACTCCTATCTGGTCAAGGGAG +CTTGCAAACGCCACGAGCCCGTACCTTGAAACTCTCCCGTAAGTCGGCTTTATACCTATGACTCCGCAAA +AAGAGGCAGGCTGTCTAATGGAACCTCCCGTATCCGAGCCGAGGGACACCGGAGCAGACAGAACCGCAAC +GCTTGCCGCAGAACCTCCCGAAGAACCTCCCGGAACTCTTTCTAAATCCCAAGGGTTTTTAGTGGGAAAG +AAGGCGGAGTACTCCGTAGAGGAGCCCATGGCAAATTCGTCAAGGTTAGTCTTTCCTACAATAAGGGCTC +CTGCTTTTTTAAGTCTCTCTATTACGGTCGCATCATAGGGAGCTACAAAGTTCTCTAGTATCTTGGAAGC +ACAAGTCGTTTTCTCTCCTTCAACGAGTATGTTGTCCTTTACCGCAATTGGAATACCAAATAGGGGGAGC +TCCCTTTCTTTTAAGCTTTCCGCCTGCTTTAAAGCTTTTCCGTAGAGGGGTGTTATATAAGCCTTTACCT +TTTCTTCCGTTTGGTTGTATCTATCGTAAAAACTCTCTACTACTTCCTTCGGAGAAACTTCTCCTCTTTT +CAGGAGCTCCCTCAGTTCACTCAGGGACTTTTTCCAGAGCATAGGAGTATTCTATCACGCTTCCCCTATG +TCCTCCCTTTCTACCTGTATGTTCTCAGGGTTGTACATGTCAACACCGTAAGAAGGCATGTACGTTCCGC +TTTCCCTTTCTACTTCTTCCGCACACTTGGCGCAGTACCTTGTCCACGGAATAGCACAAAGTCTCGGTTC +GGGTATCTCCTCCCCGCACCTTTCGCATATACCGTAAGTGCCTTTCTCTATCTTCTCAAGGGCGTAATCT +ATCTCTCTCAAGGTAGCTATTTCAACGTTGGATAAGTTGTCGAGGAGTTCCTCCGTGTAGGTCATCTGTC +CTATGTCTTCCCAGTCCCTGGGTTCTTTTGATTCTTCCCCGAGTCTTTGCTGGGTTTCTTCTTTTTCTAA +ATACCTCTCCAGAATTTTAGCTTTCTCTTCAAGGAGCTTTTGCTTGCACTTTTCTAAGAGTTCTTTATTC +ATCTCCTCCTCCTTTCAATAAGGAAAAAAATATAATCTGAGCGAAACTTCATTTCAAAACTTTTTTCGTC +TTTATGTAGAAGATGTAAAGGTCAAGCTCTCCTAAGGAAAGACCGAGTTCTTTTGCCAGACTTTCCAGAG +CTTTTTCAGCCTCAAGATAAACTTTAGGTGTTATGCTCTTTACCTGCCTTAGAAGACCTTTTTCCATTAA +GAAACGGGATATGTGTCTGTCTATTATTGCAAGGTCCTTAAAGCCAATGTTCCTCAGAAAGTGGGAAGCT +TCCTTGTAACCGAAGCCTTTTATTTTGTAGGGTGACTTTGGATCCGCGAGCAACTCCCTAATAACCTTGG +AATTCTTTTCCTTCTCTATCAGGGACTTTACTTTTGGAAACTTTTCCCGTGCCTCCACGATTCTCTCTGC +CCTTTGTCCTGCGTACCTGTGCCCGAACTTCCTGAACACTTCTTCAAGCTCTTCCTTCGTCTTGTTTAAA +AAACCTTCCTCTCCTAAATGTGCCTGTATCTTTATACCGAGCGTGGCGGACGAGTTTGCGGTAAGGATAC +AGAAGGAGAGTTCCGAAAAGAGTCCGGCATCGTAATCTATGTCGAGAAAGGGTCTAAAATCGAAGTGTGT +CCATCCTTCCCTTCCCAGTCTTTCAAACTCTTCCATCCTCTGGTTTACGTACTTTTGAACCTCGGGTATT +ATCCTTTTTACTTCCTGAATCGCGTCCATAGGAGAGAAATTAAATCACTTTTCCCTTAAGTATTCCCGTG +AAAAGTACTTGATTATGTGAAGCTTTATCCTTGAAAATGCCTCTTCCAAGGCTTTTCTTCTGGGTAGTTC +CGCGAGAGAACCTGAAGGAAGAGAGTAGGGAACGGATGCGGAAAAGCTCTCCTCTCCCAAGCTTACACTC +AAGTAAAGGGTGTAAGAAGACACTCTCTGCCTTGCAGAAATCGTGGAGGGTACTTCCCTGTAATTTGCCC +TTACCTTTATCCTCAGCGTATTCTCCGTACACTTTACTTTAAAGCCTGCTTCAAGAACGTACTCTTCAAC +CTTTCTGATTATCGCCTGCTTTACGTAAGGGTCGTCGGTGTCAATCTCCGAAAAGTCCAAACACACCTCT +TTTGCAAACAAAAAGAAGGGGAGTAAAAGTATCAGGAACCGCAATTGAACTTCTCCCTCAGCTTTTGTTT +TACGTAAGGATGAACCATATTATCCAGATCTCCGCAGTAAGACGCCACGTCCCTCACGATCGTTGAGCTT +ATGTGTATGTACTCCTGTGAAGGCATCATGAACACCGTTTCCACTCCCGCGAGCTTGTAATTGGTGAGGG +CTATCTGAAGTTCGTACTCAAAATCCGTAAAGAGTCTCACTCCTCTAACTATTACGTTTATACCTTCCCT +CTTCATAAAGTCCACGAGGAGGCAGTCAAACATCTTGACCTCTACGTTTGGGATATCCTCCACCATTTTT +TCAAACATTTTCACTCTTTCCTCTGCGTCAAAGAGTAGGAACTTTCTCGGTTTTTTTGCAACCGCAACGA +CCACTTCGTCAAAAATCCGCGCACTTCTCTTTACTATGTCCAAGTGTCCGTAGTGTGGAGGATCAAAAGT +TCCTGGATACACTACTCTTTTACCCATATTGATAATACTGTATCACCGTATTTCCTCTCTTCGGGTGCGT +TAAAGTTCTTTTTCTTGTCGTGCTCAAGGATGAACACTCCACCCTCTTCCAGCTTATTTAGGGCAAGTTT +TATAAGTTCGTCGTACTTGTCGTAAATGTAAGGAGGGTCCGCAAATATCACGTGGGCTTTACCCTTCCAG +TTTCTCAAAAAAGAAAGGGCATCCCCGACAATTACCTTTCCCTTAGTTTTCTTCTTTATTTCGTTTGCAA +GTTTCCTGTTCTTTTCTACGAAAATGACCTTTGCACCCTCCTTTCCGCCTCCAGTCCAATCTGTCCCGTT +CCCGCAAAGAGATCAACAAAAGTAAGACCGCTTATGTCTCCGAGTATGTTAAAGATGGCGTTTTTAACGA +TGGATTTCGTCGGTCTGAGGTAATTTAAACTTTTTTTTTCACAATTGTTGTATTATACTTTTATTTTGCC +GAAGGAGGCAAAGTTATGCGACATGTAATTTTTGAGAAGCTTTTCAAAAACTTTTCAAGGGAGGATAGGA +AATGGCAAAGACCCTCGGACTGCATATCCTAGCGGACCTTTACGGTGTGGACGCGGATAAGATTGACCGC +GTCGAAGATATCAGAGAGCTCCTTGAAGGAGCTGTAAAGTACGCCAACCTCACCAAAATTTCCTCCCATT +ACTACCAGTTCCAGCCCCACGGTGCCACAGGAGTTGTACTCTTAGCGGAATCCCACATATCAATCCACAC +GTGGCCCGAACACGGACTCGCAACCGTAGACGTTTACACCTGCGGTGACCCCTCCAAAGCCTACAGGGCA +ATGGACTACATAATCACCCAGCTCAATCCCAAGAGGATTGACAAACAAGTTCATGAAAGGGGAATAGTTG +AAGAGGAAAGTAATCAGAGCGAGGCTGAAAAACTCCGAAGTATACTCCTTCAGGTTTAAACACCTCCTTC +TCCTCCCTTAAAATAAATCCCGATGAAAGTGCTCATAGTCTTTTACAAGGATCTGGAAAAAAATAAAGAG +GAAATTCTTAACTTAATGAAGAAAAATTACAAATTGATTAAGAGAAAGCTCGGGATAGATAACATTTACG +CCTCAATTACGGAAGAATTTTTAGAAATTTTTTATTTATTCCCAGAAATATGCTTAATAAATAACACAAG +GGGAACGCTGAACTTCGGTCTTTACAAAGGATTGAGGAAGTTAAAGGGAGACGACATACTCGTTGTAGAC +GCGGGGAAATCCTTTTCAGAGGGTAAATTCGAAAAAGTGCCTATGGGAGACCTTCCTTCAATACTCATGG +ATAAAGAAAAGTGGGCTGGACTTGCCTACATACCGATGAGGGAGATGTACTACTTTATAAGGAGTTTGGA +GGAAAACTTTGACAAGTGCATAACCGAGGCTTTTGAGACCTTAAAGAAATCTTATGGAATAAACTTTGTA +AAATCGTTTATAAGTTAACTTATGGTAGACGCTGATATTTTACTAATAGCATTCGTGGATACCATCGAGG +GGGTTAAGAACTTAATCGGTGAGAGGGGAGCAGGGGCAGTTTTGAGGGATGCGGGAAGACACAGCGGTCC +CAAACTGCTCGAAAGTCTGATAGGCAAGCTACCCGAAGAAGTCGATAAGGACACAGCGTTAAAAAGAACC +GCTGCAATACTGAAAGAACTCGGATTTGCGGATGAAATTAATTACGGAAACGGAAAGTTCATAATTAAGA +ACGACGTGTTTACGGAAGCGGTAAGGGAGGACGTGAACGTACAGACACCCGTCGTTTACTTCCTCGCAGG +ACTCGTGGAAGGGTTCGTCCAATTCATGTCCAACGATAAAGTAGTACTAAAACCCGTAAAAGCCGAAAAA +GGATACGTGGAGTTCGAAGTCAGTCCTTAACTTCCAAGAGGGCAATGCTCTCTATGTGGTAGGTTTGGGG +GAAGTTGTCTATAAGTTTTAGTCTTTTCAGTTCGTATCCGCCTTTAGTGAGTATTTTTAAATCCCTGGCA +AAGGTCGTAGGATTGCAGGATATATAAACTATTTTGTCGGGTTTATTCTTAAGAAGTAGGTCTCTTTCCT +CCCTCAGTAATCCGCTTCTCGGGGGGTCTACCACTACAAGGTTTATCACTTCCCCTATTCTCCTCTTGAG +GTGCTTAAAAGCTGTTGCCTCTTCGAAGATGACGTTATCCCTGTTGTTGATTTTTGCGTTATACTCGGCG +TCTTTTATAGCAGAAGGATTGGCATCCGCACCTTCTATGAAGTTGCCCTGCTCCGAGAGTGGTATGGTGA +AAAATCCCACCCCGCAGTGAAGGTCAAGTCCCTTTTTGTAACTTTCCGAAAAATCGAGAACTTCTTTCAA +AAAGTCTTCCCAGAGCGTGTAATTTACCTGAAAGAAGCTGTCGTTACTCACCCTGTACTGCCACTTTCCC +ACATCCATAAATATGTGTTCCCTACCCACCTTATACCTTTTTACGAGAGAATTCCCAACCTTTCCGTAAT +CGCCTATCCCAACAACCCACTCAGGTAGAACATTTTCAAGTATATTCTGGAGTAATTTCTCATCTGTATG +GGTTATAGTTACGAACTTTAGAGTTGCTTCATCCCTTGTAGGGGAGTAATTCACGTGAACCTCTTGAAGG +TCTTTGATAACTTTCAATACTTCTCTGATGTGTGGTATTAACTCGTTTATCCTCTCGTGGGCAAGAAGGC +ATTCCTCAACGTCCACAACTTCCTTTACGTCCCACCTGTAAAACCCAACTCTGTTTTCCTGAATTTTGAA +CTGTACTCTTACTCTGTAATTGAACTCCTTCTTTGAAGGGATTTCTCCCTCGTATGGAACCTCCTTTATC +TTCCCAATTCTTTCTAGACTCTCAAGGAGTATGTCTTTCTTTGAACGGAGCTGTTCCTCGTAGTTTAAGT +GCTGTATTTGACACCCTCCGCACTCACCGTAATAGGGACAGGGAGCCTTTCTTCTTGCGGGAGAGGATAT +AAGTACTTTAGTGACTACGGCTTCCGTATAATCCTTTTTCTCCTTTACTACTTTTGCCTCTACCAGTTCT +TTGGGAGACGCAAAGCGGACAAAAACTGCCTTACCGTTTAATCTGGAAAAACCGTAACCGCCGTAAACGA +GTTTTTCTACAGTGAGTTTAAGAGGTTTGTCCTTCATCTTCTTTCTTTCTCAATTCTTCAAGCTTCTCAA +AGTCCTTAGTTGAGAGCACGTCTATGTGCCAGCCTGTTAGCTTAGAAGCCAGCTTTACGTTGATGCCTTT +CTTACCTATAGCCAAGGAAAGTTCTTCCTCGGGAACGGCAACTTCTGCCCTCTTCTCGTAAGGGAAAAGT +TTTATCTTTTCTGGATGTGCGGGAGCAAGTGCCCGCTTTATTAATTCCGCTATATCGTCGCTCCACCTTA +TCACGTCTATCTTTTCACCACCCAGCTCTTCGGATACCTTTTGAATTCTCATTCCCTTTAAACCAACGAC +TATACCAACAGGATCCATCTTCATTTCCTTTGCTTCCACAGCCACCTTAGCCCTTTCTCCGGGAATTCTC +GCAACTGCCTTTATCTCAACTAATCCCTCCTTTATTTCGGGAACTTCCTGCTCAAGTAGTTTTCTCAAAA +AGTTAGGGTGCGTTCTTGAGAGTATTAAAACCGGCTCCCCTCTGCGCTTTCTCACCTCAAGTAAAAGAGC +CTTTACCTTATCTCCCGTTTTAAAGTTATCCGTGGGGAGTTGTTCCCGTTTCGGGAGTATAGCGTCTATC +CTTCCCAGATCAACTATAACGTCCCCATTTTCGAGAACTTTTCTTACTATCCCGTAAACTATTTCCCCTT +CAAGTTCCTTAAACTCAAGGTATCCCCTTTCCTGTTCCGCCCTTTCAAGTTCTTTGTAAAACTCTTCCTT +TGCCGCATAAGCTGCCAATCTATTCAGATCCTCAGGGGATATATCTAAAGGAAACTTAAATTTCTTGTTC +CCTTTTCTCCTTACTACGTATACCTTGATACCTTCATCGGTAAACTCAACTTCCAGTTCGTCCCTGATTT +TCTTCTCTTTCCTTATGGCTGTGATTATCGCGTTTTTTAGTGCACGCTCCACAACTCTTTCCGGAAGGTC +GTGTTCCGTTGCTACCTGCTCTATCAATTTTTGGAGCTGTGCCTTTACCATCCTTCAATCTCCAGTCTTC +CCTTAGCTATAGCGGAAAAGGGTATGTGTAAAACCTTGCCCTTCTCCTTTTCGCGAATATCTATTATACC +GTTTTTAACGTCCTCTATATAGCCGACTACTTCCCTTTTACCCTCTATGGGTTCTTTAAGGATGAGTTTA +ACGAGCCTTCCCTTGAAAAAGTCGTAGTGTTCTACCTTGGTAAGGGGTCTCGTGAGTCCCGGAGAAGTTA +TTTCGAGAAGGTAAGAGAAGGGTATTATATCCTCCACGTCAAGCAGAGCACTTACCTTTCTGCTAATCTC +TTCACAGTCCTTTATAGTTATGCCTCCTTCTTTATCAGCAATAATCCTGAGAACCCAACCTCTACCCTCG +GGCTTGAACTCAACGTCGAAGAGCTTAAACCCCATACCTCTGATAACAGGCTCTACTATTTCCTTAACCT +TTTTCTCTATTTCCTCTCTATTTATTTCCATACTATTTATTTTGTATTAATAAGAATAATAATAGGCGGC +TATTTTCATGTGACAAATTTCAAAACCCATTGATTTTCAAGCTTTTCCCGAAAAACTTTCCACAACTTTT +CCACATGAACAACTTAAGTTATTTATAATTCGTAAGTTTTAAGTCACCGGATTGTTTCGTAGTATGAATA +ACTTAAGAAGTTTTCCACATTTATCCACATTTTTAACGTAAGTAGTTTATACACCGTGGTTTTCTTTTGA +GTAGATTGTGTCGTTATATGAACAACTTATGAGTTTTCCACAATTCTCCACATGTGAAAAGTGAGTTATC +CACATACCGAATAAAAAGTTTCATTGTACGAATAACTTACGAAAAATTTAAAGGATTCTATGAATACATT +GATTTTCAGGCAGGAGATTGTTTTGTGGAAAATTTGTGTGAAAATATGTGGAAAGATTGTGGATAATTTG +TGGAAAAAATGTGGAAAGAAGGAGAAGAAAAGCCTTGATTTTCACAGAGTTCTCAGGGGGTATGTGTTGG +AATGCTTTAAGGTGATATTTCTACCCTCCCATTATCGTCGTAAATGTACAGCTTTCCTTCCTCTTCGTCT +TTAGTCCTCTTGTGAGAACCGTCGCAGAAGGGGAACTTTTTTGAAAGTCCGCACTGGCATATGTAGTAAG +TTTCTTCTCCCGCCTCCAGCTTGTAAGGCCCTTTTTCTGTGAACTTAACTAATCTTGCCATGGCTCACAC +CTCCTTTATTGAAGATTTTTAAAAACTAAAAAATAGTGGTAGGGATATACGTCAAGGTCTTCTTCAAGGA +CAAAGCCGTTATCTTCCATAATCTCTATTGCTTTTTCTTTCGGTATCCTTTCCTCCAGAGGAGGTCCTGC +AGGTGAGGGAAGGGGATGCCAGTCTATAACCACTATCTTTGCCGCAGGTTTGGAAATCCTCTTTACTTCA +GATAAAAACTCTTTCGGCTTTATCAGTTCGTGAATAAGATTAGCCATCAGGACTCCGTCGGCGATCTCAT +CGGGTAGAGGTATCCTGTCCTCCTCACACTTCACAAATTCTATGTTCTCTATTCCTTCCTCTCTTGCCCT +CATTTCACAGACTTCAAGCATTTTTTCTTCGAGGTCAACCGCGTAAACCTTCTTAACCCTCTTGGCGAGC +GGGAGGGTAAAGTAACCGGGACCACAACCAAGATCTACCCAGACTTCATTCTCCGAAGGATTTACAGCCT +TTAAAAATACTTCTACACTCTGCCACTCAGACCTTTCTGGGTTCAGAAGAACTTCCCAGTTCTCTGCAGG +GAACTTAAAAGCCATCAGCCTTCCTCCGACGTGTTATAGAGAAAGCCTATCACATCGCCCTTAACTATCC +CGGGTCCGGGGAGCCTATTCCATACCTGAGGTAGAACGAGAGGTATTGAGAAGAGCGTTGCGTCTACCTG +ATGATGGAAAACCCACTTCATATCCTTTATACCCGGAAAGAGACCGAAGAGTCCAAACCATTTGGCGTAA +ACTTCATCCAGAATTACCATAGCCCAGCCACCCGTTTAAGAGGCAAAGAGAAAATTGCCCATCTCCTTGT +ACGCTTTAGGAAATTTAAGGATATACAGAAATCCTGTCAAGAACTGAATTTTTTGTAATATACTATCCTT +ATGGAAACTAAGAGTTCTCCTGTGATACTCAACGGTAAGGAGTACTACTGTCCCGTTGAGCTAGTCATAG +ATCTTATAAGCGGTAAGTGGAAGCTATTAATACTGAAAGAGCTTATGTCCGGCACTAAGAGGTTCTCTCA +ACTTCAAAGAGCTATACCCGGAATCACCCAAAAAAAAAATGCTTACCAAACAATTGAGAGAACTGGAAAA +AGCGGGTCTTGTTCGTAGAAAAGTCTATCCGGAAATTCCGCCGAGAGTGGAATATAGTTTAACAGAGCTC +GGTAAAAGTCTTGAAGAAATATTCAACGCCATGCACCGTTGGGGTGAAAGGTATATGAAGAGTATGAAAA +ACGAAACAAAGGAATTATAATTATTTATCTGGTAGGAAGGGTGGCCGAGCGGTCGAAGGCGCGGCGCTGG +AAACGCCGTGTACCCCGTTTGGGGTACCGAGGGTTCGAATCCCTCCCCTTCCGCCATTCCCGCTATGAAA +ATCAGGATTGGAACTAGGAAGAGTAAACTCGCCCTGTGGCAGGCGAATTACGTAAAAGATTTCTTAGAAA +AACACTGGGGTGTTGAAGTAGAACTCGTAAAGATAACAACAACGGGAGACAAAATTACCGATGTTCCCCT +TGCAAAAATAGGAGGAAAAGGACTTTTTGTTAAGGAGATAGAAAAAGCGTTGCTCGAGGGTAGTATAGAC +CTTGCGGTCCACTCCTTGAAGGACGTCCCTATGGTTATACCCAAAGGTCTGAAACTCGGAGCTATAACAA +AGAGGGAAAACCCCTACGACGTTTTAATATCGCGAAGCGGAAAGAAACTTTATGAACTTCCCTCGGGTTC +TGTTATAGGTACTTCTTCTCTAAGGAGACAGGTTCAGATAAAGAAAAGGAGAAGGGATTTAAAGGTAGAA +GTCCTAAGGGGAAACGTGGACACTAGAATGAGGAAACTGAAGGAAGGACTCTACGACGCAGTAATCCTAG +CATACGCAGGTGTAAAGAGGATGGGTTACGAAAGTGAGATAACGGAAGTGCTTGAAGACTTCATCCCTGC +GGTAGGACAGGGCTCTCTCGCAATAGAAATCAGAGAAGGAGATAAAAGGATAGAGGAGTTAATAAAACCT +CTAAACAACGAGGAGAGTTTTCTCTGCGCAATTGCGGAAAGGACGTTCTTAAGGAGGCTTGAGGGAGGAT +GTCAGGTTCCCGTGGGAGCCTTTGCTAAGATAGAAAACGGAACTCTTAAGATGAAAGCCTTTATATCTGA +CATTGAGGCTGAAAGGTATATAGAAGGGTATAGAGAAGGAAATCCCGAGGAGGCAGAAAAACTGGGACTT +TCACTTGCAGAAGAACTCTTGAAAAAAGGCGGGGAGGAAATATTGAAGGAAATATACTCTTCCCAATGAG +GTTTTTAGGCTTTGGAATTTTCTCTCCCGAAGAGAATATGAAAATAGACGAAGAATTACAGATTAAACTT +GAAAATGGAGAAATTGAACCCTGTTTTCGCCTTTATAAATGGAAAGGAGTATGCGTAAGTCTCGGGAGAA +ATCAGGAAGAAAAGGAATTTCCAGTAAAAGTAGTGAGGAGACCGACGGGTGGGGGAGCACTTTTACACGG +CTGGGATTTGAGTTTTTGTATAGTGGACTACAAAAATGGGAGAAATTTTATGAGATTTTACAGGGAAGTA +TCAAAAATGTTTTACAATATATTTAAAGAATTCGGTGTAAATTTAAAGTTTGAAAGGAATAAATCTTATA +GTCTTCAAACCTATTACTGTTACTTTTTCCCAACTTTTGGGGAGCTTAAAACCGAAGAGGGAAAGAAGGT +AGTGGCTATTGCTATGAGGGAATTGAAAAACACATTTTTACTTCACGGAAGTGTTTACGTGGATTTTGAT +TACAATTATGCCTCGAAGATATTAAATGTCAAGGAAGAAGAACTCAGGAAAAGAGTTACTACGCTTAAAG +AGTTAGGAATATCCGAAGAGGACTTTAAAACACTACTCTGTTCTTACCTGTCCTCTTTGCGAGGTAGAGC +TTTTCATCCGCACACTTGATGTATTCTTCTGGAGATTTTAAGCCGTTGTATACATCCGAGCACACGCCCA +CGCTTATCGTTACCCTTATCTCCTTTCCCTGCCAGCATATAGGAGTATTTTCCACTTCTTTTCTGATTTT +TTCTAAAATCCTCACTGCATCCTTTAATTCCGTCGAAGGCATGAGTATTAAAAATTCTTCACCGCCGTAC +CTGAATACGTAATCGGATCTTCTAAGGTTCTTCTTAATAATCTTTGCCACTTCTTTTAAAACCTTATCTC +CAAATAAGTGCCCGTATGTGTCGTTTATCTTTTTGAAGTTATCTATATCAACCATCGCTATTGAGAAGGG +GGTCTCTGTGTATAGAGAAAGTTCTAGGACGTCTCTCAGTATGTAGGGTAAAACTCTTCTGTTTAGGAGA +CCCGTAAGCGGGTCAACTTTTAGCGCTTTTGAGAAAGACCTTATCTGCTTCAGTGAAAGAAGGGAAATTG +CCCTGTAAACGTTTTTCATGTACTCGGAGTAGTAAAGAAGTGCATTTATGAAGTCTTCTTTTTCCACGTT +TTCTATTAATTTTGCCTTTAAGTCCTTCAGAAGGTTTAACGTATCCCTCAAAACTTTCTTGTATCTAATT +CTTTTTCCTGATAAGGAAATATACGCATCCCTTTTTTCAAGATTTGTCAAATCGTTTAAGCGGTTCCTGA +TTTTCTTTAAGAACTTGAGTTCCCTTCTGAGGAACTTGATATCCTCCTTTTTCTCCGATACCCTTTCGAG +TTCTCTGATAAGAATATTACTAAGTATGTTTATGTCCTTTGAAATTTCCAGCTCGAGGAATTCCTTGGAA +ATCTCGTTCAGAATCTCCAGAGCTTCTCTCTCGTCTTTTTCTTTCAGTTTCTTCCAGATGTCGTAAAGGG +TACTTCTCTCGAGTTTCCACCTGAGTTCGTCCGTTAAGATGTCGTAATACTTCCTCTCCATTTATTTTCC +CTACTTTAAATATAATCATTATCAGGAGTAATCTTATGGATGTATTATGATAAAAATCAATAAGTAATTA +ATTACTTTCATAGAGGTAAAAAAGGATGTTTTACGTGTCTAAGGTGACGCCCTTCTTTTTTGCTCTTGCC +TTGTTGAATTTATTAATTTCTCTATTCATAAGACTCTCTCAGGATACTTCCCTTTTCTTCGTGAGCCTCG +TCTTCGGATTTGTAGGACTAACCTTAATGGGAGCTATGTACCAGATAATCCCGAATTCCCAAAACAGAAA +ACTTTCAATACCCAAAGTCTCTTATCTCGTTTTCTTCCTTATTCTCGTTTCCTTCTACGAGTTTTACACG +GGCAATACGGAAAGCGGTTCCCTTTTCCTGTTTCTGGGAAGTTTAATCTTTTTCTTTCACCTGCTTTTAA +ACGTTAAAAACTTCTATCCCTTAACCGTAAGGTTTTTACTCGCCTCTATGATTTACCTGGTTCTTTCAGC +CCTTTTCCTTTACCTGCATTTTAAAGGCTTTTTACCCGTTCAACTCTCCGTTCATACCCTAACCGTAGGT +TCTATGCTGAACGCCATTTACGGGGTGGAACTTGCCTGGATACCTATGCTCATTATGGAAACTCTGAACA +TAAGAAAGGGAGAAAAACTCTTTACGGCAAAACAGGTGAGCACTTTAGCTCTACTTCTCGCCTTCTGGAG +TATGAATTACAAATTAATCGCTTTAGCGGGACTCTTGGAGTTTGGTGTAGCGCTTTACTTTCTTTATCTG +AATTACGAGCTATTCAAGAGGAAAAGAATGCCGACACCTCCTCCAAACGTTGTGAAGATATTCCTATTTG +CCCTCTTATTCCTGCCTTTGGGAATGCTTCTGGGTATCTTTTCCGCATCGCACGCTCAAGCCCTTCCTTT +TTCTTTACGTTTGCACCTTGACTTAATCCTTTACGGTTTCGGAGCCTTTACTATTTTCGGGGGAATGCTT +CACCTCCTTCCGAGGATAGTCTGGAACTGGAAGGTTCAGGAAAAGGAAAACCCAGGGTTTACCATGGGCG +ATCTGGTGAACGAAAGGGAATTACAAACTTTCTTGGAATACTCAGCCCTCCTTTACGCCTTATTTTTGGC +TGTTGATTCCCTTTTTTCTCCGCTTCACGTCATTTCCACAGTAGTTTACCTCGTGATAATGGCTCTATTC +CTGAAGGAAATACACAAGGCTTTCCTTTACATCTTTAAGTGATTTCCCTCCCTATTTTACTTATTTCATG +AGCATAAAATAATTTTATGGAGGTTATTAGATACTTTCGGGTTTACGCAAGAGAAAAGTTCGGCACAATG +GTCTGGATAACTCACAAATGGAAAAAGTAAATTATGAGTTACATTATATTATTATGATATTTTCTGATAC +AGTCAGGTACGCTCTTATAGCCTTGGCTTACTTGGCCTTGAACAGGGACAGGTTAGTAAAGGTTGAAGAG +ATAGCAAAAGTGCACAAGATACCACGTCCCTTTCTTGCAAAGGTCATGCACGAGCTCTCGAAAAGGGGAG +TTGTTTACTCGGTAAAGGGACCAAGGGGCGGCTTTTCACTTGCAAAGGAACCTGACAAAATCACTATATG +GGACATTATAGAACTCTTCGGGGATGCGTATAAATACGAGATGTGCTTGCTCATGCCTCACAAGTGTAGT +GAGTTTGCCGATAACCCGTGCATAGTCCACCACAAGTGGGAAGAACTAAAGTCACAAATACAGGACTTCT +TTAAGGGGACAACTATCAAGGATCTCATCAACATAGAAGAAAAGCACCTTTTCCCCGTTTCCCGTTAAAA +AGTATAGAATCAGGAGTTTACTCTTCCTTATACTCCGCCTTAGATGTAGCCGTTTCCCAGAGAACTACCT +TAACTACCTTTACCTCCCCCAGTAGTCCCGCTTCTTCAAGTCTTTTCTTAAGAAAGTCATAAAAGAACTT +TGCAAGGGCTTCAGCGGTGGGACAAAACTCCACTGGAAATATCTTCATTGCTCCGTACTTTTCTGCAACA +TCTTTTAATTCAGGGTACATAGGGTCGTTTACGTCTATGATAAAACTGTGGTCTATCTCCTCTATTAAAC +CCTTGAGGGCGTTCTTTACGTGGTAAAAGTCCATTACCATGTCCTGCTCGCTTAAGGTGTCAGAACCCAC +AGTAACTTCCAGCACATAACTGTGGCCGTGGAGGTTTACGCATTTGTTAACAGGTTTTTCCTTCGTAAAT +TGAGCACCTCTTCCATATGTGAGGTTCTGCTTCCACACCCTGTGTCCCGCTTCAAACCTGAAGGTTTTGC +TTATTTCCCACTTCATGATATCTTAAAAAGATTATAAGGAGGTTTCGTATTGTTTCCCGAAGTTATATCA +GTTTTCGGACTGAAAATCAGCCTCTACGGAATTTTAGTAGCCTTGGGCGTTCTGGTGGGATACTTCTTAG +TTCTAAAGCTAGCAAAAAGGGAAGGTCTCAATACCAAAGCGGTTGAAAACACCTTCATGATAGCGGTTCT +CTTTGGAGTTATCGGAGCAAGAATTGCGTACATATTAGAGCACCCCTACGAGTTTCACTCCTTAGTGGAC +TTCCTCGCCTTGTGGAAGGGTGGCGTTTCCTTTTACGGAGGACTTATCGGTGGAATAATCGGGGCTTTAA +TAGGAATTAAGGTATTTAACCTACCTCTCTGGAAATCCGCGGACATAGCCGCTCCCGCGATAGCCTTGGC +ACACTTTTTCGGAAGGCTCGGGTGCACTTCCGCCGGTTGTTGCTACGGAAAACCCTTTCCTTACGCCACG +AGCAACGAAGTAGGCATTCACTTTTCGGATAAATTTCCCTTCTTTTACGTAGTTTTCCCGAAAGGTGCGG +TAGCACCTCCCTTTACTCCACTCTACCCAACCCAGCTCATGGAAGCCTTCGGGAACCTTCTTATTTTCTT +CGTCCTGCTTTTTGCCTACAGATACAAACCCTTCAGCGGTTTCGTGTTTTCCCTGTACCTTATGCTCTAC +GGATTTGAAAGGTTTTTCTTAGAATTCTTCAGGGGAGTAACCCCTCCCATTCCGGGCATAGGGCTTACGT +GGAATCAGGTCGTTTCACTTGTATTAATCGCAGGCTCTATACTTCTTATGTTCCTCCTCAAGAACCAGAA +AAGTAATGTGGTAGACTATGAAGTATGAAAATAGCTTTCTTGAGACCCGGTAAAATAGGCACTCCCGCGA +ACCATGTTTACGCACTCCTTGATTACTTAAGGGAAAAGGGTGCGGAAATAAGAGAGTACGACCTGAAAGA +AAGAGACGTTAACGATGTTGTAAAAGAAATTGAAGAGTGGAAGCCTCTATTCTTGATGGACGTAAACGCC +ACGGGTGTGATAGTTGCTGAAAGGGATGGTAAGAAGCACATACTTGCGGATATCCTCGGTATAGTGCACG +TGAGTGTGTTTTTCGAAGACCCTCTTCTCTTCTTCCCGGCCTTTGAAGGAGTGGAAAAGCCCCAGAACTA +CATAGCGTTTATAACCGAGTTAAAACACACGGACAGTTTAACAGCCCTCGGTATACAGAACATAAGCTAC +ATATCACCATTCGTGGATTTAAAACAATTTCCCGAATCCGAAGGGGAGAAGGATATAGAAATAGCTTTCG +TGGGACCGGTTGTTGATCCCCAGATAATACTAAACTCCGTTTCCCAGAACTACCCTCAGGAGATTATGCC +CTTCTTTATTGAAACCGGAGAGTTTATGTTCAGAAACCCTGAAGTTCACATCCTGACTGCGTTTAATTAC +GTCTTCGGGCTCTTTAATCCCCAGATGCAGGAACAGTTCAACAAGTGGAGAGAACAGAATCCCTCAGCTT +TCATGAGGTTTCTAAACGACATAACCGCTTACACCACTATGAGGAGAAGGATGTACCTCCTTCACTTTTT +AGACGGTATGGATGTAAAGATCCTCGGTGATTATCAGGGCAACCTCTTTGAAAACCACGAAGCCATAAAG +GTAAGTTCCTACGAGCAACTCCTTAAGTACTACTCACGTTCAAACATAACCGTTTACGTGTCGCCTCAAA +CCTATCCAACGGGACTCAGCGTTATTCCCTTAGAAATCCTGTACATGGGAAGCCTTCCCTTAATAGACTT +CAAAGGGGCTATCCCAGGCTTTTTAAAACCCGGTGAGGAGATAGAAACCTTTGCACCTCTCGACAGGGCT +GATCTAGAAGAGAAAATCGTTTTCTACATAGAGGAGAACAGGGAAGGTATAAACGAAATAGTTCAAAGGG +GTAAGAAGGCGGTTCAGGAAAGGTTCACCGTAAAAGACAGAGGGGAGTTCGTATACAACGTACTTTCGGA +TGTTAAGAGACAGTACGAAGCGGCGCAAAAGGGACAGGTCAATTAAATTTCTTTAAGAATTCCTTTATAA +ACTTAAGGTTTTCCCTTTTTATCCCTTCCCTCTTTAATAACTCTTCTTCGTTTTCTATCAATTCCGTGGC +TTTCTCCAGAGCTTTGTGAGGTTTGTCTTCAGGTTTGAGAATTCCTAAGGAGTAAAATCCGTAAAGAACC +TTTACAGCGTCTTCCATAATCCCTTCCATCATGGAGTCAAAGTTGTACTTCCTGTAAACTTCCTTTCTCC +TTTCCTGAGGCAGTTTTAAAAGTTCTCTCGCAAAGGCAAATATCTTTACCCATGTTTTTAAGGTGTTTTC +CCACTCTTCTTTAGGTAGTCCTTCGAGTTCTATGTTTATGAAATTCAAGGTGTACTTTGCCACGTACTCC +TTTGCCTCTTCTAAGCTCCTGAAGGGAAGTTCATCTCTCTTTAAAAAGGTGCTCAAATCAAGCTTCACCT +TTCTCCTCCTTTATTTAAGATAAGTGTAACTCTTACATACTGATATAATCTTCTAAAAACTTTAAAGGAG +GTAGCGGAGTGTTTGAGTTTTCGGACAGGTTAAAGGTTCTCCCGCCTTACCTTTTTGCAGAACTCGATAG +GAAGAAACAGGAGAAGATAGAACAGGGTGTGGACGTTATAGACCTCGGTGTGGGAGACCCGGACATGCCC +ACACCAAAACCCATAGTTGAAGCTGCAAAAAAAGCCTTAGAAAATCCTGAAAATCACAAGTACCCTTCTT +ACGTAGGGAAGTACGAGTTCAGGAAGGCGGTTGCAGACTGGTACAAGAGAAGGTTTGACGTTGATCTTGA +TCCAAACACCGAAGTTATAACCCTTATCGGTTCAAAGGAAGGGATAGCACACTTTCCCTTAGCCTTCGTA +AATCCCGGAGACATAGTTCTCTGTCCAGACCCTGCGTATCCCGTTTACAGAATTGGAGCAATATTTGCCG +GAGGAACTCCATACACGGTTCCCTTAAAAGAAGAGAACAACTTCCTCCCCGACCTTGATTCAATTCCAGA +AGACGTGGCGAAAAAGGCAAAGATTATATGGATTAATTACCCTAATAACCCCACTTCCGCACCACCTACC +CTTGAGTTTTACAAAAAACTCGTTGACTGGGCTAAGGAGTACAACGTTATAATAGCCTCCGACAACGCTT +ACTCCGAGATTTATACGGGACAGGAAAAGCCCCCTTCCATACTCCAAGTTCCCGGAGCCAAAGACGTAGC +CATAGAGTTTCACTCCCTCTCCAAAACTTACAATATGACGGGATGGCGTATAGGCATGGCTGTAGGGAAT +AAGGAACTCGTTGCGGGATTAGGAAAGGTAAAAACGAACGTGGACAGCGGTCAGTTCGGAGCTGTTCAGG +ATGCGGGAATAGTAGCCCTGAACCTGCCCGAAGAAGAGGTGGAAAAGATAAGGGACGTTTACAGGGAAAG +AAAGAAGATAATGACGGAAGCCCTTGAAAAGATAGGACTCGAGATTTACAGGAGCGATTACACCTTCTAC +CTCTGGATAAAAGTACCGGAAGGATACACTTCCGCAGAGTTCGTGGGAAGACTCATAGACGAGGCGGGTA +TAGTTTGCACCCCCGGAAACGGTTTCGGAGAGTACGGAGAGGGTTATTTTAGGATTTCCTTAACAGTTCC +CACCGAGAGACTCCTTGAGGCTGCGGAAAGAATTAAAAATTTAAAACTGTAATCTCCCTTTCTCCTTTTC +CTTTCTTTTAAGATTAAATCTTATGAACGCCTGTGAGAGGTTATCCCGCGTCCTTGAGAGAATTCAGAAA +GCCTGCGAGAGAGCGGGAAGGGGTGAGAACTGTGCGAAACTTCTAGGAGCTTCTAAGACCGTACCTCCAG +AAGTTATAAGGGAGTTTTATAACTGCGGACTGAAGGTTTACGGAGAAAACAGGGTTCAGGAGTTCCTCAA +AAAGTATGAAGCCCTAAAAGATTTAGACTTAGAGTGGCACTTCATAGGGAGACTCCAGACGAATAAAGTG +AAGTACCTTATGGGTAAAGTCGTCTTAATCCACTCCCTTGACAGGAAGAACCTCGCGGACGAAATACAAA +AAAGAGCCTTTAAAAACAACATAGTTCAGGACGTTTTAATAGAGGTAAACGTGGGAGGCGAAGAAACGAA +GGGAGGAGTAGAGCCCGAGAACTTAAAGGAACTCTTTGAGTACACTTTAGAACTTCCCAATGTAAAGGTT +CTCGGACTCATGACCATACCTCCGTATCTTGAAAATCCCGAAGATGTCAGACCTTACTTCAGAAAACTCA +GGGAACTGAGGGACGAGCTCCAAAGGGAGTACAACGTTGCACTTCCTCACCTCTCCATGGGAATGTCCCA +CGACTTTGAGGTTGCGATTGAAGAGGGTGCAACTATCGTGAGAATAGGCACTTTGCTCTTCGGGGAGAGG +AAGTATTGAAACTAAAGTACAAGATATGGTTTGAGATAGACGGAGAGCCCGTAATAACGAAGTTAAAGTA +TGAGCTTCTTAAAAATATAGAAAAGACAAAGTCAATAAAGAAGGCTTCAGAACTCCTTAACATCTCTTAC +AAAAAAGCCCTTGAACACATAAAGGCTATGGAAAAAAGACTGGGTAAAAAAATAGTCGTAAGGGAGAGGG +GAAAAGGGGCTTATTTGACAAAGGAAGGAAAAAAGTTAATGGAAATGTACGAGAGGGCAAAAAAGGAATT +TGAAAAAACCGCCCGTTTAATTGAGGAGAAGGAGGGCATTTGAGGCTGTTGAGACGTACCTGTGGGGGAG +TTTAATCCCTCCACTTTTCAGTTTTGGATTTTCGTTTATAGCCCTTTGAATGTCTTCTTCACTTATCTTT +AGTTCTTCTTTAGCCCTTTCGTACTCCTCAAAGGCTTTCATCTTTGCTTCGTAGAGCTTCATGAGAACTC +TGCTCTTTACGTTAGCCTCCGCGTCTCCGGAAGTTTCCACCGCAACGAAGAGACTGCCTCCGAGGTCTTC +TATCACTTTCGACTGAACACCGTCGCTCTGTGTGGAGGGCATGCAACCAAATGGTTTTACGGATATTACC +ATGTGGGCTTTTTTGTGTTTAATCATGTATATGTGTTTTCCTACTTCCATGTGCCCCTCACCGCCCGAAA +GCCTTACGTTGTAGTACCTGTTTGCGTACTGTGCGAGTTTTTTCTGGCTCTTTAATGGATCGGGTTTATT +CCCCAGTGCCAGCCTGTAGAAGTTGTAAAGTCCCCTGAAGTAAACGTTCAGGGCTTTTAACGCCAGTATC +GTCTTGAAAGCCTGCTTTCTATTTTTGAAAGCCTTTTCCTTAGTGTCGAGAATTTTTTCGTAAATCAGGT +ACTCAATCCACGTGGATACGGGCTCAACTATCGGTTCCGCTCCCTCCTCTATAAGCCACTTTGCCATTCT +GTAATTTCCGTCTCCTTCCGTAGTTTGTGCGAAGAACTCTCCCGTAATCTTTACCTTCGGTTTTGGCTGG +AAGTAGTAAACCTTAAGATTGTCAAGCTTTCTCTTAACTTCCCTTAGGGCTTTAAATAAACTCCTCCCGT +TTCTGAGTGCCTCGTAGAGTATGTTCAGGCTCTCCTCCTTCCACATATCCGCGGAATTGGGAACTTCTTC +GTACGGCTTTACTTTGTAGTAAACGTCGTTTATGAGGTCTCCGAGAATTACCGCCTTCATCAGACTCAAG +AAAAAGTCCTTGTCGAACTTAAGTTCGCTTTCTCCCATTTCCTTTAGTACAGCCTCACTCTGCTCGAAGG +TTATTACTTTGAAGTCTCTAAAACCTGCGTCTTTTAAGGCTTTCCTGTACTCCATTTCGTACATGCCGAA +CCTGCAGGGACCGCACGAGCCAGCTGTTACGAAGACGTACTTTTTCTCTATGTCTCTTTCGCCGCTTTCC +CTCTTTTCCATCAGGTACTTTACGAGGTTTCCAACGGTGTAGTAAGTGGGGTTACACTGTCCTTTATTAC +AGAACTCCTTCCCCACTTTAAGGGCTTCGTTATCGGGAGTTGGAAGGGGTTCAACGTCGTAGCCCAGCCT +CTCCATAGCCCCCTTTATTAAAAAGTCGTGAGCCTGAGTAAGTCCCCCGTAAAGTATCTTCATACCGCTA +CCTCCCTTCTTTTTAATACTTCCTCTTCGTACCTCTTCAAAAAGTAATCAATAGTCTCAACTCTTATCTT +TATAGAACCAGAAGGTTTGTTTTCGTCCAGCTCGTGAAAGGTAAAGTAGGGAGTGTTGGTTTCTTCTAAG +ATTTCCTCTATTAACGAGTATATGGGGGCGTCGTGCCCGCACCTGAAGGAAGATAGGTCAACTCCTGCAA +GGTTCGGGTGTCTTGCCGTGTACTTTGCCGCCCATACTTTCATGGAAGAATTTTCGCTGTAGCACTTCTT +CCAGACGTCCCTTATATCCATAGGGTGTTCTATCCTTCCCTCCAAAATGTCCCTCTCAAATATCCTGTAA +AGGATGTCCTCGTCCCTCGGAAGGCTCTCTATTGTAAAAATCGGGTAGCCCCTTTTGTTTATCTCGTCTA +AGATTTCGTGGTTTATCCCCGGGTCGTTGTGGTAGGGTCTTCCAAGGAGAACTACTCCAACCTTTCCTTC +CCTTTCCAGTCTCTCCAGAACTTCCCTTGCCCTTTCCCTTAAAGTTCTCCTGTACTCCTCAAGTGCCCTC +AGACCTTCCCTTACCGCCTCCCTGTTTTCCTCTTTCGTTATTCCGAATAAGGGATTAAATACTTTGTAGA +GTTGTCTCTCTAAGAGTTCCGTGTCTTCCAAATCCAGAACCGGGTCAAGGTATATCACTCCCCTTTCCCT +GAATTCGTCCCTTTCCTTTGTAAAACTAGCCTTCACGACTTCGGGTGTTGCCGAAACTGTGGGACACGCC +CAGTGCCCTTCAGCCTTGTATATCTCTCCCTGAAGTGTCCTTATACAGGGGAAAAAGATGATGTTCACTC +CTTTCTTTTCAAAAAGGAGGTTGTGAACGTGGGCTATTGCGACCTTTGAAGGGAAACACGGGTCTATTGA +TCCCCTCTTTGAGCCTCTTCTGTAGAGCTCTTCGCTCGTGAAGTCAGAAAAAACTACCTTTTTAACTCCG +AGGGCTTCGAAGTACGTCCTGAAGAAGGGAGCGTAAGAGTATACGTTCAAGACTCTCGGAATTCCGATTA +CCGCGTTCTTCAAGAATTCAAGTTTTTTCTTCCTGAAGAAGTTAATTATTCCATTTTCCTTTACCACTTT +TTTCGGTTTGTAGGACTTGAAGAGGAGTTTATTCGAAATCTCAACGAAGTTCGGGTACTTTTCCTGCAGG +GAACTCCTTTCTTTTAGGAGTTTTTTTAGCTCTTCCTTGCTCTCCACTTCCCCTTTATCGCACGTGGCTA +TTATGAACCTCTTTTTTTCTTCGTTTACCTTGAGATCTATGAAGGTTCTTATGCACAGGTTCTTACAAAA +GTGACAGCGGGTCTCCTCGCCCCTTATGGTTTCGTAATCAATCTTATCCAGGTTTTCAAAACCTATAAAG +TTCGTCATACTAATACTCCCTCCGCTTCTTTTACTCTCTTTGCTTCAAGGGCTGCACCTATTGCCCCTGC +TACGCTTCCCATGGGGTGAACGTAAACCTTTGCTTCTGGGACTTTAGACTTTATGTAATCCACCTGAGCT +TTTACCACCGCGAGGTTTTTATGGGTTCCTCCCTGAAGAACGAATACCTTTCCGAGCTTCCTCAAGTTCG +GCTCCTGCATTACGTAAAGCCAGACATTCAAGGGCAGAACCTTTGCGAGTCCTGCCATTATCTCTTCCGC +GGTCCATCCGAGTTGCTGGAAGTTAACTATGTCCGCCTCTAAAAATACAGCACAACCAAAGTTAAAGGAG +GGACAGTACTTGGCTTTAAAAGCCACGTCCGCATACTCTTCCACCCTGTATCCGAACCTGTTTGCGGTGG +ACTGGAGGTAATAACCGTTTCCAGCGGAACACTGGGTGTTCAGTCTAAAGTCTTTAACCTTTCCGTTCCT +GAGGATTATGACCTTTATATCTTGCCCGCCCACGTCGCATATCACTTCCGCGTCGGGGAAAAACTTAAGG +GCTCCGAGCGTGTGGGCTACCGTTTCAACTATTGCAACGTCTCCGCCGAAAGCCATCTTGAGAAGATCTT +TTGCGTATCCCGTAAAACCGACTCCTAGAACCTCTATATCAACTCCCTTTTCTTCCATTTCTCTCTTCAT +CTTCTTGAGAATCCCCTTTGTGTCTTCTATAGGGTTTCCTTCCGAGAGTTTGTAGGCCGTTGTAATCACC +TCTCCCTCTTCGTTTAAGAGGACTCCTTTTGTTGAAGTAGAGCCCCCGTCAACGCCTATGTAAACTCCTA +CCTTTTCTCCTGGGTACAGTGCCGGAGGGGTGAAGGGTTTGGATGTGTACTCCTTGAGGAATTCTTCGAG +CTCTTCTTTCGTCTTCCAAAGGGCTACCTGCCCGCTTTGAGCCTTTATCTTTTCCCTTTCTTCTAGGAAC +CTGTAAAGTGGAGATAGGTCTTTAACTACAAAGGAGTCCTTTTCCTCAAACTGAGAAAGGAGTGCACTCC +CGAAGGCAACGTAATACAGGGCATCTTCGGGAACGTATATGGGGTTTTCTTCTTTGACTTCAAAACCTCT +TTCTTCCCAGAGTTTCCTTATTTGATACTCCCACGCTTCCCTGAGAGCGGGGAAGTAGTTGTTCGGACCT +CCCAGTAATAGTACTTTTGGTCTTGGTGTGTATCCCCTCGTCAAAACGGTCAAGTTCTGGAGAACTATGG +CGTCAAAGAGGGAAATCATGAGCTCATCCTTGGGAACTCCGTTTTTCTGGAGGGAGTTGATGTCCGTTTC +TGCGAAAACTCCGCACTTTCCCGCAACCGGGTGGACTTTTTTAGGGTCGTACTTTACGTTTTTCACTTCT +TCGGGTTTCAGGTTCAGTTTCATTAGAATCCTGTCTATGGTTGCTCCCGTTCCCCCCGCACACTTGTCGT +TCATAGTTGCGAATTTCCTGACACCTTTCTCGTCCCTTATCCAGACAATGAACTTAGCGTCCTGTCCTCC +AAGTTCAAAAACGGAGCCCGCATCCTTGTGAAGGTGTTCCACCGCAAAGCTGAGGGCGTTAACTTCCTGT +ATGAACTTCCCGCCGAGGAGTTCCGCTACCTTCCTTCCGCCGCTTCCCGCCGTGAATAGTCTGAACTCCT +TTACACCGAGCTCTTCCCTTATCCTTTCCAGGAACTCTATAACTTTCTCTATTTGTTTTGTCCTGTGCCT +TTCGTAATTTTTCCAAACTATATTTTTGTTTTCGTCTATCACCACAGCCTTTACGGTGGTTGAGCCGACG +TCAAGACCTACCGTTAACATTCCATACCCCTCCCAGACAGAATTTCAGAAGTTCATCCGCAACTTTTTCT +GAATCAACTTCCTCTTGCAGATAAGAGACTTTATAACTTCCTTAACTCCTCCGAGGATTACCCGTGCTAC +TACCTCCGTGTCGTGAGGCTTTAAAATACCGAGTTTTATCCCCTTCTCGAGGGATCTTGAAATTAAATTA +ACTACGTCTTCAAAGAAACAGTCTATTATCTTCGCGTAATTGGGTTCGCAACTCCTGAAAAGGATTATTT +TCGCAAGTTCTCTGTTCTCAAGGGCGTAATCTATTACTCTCTTTACGTTTTCCTTTACCTGCTCTACAGG +GTCCCGGGATATATCAACGGGTTTTATACGTTCCTTCAAATCCTCAACGACTTTTTTGAGTATCTCTTCA +AAGACTTCTTCCTTGCTCTTGAAGTATATGTAAAAAGTTCCCCTCGCAACTCCCGCACTTTCCACTATGT +GAGAAATCTGGGTATTATAAAACCCCTTTTCCGCAAACTCCTTTGCAGCTGCTTTTATTATCCTCTCCCT +CGTCTGAACTGACATGTCATTCACCTCCTAATATGAGTATTATCACAAAAAGTTCTATGATATTAATCAC +AAAATCCTTTGCGCCAAAAACTTTCTTCTCATTAATGTCCATTCTACAAATCCCATAAAATCTTCCCTTA +TGAAAAGGGAAGACGTGCCTAAAGTTCTTGAAATTCTAAAAAGGGAATTTCCGAAATGGAATGCTCCCGT +AGTTCACATGATAGCCCAGCACGATAAAGATCCCTTCAGGGTTCTGGTGTGTGCACTGCTTTCTACGAGA +ACAAAGGACGAACTCACTTGGAGAGTTTGTAAAAGGTTTTTTGAAAAGGTAAAATCTCCCGAAGATCTTA +TAAAACTTTCCGAAAAAGAAATTGAAGAACTAATTTATCCTGTGGGTTTTTACAGGGTAAAGGCTAAACA +ATTAAAAGAGATTGGAAAAATCCTGATTGAGAAGTACGGCGGGAAAGTCCCGGATACACTGGAAGAACTT +CTGAAACTTCCGGGTGTGGGCAGAAAGGTGGCAAACCTCGTCCTTTCAAAGGGATTTAATAAACCTGCTA +TAGTCGTTGACGTTCACGTCCACAGGATAGTGAACAGGTGGTGTCTGGTGAAGACGAAAACACCTGAAGA +AACGGAGAGGAAATTAATGGAAATAGTTCCAAAAGAACTCTGGAGCGATATCAATTACCTTTTGGTTGCC +TTTGGGCAAACGATATGCCTTCCGAGAAAGCCGAAATGCGAGGAGTGCCCTGTAGAAAAGTACTGCGGAA +AGTGCCTTTAACTCTTTTCACCGCCTATTTCAAAGTCTTCGGGTTTAATATTTTCGAGCCACTCCCTTAA +CTTCTTCTTCTCTTCGTCCTCTTCGGGTTCCGGCAGTTTTGACTGTTCAAGGACATGTTCCGCCACGTAT +ATGGGAGCTCCGAACCTGAGGGCGAGGTTTATAGCGTCGCTCGGCCTTGAATCTATAACGAGTGTGTTGT +TCCCCTGATTTATGTAAATTTCCGCGTAGTAAGTGCTGTCTTTGAGGTCGTTTATTACAACCTTTTCAAC +GTTTCCGCCCATTTCCGTGATTATGTTTTTAAGGAGTTCGTAAGTCATGGGTCTCGGGGGTTCTACACCT +TGGAGTTTCATGGCTATGCCGTTTGCCTCAAAGGCTCCTATCCATATAGGGAGTATTAAGTTTTCGTCTT +CCTTTCCCTTTAAAACAACTATAGGCATCTGAGTCGTGGGATCAAGAGTAATTCCGTGAACTTCCATTTC +AACAAGTTCGCTCATTTTATCACCTCCAAAAGTTCGCCCTCTAAACTGAAGGGAGAAGACTTAATAACCT +TTATCTTCACTATCTTTCCTAAAAGTGAAGGGTCTCCCTTAAAGGAAGCCCACTTGTTCGTTGTTGTTCT +GCCTATAAGTTCACCGTTCTTCTCCTCTTCAACAAGGACTTCCTGAACCGTTCCTTCGTACTTTTTGGCT +ATTTCCGAGAGTATTGACTTTTGGAGTTCTAAGAGTCTCCTCATCCTTTCCGTTTTCACATCATCGGGAA +TCTGTCCCTCCATTTCCGCGGCGGGTGTTCCAGGTCTCGGAGAGAACTTGAAGGAGAACACCTGTTCAAA +CCTTACCTTTTTAAGGACGTCCAGTGTGTGTTCAAAATCCTCCTCAGTTTCCGTGGGAAATCCAACGATT +ACGTCCGTGGACATTGCGATGTCCTTAACTTTTTCCTTTAGTTTTTCTATCTTTTCAAGGTATTCCTCTT +TTGTGTATCCTCTGTCCATCAAGGCAAGAATCCTGTTTGAACCTGCTTGGAAGGGAAGGTGGAGTGCGTT +GCACACCTGCGGAATGTCTGCCATAGCCTCTATTATGTCGTCTGTGAGATCTCTCGGGTGTCCAGTAGTG +AACCTTATCCTCTCAACGCCGTCTATCTTTGAAACCTGATACAGGAGTTCTGAGAAGGGAATGGGTTTTT +CAAAGTCTTTGCCCCATGCGGTTACGTTTTGACCAAGGAGGTGTATCTCCCTTACCCCATCGTCAACAAG +TCTTTTCACTTCGTCAAGTATGCTGTGAAGTGCTCTTGAACGCTCTTTACCTCTAGTTCTCGGAACTACG +CAGTAGGTGCAGTTCTTGTCGCAACCCTTTATTATCGTCACGTAGGCGCAGTACTTATTATCCCTCTCTA +CGGGGTATTCCCATATCTTGTCTTCGTCTTGGGGAAGCTCGTCAAGGATTGCAATAGCCTTATAGCCCGC +CTGAGCTTGATTTATGAGTTCGGGGAGCTGGTGCATGTTAAAAGAGGAAAACATTATGTCTATTACGGGA +GCTTTTTTTACGAGTTCCCATCCCGTTCTCTGAGCTAGGCAACCCGCAACCGCGATAAGAGCCTTCGGGT +TCTTTTCCTTAATTTTTTTATACTCACCGAGGTGGGATAAAACCTTCTGGTCGGGTTTTTCCCTTATGGT +ACATGTATTTAAAATTATTAAATCCGCCTCTTCCCAGTTGTCTGTCTGCTCGTATCCGATAGTTTTAAGG +AGTCCCCTTATACGTTCGCTGTCGTTGAAGTTCATCTGGCAACCGAAAGTCTTTATGAAAAACTTTTTAC +TCATAGATTATTAATTTATAGTTTTCGCAGGATTAATGGTGTTTGTGTTCTTTCTCCTCCAGGTGTTCCC +TGTGGGACAGGTAAAGGGCTAAAGCTATACTTACGAGCCCCAATCCGAAGAATAAGAAGTCTATAGATTG +TGTAAAGTTGAAAAAAAGTGCCTGTTTGAAGAAGTAAACCGAGAGAACCATTATAACTATCTTTCCCAGT +TTCATTTTGAGGTCTTCCAAGTTCCTTACTATTAAAATTCTCGAACTCCTCTGATCCCTTTCCGCGGGGT +CTATCTTTGATATGAAGAGCTCGTAAAGTCCCAAGGAGAAAATTATCAGGAATGTAGCTATTAAAAACAG +GTCAAGGGAGGAGATAACCGAAGCGAGTATCTTCCTCTGAAATATCTCGTAATCTCCTGTATCTACGAGT +TTTATTACCGGGTAAATTATCTCGTATACTCCGGCAAGAAACAGCAAAAGCGAGGCAAATAAAGACATTA +CAACCGCTATTAATACCAAGAGCCTTGACTTCCACAGAAAGTTTTCAAAGATTATTTCAAGCAATCTCAT +CAGAGGTGTATTTTACCTTTAAACTCTCTTTCGAGTTCCCTCTTCATAGCTTTTTCTTTGAGTTCTCTCC +TCCTGTCGTAGAGCTTCTTACCCTTTGCAAGGGCTATCAGAACCTTCACTTTGTTGTTCTTCCAATAGAG +CTTTAAGGGAATTATAGTGTAGCCCTTTTCCTGAACTTTTCCGTAGAGCCTCATTATCTCCCTTTTGTGA +AGAAGGAGCTTTCTCTTTCTTAATGGATCGTGGTTTTCTATAGTCGCGTGTTTATACGGGGCTATGTAGA +GGTTGTAGAGCCACGCCTCTCCGTTTTCTATCCTTACGAAACTATCCTTAAAGGAAACGGTTCCCTTTTC +CCTCAGGGATTTTACCTCGGAACCTTTCAAGACTATTCCCGCTTCGTAGGTCTCAAGTATGTCGTACTTG +GCTTTTGCTTCCTTGTTTTCAGCTATAGGGATAATTTTGTCGCTTTTGCCCATAATAAGTTCACTTTATC +ATTTCGGCGTAAGTTCTCGCGAGTTTAAAGAACTTAGTAGCCCTCTCCTTTGCCTTCTCCTTTTCTTCTT +GAGTTAAGTTAGGATCGTCAAGTAAGAAGGAGTTCACCTTCCCTCTCACGTAAGCCCTGTAGCACTTGAA +AAAGGGAAGCATAAGGTCAAAGTCGGGATCTTTTGATATCCTCCTGTACTCTTCCTCGTAAGCCCTTGCG +AGGTATTCCCTTCCGAAGTACTCCAGTTCCATAGAAAGGAAGCACATGTCGTTGAGAACGTCTCCGTACC +TGAACCTGTCGTTAAACTCAATACAGTCAAAGATACACACTCCTTCTTCCAGGAAGGCAACGTGTTCCGT +CCTTATGTCCCCGTGCCCGTCCCTTATCCTCCCTTCCTTTATCCTCTTTTCGAAAATGTCCGCGTGCTTT +TCGTAAAATTCGTTTGTCTTTCTCTTTATAAAATCGTAGTCCTCCTTGCTTATCGTTATCCCTATATACT +TTTCAGTCTGGGCGAAGTTCTCGTCGGTGTTGTACTTCATTACTTCCATCTTTCCGAACTCGTCCACCCT +CTTAGCCCTCACGTGGAAGTCCGCAACAACTTTTGCGACCTTTTTCAAGTCTTCTTCCGTTGTCTTATCG +AGTCTGTTTGAGAGGATAGCTTCATCCGGTATCCTTCTCATCTTTACGGCGTACTCCACCACGTTCTCGT +CGTTTTCTATTACCCACTTACCCTTTACTTCGCTTATGGGAACTACACCTATGTAAACCCAGGGGCACAG +CCTCCTGTTGAGTTCCACTTCCTTGTAGCACATTTCTTTCCTTTTCTCGAGCGTTGAGTAATCGAGAAAG +CCGAAGTTCACAGGCTTTTTTATCTTGTAAACAACGTCTTTCAAAAGTAAAACCCATGAGGTGTGGGTCT +GGATAACTTCTGCACCCAGTTCTTTTGCGAGTTCAAGTACTTTGCTCACAAGTGTAATTTTAACTTAGAA +TGTTTTTATGTTTTCTAAAGTCCTGAGCGGAGGGCTGTGGGGAGTAGAAGCCTTTCCGGTAGAAGTTCAG +GTAGATATCTCTCAGGGGCTTCCTTCCTTCAACGTAGTGGGGCTTCCAGACAGTTCCGTAAAAGAGGCAA +GGGAGAGGGTAAGGAGTGCTGTAAAGAACTCCGGATTTTCCTTTCCCTTGAAACGGATAACCGTGAACCT +CTCCCCTTCCGACAGGAAGAAACAGGGGACCTTTTACGACCTTCCCATAGCCCTCGGTATTTTGCAGTCT +TCCGGAGAAATTCCGGAACACGATTTCGTAGTTCTGGGGGAACTTTCCCTGGACGGGAGCTTAAATAAAC +TCAGCGGATTACTTGCGGTCCTGATTTCTTTAAAGGAGAAAGGCTTTAAGAAGTTCATAATCCCGAAACA +GAACGCAGGAGAGGCTTCTCTTATAAAAGGTGTAGAGGTTTACACCTTTGAAAACTTGAAAGAAGTAGTT +GAGTTTTTAAGGGGAAATCTGAAAAGAGAACCTATTTCCCACAGGAAACATCAAGTGATAGAAATTTTTG +AAGGAGACTTAAAAGATGTAAAGGGACAGGAACTCGCAAAAAGAGCCCTTGAGATATGTGCTGCGGGCTT +TCATCACCTTCTCTTTGTAGGAAGTGCGGGAGCGGGAAAGTCCATGCTTGCCACAAGGATTAAGAGCATA +GCCCCGCCGATGGAAGAGGAAGAAATTCTTGAAGTATCAAAAATCTACAGCGTTGCGGGGATGCTTGAAG +AGAGCCTGATAACCGAAAGGCCCTTTCAAGCTCCTCACCACACGAGCTCAGAAGTCTCCCTGATAGGTGG +AGGAAATCCTCCGAAACCCGGACTCATATCCTTGGCCCACAGGGGTTACTTATTTCTGGATGAAATGGCT +GAATTTCCGAGGCGATTTATAGAGTCCTTAAGGCAGCCTATGGAAAACGGTAAGGTTCAGGTGAGCAGGG +CCGGAAGTAACGTAGTTTTTCCTGCGGAGTTTACCCTGCTTGGGGCCATGAACCCCTGCCCCTGCGGAAA +TTACAAAAACCCTTTTAAGGTTTGCACGTGTTCGGAAAGGGAAATAAAAAATTACAACAAAAAGATATCA +GAACCAATAAAAGACAGAATAGACCTCAAAGTTTGGGTGTACCCCCTGAAGGAGGAGGAACTCGTAAACC +TCCCTGAAGGGGAAAGTTCCGAGAAAGTAAGGGAAAGGGTGATAAGGGCCTTCCGGATACAAAAGGAGAG +GGGAAAGTTTAACTCGAGACTCTCCAACGAAGAGGTAAAGAAGTACTGTCTGGACATGCTGTCAAGGGAA +GCAAAAGAACTCTTAAAAGAAGCCGTTAAAAACTTAAACCTCTCGGCACGTTCCTACTTTAAACTCCTTA +AAGTGGCAAGGACTATTGCGGACCTGGAGGAAAGTGAAAGGATAGAGGATTATCACATTTCCGAGTGTTT +GCAGTTTAGGGATTAATATACTAACCATGAACAAACTCACTCTCTTGCTTAAGTTTTTGATACAAGCCTT +CATGTGGTTTGCCATAGCTTCGGAATTCGTCTCCTTACTTTACGAGATATTTCACTCCTTAAAAGAGAAT +TACTTTTTAGGTTTAGAGACTCACAAGATACTAGTTAAAGTTCTGAATGTCATCATTATATACGAGCTCT +TCACTACTCTTTTGATAGCACTTGAGGAAAGGAGGATAAAACTTATCCTGATAATAGACACCGCGATGAT +ATTCTTCATAAGGGAACTTCTCATCGTTCTCTTTACCTACAAAAAGCTTGAACTTAGTGAGGGTATCGCT +TCAGCTTTAATTCTCGGGACACTTGGTATCTTGAGGTTTCTCTACTTGAAGTACAAGATAGATGTAGAGT +AATTCTTATGAAAAAGTTCTTTCCCCTCCTTCTCCTTCTGCTCCTGACTTTCGTTCCCGCTTTATACCTC +CTCAATAAAAAAGAGTACGAAATTTATACCGTAAAGAAGGAAAAAGTTGAAAAAACCGTTTACGCTACCG +GGTATGTAAAGGCTTTAAACGAAGTTGAGGTAAAGGCCAAGGTTGCCGGGTATGTATCGGAAGTTTACAA +GGATGTGGGTCAAAAAGTCAAAAAGGGAGAACCCCTCGCACGCATACAGAATAAACCCCTTGAAGAAAAA +GTGAAAATTTTAGAAATTCAGCTTCAAAATTTAAAAGAAAAAATAAGGGAAGATTCACCCTTCATACGGG +CTTACGAACTGAAAATAAAAGCCCTCCGCGAGGAGGTAAAGGAACTAGAAGAGAAACTCAAAAGGAGAAA +GAGACTATATGAAAAGGAACTAATTTCCAAGGAAGAGTACGAAAGCCTGAAGAGGAAGTACAGAGCAAAA +CTGGAAAGCTTAAAAGCCCTTGAGAGTGAATTCAAGGAGAGCGTTGAAGAAGTGAGGAGAAAGATAAGGG +AAGTAAAGGCGAATTTAGAAAAGGCTAAAGAGGAACTCGGAGAGTACACAGTCAGGAGTCCCATAGACGG +AGTTATTTTGAAGAAGAACGTGGAAGTCGGAGAGTACGTAAACACATTCATGGAGACAAAACCACTTTTT +GTGGTGGGAAATACAGAAAAACTAAAAACTTACTTAGAAGTTGACGAAGAGTACTCCTCACTTGTAAAAA +AGGGACAGGAAGTTTACGTAAGCGTTGAGTCTTTAAAGGACAAACTCTTTAAAGGGAAAATCGTAAAAGT +TCACAAAAAGGTGGACGAAAAGAAGAAGGTTTTTTTAGTTGAAGCGGAGGTGGATTATTCAGAGAAAGTT +CTTCCGGGAACTACCGTTGAGGGATACATCGTGGTTTACAGGGGAGAAGCACTTTTGATACCCGAAAAAG +CTATTTTAGAAGGAAACAGAGTGAAGATTTTGAAGAACGGGAAAATCATCGATAAGACTATAAAACTCGG +TGAAACTTACGGGGACAAAGTGGAAGTCCTTGAAGGTTTGAAAGAAGGCGACAGGATAGTGATTGAGAAA +TGAGGGCTGTTCTCTTTCTGTCCTTTAAGTTCTTCGTGGAGAGGAAAAGACAGAGCTTTATAGCTACTCT +GGGGGTGATGATAGGAACGACTGCTTACATCGTTATGAGTTCAATGGTAAACGGCTTTCAGAAGTACTTC +TTAGAAGAAGCCCTTAACATAAACGGACACGTAAAGATATTCGTGGAAGCAAGGGAAAAGGGAGAAAGTT +TTTTAAAAAAGTTCTTTCCCGATAAAAACTTCAAGATTCTGGGAGAAAAACCGGAAGAGACAAAGGACAA +AATAGCGAACTACCGTGAAATCCTGAGGAAATATTCACAGGATAAAAACGTCATAGGGATAACCGTTCAC +CTCATCGGAAACGGAGTCCTCACTTACGGGGTAAAGGAAAAACCCGCTACCTTTGTGGGCATAATCCCAA +AGCTTGAGGACAAAACTTTAAACGTTTCAAAGTATTTACAAGAGGGAAGACTTAACGAACTTGAAAGAAA +CAAGGACTACGTAATTCTCGGTATAAAGCTCGCTCAGGAACTGGGAATAAGGGAAACGGGAAAAAAGGTT +CTCCTTTACGCTCCGAGCGGTGAGGTCTACAGACTCAAAGTAATAGACTTTCTAAACACCGGGATAACCG +AGATAGATAAGTCCAGAATCTACCTTCACATAAAGAAGCTCCAAGACATTCTTGAAAGACAAGGGGAAGT +AAATGAAGTAGTTTTAAAGCTAAAGGATCCAGACCTTGCACCTTTTTACGCGGAAAAGCTCTCAAGAGAA +ACGGGCTACAAGGCGGAAAGCTGGCAGGAGTCTTTTAAAAACTTCCTCTCTATATTCAAAATTCAAAAGA +TAATCACGCGTTCCGTAGTCTTTTCCATACTTTTGGTTTCGGGTTTTGGGATATTCAACATAATAATGAT +GACAGTGATGGAAAAGCGAAGGGAAATAGCGATTCTAAAGGCTATGGGCTACGAAAAGAGGGATTTAATC +CTCATCTTTACCCTTCAGGGACTCATCATAGGACTCTTGGGCGGTATCCTCGGAAACATCCTTGCCTACG +GAATGCTTGAGTGGCTCGAAACCCTAAGGATAGAAGTTGAGGGAATTATCAGAGCGAAGGGTTTTATCCT +TGACAGGAGTTTGTGGTATCACTTCTTCGGTTTTGTGTTTGCGCTCCTCACCTCTTACCTTGCCTCCTTT +TATCCCGCATACAGGGCTTCAAAGTTCCATCCCGTGGAGGTCTTCAGAAGCGGTGGCTGAGATACTGAGG +GCTGAAAACATCAAAAAAGTTATAAGGGGATACGAGATATTGAAGGGTATAAGCCTGAGCGTAAAGAAGG +GGGAATTTGTGAGCATAATAGGGGCTTCTGGCTCGGGAAAAAGCACATTACTTTACATTTTAGGGCTCCT +TGACGCTCCAACAGAAGGAAAGGTTTTCCTTGAAGGAAAAGAGGTGGATTATACAAACGAAAAGGAATTA +TCACTTTTAAGAAACAGGAAACTCGGTTTTGTTTTCCAGTTTCACTACCTGATACCCGAACTCACCGCCT +TAGAAAACGTTATAGTTCCCATGCTAAAAATGGGCAAACCTAAGAAAGAGGCAAAGGAGAGGGGGGAGTA +TTTACTTTCCGAACTGGGACTCGGAGACAAATTGAGCCGAAAGCCCTACGAACTCTCCGGGGGAGAGCAA +CAGAGGGTAGCGATAGCGCGAGCTCTGGCAAACGAGCCAATCCTTCTCTTTGCGGACGAGCCTACGGGAA +ATCTAGACTCGGCGAACACAAAAAGGGTAATGGACATATTCCTCAAGATAAACGAGGGCGGAACGAGCAT +AGTTATGGTAACCCATGAAAGGGAACTGGCAGAACTCACCCACAGAACGCTGGAAATGAAGGACGGCAAA +GTCGTTGGGGAAATTACTCGGGTCTAATCACGTCCGTTCCCACGTAATCTCTGAGAACTTCCGGAACTAC +TACGCTACCGTCTTCCTGTTGGTAGTTTTCCAATATAGCCGCCAGAGTCCTTCCCACCGCAAGTCCGGAG +CCGTTCAGAGTGTGTACGAACCTATTTTTACCAGTTTTTGAGTCCTTAAAGCGCGTGTTCATCCTCCTCG +CTTGAAAGTCCTCGCAGTTGGAGCAGGAGGAGATTTCCCTGTACTTGTTTTGAGAGGGAAACCACACTTC +TATGTCGTAGGTCTTTGCGGCGGAAAAACCGAGGTCACCCGTGCAGAGTTCCACCACCCTGTATGGAAGT +CCGAGAAGCTGGAGAACTTCTTCAGCGTCTTTTACAAGTTTCTCAAGCTCATCGTAAGAAGTGTCCGGGT +GGACTATCTTCACAAGTTCTACTTTGTCAAACTGGTGCTGTCTTATTATCCCCCTTATGTCTTTTCCGTA +TGCTCCCGCTTCCCTTCTGTAACAGGGCGTGTACGCAGTGAGATATATGGGAAGGTTCTCTTCCTTGAGT +ATCTCTTCTCTGTAGAGGTTTGTCAGGGGAACTTCCGCGGTGGGTATCAGGTAGAGGTTATCCCTTTCAC +ACTTGTAGAGGTCCTCTTCAAACTTCGGTAGCTGTCCAGTTCCTATTAAGATTTCCGGCTTTACCAAATG +GGGAGGACATATTTCCTTGTAGCCCTTTTTGGTGTGGAGGTCCAGCATAAAGTTTATAAGCGCCCTTTCT +AATCTCGCACCCCAGCCGGCTATTACGGTAAACCTGCTTCCAGAGAGCTTTGCACCCCTCTTGAAGTCGA +GAATTCCCAATCTTTCCCCTATTTCCCAGTGAGGTTTTGGTTCAAAATCAAACTTCCTCGGCTCTCCCCA +TCTCCTTACTTCCACGTTGTCCTTTTCGTCCTCTCCCACTGGAACACTCGGGTGGGGGAGGTTAGGTATC +CAGAGGAGCGTGTTCTTTAACTCCTCTTCCACTTTCCTTAACTCTTCCTCAAGTCTGTCTATTTCCTCTT +TCAATTCCTTTACTCTGTTTTGTATTTCCGTGGTGTCCTTGCCTTCCCTCTTTAGTTTTCCTATTTCCTT +GCTCAGTTTATTCCTCTCACTCCTTAAGGCTTCAAGTCTTTTTATTATTTCCCTTCTCCTTTTGTCAAGT +TCAAGAACTTTGTCAACTAAGGAAACGAGTTCTTTATCCCTCGTTGCGAGTCTTTCCTTCACGTAATCGG +GTTTTTCCCTAATGAGGTTTATATCTATCATTTAAACAAGAATTATAATTGAAGTTAGACATGTGCGGGA +TAGTCGGATACGTAGGGAGGGATTTAGCCCTTCCTATAGTCCTCGGAGCTCTTGAGAGACTCGAATACAG +GGGTTACGACTCCGCGGGAGTTGCCCTTATAGAAGACGGGAAACTCATAGTTGAAAAGAAGAAGGGAAAG +ATAAGGGAACTCGTTAAAGCGCTATGGGGAAAGGATTACAAGGCTAAAACGGGTATAGGTCACACACGCT +GGGCAACCCACGGAAAGCCCACGGACGAGAACGCCCACCCCCACACCGACGAAAAAGGTGAGTTTGCAGT +AGTTCACAACGGGATAATAGAAAACTACTTAGAACTAAAAGAGGAACTAAAGAAGGAAGGTGTAAAGTTC +AGGTCCGAAACAGACACAGAAGTTATAGCCCACCTCATAGCGAAGAACTACAGGGGGGACTTACTGGAGG +CCGTTTTAAAAACCGTAAAGAAATTAAAGGGTGCTTTTGCCTTTGCGGTTATAACGGTTCACGAACCAAA +CAGACTAATAGGAGTGAAGCAGGGGAGTCCTTTAATCGTCGGACTCGGAGAAGGAGAAAACTTCCTCGCT +TCAGATATTCCCGCAATACTTCCTTACACGAAAAAGATTATTGTTCTTGATGACGGGGAAATAGCGGACC +TGACTCCCGACACTGTGAACATTTACAACTTTGAGGGAGAGCCCGTTTCAAAGGAAGTAATGATTACGCC +CTGGGATCTTGTTTCTGCGGAAAAGGGTGGTTTTAAACACTTCATGCTAAAAGAGATATACGAACAGCCC +AAAGCCATAAACGACACACTCAAGGGTTTCCTCTCAACCGAAGACGCAATACCCTTTAAGTTAAAAGACT +TCAGAAGGGTTTTAATAATAGCGTGCGGGACCTCTTACCACGCGGGCTTCGTCGGAAAGTACTGGATAGA +GAGATTTGCAGGTGTTCCCACAGAGGTAATTTACGCTTCGGAATTCAGGTATGCGGACGTTCCCGTTTCG +GACAAGGATATCGTTATCGGAATTTCCCAGTCAGGAGAGACCGCTGACACAAAGTTTGCCCTTCAGTCCG +CAAAGGAAAAGGGAGCCTTTACCGTGGGACTCGTAAACGTAGTGGGAAGTGCCATAGACAGGGAGTCGGA +CTTTTCCCTTCACACACATGCGGGACCCGAAATAGGCGTGGCGGCTACAAAGACCTTCACCGCACAGCTC +ACCGCACTCTACGCCCTTTCGGTAAGGGAAAGTGAGGAGAGGGAAAATCTAATAAGACTCCTTGAAAAGG +TTCCATCACTCGTTGAACAAACACTGAACACCGCAGAAGAAGTGGAGAAGGTAGCGGAAAAGTACATGAA +AAAGAAAAACATGCTTTACCTCGGAAGGTACTTAAATTACCCCATAGCGCTGGAGGGAGCTCTTAAACTT +AAAGAAATTTCTTACATACACGCGGAAGGTTATCCCGCAGGGGAGATGAAGCACGGTCCCATAGCCCTCA +TAGACGAAAACATGCCGGTTGTGGTAATCGCACCGAAAGACAGGGTTTACGAGAAGATACTCTCAAACGT +AGAAGAGGTTCTCGCAAGAAAGGGAAGGGTTATTTCTGTAGGCTTTAAAGGAGACGAAACTCTCAAAAGC +AAATCCGAGAGCGTTATGGAAATCCCGAAGGCAGAAGAACCGATAACTCCTTTCTTGACGGTAATACCCC +TGCAACTCTTTGCCTACTTTATAGCGAGCAAACTGGGACTGGATGTGGATCAGCCGAGAAATCTCGCCAA +AACGGTCACGGTGGAATAATCACTCTTCCTCTTCCACGAAGGTTGCGAGTATCGTCTCTATAATTCCGAG +AATAATAGATACTATATTCGCCGCGAGGGCTCCCATGGCGAGTCCCACAGCCTCCTCAACGCTTCCAAGG +AAGTAAACAAAGCCCGCGGGTATCAGGTGAAGGTCCGCAACCAAACTGGAAGCCATGAGCTCGTTCGAGA +GAATTCTTCCTTCTCCCATCTTAAGGATTGTGGCAAATAGGTTTGCGGAAATCGTGATGGCAAGCTCGTA +AGGATTGGGACTCAAAACGAAACTTATGTTCGTGGTAAGAGCCATGAGTATAAAGAAGTGGGTAAGTATT +TTCCTTAATCTCATACCTTAGCCTCCACTTTTCTGAGCAGAATCCTTTGAGCCTTTCTCAGGTTTTTAGG +ATGACCAAACAGTATTAAAGTGTCTCCTGGTTCTATTTTCGTTTCACCGCTCACGGTAACGATAAGTTTT +CCGTCTGGTTTCCTTACCGCTATTACCGTAACACCGAGGTTTTTCCTGAGATCGAGTTCCTTTAACTGCT +TTCCTACGAGCTCGGAGTCTTCTGGCACCGTTACTTCAAGTATATCTATTTCCGTCTCTTCACCGAAAGC +TATCCTGTCAAAAAGGTCCGAGATAAAAGCAGAACCAGCATGGAATACATAAGCTGCCACCCTCGTCGCC +AAGAGCCTGTAAGGAACTACTGCCCTGTTTGCACCCAGTTCTTCCAGTTTTTGAGCCGTGTCTTCGGAAG +AAGCGAAGGAATAAATGAAGAAGTCTTCCTTTTTAGGTCTCATTAACCTCGCGGTAACTATAACAGCTAT +GTTTTTAGCGTCGTCTCCTAGATTCACTACCATTCCCATTGCCTTATATATGCCAGCAGCCTCAAGAACT +ACTCTCTTGTATGGTTCTTCAATTATGTAGTACTTAACCTTTGATTCCTTTATCTGCCTTTCAACTTCTC +TCCTGCTATCCACCACTACGATTTCTATCTTTCTCTTCCTCAGGAGCCGTATTAATTCCTGAGAAGTTTT +GTTAAATCCAACTATTATGAAGTGTCCCCTAAGCTTCTCTATATCCCTTAACATTTTCCAGGCTCTTAAA +ACACCTATAAAGTCTTCCTGAAAGAATATTCTAATGAGAATGGTAACCGAAGTTGTAAAAACACCTATTC +CGCCGAGAGCCAGAAAAGTGGTAAAAGTTCTTCCGATGAGTGTGTCGCTTCCCTCGACAACCTCTCCGTA +CCCAATAGTTCCAACCGTTATAACAGTCATGTAGAGGGAGTTTATAAAGTCACCATCGGACAAAATCATG +TACCCAAGAGTTCCTATAGTTAGTACAGTATGGAGCATAAGGAGGGGAAGACGAAAGAGGGAAAGGATTT +CAAAGAGGCGGTTCTCGTAAATGTCTATAAGTCTTTTTCTTCTCTTCTTTTTTCTAACAAACCGCATTAA +GCTCTATACCCATCTCGGAAAGTGCTTTTGCACACCTTTTGCAAACGCATCCCACGAACTCCTCTTTCTG +GTAGTATATCCAGCATCTCGGACATTTCTCCCCTTCCGCTTTATTTACGCCTACCTTAACGGGAAGTTCT +TCTCCTTCTATCTGAACTTCTCCTCCCTCTCTCAGCTCAACCTGACTGACCGTAAAGAAGAAGTTCAGGT +AATCCTCGTACTTTTTAAGGAGACTTTCTACACTCTCGTCACCCCTTATGTAAACCTTTGCTTCGTAAGG +GTGCTTGATTATTCCCTTTTCCTTCCTAGCCACTTCCAGTGCCCTCATCACCTCGTCCCTTACCTTTAGG +AGAATTTCGTAGTCCTTTAGTACTTCCTCATCTTTCAGATTCTCATCGGGCTTTGGCATTTCGTAGAGGA +ATACGCTCTCGGGAAGTGAAGGGTCAAGCTTCCCTACGTGCTCCCATAGCTCTTCTGCTGTAAAGCTCAG +ATATGGAGCTGTGCTCGTTGTGAGTGCGATAAGTAGGTGCCACAGGGCTGTTTGAGCAGAGCGCCTCTCC +CATGAGGCCGGAGCGTAAACGTAGAGTCTATCCTTTAAAACGTCAAGGTATATCGCAGAAAGGGTAGTTA +TTACGAAGTTCTTTATGTGGTTGTGAACGCGATAAAAGAGGAACTTCTCGTAATTTTCGTGAACCTTCTT +AAGTAAGTTCTGGAGTTCGGAGATTATCCACCTGTCAAAGTGGTGGAGCTTTTCAAAGGGAAGGGCATTC +GTTCTTGGGTTAAAGTCGTACAGGTTTCCTATAATGAACCTTAAAGTGTTTCTTATCTTCCTGTAGTCAT +CAGCTATCTTCTTTAAGAGGTTTTTACCGAGCTTTACATCTTCTGTGTAGTCCTCGGACACAACCCAGAG +TCTTAAGATATCCGCCCCGAACTCCTTTACCACTTCCTGAGGGGATATCACGTTCCCGAGGGACTTGGAC +ATCTTTCTTCCTTTCTCGTCCACTATAAATCCGTGGGTGAGAACCGCTTTGTAGGGAGCTTCTAAGTATG +AGCCTACGGACTCAAGGAGAGATGCCTGGAACCAGCCTCTGTGCTGGTCCGAACCTTCTAAGTATAGGTC +CGCCTTCTGAAAGCCGAGAGGTCTTATTACCGCTGCGTGGGAACATCCCGAGTCAAACCAGACGTCCAGG +ATATCTTCTTCCTTTGTAAAGCTATCTCCTCCGCACTTGGGGCATTTGTAGCCCTCTGGAAGGAGCTGGG +AGGAGGTGAGTTCAAACCACACGTCGCTTCCCTTTTCCGAGTTCTCAACGAGCTGGGCTACTCTCTCAAA +AACTTCCCTATCTTTTATAATCTCCCCGCAGTTCTCGCAGTAAAAGACCGTTATGGGAACACCCCAGAAC +CTCTGTCTGGATATACACCAGTCGGGTCTGTTCTCAACCATGCTCTTTATCCTGTTCTTACCGTACTCGG +GAATCCACTTAACTTTTTCTATTTCCTCCAGTGCCCTCTGCCTTAAGGTTTTCCCGAAAAACTCAATGTC +CATGCCTATGAACCACTGGGGTGTAGCCCTGAAGATTACTGGGTTTTTACAGCGCCAGCAGTGGGGATAA +GAGTGCCTTATCTTTTCCTCGTGAACTAAAAAGCCCTTTTCTTTCAGAACTCCTACGATTAAGTGGTTTG +CGTCAAAAACGCGAACGTTTATGAGAAATTCGGGAGCAGGTTCTACAAACCTCCCCTCGTCGCTGACGGG +TGCGTAGGGCTCAAGTCCGTACCTCTGACCGACTACGTAGTCTTCCTGCCCGTGTCCGGGAGCCATGTGA +ACGAGTCCCGTTCCCGTATCTAAGCTAACAAATTCCGAGGGGTATATCTTCCACATGTTCTTTAAGGTTT +CCTCGGAAAGATGTCCCTTTAACTTTTCCTTTTCCACGAATGGGTGGGTGTATTCAAGTCCCACTAAATC +CTTTCCCTTTACGGTTTCAAGGACTAAACCTTCTGGTCTGTTTACGGTTTCAAAAAATTTGTCCATTAAT +TCCTTTGCCACTATCCAGACCTCATCTTCAACTTCCACGAGGACGTAGTCCGCGTCTTCCTTTACCATTA +TTCCGAGGTTTGCGGGAAGGGTCCACGGAGTTGTGGTCCAAATAATCGCGAAAACTTTCTTATCCTTAAT +ACCGAACTTTTCTCCGCTCTTTAGGGGGAACTTGACGTAAATGGAGGGGTCCTCTTTTTCGTAATACTCC +ACTTCCGCTTCCGCTTCCGCTGTTTTGTCGTATATACACCAGTAAACGGGCTTCTTACTCCTGTAAGCGA +GTCCACGTTCAAAGAACTTCCCGAGCTCCCTTATCTCCTGAGCCTCGTATTTGGGGTCCATGGTGAGGTA +AGGGTGTTCCCAGTCTCCGAGCACTCCGAGTCTTACGAAGTCCTCCCTTTGTATGTTTACGTATTTCTTT +GCGTATTCCCTGCAAAGTTCTCTGAACTCTGTCTTTGGGAGGCTCTCTTTTTTTATTTTCTTCTTGGAGA +GCTCCTTTTCCACAGCTCTTTCTATGGGAAGACCGTGGCAGTCCCAGCCGGGAATGAAGTTAACGTTCTT +TCCGATAAGGAGGTTGTACTTATTTATAACGTCCTTGAGGATTTTATTTAGGGCATGTCCCACGTGTATG +TGTCCGTTAGCGTAAGGGGGTCCGTCGTGGAGCACGAAAACCTCTCTACCTTTTCTCTCCTTCTGTATTT +TTTCGTAGAGTCCCTTCCACTTTTCCAGGATTTGGGGTTCTCTCTGGGGCAGGTTTGCCTTCATGGGAAA +TTCCGTTCTGGGCAGATTCAGAGTGTCTTTCAGGTCAACCTTCTTCTCTTCCATAAGGATTATTTTACGA +AATGGTTTAAATTTTCTTTCTTATGGAGAAATCTGAGAAAGAGCTCACTCCCATGCTCTCACAATACCAC +TACTTCAAAAATCAGTACCCCGACTGTTTGCTTCTCTTCAGACTCGGAGACTTTTACGAGCTCTTTTACG +AAGACGCTTACATAGGCTCTAAAGAACTGGGACTTGTTCTCACCTCAAGACCCGCGGGAAAGGGAAAGGA +AAGGATACCCATGTGCGGAGTTCCCTACCACTCCGCAAACTCCTACATAGCTAAACTCGTAAACAAGGGA +TACAAAGTAGCCATATGCGAGCAGGTGGAGGATCCTTCTAAGGCAAAAGGTATCGTAAAGAGGGAGGTAG +TAAGGGTAATCACTCCCGGAACTTTCTTTGAAAGGGACACGGGAGGACTCGCATCACTCTACAAAAAAGG +AAATCATTACTACGTAGGTTATCTAAACCTTGCGGTAGGGGAGTTCTTGGGAGCTAAGGTAAAGATAGAG +GAACTCCTTGACCTTCTCTCAAAGTTAAACATAAAAGAAATACTCGTAAAAAAAGGGGAAAAATTACCAG +AAGAACTGGAAAAAGTTTTGAAGGTTTACGTAAGCGAGCTGGAAGAGGAGTTCTTTGAAGAAGGGAGTGA +AGAAATTTTAAAGGATTTCGGGGTTTTGAGCCTTCAAGCCTTCGGTTTTGAAGAGGACACTTATTCCCTT +CCCTTGGGAGCTGTTTACAAGTACGCAAAAACGACACAAAAGGGCTACACACCTCTCATTCCGAGACCAA +AACCTTACAGAGATGAAGGCTTCGTAAGACTCGACATAAAAGCGATAAAAGGGCTTGAAATTCTGGAAAG +CCTTGAGGGTAGAAAGGACATATCTCTCTTCAAGGTAATAGACAGAACCTTAACGGGGATGGGAAGGAGG +AGGCTAAAGTTCAGGCTTCTTTCTCCCTTTCGTAGCAGGGAAAAGATTGAAAGGATACAGGAAGGTGTGC +AGGAGTTAAAAGAAAACAGGGAAGCGCTTTTGAAGATAAGGCAGATACTGGAGGGAATGGCGGACCTAGA +AAGACTCGTTTCCAAGATAAGCTCTAACATGGCAACACCGAGGGAGCTCGTTTACCTCAAAAACTCCCTG +AAAAAAGTGGAAGAACTCAGACTCCTCCTTTTGGAATTAAAGGCTCCCATCTTCAAGGAAATCTTACAAA +ACTTTGAAGACACAAAAAAGATAATAAACGACATAGAAAAGACGCTCGTTGAGGACCCTCCCCTTCACGT +AAAAGAGGGCGGGCTCATAAGGGAAGGTGTGAACGCGTATCTTGACGAACTCAGGTTCATCAGGGACAAC +GCTGAAACTTACCTCAGGGAGTACGAAAAAAAACTGAGGCAAGAGACGGGCATCCAGAGCCTGAAGATTG +GCTACAACAAGGTTATGGGCTACTACATAGAAGTGACAAAGCCAAACCTAAAGTACGTCCCTTCCTACTT +CAGGAGAAGGCAAACTCTTTCTAACTCCGAGCGTTTCACCACGGAAGAACTCCAGAGACTTGAGGAGAAA +ATACTTTCCGCCCAGACACGCATAAACGACCTTGAGTACGAACTCTATAAAGAGCTCAGGGAAAGAGTAG +TAAAGGAACTGGACAAAGTAGGAAACAACGCAAGTGCGGTTGCGGAAGTTGACTTCATTCAGTCCCTTGC +ACAAATAGCTTACGAGAAGGACTGGGCAAAACCCCAAATCCACGAAGGTTATGAGCTGATAATAGAGGAG +GGAAGGCATCCCGTAATAGAAGAGTTCGTAGAAAACTACGTCCCTAACGACACGAAATTGGACAGAGACT +CCTTCATACACGTGATAACAGGTCCGAACATGGCGGGCAAATCCAGTTATATAAGGCAGGTGGGAGTCCT +CACACTCCTTTCCCACATCGGTAGTTTTATCCCTGCAAGGAGAGCAAAAATACCCGTCGTTGACGCCCTA +TTTACGAGGATAGGTTCGGGAGATGTTCTGGCTTTAGGAGTTTCAACCTTTATGAACGAGATGCTTGAGG +TTTCTAATATCCTGAACAACGCAACCGAAAAAAGTTTAGTAATCCTGGACGAGGTGGGAAGGGGAACTTC +CACCTACGACGGCATAGCTATATCAAAAGCCATAGTAAAGTACATAAGCGAAAAGTTAAAGGCAAAAACT +CTTCTCGCCACACACTTTCTGGAAATAACCGAGCTGGAAGGAAAAATAGAAGGAGTAAAAAATTACCACA +TGGAAGTGGAGAAGACCCCCGAAGGAATAAGGTTTTTATATATTCTCAAGGAAGGAAAGGCTGAAGGCAG +TTTCGGTATAGAGGTAGCAAAACTCGCAGGACTTCCTGAAGAAGTGGTAGAAGAGGCGAGGAAAATTTTA +AGAGAGCTTGAAGAAAAGGAAAACAAGAAGGAGGATATCGTTCCCTTGCTTGAGGAAACCTTCAAAAAAT +CCGAAGAGGCTCAAAGACTTGAGGAGTACGAGGAAATAATCAAAAAGATTGAAGAAATAGACATAGGGAA +CACAACTCCCCTTCAGGCACTCCTTATACTTGCGGAGCTAAAAAAGAAGTGCAGTTTCTCTAAAAAGGAG +TCCGGAGCTTGAACTTACGGATTATGGAATTATCTTGACTTAGTAGGAGTGATATGTATGGTAGGAAAAG +ATGAAATCGTAGTAAAAGTTTTACCTAAAGGACAGATAACCTTGCCCAAGAGAATAAGAGAAAAACTAGG +AATACGGGAAGGCGATATTTTAATTGTTGAAGAAAAGGAAGGAAAATTAGAAATCAGGAAACCTAAAAGC +CTTAGGGACTTCTATGGTTTCCTGAAAGGAAAGAAATCTATTAATAGGGAGAATATAGAAAGAGTTATTG +AAGAGGTTGTAAAGGAACGTGAACTTGAAAAAGATAGTCGTTGATACAAGCGTATTTATAAGACTGTTTA +CAAGAAATGATGAGAAGAAATTTGAAAAAGCGGAGAAACTTATAGATGATGCATCCAAGGGTAAAATTCA +GTTATTCGTTCCGTTTATCGTAGTCGCGGAAATAGTTTGGGTCTTGGAGAAGGTTTACAAAGTTAATAGA +GAAAACATAAGGGATGTGGTGGAGGCACTTATCAATACACGTCCACGTAGCAATTACAGCATCGGAAAAC +TTTATTCTTTTTTCTACGTATAATTTTATAGCGTTAAGGATTAAATCTCTTTGTTCCACATGTATACCAC +ACTCATGAAAAACTTAGATGAACTAGTCACCTTTGACGAAACCGATTTCAAGAAATTAAAAGATATAAGA +GTGAGAATTCTTTAGAAACTCTATTGCTTACGTTTTGAGCTTCCTCCCAAAAACCAAGTACGCCGTGTGG +GCCACCATTTGATCCTCGGGTCTGAACCTTTCTGAGATAGTCTTGTAATGCCTGTGGAGTATCTCAACCA +CTTCAAGATTTCCGAAGTAATTTTCTATACTTTCCAGGAGCTTTATAACTTGATTTGCGGTGGGAAGGAG +AAAACCAACTGGAGCACCCTCCATCAAGCTTTTGTGAACCTTTTCCAGATAATGCCAAGGTTCCCTTACG +TCCACAAAGGCAGCGTGGAATATTCCTTCCGGGACTTCCGCGTCTTTGAAGTCCACGTTGAAAAACTTTA +CATTCTTTCCCAGATTGAACTTCTTCAAATTCTTCTGGGCTGTTTTGTAAAACTCTTCTACTGCTTCAAA +GGTCCACACCTCTCCCGCAACTTCCGAGAGAACTGCAAGGAGTGCCCCGCTTCCAGTCCCGAACTCCAGA +ACTCTCTTTTCTTTGTTCAGGTTTAACTTCAGGGCTATATAAAAGGAATCCTTCGGGTATATTATCTGGG +TTTTCCTCTCAAATCCGAGGAGTATGATCTCCTCGAGCGTTGGTCTGTAAACTTCAAATCCGTTTATCTT +TACACCTTCGGGCTTTCCTATAACTTCGTCAAACTTTAAAACACTTTTCTTTACACTTAAACTCTGTTTT +GGTAGCAGTTTCCTCAGGAACTTCTTTTCCCCAAAGCGTATGAGGACGTACTCTCCTTCCTTAAAAGAGT +TCATCGGAGAATATCTTTTCCGGGATTTCCGCCTTAATTATACCCCTTTCCTTTCCAAGTCTAAGTAAAA +GCCTTACCGCTTCTCTTCCATCTTCTCCGTAATCCACAGTTCTCTCGTTCACGTACATACTCACAAACTT +CTGAGTCCTTTCTAAGTCCTCGCTCAAATCCCTCGCGTAATTTATTGCGTATTCTAACGCCCTTTTCCTT +TCCTTCAGTGCGTACTCAACACTTTCTCTCATAAGTCTCTCTATTTTCTTTACGACTTCCCTTCCGAGAT +CCTTTCTCACAACGTTGCAACCTAGAGGCAGAGGCAGTCCGTACTTTTCCTTCCACCACTCTCCCAGATC +AACGATTTTCTTCAGTCCGTAGTCCTTGTAAGAGAGCTGACCTTCGTGAATAACTAGCCCCGCGTCCACT +TTTCCTTCCAGCACTGCTTGTATTATCCTGTCAAAAGGAATGACTACGTGTTCAAAATCGGGTTCGTAGA +GCTTAAGCGTTAGGAAAGCGGTTGTAAGCTCCCCGGGAACTGCTATCTTCTTCCCTTTTAAAGTACCGAG +TTCTTCCCTTGCCACCACTATCGGACCGTAACCTTCTCCTATGCTTCCGCCGCTTGGAAGAACCGCGTAC +TTGTCTGCAACGTACGGGTAAGCGTGAAAGGAAATCGCAGAAACCTCGTAAGTTCCTTTGAGTGCTTCCC +TGTTCAGGGTTTCTATATCCGCCAATACGTGTTCTATTTCAAGACCTTCCGTATCAATTAAACCCTTCAC +GAGCGGATAAAACATAAAAGCGTCGTCCGAATCGGGACTGTGAGCTATCCTGATCCTCATAATCTTAATT +ATTGTAATAACAGATAAAGAACCACGGAAGTGATCAGTCCTCCCACCACATCGTCCATCATAACTCCAAG +TCCACCGGGGAAGTTTTCAAACAGGTTCACGGGAAAGGGTTTAAGAATGTCCACAACCCTGAAAATAATG +AATGCGAGAATTAAGGATTTTAGGGTAGGTTCTACAAAAAGGAAACACAGTAAGTACCCTACGATTTCGT +CTATAACAACCTGTTCCGGATCTTCGTCTCTTAAGTTCTGAACCATGTACTCCGAGGAAATCCAACCGAG +AAAAAAGAAAATTAAAGTTCCAAAAAGGTATAAATTCCTGTCAAGGTAAAGAAGTAAAACTAAAGGAATT +CCCACAAGTGTTCCAAAGGTTCCTGGGGCAACGGGCAGTTTTCCCACGAGGAAACCCGTAGCTAAAAACT +CTAGAATTACGGACATAGGTTTACATTTTAACTTTATGGAACAGGTTATTTTTCTGTTACTGCTGGCACT +AATAGGCGGACTCCTTTTGTGGAAAGGAAGGAGAAAGAAAAATTGTTGTGAGGTTTAAACCTTTTCGGGA +AATCTTATCTCCACTTTCGTTCCCTTTCCCCTTTCACTTTGTATGTTTATTTTTGCCCCGTAATTCTGGG +CTATCTTCTTCACGAGTGCAAGTCCAAGTCCAAGACCTTTGCTCTCTTCTCCTTTTACAAAAGGCTCAAG +TATTAAAGGGATTTTCCTGTTTTCTATACCTATTCCCGTATCTTCTACGGAAAGAACAATTGCGTTTTCG +TCTTTTCGGGTTTCTACTAAGACTTTCCCTCCTCTCTTGTTGTACTCCACCGCGTTCTGGAGCAAATTCC +TGATGATAACCTTTATCTCCTCTCTGTTTCCCTTTAAGCATTTTTCCTTTAAATCAATTTCTACGGAAAT +TTCTTTCTCCTTTATGTTTTCTTCTAAATCTTTCAAAACTTCACTTAAAACTTCTTCTAAATTTACTTCC +TCCCTGACCTTGCCCTTTCCTTTAGAGAAGCTGAGCATGTAAACGGTTTCCGTCAGGGATATAGCTTCCT +TTACCCTCTTCAGAGCCCTTCCTATGAGTTCCCGTTTTACAGACTCTTCTTCCATGTCCAGCAAGGTTTC +TAACGTGTTCATCACAACCGCCAGAGGGGTCTTCAATTCGTGACTGAGGTTTGCTAAAAATTCCTTTTGT +GTCTCCTTCATGAGTTCTCTATCCGTTATGTCCTTGACTAGTATACCAACCCCGTCCTCGTAAAGAAAGG +TTCTTACCGCGTAAGTTCTATCCCTGAAGGTTATTCCTTTTTCCTGCGGTGTTCTGGTCTGGTAAGTTTC +TTGTATTAAACCAATCAATTCTACACTCCTCAAACTCTCGTAGTATGTCCTTCCCTCTTTGCCTAAACTC +TCCTTTAACCTCTGGTTCATGAATTTAACGTTCCCCTCCCCGTCAAAAATCGCTACACCTTCTTCCAAGA +AGTTCAAAAAGCTCGAACATAGTAATATATTAATAAGTCTTGAAATCTTATACTAATATACTTAAATTTT +CTATTAACATTAATTTAAAACATTTCCTTAACCGAAACTTAAAATTTGGGGTTTAAAACCTTAAGTAAGG +AGGTGTGAGATGAAGGTCTTAGCAGTCAGGAATAAGAGGCAGAAAGAGAGGGTAATTAGTAGGTTTTTGA +AAAAGAGGAAGGTTGTAGCGGTTGTGAACAATCCCTCTCAGCTGAAGAACGATATTTTAAAGAAAGCGGA +TGTTGTAATTTATGAGGAGGAAGATGGAAAGGATAGCTCTAATTGAGGACGACAAGGATTTAGCCTTTCT +CGTGAAACTGAATTTAGAAAGGGAGGGGTTTGAAGTAGAGCACTTTGAACGTGCCACTCCCTTCTTTAAG +TTCATTTCTGAAAACAGTGTAGACCTTATCCTCATAGACATTATGCTTCCCGACCTAGATGGATTCAGGA +TAGCTAACTTCTTAAAGAGCAGGGCGGATTTAAAAGAAATTCCCGTTATATTCATAACCGCAAAAGGGGA +GGAAGAGGACAAACTAAAGGGCTTTGAACTGGGAGCGGACGATTACATAACTAAACCCTTTTCCATGAAA +GAGTTAATAGCAAGAGTAAGAGCCGTTCTAAAGAGGTATAAAAAGGTTTCCGAGAGCAAAGTTTTAAAGT +ACGAGGGCGTTGAGCTGGACACGGAAAGACAAAAACTTTTCGTGGACGGTAGGGAGGTATACCTGACTCC +TGCGGAGTTTAAAATCCTGAAAACCTTGATGGAAAACTTCGGAAGACCTGTCAGTCGTTCGTCCCTCGTT +GAAAAGCTCTGGGATTACGAGAGGGAAACCACGGAGAGGGCTATAGACGTTCACGTAAAGCACATAAGAG +ACAAGCTCGGAAAGTATAAGGGTCTTATAAAAACTGTGAGGGGTGTCGGATACAAGTTCGAAAATTAAAC +TTTTATTTATGTCCAAACTCAAGACTGAAAAAGAGTTGAAGAAACGGGAAATAATGAGGGTAGCCTGTAA +ACTCTTTGCCCAGAAAGGCTATCACAACACCACTATGCCAGATATAGCTAAAGCATTAGGTATGAGTGTT +GGAAACCTCTACAACTACTTCTCCTCAAAAGAAGAACTGGCAAAGGAGATAATGCTCTTTACCTCTAAAC +TCGTGGGGGAAAGATTGAGAAAGGTAAACGAGAGTAATCTGGATTTCAAGGAAAAGACAAAGCTTCTCGT +CAAGAGCTTTTTACAAATAGCCCTCGAAGAACCCGAACTCATAAATTACTTCCTGAAAGTTTACCTCGTA +AATACGGAAGTTTTTAAAGATGATTGTAAAGGTTTTGCGTGCGTCAGTGACGTGGTAACGGAAGTTATGA +TATTTGTGAGTGACGGGGTTGAAAAGGGCATTTTCAGGAATCAGGACTTCTTCACAGCCTTTGTAACCAT +TATGGGTCCTCTTGGGGGTATAGTATTTCTCCACAACGAAGGACTCCTCGAGAAACCCCTTCTTGAATAC +GCCGAAGAACTTGCACAGAATATATGGAACGCTTTAAAAGCTTAACAAATCTTATCAAAAGCCTGTTTTT +CTAAAAATCCTACAAGGTGTTTAAACTTCCTATCCTTTTTCTTCTCCTCCTCCACGGACCTTATGGCGTG +TATGACCGTAGTGTGATCCTTCCTCTTAAAAGCCCTTGCGATTTCTATCAGACTTGCGGAACACACCTTC +CTGCACAGGTACATCGCTATCTTTCTCGCCTCGCTCGTCCTTTTATTCCTCTTGTCAGAGAGTATGTCTT +CCACCTTCACCGCGTAGTAATTTGCCACAAACTCTACTATTTGCATTAGCTTGTCCCTTTCCTTCCTTTC +TTTTCTTTCTAAGCCTTCAAATCCCTTTAACTTTATGAGTTTAATCTTCCCCTCTATCTCCCTTACGTTT +TTCGTGTTCTCTAAAAGGTAATCAATAACTTCCTTTCTGAGTTCAAGGTTAAACTCCTTTAACTTTTCCT +TTATTATCTTGAACCTCGTTTTATTGTCCAGCTCTATCTCTACCAGAATACCGCCTTCGAACCTGCTCAC +CAGTCTGTCAGAAACTCCGTCGAGCTTTTGAGGGTGTCTGTCTGAGGCTAGGATTATCTGCTTTTCTAGG +AGGTAGAGAGTATTAAAAATGTGGAAAAACTCTATCTGAGTTCTTTCCTTCCCCGAAAGGAATTGAACGT +CGTCGAGGAGAAGAAGGTCAACACTCTTGTACATATTCCTGAACTCGTTTATCGTTCCCTTTTTCAGATG +TTCAACCATAGCCTGTGCAAAGTCGTCCGCCGAGGAGTATATAACTCTGTAGCCTCTCTTTTTCGCTTCG +TTTCCCGCGGCCTGAAGGAGGTGTGTCTTTCCAGTTCCCACGCTACCGTATATAAAGATCGGGTTGTACA +AACTTCCGAGGTTTTCTAAAGCTTCCTTTACTACCTCGTAAGCGAGTCTGTTCCCCTCACCTACTATAAA +GTTCTCCAGAGTGTACTTGGGATTGAGGAAGTCCTTTATCTCTACCTTTTTCTTTTCTTCCTTTTCTTTT +ACCTCTATAAGTTTTCTTACTTCTTCTTCTAAGAAGGTGTTCACTATTGTCTCGAGCCACTCTCTGTAGT +CTTCTCCTGGAGCTATGAACAAAAACTTTCCCTTTTCCTGTTTTATCTCGAATTTTTTCAAAAACTCCCT +CGCGTAGGAGTCCACGCTCTCTATCTTCTTTATTAGTGCGTTTAGTTCCATCTACAAAAAGCTCATTATC +CACGGGAAAGTGAAGGAGGTAAACTCAAAAAAGTCAAGGAGAGTGAAAGGGAAAAGAGGAAAGAACTTAA +ATCACTTAAAGAGTGTTAAAAACTTTTCCCTCTCTACCGGCGGTATTTCAAGGACTTTGATGTTTTCGAG +CAGGTGTTGAGTCTTGCTCATTCCTATTAGGAAAGTTCCCACTCCCGGGGTGCTCCTTACAAACTGTATG +GCCACGTGAACGTCGTTTTCAAGTCCGAAGAATTCCTTTAACCTTTCGGGTACTCTTCCTATTACGTTTC +CCTGATAAATGGTTGCGCTGATATACGTGTAAACGCCGAGTTCCTGTGCAGCTTCCAGAGTGGATAGCGT +TTTGCCACTTACCTGCTGGTTCTTAAGCGTGAAGGCTTCCGGCATACCGAGGTTGTAGGGGAGCTGTATG +AACTTAAAGTGGTGGTTTTCGCCCGCAACGCTCTTTGCTATGTCCAGAATTTCCAAAAGACTTAAGTACT +GCCTAGAAGAGGGAGTAAGTCTAAAACCGTGCCACGTTGCAAAGCCGTAGAACTTGAGCTTTCCTTCCGA +AACCTTCTCCTCTAAAAGTTCAAAACACTCGGCCACCTTTTTATTGAAACGATTCCTGTCCACGTAAAGG +AGTTGCTCCTCTGGGTTATGTAGGAAGTACACGTCTATGTAATCGGTTTTCATGTTTTCAAGGCTTTTGT +TGAAGCACCAGTTTATGAATTCCCTTCCAAGGTAGTGTCCCTGAGGTGTCATTTCAGAGAGGTCTATAAT +CCCCGTCTTTAGAAAGTTCTTTTCAAAGTACTCCTTAGGGTCTTCACCGCTTTCTACGTCGTAGGGGATG +TATCCGCCTTTTGTGGAAACAATTACCTTTTCCCTTTCAACCTCCTGAAGGACTTTACCCACAACCCTTT +CGCTCTTCATGTACCTGTAATTGATTGCGGTATCAACAACGTTTATTCCAAGCTCAACAGCCTTCTTTAT +CGTTTCGTAATAACCCCTGTCCGTCTCCTCGTCGAGCTCACCGAGATACGTCCCGACGCCCATTTCTGAA +AGTCTTAATCCTTCAAACTCTTTGTAAAGCATAATGTAGTTAATTTTAAGTTAGGAACACAGCTTGGGAT +TTCCTTAAGGGAATATAATATTTATTTAGTAAATCTTTATAAGGAGTGGAGAAATGTACACGCTCAGAGA +ACCCTACAAAGGCTACGAGGTCAAAGTAACGCTCCTGCCTATAGAGGATATAGTAATCCCTCCCATACAG +AGGGATTTATCGGAGACATTGATAAAGAAGTTAATGCTCAGCATAGAAAAAGTTGGATTTGTAGATCCCA +TACTCGTCGTTGAAGGAGAAGAAGGAAAGTACGAGGTGATAAACGGTCAGCACAGACTCAAGGCTGCGGA +ACTCCTCGGCATAAGGGAAATTCCCGCAATAATTCTGCCTCAGGAAACTAAAGACTACATAATATCCCTC +AACGTTGAAAAGGCACCGAACTTAAAGGACAAGGCTCATCAGGCTTACGAGATATTCATGAAGTACCTTA +AGGAAAATCCCGAAATGGAGGAAGTGGAGCTCGAAAACATGGTGGAAGAACCTTACTTCCTTACGGTTGG +TTTCATTACTGACCGCTTCGGAGAAAAGAGGTTTCCCGCTTACGCCTTTGAAAAGGTTCTGAAAAAAGTA +GACGAGTTTTTAGGTCTTCCCCTGGAGGAAGCGGAGAGGGAAAGGGAAAACAGGGCAAACGTCCTGAGAG +ACGTCAGGGAAGTTATGGAGGAGAAGTATCAGGAACTCGGACTCACAAACGCCCTTCACAAGGAAGCGAT +AATTTCTAAAGCCTTCCAGTCCGTGTACGGAAAGAGAGTAAGGAAGGTAGATGACGACTTTTATACGGTA +TTTGAAAAGATAAAGGAAGCCATACCCAGAGTTTCCTTTACCGAAGAAGAGCTGGAAAGCTTTTAAAGAA +CGAATACTTCCGAGGTTATCTTTGGCTCTACTTCCTCTCCGAGTATTAACTTAATTAACCTCTCTAAATT +CTGAGACCTGTCCGTAAAGTAAAGCTCAAGACTTCCGCTTCCTTCGTTTTTTACAAAGTCCTTTAAGGAT +TTCGCGGTTGCACGGGAGGAGTCTATCACATTCACACCTTCCAGAAAGTTTTGTATTTCCCTTTTGAGCA +GAGGATAGTGAGTACAACCGAGGATTAATGTATCCACCTTTCCCTTAAAGTCCTTCAGGTAATGCTCCAC +TACCTTTTTCGGTATTTCTCCCTCAATCATTCCTTCTTCCACCAGAGGCACAAAGAGCGGACAGGCTTTT +GAGTAAACCTCTGCTCCTGCCCTTTTTAAGGCTTCCTGATAAGCACCGCTCTTTATAGTAGCCTGCGTGC +CTATGACTCCTATTCTCTTCGTTTTTGATTTTCTAAGGGCTTCCTTAACTCCCGGCTCTATTACTCCGAA +AACTGGAAAGGGAAACTCCCTCTTTAATTCTTCAAGGGCGTAGGCGCTTGCAGTATTGCATGCGACTACG +AGCAAGTCAACACCCTTGTCCTTCAGGAAGTTTGCGCACTCCTTTGAGTACCTTACTATCGTTTCCTTTG +AACGTATCCCGTAAGGAACTCTTGCTGTATCTCCCAAGTAAACTACGTCCACGTTCGGATAAGCTTCCCT +TATGGCTTTTAAAACCGTCATTCCCCCCGCACCACTGTCAAAAATCCCTATTTTCATAAAGAAGATTTTA +CAATTCATTCCTTGATGCAATTTGAAGTCCTGAAGAGGTTTTTCCCTAAAGAGAGTCTGAAAAATTGCAA +AGGAGCTTTATGGGTTCACACAGCAAGTATAGGAGAATTCAATACTTTCCTACCTATCCTTAAAGAACTA +AAAAGAGAACACAGAATTCTGCTCACTTACTTTTCCCCCCGTGCAAGGGAATACCTAAAGACAAAAAGTG +ATTTTTACGACTGCCTTCATCCTCTCCCTCTTGATAACCCATTTTCCGTAAAGAGATTTGAAGAACTATC +AAAACCAAAAGCCTTAATAGTAGTTGAAAGGGAATTCTGGCCCTCTTTAATAATTTTTACTAAAGTTCCC +AAAATCCTCGTCAACGCCTACGCAAAAGGGAGTTTAATAGAGAAAATTCTCTCAAAAAAATTTGACTTAA +TAATAATGAGAACTCAAGAAGATGTGGAAAAATTTAAAACCTTTGGTGCAAAGAGGGTATTTTCCTGCGG +GAATTTAAAATTCATTTGTCAAAAAGGAAAAGGGATAAAATTGAAAGGTGAATTCATAGTAGCGGGAAGT +ATCCACACGGGCGAAGTTGAAATCATTCTAAAAGCCTTTAAAGAAATAAAAAAGACTTATTCAAGCTTAA +AACTGATACTTGTCCCGAGGCATATAGAGAACGCAAAAATCTTTGAAAAAAAGGCGAGGGACTTTGGTTT +TAAAACTTCCTTCTTTGAAAACCTCGAAGGTGATGTTATCCTAGTGGACAGGTTCGGGATACTTAAAGAA +CTATACCCGGTCGGAAAAATCGCAATAGTTGGCGGAACTTTTGTAAATATAGGGGGGCATAACCTTCTGG +AGCCCACCTGCTGGGGCATTCCCGTAATTTACGGACCTTACACGCATAAAGTAAATGATCTGAAGGAATT +TTTAGAAAAAGAGGGAGCTGGATTTGAAGTAAAGAATGAAACAGAGCTCGTGACAAAACTCACGGAGCTC +CTATCCGTAAAGAAAGAGATTAAAGTGGAGGAAAAATCAAGGGAAATTAAGGGATGTTACTTGGAAAAAC +TTAGGGAGTTTTTAAGAGGTCTTTAACGAAGGGAATTACGACCTCGTTGAACTTTTCGGGGTTTTCAAAA +GGCGGAAGGTGTGCGGAGTTTTCAAGCTCGTAGTACTTTGCTCCCTTTATGCCCTCTGCAATCTTTTTCA +CAATCTCCGGAGGAGTGACTCTCTCGTCGTCTTTTCCCGCTATCACGAGCGTAGGAACGTCTATACTCGG +AAGCAGATCCGTGTTATCCTTCCTTTCTGCTAGAGCCTTTAATGTCTTCACTATGCCTTCCCTCGTTGCC +TTTTCCATTATGCACCTGAGTGTCCTCATCTTGTTTTCGTCCTTCTTCGTGGCAGGGGAAGTCTGGTTTT +CGAGCATAGCCTCTATTAAGAACTCCTTTCCTTCCTTCTGTACTTTCTCTATTAGGGCGTAGCGTGCTTT +TTTGCCCTCTTCGGTGTCCGCCTCCGCCCTGGTTGCAACGAAAACAAATCCCTTTATCATTTCCCTGTAG +CGTCTCCACATGTCGAACATTATGTAACCGCCCATACTGTCTCCTATCGGGATTACCTTCTTTACCCTGA +ACTTTCTGAGTTCGTTTACGACGTAATCCGTTAATCTCTCTACCGTATACTCTCCGGGAAGGTTTGGAGC +GTCTCCGAAGCCCGGATAATCTAAAGCTACGTAAGGTATTCCTTCCTCTTCAAAGGCACAAAACTGGTAC +CTGTACATCTCTTTGTTCAGGGGAAAAGCGTGCAGGAAAAGTACAACTTCGGGAAAGTAAGTTCTCAGCA +TAAAAATTATTCTAAAATAGAAACTATGCTGAGACCTAAGGGATTTGACAAATTAGACCACTACTTCAGA +ACAGAACTGGACATAGACCTGACCGATGAGACCATAGAACTGCTCCTGAACTCCGTTAAAGCTGCCTTCG +GAAAACTCTTTTACGGTGCGGAGCAAAGGGCAAGGTGGAACGGAAGGGACTTTATAGCCCTTGCGGATCT +GAACATAACCAAAGCTCTGGAAGAACATATCAAAAACTTCCAGAAGATAGAACAAGATATGGGAGTGGAC +GAGCTCCTTGAGTACATAGCCTTTATTCCTCCCGTGGAAATGAATGTAGGGGAAGACCTGAAAAGTGAGT +ACAGGAACATAATGGGCGGACTCCTCCTCATGCACGCGGACGTTATAAAGAAGGCAACGGGAGAGAGAAA +ACCCTCAAGGGAGGCTATGGAGTTCGTAGCCCAAATAGTTGACAAAGTTTTCTAATTGATTATTCTTTTC +AGATAGGGGCTAGTATGAATAAAAAGGAACTTATTGACATACTTCTATACGACGTTGCATTAGAGCATTC +TGCCATAATCCAGTACCTCTACAACGTGTTCCTGATAGGAGATCCCGAAATAACGAACGAGATAGAGAGT +ATAGCAAGACAGGAAATGCGTCACCTCAAGTGGTTTGCCCAGAAGGTGGTAGAACTTGGCGGAAAGGTAA +CTCTGAACAGGATAGAGGAGGCTATAAAGGTAGGACAGAGCTGGGAAGAGATGCTCAAAAACGACGTGGA +TGCGGAAGAGGAAGCGATAAAGATATACTCCCAGCAACTTGAAATAGTGAAGGACGATTCTGTGAAAAAG +CTCTTGGACAGAGTGATAAACGACGAGATGAGGCACAGGGACGAGTTTTCCGAAATGCTCGAAGAACTCA +AAAACAAGAAGATAGAAGAAGCTAAACAGGAAGCAGGGATAGACTCCGAAATATTCAACATACTCAACAA +ACTCCTTCAAAAGGAGTACAGGCTAATACTGGACTACCTCTACCACTTCTTCCACTCAAAAACGTGGCAG +GAAAAGGACACTTCTTTAGATATAGCAATTGAGAGCATGTTCCACATGGGAGAGCTTGGTGAAAAGATAG +GAGAACTGGGAGGTTATCCCGACCTTTCCCTACCGAAGGCAAAACACTTTAAAGGATTCACACCAGAGGA +AGTTATAGAGGACATAAAGGAAGAAGAAACTGCAAGCAGGATGTACGAAGAAAACGCAAAGAAGGTAACG +AGGGAAGACTTAGTAAAACTCTTTAAGTGGTTTGAAAAACAGGAAGACTACCACGCTCAGAGATTAAAGG +AATTATTTAGGAAGATGAACAGGTTCACTATAGGGGGCTTGGGAGAAGAGTCTTAATACTTGCCAAATAA +AGGGCTTTTTTATAAAATAAAAATCTTAGGTAAGCCGGAGTGGCGGAACTGGCAGACGCGCCGTCTTGAG +GGGACGGTGCCCTTTACGGGCGTGCGGGTTCGACTCCCGCCTCCGGCACCACAAAATCCCTTAAAATAAT +CAAATGCCGAAAAACGACCTCCTTTTGAGAAGCCTCCGCGGAGAACCCATAGGGCGATTTCCCGTCTGGT +TAATGAGACAGGCAGGCAGGTACATGCCTGAGTACAGGAAAATAAGGAACAGAGTTAAAAACTTTCTTGA +ACTCTGTAAAAACGTAGACCTTGCCACCGAAATCTCGCTCCTTCCTTTAAAAATTCTTGGTGTTGATGCG +ATAATCATCTTTTCCGATATCCTCGTTCCCTTGGAACCCTTAGGTGTAAAGGTCGAGTTCGTAGAGGGAG +AAGGTCCGAAGCTCTCTTGGAGCGGAAAGGTTTCTGATTTGAAAAAGTACGACCCGTCTCAAAACGCATA +CGTTTACGAAATTATTAAAAGGGTTAAGGAAGCTCAGGACGAAGTTCCCGTTATAGGTTTTGCCGGAGCA +CCCTTTACACTCCTCTCGTACCTGATAGAAGGCGGGGCGAGCAAAGACTTCAAAAGTACTAAACTCTTTA +TGTGGGAAAATCCCAAGGAGTACAAAAGGTTGATGGACATACTTACGGAAACTGTACTGGCTTACTTGAA +GGAACAGATAAAGGCTGGAGCGGATGTGGTTCAAATATTCGATAGCTGGGTCAACAACCTGAGCCTTGAG +GATTACGGTGAGTACGTTTACCCTTACGTGAATTACTTAATTTCTGAGCTGAAAGACTTTTCGGATACAC +CCGTTATATACTTCTTCAGAGGTTCTTCCTCATTTATAGACCTGGCGGTGGACTACAGAGCTGATGCCCT +TTCTGTGGACTGGAGCGTTGATATACCCGAACTCTTTAAAATCTACGATAAAGGCTTTCAGGGAAATCTT +GAACCTGCGGTTCTGTACGCAAGCGAGGAGGTTATAGAAGAAAAGACTTTAGGACTCCTCAGAAGAATTC +CCGTAAAAACTAGGTACGTTTTTAACTTGGGGCACGGGCTTGCCCCCGACATGGAACTTGAGAAAGTTAA +GTACCTCGTGGATCTGGTCAAGTCCTTTCCTTTAACATAAATCTTCCCGCGTAGTCCTTTGCAAATTGAT +AGGCAACTCTTCCCGAAAAACTGCTCCTTTCCGTAGCCCACCTGAGGGCTTCCCTCTTAACTTCTTCGTC +CATGGGAATACCGAACATCTTTAAGTAGTTTTCCACGATTTCTAGGTAGAGTTCCTGAAAAACGGGTGGG +AATTGAAGTCTGATACCGAAGCGTTCCACTAAAGAAAACTTTTCGTGGAGTGCTTCCTCCGGAAATTTAT +CCTTTTCTTCCAAATCCGGAGAGAGGTGTCTCCTGTTTGTAGTTGCGTAAACAAGACGTTCTGGGGTCTT +TCCTCAACATCTCCCTCCATAATAGATTTTAAAAGTCTAAAGGCATCCTCATGTGGCTCAAAGGTCAGGT +CGTCGAAAAAGAGTATGAACTTTTCTTCTTTATCTCTCAGGACCTCGTAGAGATCTGCGAGTTCGGGAAT +TTCGTGTTTGGTTACCTGAACTATCCTTAGTCCCTCTTTTCCGAAAACTCCCAAGAGAGCTTTTACCAGA +GAAGACTTTCCTGTTCCCCTCGCACCCCAGAGGAGCACGTCGTTTGCGGGAAGTCCCTTCACGAATTGAG +CCGTGTTCCTGAGTAAGACTTCCTTTTGCTTTTCTACTCCGAGGAGGGAGTTTATATCTGGTATGTGGGG +GTGTTTTACGGGCTCAAGCTTGTTTATCTTCAACCTGAAGGCGAGGTGTTCTTTGAAAAACCCTTCGGGA +TAATCCCTGGTGTTTAAACCCTTTGAGAGTTCCTTTACGAGTTGCTCTACGAGGCTCATAGGTTTATAAT +AATACTTTGTAGAGCGGGCGTAGCTCAGTGGTAGAGCGGCTGCTTGCCATGCAGCAGGTCGCGGGTTCGA +GTCCCGTCGCCCGCTCCATATAAAAAGGCGACGTGGCCGAGCGGTTAGGCGGGGGACTGCAAATCCCCTT +TACGGCGGTTCGAATCCGCCCGTCGCCTCCACCAATTCCTTGATTTCTAAAGATAAACAAACAAAACTGG +GATTTCTCAAGTCTTCCTTGTTGTACCTCAAAGGTTCTCTGAGTTTTCCCTCTTCGTAAACGAAGAGTTC +ACAGCCCGCCTCTTTTGCTACGGCATGCCCCGCTCCCGTGTCCCACTCCATAGTTGGGGCAATTCTCGGA +TATATATCCGCACTTCCTTCCGCAACCATACATATCTTTAGTGAACTGCCCTTTGAAAGGAACTGGAGTT +TACCAAATTTCTTTTCTAAATTTTCGAGGAATTTCTTGGTTTCTTCGTTCATGTGGGAACGGGAAGCCAC +GACCCTGAGGTTTTCCCTACTCCAATTTCCAATGGGAAGTTTTTCCATTTTTCCCTTTACCTCTCTGTAA +GCTCCGTTCCCTTTCTCGGCAAAGTAAAGCACTTCTAAGGCAGGTGCGTAAACTACTCCGAGAACAGGTT +CTCCTTCCTCTACGAGGGCTACGTTTACGGTAAACTCTCCGTTCTTCTTTATAAACTCCTTCGTCCCGTC +CAGTGGATCAACGAGCCAGAACCTTTTCCATTTTCTTCTCTCTTTAAAAGGAATTTCCTTTCCCTCTTCC +GAGAGTACAGGTATTCTAGTTTCCTTTAACTCTTCCGTTATTATTCTGTGAGCCCTTCTGTCCGCTTCCG +TAACGGGAGTCCTGTCTTCCTTTTCTTCAACTGTGAACTCCTTTGAGTAAACTTCTAAAATTTCCTCACC +TGCTTTTTTGCAGGCTTTAATCACCTTTTCTAACATTCTTTACTCCTTTTCAAAAACCTGTATGTAAATG +AGTCCTAAAAACTTTCTGCTGAAGTAAATCTCCTTAAAGCCGAAGCTTGTGAACATTGATCTCGTTTCCT +CAGGAGAAAGGCTTTCCTTCAAACTCTTTATAAAGAACTCCCACTTATCCCTGCCGAAGAAGAGAAGACC +TACAGGAAGGAGTAAAGTTTTCATTAAAAGAATCAGAACTCCTGTTCCTTTAAACCTCCCTATGTCTATA +ATTCCCACCCTAACTTTTTCTTTTCCGACTCTTTTTGCCTCCTCTAGGAACTTTTCCTTATTTTCAAGGT +GTCTGAACACGAGAGAGAGGGAAACCCTATCAAAACTCTTGTCCTTGAAGGGCATATTCTCCGCATCCGC +AAGTAAAAAGTAACAATCCCCGCACTTTTCCTTAGCTCTTCGGAGCATACCGAGGGCTAAATCTATCCCG +ACTTTGAGGTCAGAGTTTTTTAGTTTTAAAAGCACTTCCCCCGTTCCCGTTCCGACATCCAGCCAGTTTC +CCTCCTCTCCCATCCTCTCTATTAATTCCTTCTGCCACCTGTGTATACCTCCGAAGGTTGCAAGACTCAC +GAAAAAGTCGTAAACCTTTGAAGCACCGGAAAATACTTTAGCCATTATTTCCTTTTCAGCCATAGATGTA +TTATTCTAATTCTTTACGGAGATGTTTACCTTTGCTTTGTGTCCACACGATACAGAAGAGAAAAAAGAAT +TTGAATACTGGGAGAATATAGCAAAGTCAATATCAGAAAAATTAAAAGAAGATGTAAAGATAATAACTTT +TAAAGATTATGCGGAAGAAAAATTAAAACTACCTTCTGCGGATTACGATATTTACTATGCAAATCCGGTA +AGCTCTTACTTTTTATACAAAAAAGGATATAAACCCCTTGCAAGATTAAAAGGGAAAAGGGACAGTTTTG +TAATTATTGGATACGAAAATGTAAAAGACCATCAACTTACTGTAACGACAACGTACATAGAAACCCATTT +GCTTCCCGTTTTAGTTCTGGAGCATTTTGACTTTTTAAAAACCAACATATTTTTCGTTAAAACCCAAAAG +GAAATATACGAAAGCGTAAAAAATAAAAAAGCAGACTTTGGAATAATGTTTGAAGATGCATACAATGAGA +TTGAAGACGAAGAAAAAGTACCCGTTATCGTAAAAATACCTTCAAACTTGAGACATACCTTAATGGTAAA +ACCCGAAATTTATAAAAAACTAAAAGAAGTTATAAAAGAGTTTGAAGAGTTTGAACTGATTGATGATAAG +GAATTTTTGGAAGGTATAACTGAAAATCTGCCAATATTGGCTTTTTTAAAAACAAAAGAGTTATTCGACG +TATCAAAGGCTATTTACAACGAGCCTTTTGTTGGGGTTTTAATTTACAGGGATAAAATTGTTTATGCAAA +TGAAACGATTCAAAAACTAACGGGATACACATTAGAAGAACTTCAAAATTTACCTTTTGAAGAATTAGTA +GCAGAAGAACAAAGAGAAGAAATAAAAGAAGCAGTAAAAAGAAGATTAAGAGGTGAAATTTTTTCAAAAG +GTTATGAAAACTTAAAAATAAAAACAAAAGACGGAAAATATTTATATACACTTGCCTTTTCAACCACAAT +GCTTTATAAAAACTCATACGCGGGACTTGTTTTCTTCATAGATATAACAAAAGAGGTTTTATACCAGAAG +CTTTATAAGGCATTGAGAAATGTAAACAGGGCAATAGCAACAGTTTTAACGGAAAAGGAACTTTACAAAA +CAGTTTGTGAAACTCTCGTAAAAGAACTTGATATTAAATTTGCATGGATTGGTGTCCCCGATGAAAAAAC +GAAAACGTTTAAATCTATATATAAATGCGGTGAGGAACAGGATTATTTAAAGCATATAAAAATTTATGCA +GGAGGAAGTCTTCCAGAGGCAAAAGGACCTACAGGAAGAGCGTACACTGAAGGGAAAATAGTAATAAACC +CTTCAACGGAAGAAAACCCTCTAATGAAACCTTGGAAAGAAGAGATGTTAAAAAGGGGTTTCCTGTCTTC +TGCAGCTATTCCTATAATGAAAAACGGAAAAGTTCATGCGGTATTAAATATATACGCTTCCATTCCTCAT +TACTTTGATGAGGATATAAGAACTCTTTTAAAGGAGTTAAAACAAGATTTAAGCTTTGCCCTTGAGAAAA +TTGAAAGTATTAAGGAATCAAATATCCTGAAAATTGCGATAGAAAACTCTAGAGAGTGGATATTGATAAC +GGACAAAGACGGAAATATAGAGTACGTTAACGATTTCGTTTCAAAATTGACAGGTTATAAAAAAGAAGAA +CTGATAGGTAAAAAGCCGAGAATTTTTAAGTCTGGATATCACCCGAAAGAATTCTATGAAAAACTCTGGA +AAACTATCTTATCCGGAAAAAGAGTTTGAGGCTATATTCGCAAACAGAAAGAAAAACGGTGCAATTTTTT +ACATAGAACAAAAAATTATCCCTGTAAAACTCCCGGACGGAGAAATAAAGTTTGTTGCTATAGGAAGGGA +TATAACTACGGAAATAATGCTTTTAGAGGAAAACGAAAGGTTGAGATACTACGATGTGTTAACGGATCTT +TACAACTATAACGGATTTGCCTTGCAGGTTATAGATTACATTAAAAAAAAATCCCGATAATTTATCCGCA +CTTATATTAATAGACATAGCTGACTTTTCCTACATCAACAAAGTTTACGGATACGATTTCGGAGATGAAC +TTATAAGAAAAATTGCAGAAATATTAAAGAAGAATTTTAAAGAAAGTGATATAATAGGTAGAATTGAGGG +AGACTTATTTGCAATATTTGCAAAAAATTTAAAGAAAAAGGAAAATGTATTCTCCCTTATAGAAAGGCTT +AAGGAAATTCTGGATAAAGATGTTGTCTTTGAAGTAAGGGGCAAAAAATTACATATAATCTTCCACGGAG +GCGTGTCTATTTATCCGGATGATGGAAAAACCTTTGAGGAACTACTTCAGAACGCCAGGATTGCTTTAAA +AGAAGCCAAACAGGAAGGTTATAACGTAGTAAAAATATACAATAAAGAACTGGAAAAAAGGCAGAATCTT +TCATTTATATAGAAAATCTTCTAACGGAAGCGGTAAAGGAAAACCTATTCGTATTCCATTACCAGCCCAT +CTTTGAAGCAAAAACGGGAAATTTGGCAGGATTTGAGGCACTGGTCAGGATAAAGAAGGAAAGATACATT +ACCCGAATGAGTTTATAAACTTTCTGGAAAATTCCCATTACCTTGATTACTTCAGGGAATGGGCTTTAAA +GGAAGTGACGGATAAAATAAAAAAGTGGAAAAAAAACCCATAAGCGTGAACGTAACCGCAAGGACGTTTA +AAAATGAAAACTTCCCGAACGAGTTATTTAAATATGCAAAAGACATTCCTGCACCCCTGATTCTGGAAAT +AACGGAAAGGATTTACATGGACGATGTAGAAACCTCAAGAAAGATTATAAAAAGGTTAAAAGAGAACAAA +AATGTAAAAATAGCGATAGACGACTTCGGAACAGGTTACTCGTCCCTTTCTTACCTGAAGGACATAGATA +CGGACATCCTGAAAATAGATATGTCTTTTGTAAGAAGAATTGTGGAAGACGAAAAAATAAGGGCGATAGT +AAAGGCAATAATAACCCTTGCGAAAGACCTCAACCTCTCAACTCTGGCGGAAGGAGTTGAAACGAAAGAA +CAGTACGAAATCCTTAAAAGTATGGGAGTTGATTTAGTTCAGGGATTTTACTTCTCAAAACCCCTGCCTG +AAAACGAAGCCCAGCTTTTGATATAAGCTAATTTCTATGAGTAAAGAAAAGTACTCCTTTGAAGACCTCA +TAAAGGTTATGGAAGAGTTAAGGAAGAAGTGTCCGTGGGACAGGGAGCAGACCCACGAAAGCTTAAAGAA +GTACTTAATAGAAGAAGCTTACGAGGTTCTGGACGCTATAGACAGCAAAGATGACGAGAAGTTAAAGGAG +GAGCTTGGCGACCTCCTCCTTCAGGTAGTTTTCCACTCTCAGATAGCTAAGGAAAGGGGAGCTTTTGATA +TAAACGACGTTATAGATACTTTAGTTAAAAAGTTAATAGAGAGGCACCCTCACGTTTTTGGATGCGCAAA +CCCCGAAGACGTTCTGAAAAACTGGGAAAAGAAGAAGATGGAAAAGAGGAAGAGTATATTCGAAGGAATA +CCGAAGCACCTTCCCGCCCTGATGCGTTCCCAGAAACTTCAGGACAGGACTTCTCAGGTAGGCTTTGACT +TTCAAGACATAAGTCAGGTATTTGAAAAGATTCAGGAGGAGATAAACGAACTCAAAGAGTCTTTAGAAAA +AGGAGACAGAGAAAATATAAAACACGAGATAGGTGACATTCTTACCGCAGTTGTAGAACTCGCGAGGTTT +GTAAACGTGGATGCGGAAGAAGCCCTGCAGGAAGCTAACGAGCGCTTCATAAGACGCTTTTCCTACATAG +AGAAAAAGGCGAAGGAAGAAGGTAGAAAACTGGAAGATATGAGCCTTGAAGAAATGGATAAACTCTGGAT +GGAAGCCAAAAAACTCGAGGAACAAGGAAAACTATCCTAAAGGTAAGAATTTTGAGAATTCCTTCAGCTT +CTCGTACCCCACCACCTCTTCTTTTTGGTAGGGAATGGATATTTTTTCAATATCCATGAAGTAGTTTTCT +ATTTCCTTTAAAAACTTTTTTTCCACTTCTTTCCTCGCTTTTAAAAACTCATCCTGTGGATTTTCTGGAA +GAACCTTATTTATTATGAGAGCTTTTACCCTTATTCCGTAGTGTTTTAAGGAATTTACGAGTCTTTTCGT +TTCCTCAAAGGGGAGTTTTTCGGGAGTAAGTACCGCAAAAAAGTAGGATTTATCGTAAATTATTTCAGAA +AACTTTTTGAAACGCTCCTTTCTCTCTTTTAAGTATTCCAGTGCCTCTTCGTGGACGCTTTTTCCCGACA +ATTTCTTGAGTTCGTAAACTTTTTCCTTGAGTTTTACTATTTCTTCTAAGAAGTTCCCGAGATTTCTTAC +GGTTTTTAAAAGCCCGAGAGTGTGTCCCGTGGGAGCGGTATCCACGACTATGTAGTCGTACTCATTTTCT +CTGTACACAACTTCCTTTGAAAGGGCTTCGAAAATAACCACGTCCTCTATTCCCGGACTCTCTTCAAGGG +AGTGTATAATTCCCTCAAGTTCTCTCAAGGTTTCCTTTCTCAGCGTAGCCTCTGCGAGTTTAAAAACCCT +GCTTCTGTACTCCTTTAATTCCTCGTTCAGATCTATTTCTTTAACTGTCAGGTTTTCGCTCAGTTTCGTT +TCTCCTTGAAGTTCTGTGTTAAAAACGTCAGAAAGGGAGTGGGCTGGATCTGTAGAAAGGAGTAAAACCT +TTTTTCCCTGTTCTGATAGCTTTACCGCAAAAGCGGAAGAAGCGGTCGTTTTGCCTACTCCTCCCTTTCC +TCCGAAGAAGAAAACCCTCATTTTTTAACTCTCTTAATTATGTAAGGGAGGTAATCCTTTATCCCTTCTT +CTAAGGAATACTCAGGTTCGTATCCGAGGGCTTCCCTTATTTTTGTGAGGTCTGCTTCTGTGAATTTCTG +ATAAAAATCGTAAGGACAGTCAAAGTACTCAATTTCGTAATTCGTCCCGAGTTCTTTGTTGAGGATAGAA +ACGATTTCGTTGAAACTCCTTGCCCTTCCCGTACCCACGTTAAATATACCAGAGACGTTCTTTTCAAGGG +CAAGAAGGTTTGCCTTAATTACGTCTTTTATGTAAACGAAGTCCCTCCTCTGTTCTCCCCATTTAAAGAG +TCTCGGTCTTTCCCCTTTTATCATCTTCACCGCAAGCTGGTAAATCATACTCGCGGTTTTTCCTTTGTAG +TCCTCCCTCGGACCGTAAACGTTGAAGTACCTCAACCCCACTATGTTCATCTCGGGATACCTTTCCATAT +AGTCCATAGCTATGTGATCCATCATGAGTTTTGAAAACCCGTATATGTTTTCAGGTTCAAGTCCCTTGTC +TTCCCTCATGGGAGGCGGAGAGTTCCCATAGACCCCTGCGGAGGAGGCGTATATGACTTTTGCATTCCAC +TCAACCGCAAGGTCCAGAATGTACCTGAAAGAATCCGCATTCGTTTTCATCATAAAGTATTGATCTTCCA +CCGTTGTGTCCGTTATAGCCGCTTCGTGAAATATCACGTCAAAGTGGAAGTTTTTCCTTACGTAATCCCA +TAAAGAAGGATCTGAAATATCTCCCGTAATAACCTGCCCTTTAAATCCGATTAAGTTCTTAAAATGCCCG +GAAGAAAAGTTATCAAGCACGTAAATCTTCGCTTCGGGATACCTTTCTTGAAGCGCAAAAGCTAAATTTG +AACCGATAAAACCCGCACCGCCTGTGATTAGGAATTTCATAATTATATTATGCAGTTCCTGAAAGGTGAT +AAGGCTTTTAACTTCTTGCTTGGGCTTATATACGGATACAGAACCGCGGACGTGGATATGAAGATAAGAC +CACTTGAGGAATTCAAAGAGGAAGAGTATTCCGATTTCACCATTTACTACATAGATAGAAAAAGCGGAGA +AGTGAAAAAGGGAGAAAAACTTTCAGAATACACTCACGTGGTTGTACTGAAAGAGGACCACGAAAATAAA +AAGGTCAGAATTGTTATATTCAAGAGGTTGAAAAACTAAAGTTTTAAAATATCAGTAATATCCAGCTGGC +CCGTTTTTCCCGAAGGATAAAACCTACTAAAGAAGCTACTGTCGTATAAGCATATTCTTAATTCTTTATA +AGTAAATTGAATTGCACTTTCATTGAAGGGCCTTTAACTTAAACTGAGTGAAGGAAAAGTGGAAGTCAAT +TGCAAACTTATTGGAAGAGGAGTTTGACTTAGAAGTTCAGCCATCTTACGAAGGTTGGGGAGCGGGATAC +GACCCCAAATTCCTGCCCATACTCGAAATGTGGGCAAAAGGGGAAGTAGAGGAAATACCCCAGGGAGCAA +AGATACCGAGGGGAGTAATATTCAACGTAGTTGACTTTTTGAAGAAAAGCGAAGATTACACAGTTAATTC +TATAAGGCACGAAATAGGATTACTCCTTAACACTCACTTTCCCAGCTGGCGCTTCGGTCAGAGAGAGGTA +TTCAGAGCGGGATACGTTCCCACTTCCTTCTTGGTGCTCTTTGCGGTTCTGGAGAGTTTAAAAACGGACA +ACAAGATAATAGAAGAGCTCCCTTCCGCTTTTGTTTCTCTAAAGGCACGCTATAAGGAAATACTCTCTCA +AATAAAGGCACCGTACCCTTACCACCAGCTTGCCCTTTCCTTTGTGTACGCCTGGATAAACGAAGAACAG +GACACCTCCGAAGAGGTAAAACACTACCATTCCACTATGGAAAAGGCTTTTTACGAGTATCTGAAGGAAA +AAAATCCGCAGAGTGCTTACGACATAGTGACGGAGGAGCTCTGGCAAAAGTTCAGAGTACTCGTTGACCT +TTCTAAGGATCTAAACTACGTGGATCTTCTGATAGAAGAAGCAAGGGGAAGGAAGAGAGAGGACGCCCAC +AGGGCACGTATAATGACGGATATCCTCTCAAAACTTCCCGAAGAACTCAGGAATTACATAAAGGAAAACA +AAGACAAGAGTGCGGTAGAACTTCCTAAAGAAGACGTAAAGGTAATACTGAAGGCTCTTGAGGCTATACC +CGACTGGATGAAGGATTACATGAAACAGATGAGTTATATGAGCCTCCTTGAGAAGGATATAGAATTCCTG +AACTTCTTCCTGCCCAAAACCCTTGAAATAGACGTGGAACACAGGGGATTTGTTAGCTTCATATTCAAGG +CTTGGGAAGAAATTTCCGCATCTCAGAACCTGAAATCCAAGAAAAAACAGGAAGAGGAAGAAGAGTTATC +CGATTTAGACAAGAAGTTCAAGAAGGAGCACGGATTAACCCAGAAAGAATTCCAGAAGTACCGTTTAATC +TTAAAGAGCGTTCTTCCCTACGTTGAACACTTCAAAAGAAAATTTGATAACTTCTTGCCAAAAGAAGAAG +AACTGTGGGACGGCAAACACTTCAGGGGAAAGAGGATAAATCCGAGGAGGATAGCTACAGAAGTTCCGAT +AGGCAGGGGAAGGATATTCATGAGAAGGGAAGTTCCCCAGAGAAAGGAATTAATCTTTGAACTCTTAATG +GATATATCTTCGTCTATGAAAAAAGAGGAGAAAATCCTAAACGCTCTCAAGTCCCTTATACTCGTGTCCG +AAGTTCTCGATAAACTAAAAATGGAGTTTTCCATAAAAGTGTTTAACGAAAACGTCTACACCTTAAAGGA +CTTTTCCGAGGACTACAAAGTAGCCAAAGCTAGAATTATGGATCTCCTAAACGACTTGGGAGGAAGTACC +GACCTCAGCAAAGCCATAACCGTCGGGGTAGAGAGCCTCGAAGTGGTTATGAAAAAAGAACACAAGAAGG +GCGTACTCATACTGTTTACCGACGGACAGCCCACGAAAGGGCTAAGAGGGGAGGAACTTAAGTACTTTAT +CTCTCAGATGAAGATGAAACTACCCATCGTGGCGATAGGTGTCGGGGAAGCTACACACATGGTTAAAGAA +TACTTTGACAAAACCGGTCTAAGCGTTGAAGATATATCAAAACTACCTTCTGCTTTCTCCTTCGTTATGG +AAAATCAGTTCAAGAGACTCCTTTCCGTGGCTTAAATTAAATCCTGTCTGTTGCAGTACTCCATTGCGTG +CTCGGGGGAAATTTCTATCGCCCTCATTAAACACCTTACAGCTTTTTTAATGACCTGAGAAATTACCTTT +TCTTCCTCGGGTGAAAAGGGGGAAAGGACGTACTTAACAACGTCTTCCTTCTTCTTCGGTCTTCCTATAC +CTATCCTCAAACGGGGAAAGTTCTGTGTTCCTATGTACTTTATTATGGACTCAACGCCTCTGTGTCCTCC +TGAACTCCCTTTTAACCTAAGTCTCATATGCCCTAAGGGAAGATCAAGGTCGTCGTAGACCACTATCATC +TGCTCGGGTGATAGTTTGTACTCTTCGAGGAGGTTGTAAACTGCAGCCCCCGAGTTGTTCATGTAAGTCA +TGGGCTTTGCGAGTATTACTTCTTTTCCTCCGATACGGGCTTTGTAAACGTGGGAAAGGGCCTCCTCAAA +GGGCCCCTTTGCCCTAAGAGCCTTTACAAGTTCGTCTATTACCATAAAACCGACATTATGCCGGGTTTTC +TCGTACTCCTTCCCCGGATTTCCTAAACCTACTACTAGTTTAATGTCCATTCAATTAGGAAGTTGCTTCC +GTTTCTCCCGTTTCTTCTGCTCCTGTCTCCTCTTCGCCTATTACTTCTTCTTCGGGCTCGTAAACTACCG +CTACCGTTTCTTCAGGATTGTCAAGGATCATACATCCTTCGGGAGGTGTTATGTCTCTGACGTGGAGCGC +TTCTCCGAGTCCGAGTCCAGATACGTCAACCACTATTTTTTCGGGTATCTTTGCAGGAGGAGCTTTGATT +GTCAATGTGTGCATTACGGGTTCAAACGTTCCGCCGGCTTCTACACCCGCGGGTGTTCCAACGAATTCAA +TGGGAACTTCCACTTCAATTTCCTCAACGTTTGAGAGGTCGTACAGGTCGATGTGTATGGGATTGTTTCC +GAGCCAACCGAATTGAATGTCCTTTAAAAGACAAACCCTCGTTTCTCCGTCAAGTTCTGCCTCAATAAGA +AAAGCCTCTCCGTGGGGCAAGAAGCAAAATCTTTAACGTTAATCCAGGCGTGCTTATTCTCAACTCCCTT +TCCGTAAATTTCCACAGGGAGCCACCCTTCCCTTCTTTTCCTCTTAAGGTCGCTCTTCCTTCCGGGTTTC +CTTGGTAAAAGCTTAACCTTTACTCTCCTCATTTTCCATTCCTCCGTAGATCAGAAAACTTTATTATACA +TAAGTTTTTCTTTAAATTTATTCCTATGAGTGAGAGGGAAGAGTTCAAGTTCAACACGGTGGAAGAAGCA +ATAGAAGACATAAGACAGGGGAAGATGGTAATAGTTGTGGACGACCCAGACAGGGAAAACGAAGGAGACC +TCGTAATGGCTGCAGAAAAGGTTACCCCTGAGGCCATAAACTTCATGGCAAAGTACGGGAGGGGACTAAT +ATGCCTGTCACTCACTCCAGAAAGGTGTGAACAACTGGACCTCCACCCCATGACTCCTATGAATACGGAC +CCAAAAGGTACTTACTTTTGCGTTTCCATAGATGCCCACCCAAAGCATGGAACGACAACTGGAATTTCCG +CCTACGACAGGGCCTTGACTATAAAACTCGCTATTTCCCCCGACGCTAAGCCCTCGGACTTCGTAAGACC +AGGACACGTTTTTCCCTTAAAGGCAAGACCTGGAGGAGTTTTGGAAAGGGCGGGACACACGGAGGCTTCC +GTTGACCTTGCAAGACTCGCTGGACTCTACCCCGCCGGAGTTATTTGTGAGATTATGAAAGACGACGGAA +CCATGGCGAGGGTTCCCGACCTTATGGAGTTTGCGAAAAAGCACAACCTGAAAATAATCACAATAGCGGA +TCTAATAAAGTACAGGTTGAGGAGAGAAACCTTAGTAGAGAAGGTTGCAAGTGCTCACCTTCCCACTCCC +TGGGGAGTTTTCAAGATACACGCTTACAGGCACAAACTCACTGGTGAAGAGCAGGTGGCCCTCACGATGG +GTGAGTGGAAAGAAGACGAACCCGTTCTCGTCAGAGTTCACTCGGAATGCCTGACTGGAGACGTTTTCCG +TTCCTTCAGGTGTGACTGCAGACCTCAGCTTGAGAAAGCCCTTGAGATGATAGCAAAGGAAGGAAAAGGA +GTTCTCGTTTACATACTCGGGCACGAGGGAAGGGGTATAGGAATAGCGAACAAAATTAAAGCTTACGAAC +TTCAGGAGAAGGGATACGACACGGTGGAGGCGAACGAAAAACTCGGATACCCACCTGACCTCAGGGACTA +CGGTATAGGGGCACAGATACTCAGAGACCTCGGGGTCAGAAAAATGAAACTAATGACGAATAACCCGAGG +AAGATTGTGGCTCTTGAAGGCTTCGGACTGGAAGTAGTTGAAAGAGTACCTATAAAAATAGAACCAAATC +CTTATAACAAAATTTACCTGCAGGTTAAAAAGGACAAGCTGGGGCACATGTTCTAAGCTCTTCGTGCCCC +GAGTTCTTCCAATCTCTTCTTTAGTTCTTCAACCTCGTCCTCTTCGGAAAGTCCCAAGTAATCTAAGAGC +TTTTTAACACTTACCCACTTTTTCAAAACCATTCCCTGAGTTATTAGTTTTTCAAAGGGCTCGTCGTCCC +TCACAAGTCCGAGATCCTTTAAGAACTTCTGGAAGAACCTGGCGTAAAGCAGGTGGAGAACTGCGTGTTC +AATCCCACCTATGTAAACGTCAACGGGCATCCAGTAATCCACCTTTTCCCTGCTGAAAGGCTCTCTGTCG +TTCTTAGGGTCGCAAAATCTCAGGAAGTACCAGGAGCTGTCAAAGAAGGTATCCATGGTGTCCGTTTCCC +TTCTCGCCTTTCCTCCGCACTTGGGACATGTGGTGTTTACAAACTCTTCTGAGGTCTCAAGAGGGTTTCC +CTGTCCCGTGAACTTCACGTCTAAGGGGAGTTTTACGGGGAGCTGATCCTCCGGAACTGGAACCATTCCG +CACTTTTCGCAGTAAACGACGGGAATGGGAGTTCCCCAGTACCTTTGGCGGGATATGTTCCAGTCCCTTA +ATCTGTAGGAGACTTTCTTTTCTCCCAGACCTCTATCTTGGAGCCACTCGGTGATTTTCCTCTTTGCGGT +TTCGCTGTCGAGCCCGTCAAAGCCGTCGGAGTTTACAAGAGTTCCCTTTCCCTCATAAGCTCCCTTTTCA +AAGTCCCACGCACCTTCGGGTTTTACTACAACCTTAATGGGAAGGTCATACTTCTTTGCAAATTCCCAGT +CCCTCTGGTCGTGGGCGGGAACGCACATTATAGCTCCCGTTCCGTACTCATAAAGGACGTAGTTTGCACT +CCAGACTGGTATCTTTTCCCCGTTTGCCGGGTTGGTTGCGTAAACACCGAGGAAGACACCTTCCTTATCC +TCTTCCATTGTCCTCTCTCTCGTGGACATCTTCTTCATCTTTTCCACGAAGTTTTCAACGTCCGAATAAC +AAGCATTTCCGAGTCTTTCCCCTATGCAGGCGAGCACGGGAACTAAGGGGTGTTCTGGGGCAAGTACCAC +AAAAGTAGCCCCGAAAACTGTGTCGGGTCTCGTCGTAAACACGTCTATGTATATCCTCTTTTCCTTTAAG +AGTGTTTCTTTAAGTTCTTCAGGAACGCAGTTCAGGAACTTTTCGGGCTCTTCAATTTCTACGTAAAACC +TGATTAAGGCTCCTTCGGAGCGTCCTATCCAGTTCCTCTGCTGGGCTATTACCCTTTCGGGCCACTTGCC +TTCCAGTTTTTTGAGGTCCTCAAGCAGTCTATCGGCGTAAGCGGTAATCCTCAAAAACCAGGAAGGAACT +TCTTTCTGGACTATGGGCGTTCCGCACCTCCAGCACTTTCCTTCTATCACCTGTTCGTTTGCAAGTACGG +TCTGGTCGTGAGGACACCAGTTAACTTTTGCGGTTTTCCTGTAAGCTATTCCCCTCTCGAGCATCTTTAA +GAAAATCCACTGGTTCCACTTGTAGTATTCCGGATCGCAGGTTGCTATCTCCCTGTCCCAGTCGTAGGAA +AACCCGAGTATCTTTAATTGTTTTTTCATGTAATCTATGTTTTCGTAGGTCCACTTTGCAGGGTGTATCC +CGTGTTTTATCGCTGCGTTTTCCGCCGGAAGACCGAAGGCGTCCCACCCCATCGGGTGGAGTATGTTCTT +TCCCCTCATCTTCAGGTATCTCGCTATGGCGTCCCCTATGGTGTAGTTCCTCACGTGACCCATGTGTATC +CTTCCGGAAGGGTAGGGGAACATCTCAAGGACGTAAAACTTGTTGGGCTTTCCTTCTTGGGCTTTGAACA +CTCCCGCTTCTTCCCATCTCTTTTGCCACTTTTTCTCTATTTCCCTCGGGTTAAACTCCTTCATCATTAC +TTAGAATATAACAGCGGTCAGGAAGTAGTCGGAAATCAGGATTAACATTGAAGAAGTCACGACGGAGTTT +GTGGTAGCCTTTCCCACACCCGCAGTTCCACCTTTAGTGTAAAACCCGTAGTAACAACTTACCGCTCCGA +TTATAAAACCGAAAAAGGTAGCCTTGTACAGTCCCCCCACGATGTCGTGAAACTCCGTTAAATCAACCAT +CTTCTGCCAGTAAAGGTATTCGTTAACTCCGAAGAGTTTAGTTGCCACGAACCACCCGCCGAATATCCCC +GCAACATCCGAAAGTACGGTAAGTAAAGGTACTCCGAACGTTGTTGCGAAAATCCTTGGCGTTACTAAAA +AACTTATTGGGTTTATAGCCATAACTTCCAGGGCATCTATCTGCTGTGTAATTCTCATAGTTCCTATACT +CGCGGTCATCGCCGACCCAACCCTTGCCACCACCATGAGAGAGGTGAGAACCGGTCCTAGTTCCCTTCCC +ATGGATATGGCAACCACCGCACCTATCAGGTATTCCGCGTTAAACCTGTGAAAGGTAGAGTAGGTCTGTA +AGGCAATAACTCCTCCGGTGAAGAGAGAAGTCACAAGCACCACGGGGGTGGTTTCAGCCGCAACGTAAGT +GAGCTGGGAGATGAAGTGTTTTAAGCGGGGCGGTTTTTTGAATAAAAAGAAGATGGACCACAGGGTCAAA +AGCGTGGCCCTTCCGACTTCTTCCAGAAATTTCGTCATTTAAGGAAGAATTTTAAAGTATTCCCTCCTCT +TCGTCCTTCATGAGTTTGTAAACTATGCTGTCGCGAAGGGCTATCCACGAAGCCTCTATAACGTTTTCAG +AAACCCCTACCGTTCCCCACTTTCTCTTTCCGTCTGTACTTTCTATTAAAACCCTTACTTTAGCAGACGT +TCCCGCACTTTCGTTTATTATCCTCACCTTGTAGTCTATGAGCTGGAGTTCTTTCAGGTTCGGGTAAAAC +TCCTCAAGGGCTTTTCTCAGAGCTCTGTCAAGGGCACTTATCGGCCCGTTCCCTAGAGATGCCGTGTGTT +CTTCCACTCCCTCCACGGAAAGCCTTACTGTAGCCTCTGAAGTTGGGAGACTGTCATCCCTCCTTTTTGC +TATAAGCACCCTGTAGGCGTCAAAGTCGAAGTAATCCTTGACAAGTCCAAAGTGTCTCTTTATGAGGAGT +TCTAAAGATGCTTCCGCGGCTTCGAAGTGGTAACCCTCCTTTTCGAGTTCCTTAATCTTATCTATCAATT +TTTTAAGTTCGGGAGATTTTGGATCTATCTCTATACCGAACTCCTTTAACTTGTGAACGAGGTTGCTCCT +TCCTGCAAGATCAGAAACTGTAATCTTTCTCTTATTACCGACAAGTTCCGGATTTATGTGCTCGTAAGTT +TTCGCGTTCTTCAGAACCGCGGAGGCGTGAACACCTCCCTTGTGTGCGAAGGCACTCTCACCCACGTAGG +GCATATTTCTGGGAAGTGGCATGTTTATTATCTCCGCAACGAAGTTCGCAAGCTCCGTTAACTTCTTTAA +ATTTTCCTGAGGTATTACGTCAAATCCGAGCTTCAATTGAAGGTTCGGGATTATTGAACAGAGGTTTGCG +TTTCCCGTCCTCTCGCCGATTCCGTTTATGGTACCGTGAACCTGTCTCGCGCCCGCAAGGACGGCCATCA +AAGAGTTTGCCACCGCAGTTTCCGAGTCGTTGTGGGCGTGTATTCCTACGTTTGCATCCTTAAACCTCTC +TTTTACTTTCTTCGTGATTTCGTATATCTCGTGTGGAAGGGTGCCTCCGTTTGTGTCGCAGAGAACGACC +CAGTCCGCTCCGCCTTTCAGAGCAGCTTCCAAAACTTGAAGTGCGTACTCGGGGTTTGACTTGTAGCCGT +CGAAGAAGTGCTCAGCGTCAAATATAACCTCGTCAACGTACCTCTTGAGGTACTCAACGGTCTCGTAAAT +CATATTTAAATTCTCTTCAAGGGTGGTTTTGAGGGCATCTGTAACGTGTAGATCCCAGCTCTTTCCGAAA +ATCGTTACCACCGGTGTTTCCGCCTTTATCAAAGATTCCACTTGAGGGTCCTCACTCACTTTCTTATTGG +GTCTCCTCGTAGAACCGAAGGCTGTCAGCTTTGCGTTTTTAAAGTTCATCTTTTTAGCCTTCTGGAAGAA +TAAATTATCTTTCGGGTTTGCGTAGGGCCAACCGCCTTCTATGTAGTGTATGCCAAAGTCATCCAGCTTT +TCCGCTATCCTTATCTTATCCTCAAGGGAGAAACTCACTCCTTCCATCTGTGAACCGTCTCTGAGTGTCG +TGTCGTAGATGTATACCTTTTCTGCCATGATAGGAATAATAAAATAGGAAAAGTTTTAACGATTGTTAAG +GGTTAAAAAACTTCTTATAAAAGCCGATTATAATAATTGATGGTGAACAGGATTGAACTCTCACGCCTTA +TAGGACTCTTACTGGAAACGGAAAAGAGGAAGAACACGGAACAGAAGGAAAGCGGTACTAACAAAATAGA +GGACAAGGTTACACTCTCCAAGATAGCTCAGGAACTTTCAAAGAACGACGTTGAAGAAAAAGACCTTGAG +AAAAAAGTAAAGGAGTTAAAAGAAAAAATAGAAAAAGGAGAGTACGAAGTAAGCGACGAGAAAGTGGTGA +AAGGACTGATAGAGTTTTTTACGTAATATAACAAATCCCTTATAAGACTATTACTCATCTTTAAAAAATC +CTAAATTATATCCTTACCTATGGATTCAATTTCCTTTTACGAGTACCTTCTTACTAAAGGTTTTGAAGAG +AGAAAGTCCCAGAGGGAGATGATAAAGATAGTGGAAGAGGCACTGGAGGAGGGAGGAGTTAAATTAATAG +AAGCTCCCACGGGAACGGGAAAGACCTTCGCTTACTTAATTCCCATAATTGTTAATAAACAAAAGGCGAT +AATCTCTACAGGAACGAAGATTCTTCAGGATCAATTAAAGAGGGACATAGAGTTTTTAGCCGGTCACTGG +AAGCTCTTGACAGGACAGAAGGTAAATTACGCGGTAATAAAGGGAAAGGGAAATTACCTCTGTATAGACA +GGTTTAAGAAAGAAGAAATTCCAGAAGCGGACAGGCTGGAAGTGGAAACCTTTATGGAAACCGAGTGGGA +CGGAGACCTTACTTTAACAGGACTTGCTTCTGAAACTATTGTAAAAATAAACGTTGATGACGATTACTGC +ACCTTTGCGTACAGGATGGCGTGTCCCTTTTACAGGGAATGTTATTACTGGGCTAAGGTAAAACGAAGGG +AGGAAAACGCTGACATACTCGTGGTAAACCACTCCCTATTAGCACTCAAAGAGTTTGAGACAAAAGACAA +AGTACTCGTCATAGACGAAGCCCACGAGCTTGACAGGTACTTAACCCTCGCAACGACCTTCGGTATAAGT +CTTTACTGGTTTAAGGATCTTCAAAAAAGTCTTGAAAAACTTCTGGGAGAAAGTGTAAACATACCCGCGG +AAGAATTCTTCAGGAATAACTTTGAAAAGCTCTTTGATGAGGAGAGCAACGAGGCAGCCCTTGAAAGCCT +GAGAGAGTACATCCCCCAGATGAAAACACTTCTTTACATACCCTTAAATGAGGCTGTGGAAAAACTCAGG +AAGAAAGTCAAAGAAGAAGTGGAGAAATTCGTCAAAGAAACCCTTATGGTCAGCTACACCTTTAAGGACT +TCCTTGAAAATACCTTGCTCTTTGACAGAGACCTGATTGATTCCGTAAACGCTGGATACGAAGAACCAAC +GGAAAGAGAAAAGGAATTAATCAACAAAGTCAAAAAAATAGATTACTACAGGAGGAAGTTAAACAAACTG +AAAGCGTTTATAAGGACTGCCGAAGACGAAGAGGAAGGCGTAGGCTACAAAGTATCAAGGGCTTGGAGTA +AAAAACTGAACGGTTATAACTACAGACTTGAAGCCTTCCTTATATTTCCGAGAAATGTAATAGATCCCGA +GGAGTACAAGGCGGTAATCTTAACTTCCGCAACCGTGGAGCCTGAAGACATATACCTCACAACTGGGATA +ACCGGGGAGTTTTACACACTTCCCCACAACTATGACTACACAACGTCTACCATATTCATAGAGGACACGA +ACCCAAAAAAGGAAGACTGGAAGGACAAACTCACGACAAATTACTACATCCTCAGGAGCGAATACGACAA +AGTCCTCGTTCTTCTCACGAACAAGGAACACCTGAAGCTTTTCGAAGAAGACGAAGAGGTAGGCATTCAG +GGAAAGGACAGCTTAACGAGGTTGATAGAGTTTTTAAGAAGCGGAAGGATAAAGGCTTTAATTGGACTTG +ATAGCCTCTGGACAGGTGTTGACGTAAAGGGAGAGAAAGGTATTCTGATGTCAAAACTCCCCTTTGAAAA +CCCGAGAGATCCCCTTACGTACCACAGGCTGAAGTTCTTAGAAAAGGTAGGAGAAGACCCCTTTACATAC +CAAAGGAGAAAAGCTTACATAAAGTTCAGACAAGGAGTGGGGAGACTAATAAGGCAGAACTCCGACAAAG +GAAAGATAGTTCTGTGCGACAACAGGATATGGCGATACAGGGAGTTCGTGGACTTCCTACGTTCCTTAGG +AATAAACATAGTGAGTAAGGGCAAGTTCAAGAGAAAGAAGAGAACTCCTTTCTGGTAGTATTTCACTAAA +TGCTGCTTGACAGGTATCTGCTTTCCCGATTTCTCGGAATATTTCTCAACGTAAGTTTTGTGAGCGTTTT +GCTCGTTTCCCTCTACGCACTCCTTGACTTCCTTGTAGGTTTTAAGGAAAAGCGAACTGACGTTGCACTC +TCGTATTTTCTCAACATCCTGCCCTTAGGTTTTTACTACATCTCTTTCATAACGCTTTCCATATCTCTAA +TACTCTTTTTAAGGAAGGTATTTGAGAAAAAGATGGAGTTAACGGTTCAGAGTTTCGGGATAAGTCCGCT +GAGGTTTTCCCTTCCTGTGCTCCTATTTTCCGTCTTTTTATCCTCTACATTTTTACTCGGTAATGAGTAC +GCCTTTCCCAAACTCCTCGGTAACCTGTGGTTCATAGAAAAGAACTATAAAAAGAAACAGGAAGTCAAAG +GATTTATAAAGAACTTCTGGTTCATTAAGAAAGAAAATGAGGTTAAAACTTATTATCACGTGGGAAACCT +GAACTTATCCGACGGAAGTTTGTTTAATTTTTACACTATGAAAGTAGAAAGAAAGAATTTAAACCCTCTG +GAAGTATTGAAAGTATTCTCAGGTGTTTGGAAAGATAAAGAAATCTTTATAAGAAGCGGAGAAATTTACG +ATTTTGAAAAGGGAAAGAGGGAAAAGGTATTCAACAAAACTTTTAAGCTCGGACTTTCAATAAAGGAAGT +AGAGCTCTTTTCCGAAAAGATAGATTTCTTAAGTTTGAGTGAAATCTTTTTCCTGATGCAGAAGAGTAAA +AAAGTGGGTCTGAACGTGGACGTATACACAGGAGAACTCTTCTACAGGGTAATGTTTTCCCTTTCTCCCG +TGTTTATCTCTATATTCAGTCTTTATCTTTTCTTCAAACATAAAGTGCTCTCTCAAGTTATTCCCAGATT +CTTGGTTTTTATCGTAATCCTGTGGCTCGTTATACTTTCGCCTAAAATCCTCCCTCAGAAGGCAAACCAG +CCCGTCCTTTACTCCCTTATTCCTATCTTCCTATTGATTCTTTACTCCTTAAAAGGAGTATACGATCTTC +GCAAAGGATTCAGGGTCTAGGCTTGCAGTTCCTACGAGTAGTCCGTTTATCTCTTCGTGTTTCATGAACT +CTTTTGCGTTCTGTGGGTTTACACTTCCTCCGTAGAGGATACGGGTCTTCCCTTCGTTTTTGGGATTGAG +CTGGTTTATTAAGTTCCTTATGAAGGTGTGAACCTCAACAGCATCTTCGGGGGTTGCGGGTGTTCCGGTT +CCGATAGCCCACACGGGTTCGTACGCTATGTCTATTTTATCCGTATGCTCTTCCACACCTGTGAGTGCGA +GTTTTATCTGTGTTTCAATGACCTTAAAGGTCATCCCAGCTTCCCTCTCTTCTTTCTTTTCCCCAACGCA +TAAAATGGGTCTTATTCCCATCTCTAAGCACGCAACTATCTTCTTGTGAATTAACTCGTCACTCTCACCG +AATATGTGCCTTCTCTCTGAGTGTCCCACTATCACGTACTCACACCCAACTTCTTGGAGCATGGGTATTG +ATATCTCTCCCGTAAAGGCTCCCCTCTTTTCGTAGTGACAGTTTTGAGCTCCAAGCTTTACACCCGTTCC +CTGAAGCATTTTACCCGCAACGTAGAGGGAAGTAAAAGGAGGACATATGAGTATCTCCCTGCTTTCGGGG +TGTTCAACGAACTTCAGGAAGGTGTTAATGTACTCTTCGGTTTCCTTTACCGTTTTGTTCATCTTCCAGT +TTGCGGCTATTAATCTTCTCATAAGATCTAATTCTACTTAAATTGAAAATTAAGGAGGTGGGAGCCATGC +CTATGTACGTCATGCTTACAAAACTCTCCCCCTACGCGGTCAAAGATCCAAAGAAATTAAAAGAAATAGA +ACAGAAAGTTAAGAAATTAATTGAAGAAAACTGTCCCGGTGTGAAGTGGGTAATGAACCTTGTCGTTTTT +GGTCCTTACGATTATCTGGACGTATTTGAAGCCAAAGACGACGAAGAAGCTTCAAAGGTAGCCCTCATTA +TACGCTCTTTTGGACATGCAACCACGGAAACCTGGTCAGCAATGCACTGGAAAGACTTCAAGGAAGTAAT +AGATAAACTAAAGGGAGTTCCAGTAGCGTAAAAGAGTTTCTTTTGTCTTTCTTAATACTTCCTCTGTATC +CAGACACATTCTTTCTTCACAAACGTTCGGAAAACAGGGAGAGCAGTCCAAATTTAGTGAAATCTGAAAA +ACCTTATCTCCTATAGGTCTCCACACGAGTGGATCGGTAGGACCGTAAACGATAAAGGAAGGAACTCCGA +GGTAGGAAGCGAGGTGAGAAATCCCGCTGTCAAGCCCTACGTAAAACCCCGCCGTTTTTAAGTGCTTTGC +TATTTCCAAGGGAGATAGACTGAGAAAGTGAGGACTTAAAACCTCTCTCAAATGCTCTTCCGCCTCGCCG +AGGAGGAATACAACTTCCTTCCCTCTTTCTTCCAGAAAATCTTTAAGTTTTAAAAAGACCTCCAGAGGCG +GATTCTTCTTCTTGGAACCGCTGGAAGGGTGGATTACAACTTTACCCTTTAGAGGTGAATCTTGAACAGG +TTTAATAGGCAACTTGGTTGAGAACTCCTCTCCCAGACCGAGGGAATTCAGGTAATGTTTTACTATCCAC +TCCCTCTTTTCGGGGAAAGGTTTTACATTTCCTTCAAAGGAAATGATTACTTTTAGATCGAATTCCTCCT +CTGGGATAAATGAATAAACTCCGTCAGCGTAACCGACCTCTTTTGCAATAGAGAAGTAATCCGTATTTCC +GACCGCTATCGTTTCGTAACCCCTTCTTTTTAAGATTTCCAAAATTGGGAAAGTTAGAAGAGTGTCACCC +AGCCCACCTCGCCTGTAGAGGAGAGCCTTTTTCATCAGTACCCCAGTCTTATTCTTACCCCTAGGTAAAC +GAGAAGTAAGCTAAGTATTAAGTTGAGAATTCCGAGCCACTTTGCCCATACCCTGTGTTTTTCCGAGTAA +AGAGCCTTTTTACCCGCCCACAGGTCGTGAAGCAGTGAGATAAAAACTACCACGAAGAATACACCGAGTT +TAGTGTGAATGCTTGGACGGAAGCCGCCTTGAATTAAATAAGTGTTTACTAACCCGGTTACGAATAATAA +AAACAAAGATAGGAAAGTTCCATACAGGGAGAAGCGCTTTCCAACTTCTTGAAAGGCTTCATTCCTTATC +TGGGGTTTGTCCTTGAGGTACGGAGCTACCACAAGGGATAAGAAAAGCATCCCGCCTACCCAGAAGGTAG +CCAGTACCACGTGTAAGAAGAGAAATAGTTCCTTCATAAAAATCATTTTACCGCCACAATTTCTATTTCT +ACTTCCGCATTAAGAGGTAGTTCTTTCACACCTACAGTTACCCTTGCGGGTTTGACCGAAACATCTTTGA +AGTAATCTTCGTAAATTTCGTTGAGTTCCTTAAACTTCTTTATGTCCGTAATGTAAATGGTAACTTTTAC +TATATTCTCCCTCTTGAGACCCGCTTCCTCCAGAATTGCGTCTACGTTCTTGAATATCTGAATTACCTGT +TCTTTAAAACCTTCGACCAGTTTTCCCGTTTCGGGGTTTATACCTATCTGTCCTGAGATGAATAAAAAGC +CGTTTACTTCAACTGCTTGAGAGTAAGGACCGACGGGAACGGGAGCCTTAGGGGTTTTTATTTCCCTCAC +TTTTTGTCCTCCTCAATCTTTTCTTTCACAAAGTCTATAGCCTTTTCTATTTCTACATCCCACTTTTCTC +CCGTGTGTCTGCTCTGAACCTCTACTTTTCCTTCCTTTACCTTTTTACCTACGACAATCCTGTAGGGGAA +TCCCACTAAATCTGCGTCCGCGAATTTAAATCCGGGGCTCTCTTCCCTGTCGTCGAATATTACGTCTATT +CCCTTTTCCTCCGCCTCCAAGTAAAGCTTTTCCGCCACATTTTTCATTTCCTCGTCTTTTGTATTCAGGA +GTATTATGTCAAGTTCAAAGGGTGCTACGGGAGTTGGCCACTTTATCCCTTTATCGTCGTGGTACTGCTC +CACGAGTGCTGCGAGAATTCTGGAAACGCCTATGCCGTAACAGCCCATAATTATGGGTTTTTCCTTTCCG +TCCCTGTCAGTAAAGTAAGCCTTCATGGGTTCCGAGTACCTCGTTCCGAGCAGGAATATGTGTCCGAGTT +CAAGACCTCTCCTTACCTTTAAAGGAGAACCACATTTGGGACATGGGTCTCCTTCCCTTACCTCCGCAAC +GTCTACAAACTCACCGTACTGAAAGTCCCTTCCCGGGTTTACGTTAATGTAGTGCCAGTCGGGTTCGTTC +AGGGCAACTACCAGGTTCTTAACGCCGTATAGGGAGTTGTCCCACAGAACCTTTATATTTTCTGGGAGGT +TGAATATACCTATGAATCCCTTTTTCGTTCCGAGGAGTTCCTGAACTTCTTCGTCCGTTGCGAGTCTGAA +GTTGTCCGTACCTAAGACCTTTTCAAGTTTGTTTTCGTCTATTTCCCTGTCTCCTCTGATTAAGACGAGT +ACAGGTTCTTTTTCGTTAACTATGTAAAGAACGGCTTTCATTATCTTTGAGGGATGGACATCTAAGAACT +TTGAGAGTTCTTCTATGGTGTGCACGTTAGGAGTGTGCACTTTTTCCATGGGTTTTTCTTCTTCTTTTTC +TTCTTCGGGTTTCGGAAGGGGAACTATTTCCGCGTTTGCAGCGTATCCGCAGTTTTCACAGTAGGCTACC +TTTGCTTCTCCATAGTCCGTGAATGCAATAAACTCGTGGGACATCTTCCCGCCTATTTGTCCCACATCCG +CTTCAGCCATTATTACGTTCAGACGGAGTTTGTTGAAAATCCTCTGATAAGCGAACTTCATAGCCTCGTA +GGAAATCATCGCGGACATATCGTCCGTATCAAAAGAGTAAGCGTCCTTCATTATGAACTCTCTTGCCCTT +ATTAAACCGAACCTCGGTCTCTTCTCGTCTCTGAACTTTACCTGTATTTGATAAAGAATTACGGGAAGCT +GTCTGTATGAACGAACTACTCTTCTAACGAGGTCCGTTATTTCCTCCTCGTGTGTAGGACCAAGGCAGTA +CTCCCTCCCGTTTCTATCCTTTAGTTTAAAAAGTTCTTCTCCGTAGGTTTCCCACCTTCCCGTTTCTTCC +CAGAGTTCTTTCGGATTTAAAACGGTAAGGAGTAGTTCCTGCGCTCCGCTCCTGTCCATTTCCTTCCTTA +TGATGGATTCAACTTTTTTAAGAACTTTGTAGGCTGGGGGAAGCAGTTCGTATATTCCCGCGGAAACCTG +TTTTATAAAACCCGCTTTCAGAAGTAATCTATGGGAAGGCGCTTCAGCTTCCTTAGGTTCTTCCTTTTCG +GTATACAAAAAGTACCTGCTCCAACGCATAGGAATATTTTACGAAACTTAAAATATGTATACATTTACTT +AATATGGATCATAAAAAAATAAAAAGGTCTCTTAAGTTTCGTATTTCCTTTGTCACAGGTATTATATTTT +TCTTAGCTCTTTTATTAACGTACATCGTGCTTTACACGGCTTTTCACACTTCGGCAAAATACGTGGCGAA +CAGAACGGCGGAGGGGATATCAAACCAAGTTTTCTCATCTATGTACCAAGTTATGAGAAAGGGATGGAAT +AGGAGTGATGTTATGGAGTTTTTAAGGGCTATGGAGGTTTCCTATTCGGACACTCCTTTGGATGTAAACA +TCTTTCGCGGGGAAAAAGTTAAAGCTTTATTTGGCTCAATACCTGAACCGGAGAAGAGCGATGAAGTAGT +AGAAGCGTTTAAAACTAAAAAGAAAATTTTTATTGAGAAAGATAAAGTTTACAAAGCCGTATTTCCTATA +CTTGCGCGAAAAGAATGTTTAAAGTGCCACACAAACGCTAAGGGGGGAGAAGTTCTGGGAGTAATAGAAA +CGAGAATAGATCTATCTCCCATATACGATAAACTCAATAAAGTCCTCTTCCTTTCTTTAATTTTCTTACT +GCCTCTGAACGGTTTACTTTCCTTCTGGGCTTCAAAGCATATTATAGAAGTGGTAAAAAGCTTTGCGAAA +AATCTGGAAAACAATATAAACAGAATCAGAAATTTAGAGGACCTTAAGAAGATATCCAGGGAAATGGATG +TGCCTTATGAGGAACTGAAGCATCTGTATCAATCCTTGTATAAACTTTCCGAGAAAGTTAGACAGATTGC +GATAGATAAGGATATTTTGGAACTTGAATCTAGATTACTGGAGAAATTTATCATAACATCACAGCTCGTT +AACGATTGGAAAGAGTATATAAAAGCCCTTGTAAACGATATAAACGAGGTGGTTAACGTAGACGTTGTAT +TTTCCATTTTCATAGAAAACAGTTTCTTAGACACGGAAGTTTTTTGGTTAAAAGAACCGACGGAAGATCA +AAAAAAAGTGTTTGAACAGAGCCTTGAAAAAGAAATAATAAGCAGGCTACCTATATCCGTTGTAGGAAAC +AGAACACTTGTAATAAACCACAACGTTGTTAGGAAAAACGAACGTTTCAACAATGTAAGCCCTGATAGAT +TTAAGATAAGAACAAAAACACTACTGCTGGATAAACCACAACTCGGTGGAATAGTGGGCATTGGGATTGA +ATCAGAATTAGCAGAAGATCCATATAAAAGGGCAGTTCTCGACAGTGTACTCGCCACTCTGGTAAACGTG +ATAGGTTCTGCAAAGGCTATAAGTTCTTACGTGAACGAAATAGAGTTCTACGCAATGAGAGATCCGCTCA +CGTTTCTTTACAATCAGAGGACTTTCTGGGAGTTACTGAACTATGAACTCGAAAGGGCAAACAGGTTTGA +ACGGAGTCTGTCCTTACTTCTGCTTGACCTTGATAATTTTAAGGTTATAAATGACACCTACGGACACGCC +GTAGGGGATAGAGTTCTTAGAGAGGTAGCCCGTATAATCTCAGAGAAGAAGAGAAAAGCGGACGTTGCTG +CAAGGTACGGGGGAGATGAGTTTGCCGTAATAGTTATCGGCGCAAATTCCAATCAAGCTTTAAATCTGGC +AAGAAGGTTAAAAGACGCTATAGAAAGTTTGTCCATTCCAGTAAGTGAAAGTGAGACGGTTTCTCCTCGT +GTGTCCATAGGTATAGCTTCCTATCCTGAACACGCTTTAACCTCAAGGGATCTTTTCATAATAGCGGACA +GTATGTTAAGAAAGGCTAAGGAGGAAGGTAGGAGTAAGATAAGGGTACCTACGATAGAAGATTTACAAAT +GTCGAGAGTGGAACTTACTAAAAAGAGCATGCTTGTACTGGACGCTCTGAATAAAAGACTTATAAAACCT +TTCTTCCAACCTATCGTGGAACTAAAATCCGGTGAACTATTTGCAAACGAAGTATTAATGAGAATTGGTA +AGGAGAATATACCCGCAAGTGAGTTCATAGAAGCGGCGGAAAACTTGGGTGTAATAGTTAGGATGGACCT +AATACTTTACGAAGAGACCCTGAAAAAGCTAGTTGAGGAACAGTACGATAAGTACGTTTTTATGAACTTA +TCTTCCAGGGCACTGACTTCCGAAGATTTTCTCAAGAATATATTAAGAATTGTTGAAAATTCCGGTTTTG +ATCCTGCAAAGATTGTTTTTGAATTGACGGAAAGAGAGAGTGTTAAGAATATAGACTTGGTAAAGCGTTT +CTTGGAGGAACTGAAAGAAGTTGGTATTAAATTCGCTATAGACGATTTCGGTTCCGGATACTCCTCGTTC +CACTACCTTAAGAAAATTCCCGTAGACTTTGTAAAAATTGAGGGAGAATTCGTCAAAGGCGCCTTAACTG +ACTGGAGGGATAAAACTTTTATAGAGTCGATAGTTACGTTGGCGAAGGGTATGCACATAAGGACAGTAGC +TGAGTTTATCGAAAACGAAGAAATAAAAGAAATTATGAAAGAGATAGGTGTAGATTATGGGCAAGGATAC +TACTTCGGTAAGCCTTCTCCCAAACCGTGGGTATAAAGGACAGAACTTGAGTTTCAACTCCACACGGTAC +ATTAGGAACATGACATTTCAGGAGGTGGAGCATGATTACTATCTTTTCGTTTCAACTCCACACGGTACAT +TAGGAACAGTATAAGCTTTCTAAGCCTTGAAAGGAAAAGCTCCTCGCGTTTCAACTCCACACGGTACATT +AGGAACTCTCTACCTTCCTTTCAACCTGTATTGCTATGTCCGGTTTCAACTCCACACGGTACATTAGGAA +CCCTGCGTGCCTATGTCTAAAAAATAACGCTTTATCAACAACTTATTAGACACCCGACCTTCACGAAATG +AATGTTAATTTCCGCTAACCCGAGGTTCTGCAAAGTTGAGTATGCCTTTATAAAATTTACACCCTTGATT +TTCAAACCATTTAACTATGTCGTATCACGATTTCATTTCATCACGCTATCAAAGCATCACTCATTAAGAC +CAATCTACCCTATTCACTTGCCAAGGAGCCTGAGAGTGCTCCAAGGAGCTCTTTTAAGATTATATCACAT +TATCGGTCGGGTCGGGAGTATCTGTAAGGATTTCTCTTTTGTACTGGGTTTTGTCGTCGAATACGTAAAT +TATTACCGAATCCTTCGTTTTGTGGATTATGTCGCTGAGTTCTGCTTTTAATCTTTCAAGTCTTGAGAGG +GTAATTTCTCCCTCAAAAACGGATTTTTGAACGTGGTGTATGTATCTTTTTGCTATTTTTCTTACTTTGT +TTAGCCTCTTAACTCCTTCCTTGTCATCGGTGGCTACGTCGTAAACGAGTATTACCTTCATTTTAATCCC +CCGTAATTTAGAGGTAAATACACTTCCTCTTCAAGTAAATGTTTTATTAATTTATAAAGTTCAAGTTTAA +TGAGAGTTCTGTGAGAAACCTTTCTATTTAGTTTTGGATAAAAAATTGTGGTTTCAAGGAGTTCGTTAAA +GGCTTTCAGGAAAACTTTTCTGCCTATTTCGTTTAAAAAGGTCATGTTAAGTTCGGTGGAAAAGTGTGTT +TTATCTATTTTATTCTCTTGTATTAAACGGATAATTAAATTGTCCACAAAAATAGGTTTAAACACCTCCG +CCACGTCTAAAGAGAGAGAAAAGCGTTTAGTTGAGGGTTCGTGGAGATAACTCACAGTAGGGTTTAACTG +AGTTTTGTAAATTTCTCCCAGAACTTTTGCATAAGTCAGGGAATTTCCGAAAGAAATAAGAGCGTTTAGA +GGGTTTTGTGGTGGTCTCTTTGTCCTCTTTTCCAGTTCCCAACCCGTTACTTCTTCCAGTTTTTTGTAGC +ACAATTTCCTGAATTCTGCTTCTACGCTCATCAGCTCGGGAATAGAATTGGTTTCTTTTACTTTGTTCAG +GTAAGTGTCCGCTGAAATTTTGTAAACATATTCTAAGTTCAGTATACTTCCTATTACGAAACTCTTTGCA +AGGTAAAGCCTTTTCTGGGCGTCCAAGTAGTGCTCAACCTGTTTGATTAAGAGGTGTCCTGATACGGAGC +TTTCCCGCGGGTAAAAAGTTCCCGTGTAGTATCCATAGTAGTTAAAAAAGTGTAGCGGAATGCCCTTTGA +CGCAAGAAAGTTCAATAGTTTTGTGTTTAGACTTAACTCCGCAAATACGAAAATCTCCTCAACGTCTTCC +ACAGGGATGTCCTTCTTTACTTCTGCGTTTTCAAACCTCAAAGTGTTCTCGTGTCTTGAGAGCGTTCCGT +GAGAATTTATGTAATAAACCCTACCCATAGCAAAACTCGTAATAGGCGCACTTCTTGCAATAGGGCTTTT +TAATAACTTCGGGTGGTTTTTCTTCCAAGAGAACTTTCTGAATGTTTTCAAGGGCTTCTACGATTACCTT +TCTATCTTCCTGAGTGAGTTCTACCCTCAGAACTTTTCTCTGCTTGGGATAGTGGATTATACCGTGGCTG +ACTTTTACGCCTGATTTTTCTAAAAACCAGAGGTAATACTTGACTTGAAGGACATGGGCCTCTTCTAGTT +TAGGGCTGTGTTTTACTTCGTGGACTACGAGTCCTTCTTCTCCGGTTAGAAAATCTATCTTTACTGGATT +CTCTCCCCACTCCACTTCCTCCTTTTCCCTCTTAAATGCCCTTTCATCAAGGAGCTTTCCGAGTTCAACG +AATTCAGATTCCGATTCGTATGACAAGCCTTTGCTAAAAAGCCACAATTTTCTCTTGCATATAACGTAAT +ACGCAACCTGTGTTCCCGTAAACTTCAGGTTTGTTATTTCTTCATAGGATATTGTCATCTTCAATAACCT +CGGGGTCTTCTTCCTTTGAAATTCTAAAGCCGAGGTTCTCGTCGTAATCTCCCTTTATCCAGAATACGTT +GAGCTCCTGAAGTTCGGACGCCTTTTTTATTTTCCCTTCTCTCAGGAGTTTCTCCGAGTAGGGATAAGAA +AATGTATAACTCTGTAGCTCGTTAAAAGCTAAAACTCTTTCTAAAATATCCGAGCTCTCTCTCCACTTTT +TGTAAACCTTTAAAACTTCCTCCCTGAACTGGTAAGGGATTACGTTTAGTGAAAGTATGTCCCTGAACTT +CTGAACAGCATCGTGTCTGCTTTCTTTAAGAGAAATACTTCCCCTCCAGAAACCTTCAACGTATTCAAGG +GCACTCTTAAACTGGTCGTAATACTTGGTTTTCTTTATGTTTTCTCCGAAGACTTCCTTAATGGCTCTTT +CCTTAACGTCGTATTCCCATATCCCTTCCGTTAAAGCTTTTCTCGTTAATTCAAGTAGTTCCTTTGGGTA +AACGCTTCCCTTACCTGAAGGCTCTTGTGTGAATACGTAAACGTTCGGGTTTTCTATGTCCTTAATCCCT +TTCCTGTTGCACCTTCCCATTCTCTGAATCAGGCTGTCTATCGTTGAGAGTTCTGTCACCAGAAAGTCCG +CGTCAAGGTCAAGGGATACTTCCGCGAGCTGAGTCGTGACCCACACTCCCTTTTCCCCGCTACTGAAAAA +TTCCTTTATTTCTTCCTCCTTCTTTGCTCTGTGCTTTTGTAAAAACCTGCTGTGGAGTACGGGAGCGTTC +AAAAGCAGAGAAAGTTCCTGAGCCTTCCTTACGGTGTTTACTATTACGAGAACTTTTCCTTCTTCAGATA +GTGACCTTATGAGGTTTATAGAGCTTTCACTTCCGAGCGTATCTTCTAGGAGTTTTACGTTGTGCCTGGG +TTTTAATTCGGGAAATTCTTTGAAAGGTATTTCCATTTTTTCAAAGAAACGCCTTAAGAATTCTGGAAAT +GTTGCTGTCATTACCATGAACTTGCTTCCAAAGTCTTTTATGACTTCAAGGGCTTTTACTATGAATGCCA +TTGTGTAGGGTGCGTAAACCTGAAGTTCATCTATAACTATTCTTGAGTAAGAAAGTAAGGCTAAATACTT +CTCGTAGCCAGAAAACTTAAAAACGAAGGGCATTATCTGGTCGGGAGTGCAAACTGTCAAAGGGTATGCA +AAACTCTTTGAGTGCTGGTAATTTTTCCATATTCCCTCAAAGGTGTTTGTATCCAGTTCATCTTCTTCTT +TCTTCATTAACTCTATTAAGGAAGAGGAGTGAAGGAGTCCCACGTTTTCTCCGAAAACAGCCCTTGCCCT +CTCGTAAATACCGTTTGCAGAAACCCTGAAGGGCAGAGTAAAAAATCCCTTGTCTTTTAGGAAAATAAAG +CCCGCTTCCGTTTTTCCGTAGCCCGTCGGAGCGACTACAACGAGGCACTCTTCCCTGTTTTCAAGCACGT +AATTCTGAAGTTCGTTCAGCTGTGCTCCCTTTTTCCTCAGGTAGTCTTTTACGTTTTTCTCGGGATTTTC +CAACTTTCCCTTTTCCATTTCGCTCAGGTGTTTATTACTGCTCGCGTGGTCTATCCTGAGAAGCAGTCCC +TTAACGAGTGTGTAAAACTTCTTTAAACTCTCAGAATTTCTTTTTTTAAATTTCTTTAGGGCTATTCTTT +CCAAAAATCTTTCTTCTTCTCCGATTAATTTGTCAAGCTCTTTCGCTTTTCCTTCGCTGAAACCGAATTC +TTTTATTAAAACCTCCTTTGCTTTTTCAAATTGGTCGGGTACTTCGTGGTGGTGGAGAACGACTTTCTGG +ACGAGGAGTTTTAAGTTTTCATCTTCACACTCTACAAAGGCGGGAGAAAGGAGGTTGTGCCTGACTTCGG +GTATTCCTTTTAAAACTTTCCAGTTTTTGTTTCCCACTTTTTTCTGAAAAAAGCAGTGGAGTTTTCCGTA +ATCGTGATACTCGCAGGAAAGTTCAAGAGCCTTCCAGAGTAATTCCCTGAAATCTTCAGGACACGCTTCT +TCAATCTTTTCTCCGAATAAGTTTTTCAGTATGCTCAGGTTTTTCAGGAGTGTATCCGTATGCTCCCTTA +TAGTGGTTCCGTCACTCTTGGCCCAAGCTTTCTTCAGAAGTTCCCTCAGGTTCTCCCTCACTCCAATCCC +TCCCGTTTAGTCCTATCAGAAAAGCGTAAACAATCCGGTTGAAGTTCTCGTCTTTCAAAGCCTGAACAAA +GATGTAGGGTATTTCCCTTTCCACCTGCATGTAAGCCCTTATTAAGTTTTGCTCAAAGGCGTCAAGGTCC +TTTCTCCTTACCGCTTCAAGAATCCTGTAAGAGAGGGTTTTTATCCTATCTTTTGCTTTTTCCTTTCCGA +GTTCCTTCTCATACATTTTCTTTAAATTCAGCCCTTCCCTGTAGGCAAAATTAATTTGTTTCTCAAAACT +TTCTCCCATGATGAGCTCCTCCTGAAATTTTATAAAGTAAAGCAGCTTTTTAGGTAAAAATTCCTTAAAA +CTCATACCTTTTTTAATTAAATCCGCATCGTATCCCTTTGGATTTTGATAACGCTTCGGGAAAAAGAAAC +CTGACAGAATTTTAAACAAGAATTCGTAAAGGCTTCTCCCGCTGTAAACGTATTCAACGAATTTAGGAAA +GACACTTTCAAAGTTCGGAGGATATTTGTCTATATAATTCTTTAAAACTTTCGCAAGTCTCGGACTTATG +CTGAATGAGTAAATGTTTGCTGTGGCTTCGCTAACCTTTTCGATCTCAACGAAGTAAATGTTTTCAAGAA +TCCAACGAGCTTTTTGTGTCTCTACGTTTCTTAAGAACTTAACCACTCTGAACAATTCTCCGAGAATGTT +CTTCTCAACCTTTTCTTTACTTTTTAGTTGAGAATTTATTGATATAAGACTGTCTAAATCGTCGGGTATA +TAAACGAATAAGAACCTGTTGTTCCCGACCTTTGTGAATCCAAAAGCTGCGAAAAACAGGTAAAACTCAC +AGTAAGGGCACAGGTACATTTTGTTTCTTCCGTTCCAGAAGAGGTTTGGGAGAGTGTCCTCGCTTGCGGA +AAGCGGAGTGAAGTGTTCCGCTCCAAATACTCTGTACTTTCCTTTATAGACGTAGGTGTGTCTTTCACGA +CAAAAGAAGCAAAGAGGAGCGTTTTTGTCTTCTTGATTGCTAATTATAAGTTTTAAAGTTTCTATTAGAT +AATATTTTATTACATTTCTTATATTTTCAAAATACCCCTTATTTTCCAAAACATCTATTATAGACTCGTA +ATCCATATCCTCTTTACGGTGAATATCATTTAAAATGGAATTTAACAACTTGCTATTTTCTTGTTTTATT +ATATCTTTATAAGGATTGTTGTTTGCAAATATACTATTACGATAGAAAGATTTAATAATATCATATCCAT +TAATAAAAGTATATGGATTCTCTAATCTGTTTTTTAAAGTTTCAATACTTAATTTTTTGCTTTTAAGAAT +CTGCTCTTTCATAGTTAAATCTATACCTTTTGTTAAAAAATCAGCATAAAGCTCGGGAAGTTTTTCGAAT +AATTCTTCAGGAAGTTCCAGTTTCCTGCTGTCTTTTACAAGGTCCTTGTACTCAACTTCTGCATCTTGCA +AAACTTCAATCAGTCCAACGCCTGAGGAAGCGGTAAGCCAGTTGTCTATGTAAAACTTCACACCCATACA +GGTTCTCCCTCCTCATCTACCAGAAGTTCCATCTCTGAAACTTTCGTGCCCTTCTGGACGTAGTAAACAC +CTACCCACTCGTGCTGTCTGGGTTTTTGAGAAATTAGGAAAGAAGGAACTCTGTAATATACGCCGTGTCC +TTCCAGAGAAACCCTGAACTCCTCCGTAAAAATGTTTTCCGGGATGTAAGCGTTCTTTGGAATATTGAAT +GTGTCAAAGTACTCTTTTCTGCACGCCACCATTTTTACTTTCGTTATTTTTACCGGGTACTCTCCTCCCG +AGAGATAAGGAAATACGTAAGGAAACTTTAAAGCTTTCTCAAACTCCTTTAAAAGGTTTTCATCTCCTAA +GATATGAACCGTTAAGCGGAAGTTGTAAAAAAGCGGAACTTCTAAGGGCAAGGTTTCAAGTTTTTTATCT +TTTTTGTTGTACTTCCTAAACCTTACGTAATCCCTGAATATAGCCTCGTAATCTCCCTGAACGGAAATAT +TAAACCTCTCTCCTTTCCACTTTTTCCCAGAAGCTGTGTACAAGAGCCCTATTACCGTGGAGTAGGGCGG +GAGCGGATAGGTTTCTATTCCCTTTATGGAAAAGGGTGTTTTGAAAAGGGCTATCGGTGAAAAGAACTCA +GCTTTTAGACACTCCATAAACTTCCTCCACCCTCTTCTTCAACTCTTCAAATACCTCTTTCACGCTTTTT +GCGTTGAGCTCCTGTCTTATTTCCTCTTCATTTGCAAAAACTCCGCTTCTTATACCGCAGAGGATTTCTT +CTCCTTCTGGAACGAGTTCCGCACAGTCCTTTAGTCTTTGAACATTTAGGAGTAACTGATTATCAACTTC +TTTTGCAAGAATTCCGTCTTCAAAGAAGGGATTTTTAACGGAAAACACTCCCCCTATCACGAAAACGGGA +GACAGATTCTCCCACCTTCCCTTTATCTGTCTACTCAAAGTAAGTATTATGTCAAGGAGATCCTTCACTC +TTTTGGCTTTTTCTTCATTTGAAAGGACTTCCTCAACCCCCTCTTCCTTTTCCCATACGCCCACTCTGTC +AAGGTCAACCGTTAGGGTGTAGTAGTAGTGAGAGGTGTGCTGTTCGGTTTGCACAATCCTTTGCTCTTCC +GCTTCTCCAACGTGCTTTATATACCTGTTGTAGGCATCTATGTTATTCATAAAGTCAAGGTCTCCCTGAA +ACTTTGAAATGGAAAAGGCGTAGGTTACTTTTACAGGAGAGGTTCTTTTTACTGAATCATATTCCTCAGG +ATAGTAAATATCCTCTTCAGATATTTTATCCTTCTTAAGCTTTTTAACTTCTTTGCCATTGACAATTATC +TTAGTGAATAAACCTCCGAATAAATCAAATTCTTCAAAGTTTTTCACTAAGTCTATTCCTAGAGAATCTA +CATCGTATACACGAATTTTCTTCTTCTTCTTCTTCTTTTCTTCGCTTTCTCTTTCTTTTATAACAATCCT +TCCTTCGTTTTGTATATATTCCTTTATTAACTTGTCAAGCAATTTCCAGCCTTTTTCTTCCTTCCCTTTC +CTCCTTATTTCGTACTTCAGAGCCTTGTCGGAAACGTATGTTATCTGTGAACCGTCTCCCAGAGATACCT +TTTTCAGAACCGATACATTCCCTATAGTTTCCCCGTAGTTCAAACTGGAAGCTTTGCTCGTTATGATGGT +CAAAGTTAAAGCTTTAGCCATCTTTAAAACCTCCTTAATTTTTCACCCCCTCACAAGTAAGTATAACGCC +CCGCGGGGTCCGTTTCTGACATCAATTTTTACTCCGTAGGTACAACATCAAAAACCTTAACGCTTTTGGA +GTTTGTGGAAACATAAGCGAAAAATCTGTCGTACGCGGTAGAATAAAGTGCTCCCGCTATGCTCTGTATC +TTCTGTCCCCCTGTTGTGTCAATAATTATCTCCCTTTCCTTTAAACCCTTTGTCTTTAGTTCTGAGTAAA +TTTCTTTCAGCACTCCAAAGTTTTTCTCCAGATTTTCAAAGTCTAATCCTTCCCTGTACTTAATTACTTC +AATTTGAGGAAAGAATTTATTCACGATAAGTTTAAAATCTTCTATTTGTTCAAAGGAACCGCTGGAACTA +TTTACGGAACCTATTACGTATACGTATTTCAAGGAACGGGAAAATTCGTTTATGAGCCTTAACTGCATTT +CCCATGGCAGTCTCATTTTTTCTTTTTCAAGAAAATCAAAGAAATCATTTATTGTAGGAATTTCTTCTAC +CTTTTCCATTAATTTCTTAAATTTTTCATCATATTTTGCACTGCTTAAAAATATTACCGTAGCCTTTACA +TTACTCGGTCTTACCTCTCTCACAGTGTAATCCACAATCTCCATTTCCCTTACGTGCAACCAGGCGGAGA +AAAATACCAATGAAGAGGTAATAAATTGCGTTATTGCGAAATCATTAAACACAATTAAGGAAAAGATAAG +GGTTAAAACTATGAAACCGAACTCGGCAATTATAGAATCTTTTTGTCCCCGCCTTAATTTTTTGTGTAAA +AAGAATATAATTGATAGTCCAAGAATCGTTAAAATCGCTCCGATAATTGCTTGAAAGGGATTTGATTTAA +GGGAGGGTAAAAATCCCGCAAGTCCGTCGGGAAACCAGGCTATTGCGGTTATCAACGCAATTGCAACTGC +CAAACCTTGAGGAGTTTTTATTTTCCCGAACTGCTTTGCTAAAACTTTTATGCCTTCCAAACTATCCCTC +CCACTTTATAACGTCTCCTACTTTCTTGTTCGGACTATGTGAACTTACTACCACCGCCCCTCCAAGCCTT +GGGTCAAATACTCCTATTCCCTTTGTCGGGTGGTAAAAGTGTATTAAAAACCCATAAAGCCATATCGGGC +CCCTTCCTGAAAGCACGATAAAGGTATTTGCGAACTTATTTTTTACTGCATCCGGTGGATTTATCTTTTT +TAAATCTTCAGGGACTAAATCTCTTTTCAGTTCAAATTCAATTAAAGTAGTATCATCGTTTATTTTTTTT +ACGCTCCACCTGACAACTTCATCTTCTGTTTTAAGGATTTCATTCATTTGTTTACCTCCTTAAAAGTAGT +GACTGGATGGCTTCTTTTAAAGCATTTTCAATTTTTTCTTTATTTTGTTCATTAACTTTCAAGATAATAT +CCTTGTCATCTTTTTTTAGCATAACTGAATTATATTCAAAACCTGCGTGTGCGAAGAAATTTCTCTCCTC +AAAATCTCGATTACCTCTTCTATTTATTTCTCTATATATTAGAAAATCTTCCGGTATGTTGTCTCTTCTT +TCATTAATGTTGTTAGTTTCTTTACTTATCCTATGCTTTAAAACAGGAAATTCTCTAAATATCATTTCAT +TTAACTTATTAATATCTTCAAGAAGAACTTCTTCTTTCTTGGAAAAACCTTTCTTTTCCAAAATAAAACT +AAGAAAGTAAGCTTTGAGCATGGTTATATAATTTTCCGTAAATCGTAATTTCCTTTTAACTTTTATTTTC +TTCTCACCTATTTCATTTTCTATTATTATATTTTTTTCGTAATAGCCTGCAGCATTATCTATTTTTGCCT +TTAAATCTTTCGAAGAAGGCATGTATGTAAGTATGTATAAAGGAGTTCCATGAATAATAGCTGAAAGGAA +TATATGCTCTCTTTCTAATTTCATATTATCGCCAATTTCATTGATTGAATCATCATATGCTTCCAGTATT +TGTTCGCATTCTTTGTCTTCTTTTTTAATTCTATAAACAACTAAATTTGGAAATATACTACTGTAGTATT +CTATTTCATTTATTCTTAAAGGTTTTTGAATATTCCTACCGATTACTGGATCTGCATTTAAAACTTTTAA +ACTAACTTCCGTGAAGTATGCTAATAATTGTGCGAGTGTTCTCACCGCTTCATATGTCATAACAGTCGTG +TAGTTTATTCCATGGCTAACATCGAGGATAATTTCAATTTTTTCAGGAATTCCTTTTTCTAAATACTCAG +TGAATTTATATACCAATCCTTTCAATACTCCAGCAAAGAAATCTTCCGCTTGTCCCTCAAATTCTAAAGT +GTTATAACTTCCAAAACTATAGGATATTATTACATCGGGTTTTTTATGAAAATTTATATTCTTAGAAAAG +AAATCCTTAATTTTATTCTCTACTTTAGATTTAATTTCCTCGTAATTCTCAAAAGGTAAGTTACCTTGTG +TTTTGTCTGATAAGTTGCCAGAACATTGTATCTTGATTTCCTTATATGGTATCCTTTTTTCTGCTAAACT +ATCAGGACAAACCAGGATAACTGAGTCGGGTTTTTCAGCTTTTATTATTATTCCTGTTGCAGAAGGGTAT +TTATCTTCATGATCGTTATACGAATACTTAACCCTTTGCCAGTTTGTAGGATCTCCCCACGGTGCAATAA +CTACTTTTTTCATTTATTCCCTCCATCAAAAATTCCATAATCCAGCCTTGTCTTTGCACCTACACCGTAA +AGTGTAAGAGTATCTTCTAGCAGTTCCTTAAGCTTATTCCGTAAGTTCTCATAATTGTTGTCTAATAATT +CATTTATTACATTTTCAAAATCGTTATATTTTTTCAGTTTCTCAGCCCTATAGCTATCAAATAAAACCCA +AAAGTGAAACTCTATACCCTTGCTTACAGTCAGGAAATAAACAGGGTTAGGATTTTCCCAATCACCGGGC +GGTTTATTCTGAGTGTAATAACTTTTATAATGTACATTTATCAAATCTAAGTCAAAAATTTTATTCTTAT +TACTTTCGTCAATCATAGGATAAGCGTCTAAAAATGTAAGTAATCCCTTAAACTTTTGTGTTCCGAAAAG +AAGCATATGTATAAGAAACTCTTTATTCTGTTCTTTCCTGATATCACCTTTCTGGAGTTTTTCCTGTAAT +CTTTTTATTACATCATCTTTTTTATCTTCTTTGATATTTTTTATATTTTCCTCTACAATTTCCCAAAAAT +GAGCCATTCTAACTATACCCTTTAAGGAGGAAGAAGGTATATAGGGAATTCCAAAAAGATGATGAAGCGC +TAAGCCAGTTTCAAAAACGTGAGTCGTTCCAAGTCCCACTATAAGACGTTCAGCAGTTTTCAGCTTAAGA +AATTCATCCTCATTGAAAACGTTTACATAGCCTTGATTTAAAAGAGATTGCGCAATTTCTCTGTTTTTTC +TCTTCAATATCTCAGAAAAATTCTTTAACTTTTCTTTTAATTTTCCAAAGTTGTCATCTTTAATAATTTC +TTCTAAAAATATTTTTTTGAGTTCTTCGTTAATAGTCCCATCTTTTAACCATAGTTTTTCGTTATTGTTT +TTTATAGTGACTATATCACCGCAAGGAATTGGAATGTACTTATTTAATAAAAGATTAAGGGATTCGAATT +CCTCCAGAAAATCTACTTTTTTTAAAGCTTTATGGATAAAGTTTTTTTTATTATCGGTTTCCTTTCCTTT +TTCTTTCCCTACTTCTAGTTTTCCTGTGGAAAAATAACCTGTTCCGAAGATCAATTCGCCTACTACTATA +GTATTTGCCATCTTGATTATCCCCCTTTAACAAAGGTTAAGTCTTATGAATCCTTTTCCTAAGCTTTCAT +CCCCACCTACCTGGATTATTTTACATCTATTTATTAGATCCTTTACTTCTTCTCTAACTTTTTCTGCTTT +CTCAAAAACTTCCTTATTATGCGGTTCACTTATATTTAATAAAGAGTAAAAGATACTTTCGGAAGGAATG +AATTCTTCAGTAAATAAAGCTCCCCTTTCCACAGTACCAGTTGCTTGATTTATTCTTATCCTCGTTCTTA +CTTCTACAGCGTAATTTACTAAATCCCTGAAAACGTTGTCAGAAACAATTACTAAATGAGTCCTAAGAAG +GCCTACTAACTCATCTGAAGGGATAATCGTATTAAAAAAGTCCCAATCTACATTTTCTGGAGCATTTAAA +ATGGGATTAAATGCGAATTCTTCAAGAAATAATTTTCCATCTTTAATCAAACCATCTGAAAATAATATGG +CTTCATTTTCTTCTAAATTTAAGTTACTAGGTACTTCTTTGCCATTCTTTAAAACTTTAATGTTTATTTC +TTTTCCAATACTCCTCAGATCTTCTTGGAATCTTCTAAGAACAATTGGACTTGTAATCCAAGCAAAAACA +CCTCTTACAGAGCGAACAGGGTAAAAAAGTATCCTGGCATCAGTTATGCTTACACAACCTGCAAACTTGG +AAGCATCATCTTCTGGTCCAAATACAGTTTCAACCTTAGCCTTATCCTTCCAAACTCTTTCAGCTACACT +TCTTAATGCTCCTTTTATTCCATTTGATCTAAGTATAGGAAAACCTGTATGTCTTTCCCTTTGAATTGGG +AGGTCTATAAAGGATATACTCTGTCCTGAACCTATATGTATTGGTGTCACTGCGTATAAGGTTAGTAACT +GACCGTACTCATACATTCTTATCCTCCTATATATTTCTACAGATTGTTTTATATCTTTCTAGGCTTAGAT +TTTAATAATTGCTCAAAGGAAAGTTCGGAATTGTTATTTATAAAATTCTTAAATTCTTCATATTTATCCC +ATTCATTATAAACAATAAGAATTCCATAAAATTTTCCTTCACTAAATTTTTTTATTTGAATTATTAAAGG +TGATACGGCTCTAGAACCACCCTTAGGCTTACACGCTATTGCTTTTATATTTGTTTCAGATTTAAATTCC +TTGTAAACTTTCTTTCTTAAATTATTCATGGCTCCTAGAGAATCAATCCAAAAATTATCTCGTTTGGGTT +TAACTAAGTAAATATCAACGTTGTTTATATTTATAAAACCATCATGATGGTATTCGCCTTTTCCCTTGAG +AACTTTTTCAATTTTTTCTTTTAATTTATCAAAACTTTTATAATCTTCTCCATTTTTTAACTGTATACTC +CCAAACCCTCTTCTCCATCTTGCACCGATTCCTCCCAAAAAGGAGAGCAATTGCAAAGTAGTATTTAATT +CCTTTTTATATGTAAAAAAAGGAGAGTATATGAAATCTATTCGGAAGGTATCGTTTTTTTCTAGTGCTTT +TCTTTTTATATTGTTATATCTTCCATATCTTTTATTCATAGCCAAATACGCATCGGTAAGTTTTTGGGAA +TATTTTAAATGCATATAAAACTGGCAAGCTTTTTCAGTAGAACCAAAAATCTCATTTTCATGTTCTCTTA +ATTTATCAATACTCTGGTTATGACTTGCATAGAAAAATCTAAACCACCACCTTAGCATGCCTTTTATTGA +GGGAATACGAAGTTCGGGTTCATCTTTATAAGTACCTGCCATTACAACAGGAGTTATTATTTCAAATGTT +AATGTTTTTTGATGTTCTTTTTTCATCCTCCACCTCCAAGTATCCGAATCCCTGCCCCGTTCTTACTCCT +AATCCGTACTTATAAATAAATTCTAACAAATCCTTAGAATCCGTTTCTATTTTGAATTTTCCTATAAACG +TTTTCACAATTCCGCCGTAATGTCTGACGTATTCTTTCTTTACTTTTACAGGGATAAACTTAAATTTAGA +AAATTGAGGTTCGCTACCCATAATTGCTATGTATCTCCTGTATATGTTTTCCACAAGACTTTCTTCAAAA +CTTTCTTCATCAGGTGTTATATACCTTTCTTCAGGACTATCTTTAGGCTTTGAACCTATTCTTTCAATAA +CAATCGGGGATAAAGTTTTAAAAAATCCTATAATTTCTCTTTCTTTTTCAGGACGAAAGTCAATTATCTT +AAATTTTCCTGTCCCAATTGGATGGATATACTGGTTCTTTTTCAATTGTAATATTCCGTTGTAAAACTTG +GCTATCGTTAAAAAGTCTCCCGAAGAAAAACGAAAATTTATGGTCCTTACATTTTCTATATATCCGTTGC +TTATTTTTGCCTCTTTTCCGAAGAATACGGCGAATGTGAAGGGCTTAATCTTATGGTTTGAGTAATATTC +CTCTCCTAAAACGGATTTTAGCAGTGAGATAAACCTGCTTCTGTAGTCTAAGCGAACTTTTGCAGGTTCT +TCTTTTAGGTTCTCCATCTTAATTAAAAACCTCACCCTCCATCCCTCAATTATTCAAATATCTTCTTCCT +GCACGCTGTACTTTTTCTGAAGTTTTTTAAGGAGCTCTATTTTCTGAGCTATGAGTTTCCCTAAGGGTGT +TTTCTTTTTAACGCTTTCTATCCTAAGTTCTTCCCATAAATCTTTAGGAAGGGAAATAGTTGTCCTGACG +AACTCCTGCTTCTTTTTCCTTCCGGCTTTCCTTTTCCTGCTCATCTATAAACACATTTTACTCCGTTTAC +TCTTCTTCGGATTTCAATTCTCCTTCTGCCACTCTCTTTAACCATTGAGTAAAAAATAGTATTTTTTGGG +TATATAACCTGTACCGGGAAAAATCCATTTCCGCAAAAAGCCGAGTTAGGGAATCAGGCACTTCCACGTT +TTCTATTTTTATCAAGTAGTTCTTAATATGGTTTTCTATTTTTTTCCAAGCCTCCTTTTCCGGGGAGAGT +TTATTTTGAGCATCAATCCCAGCTTTTGACCTTATGAATGCTACAGTCGGCAAGAGACCGTTGTGTATAA +TCATTGATGGAAGCTTGCGTACGTAAGAAGCGTATTTTTCCTCTATTTGCTCCCTTCCTTTTACTTCATT +TACACACCCATAAGCGAACTTTACTACTTTTTGGATTCTAGTTTGCATTTCCTAACCTCCTAACCAGCCC +TTTTCCTGTAGTTATATCCCCTCCCAAATGGAAAAATTCAGGAACTTCAAGATTAAGATTTTGTTTTTCG +TAGAAAAGATTAAAGTATAAAACACTCTCCGCCGGAAGGTACTCTTCCGTCCAAAGTGCACCGCTTTCAA +CCGTTCCGCTATCGCGATTTATTTTTATATGGGTTTGAATCTCGGTGTAGTTTTTAACCATGTAGGAAAA +AACACTGTCACTTACACAAAGAACTCTTTCCTTTTGATACGATTCCAGAGGAATTCTTGATATTATTTCT +TCAAATTTTTTGTTCCTTTGTTTTCTTAAAGTAAATTCTTCCAGCATAACTTCATCAATGTTAGGATATC +TATCAAAATAAACAACAGCGGTATCATCCGGTAAATCTAAACAAAAACACTCTTTCTCGCCTGTATCTTC +CAGATAGCGATTTATAACATAGGGACATGTTACTAGTTGAAATACTCCGTTAGTGCTTCTTACCGGAAAG +AGGAAGAGTCTCGCATCTGTAAATATAACTTTCCCTGCACTTGCGGAAGATTCTTCAGAACCTTCTCCAG +CCGTACCGAAGATATCTATTAGCATTTTTAAGTATTTTTTTTCTTTATCGTTTAAGTTTCCTCTTATTTC +CCCTTCTTGCAGTATTTCATCAATCATTGAAGCTGTAAGCTCTGTATTCCTAGCTACTTTTTTTATGTGG +TATTCTCTTAAACAGCCTTTTATGGCAGATCCAGGAATAAAAGGAAAGCCCGTGTGAACTTCTCTGGCAA +TAGGGAGGTCTATATGGGTTAAACCTTGTCCAGTACCAATGTGTAGCGGGGTAATTGCTTTAATAAAGTA +AGTTTCTCTTCTCATTTAACTCCCTCCACAATTATTCCTGAGTTCCATCCTCTATTTAAGAAATTTTTGA +TATTCGAAATAGGAACGTTTGTAGATATTTGATTTAACCTTTGAATTTCTCCTTCATTTTTAGCTTTTAA +AATTAATACACTTCCCGGTCTTAGCATTTCCAAGAAGGGTTTATTATATCCAGAAACGTATTCTACTCCC +CCATTATACAGCCATTCCACTTCAAAATTAATCCCCTCTATGCATATAGTTTGAATTTTGCTTTCTATTA +TTCCATTGTTTATATATGCATGTGTTAAACAATAAAATTTATAATAGTTTCCATTTTTTATCTTGATTTT +CCCTTCTAAAAAACTATTAATATGTTCTGTATGTTTAAACGAGACGATTTTACCTTCTCCTCCAAGTCTA +AAGTACTGCTTTCCTGATATTACAATGTCCTTGTTAATTTCTCCTAAAACTGCTAGCTTAACTCCGTCGT +TGAAGCGAAAAAAGTCTTGAGAGTAAAGCAAGCCCTTTTCTTCCTTTCTATTAATTTCTTTTATTGATCT +TACAACTCTTCTTTCCTTATCTAAAGTAATACCTACTCTACTTTCTTTTTTTAAGAATTCCTCAAGTAAA +TAGATTTTGAACCCATCTATGTTCTTAGCATACTTGTTCATTAAGTCACTAAAGGATATAAAACCATTTG +CTCTTTCATAGGCTTCTAAATCACCTCTTATTAGAGGAGGAAATTCTAGAGGAGATATTTTAGCCTTTCC +ACTCTCTTCTTTGCGTTTTACGAGACAATCGGATGGAACAGGAAGAAATAAATTTCCATCTTTGTATAAG +AAAACACCATAAACACTATTAAATATGTGGAAAAATCTCATTATAGGTGGTGGAAATATGCTTTTTTGTA +TGTGAGTTTCCCCTGCAGAAAAATTTTTTAATCCCCCAAAACCAATAACATCGTATGGTTTAAACAGGTA +TATTTTCATGTTTTAAGCCCTCCATATTAGCTATGAAGCGGGCTATGTAAAATGTGTTGAGTACATACTC +TAAGGCATTTTTAAGACTTCCTGTTTCCTTAATTCTTTCATTTATTAAATCCTCTATTTGAGTAATTAGT +GAGTAATATTCATATTCATTGAGTTTTTTATCATTCTGATTTTTACTTATTTGTCTTTTTAAAATTCTTT +TTATTACACTTAAAGCGATATCTTTCATATTTACTACACTTTCTTCGTTTATTATAAAGATTTCTAATTC +CTTTCGTAAATAATATGGGATTCTAGACGATAGCTTTTCACTCTTAAAGTATTCTATTAATTTGATAAAA +TTTTCTAAGTTGTCCCATTTCAAAACAAGCTCTCTCGGATAGCTGTTATGGGGTATTACACTAATACACA +GTCTGTTTCTTCCTTCATTTTTCGCCCTCCTTTCAGCGGTTCTAAGGTGTTCTAAAACAAACGCTAAGTT +TTCTTTCTCATGAGCTATAACCAACCCTGCACTCATAGTAGGGTCTTCTTTAATATTACTAGGCTTGAGT +TCTTTTTTTAGGATTTCAGAAAACCTTTTTCTAATTATTTTTGCAGCTTTAAGAATTACAGATGGGTGTG +CAACTGCAAGAACATCATCACCTCCCAAGTATACAAACTTTAAACATATATTATCTTCAATTTTTGTAAT +TTTTTGTGCAAACTTGAATAAAGCCTCAGAGAACTTTTTGTGAAAGTTTTCCGTTAACTCAACCTTTCTC +TTTTCAGGCTTAAGACCAAGCCATTTTCCCATTTCATCTCCGTCTGCCATTAAGATCGAAAAGTAGGAAT +TTTTAAATTTTTTCTCGAATTCTTTTAGTCTTACTTCTTTATCTTTATCAGGAATTTTATCTAGTCTTTT +TCTCACGAGAGCTTTAACTCTTTTATAGGTTAATTCGTCTATATTGTTGTATATGAGTTCTTTCAAATTT +CCATCATTTATTTGATTATTAGTATACATGCTTAATATTTCTCTCAATATTTCCTTTTCTTCCTCTGATA +GCTTATCTTTTTCTACCTTCTTTATAAGTGGAGCTAAGGCAAAGTGTCTTGTACTATGAAACTTAGCTAA +ATCTTTTATTCCTTCCTTTTCTTTTAAATAAAAGTGGAAAAACCTTTTTGTTAAACAAACCCCGCATAAT +CTTTCACTATCATCAAGGTGATAGGGAGGTAAATTTTTTCTTAATTCCTCCCAGTTCAGATCTAGTGCCG +GTCTTTCACCGCAAAGGGTACATCCGTGAACTTTTTTATTTTCGTCAACTCGTCCGTAATAAGGTCTGAA +AGTTTTCCTCGCTCCGAGCTTTCTTTCAAGAAGATCGTAAGTGAATCCATAAGGATTTTCTTGGTTTATT +TTAAATTTTTTCAGCGTTTCCTCATTAACTTTTAGTTCTGTCATCCACTCCTCTCTATCTACTTCCTCTT +GAATTTCACAGAAATAAGTGAAGTAATGTTTATTATGGGATTTAAAAGTTGCTTTTACACTCTCAGGTAT +TTTAATTTTATCAGCAATATACGTATAAATTTCCTCCCATATTTTAGAAAATTGATTTTTTAATTCTTCA +CAGTAATTTTTATCTTTTTCAAATTTTGCAACAAGTCTATTTGGATAGTTCATTAGCAATTTCTCGGAAT +CGTGTTCCTTTATAGCAGGGTATATGATTTCAACATCGGGATCTTCTTTAAGTTTTTCAATAAGTTTTTT +TGTAATATATGAGAGTATTAAACTCGAATTAAAAAAATCCCTTAGTTTTCTTGATTTCTCTATAAAACCC +TGTACAGGTGAAAAAGTAAAAACGAGGAGCTTCATCTAAAATCCTCCCTAGACCCTTTTATTTCCATATC +CCTCCACCTACTTTAAGTAACATTATACATTACTCGTATCTGATTACGAAACTAATCTCACGATGATGTA +TTGCTGCAATTCCACAACGGTATATTAGGAACTCAGACTATCATCCATGTAGTACACAAAACAACTCGTT +GTTTTAACTCCACTACGGTACATTAGGAACCTGTTTAACTGCACCCGATATGCGTCCTAAGTCCTGTTTC +AACTCCACACGGTACATTAGGAACTTATGAGGACGAAATCCCGGCGGACTACTTAGGAAGCGGTTTCAAC +TCCACACGGTACATTAGGAACCCTGCACGCCTGTGTCTAAAAAATAACGCTTTATCAATAACTTATTAAA +CTTCTGACCCTCACGAAACGAACGTTAATTTCCGCTAACCTGAGGTTCTGCAAACTTGAGTATACCTTTA +TAAAATTTTTACCCTTGATTTTCAATCCCTTCAGCCCTATTGCATCATGATTTCATTTCATCACGTCATC +AAAGCATCACTCATTGAGACCCATAAACCATATTCAATTGCCAAGGAGCCAGGAGGGGCTTTTTAGCCCC +TTTTTAAAAGTATATCACATATTTTTAATTTAATGTGGAATTAAGAAGGATTGAAGGGATTCTTTTAGAA +CAGTCTCTCTTATCCTCAAAAGGACAAGAAGTAGTAAAAACAGCCAGAAACTTAGAGATAAAAATAACCT +CTCAAATTCCCGAAGTATATAAAACACTGCTTAACCTGACAAAGGTAAAGGCAAAAGTTTTAAGGAATAG +AGGAAACGTAATTACACTCCTTCTGGACAACGGGATAGAGATAAATGCAAAAAACGAGATGAGCGTATCC +TTAAGGGAAGGACAGAGCGTAGTTTTAACTCTTGTAAGAGAAAATCCGCTTACTTTTAAACTGGAAGAGG +GAAAATTCGTAAAGAATACAACACTGGAAGTCCTGAGAAAGGGTTTAAAGAATTTAAAGAAATTTGATTT +TTCCCAGATAGAAAACTATGAAAACTTTAAAAACTCCGGAATTTTTTACGAAAATAAAGTACTGAAAGCC +ATTATAAAGAATTCCATAGACGACCTGAAAGTAGACCTCAAGTATAAAGCACTAATCAAACAGGACAAGG +AAATCTTAGAGTTTATAAACTTCCTCCAGATGTACGCCTTGGAAAATCCGAGGTCTATCTTGCTTCCTTT +TAAACTCCAAGACTTTGAAGGCTTCTTATCCATAAAGGTAAAAGAATTTTACGAGGTATTTGTCCACATA +AATACGGAAAAATATTCCCTTAATATATCCTTTTTCGTAGAGAAGAACCTAAACTTTTCCGAAGTGGAAA +TCTCTTCCAATAGCGAGGAAGTTTTACAGAGACTTGAAAGTCTGAAAGACGATATCAGGAAGATTTTTAA +CGTGCCCATACGGAGTTTCAATTTTCTTTTAAAGGAAAATGTAAAAGAAGAAGTATTAAGAGAAATCCTG +AAAGAAGGAGGCTTAGATTTAAAGGTATGAACGATGAGGTGAAAAAGGCTGTTGCCCTGAAGTATAATCC +GGAAGAGGATAGAGCTCCCGTAATCGTGGCAAAGGGAAGAGGTGAGGTAGCGGAGAAGATAATAAAGATC +GCAAAGGAAAAGGGAATACCTATTACGGAAGACGAGAACTTGGTTGAAGCCCTTATAAAGATAGACCTTT +ACGAGGAAATTCCGCCTGAGCTTTACGAGGCCGTGGCGAAGGTTATAGCCTTTGTAACGCTTAAGTTAAA +GGGTTTATAACTCACTTTAATACCTTTATAAAGAAATTCTTAAGCCAGTATTCGGCGATAAATATAACCT +AATATTAAGGAAAATTAAATTTAAGGAGGTTGTGTGATGGCTACAATAACACCTGACAAGGTTCTCGATA +CTTCCGGACTTAACTGTCCTCTGCCCGTGTTAAAGACCAAGAAGGCTCTTGAAGAGCTTCAGCCCGGTCA +AATCTTAGAAGTTATATCCACCGACCCAGGTTCTAAAGCGGATATTCCAGCGTTCTGTCAAAGGACTGGA +CACGAACTCGTAGAGATGACAGAAGAAGGAGGTAAGTACATCTACTACATAAGGAAAAAAGGATAAGGGA +GGGTAAAAATGCCTACCGAGAGACTTGCGATAATAGCGACAAAGGGAACACTTGATATGGCTTACCCTCC +CCTTATTCTCGCTTCCGTTGCCGCTTCTTTAGGCGTAGAAACGGCGGTATTCTTTACCTTTTACGGACTC +AACATAATCCACAAGGAAAAGGTAAAACAACTCAAACTCGCTCCCATAGGAAACCCCGCCATGCCCATGG +TTTTCCCAGACTCCGTTAAACAAACACCCGTGGTGGGACAGCTCGCTGGACTGATGGAAAGCATATTCCC +CGGTCCTCCTCAAATAATGGGAATTATTCCCGGAATGACGAATTTCATGACAGCGATGATGAAGAAGAGA +CTAAAAGAAAAGGGAGTTGCCAGTATAGAAGAACTCCTGGAACTCTGCAAGGAAGCGGACGTCAAACTCA +TCCCCTGTCAAATGACGATGGATCTCTTCGGCTACAAGAGGGAGGACCTAATAGATGGACTTGAACCTCC +CGCGGGAGCTACGGAATTCTTCAACTACGTTCTCGCTGCGGACAAACCTATGATAATATTCGTCTAAAAA +TACAGGGAGGTAAGAAATGGCAGGACAAGAGTTTGAAAAGCTCCTCTTTTACATCGTTACCGTTCCCTTC +TTTGTAAGGGCGGAACCAACCACCGGAGAATTAATTAACCCTCAGGCTGGAGCACCCTTCTTCCTCGCAA +CCGCGGCAACTACCATGGACTACGAGGTTGAGATGGTCATCACTTCCGAAGCTGGATACCTTCTCATGAG +GGACAACGCTAAGAAGGTAAAGGTAAGACCCGGAGTAGAACAGACGGTTTACGATTTCATCAAAATGGCA +AAAGACGCGGGAGTAAAGATTTACCTCTGTACTCCATCCTTGGATCTTACGGATATATATAAGGAAGAGG +ACGTAAACAAGGAAATCTGCGACGGAATACTCGGCGGAGCCGCATTCTTGGACAAGTTAATGAGCGGTGA +GTATGCTGTTATCACACTGTAATTTTCCTTCTTTCTTTTTTGCCCCCTTTATAAGAATATTTTTATATGA +CTATAAAAAAATTTTTTTGATTTCCCTCATCTACTCGTGTAACTTAAAAAGAAGAAACCTGATCAGGAGG +GTTTAGGTATGGCTGAGCAAACTCAAGTTCGTAAATATGGATACAACATTCCCATCTCGGAGAAAACTCT +CCAAGTTCCATGGGAAGAAAAGGTAAGAGTAATAGAAGAAGTCAAATCAGACTTCAGGTTTAAGGAGTAC +CTCTTCGGATGTCTCAACTGCGGAGTTTGTACGGCATCCTGCCCATCAAATAGATTCTTCGACTACTCCC +CCAGAGAAATAGTTCAGAGATTCCTAGAAAATGACATAGATGTCCTCTATGACATGATGCACGAATACAT +ATGGGCATGCTCCCAATGCTTCACGTGCTGGATAAGGTGTCCATTCGTAAACAACCCCGGCGGACTCGTC +ATCATAATGAGGGAAGTTGCGGTAAGAAACGCGTTTGAAGCTACTAAGGATCTCCTCAAACCCTACGGAA +GAGTTCTCCTCAAAGTTATGACCACGGGTAACCAGCTGTCCGCGGACATGCTACAACCGGACTTCTTCCC +CGACTGGGGACCGAAGATGCTTGACAACATGGAAAACCTCAGACCCAAGAGAATGGCTATCCCCTTCGAC +GTGGGTAAGTCCGTGAAGACGGCTTGGGAAGTATCCCTTCAAACTGCAATAGAGATGTACCAAATATGGA +GAGACACGGGAATATTCGAAATGCTCGAAAGACTCGATCCGAACCTCTACAACGTCATAATGGACATAGT +TGAAGAAAACGAAGAAAGGTGGGAAGAACTTATGGAAGAAATGGAGGAGGCTGAGGCTTAAGCTAATGAG +GGGGGTTGGTGCCCCGCTCTTAAAATTAAAACTTTAAGGAGGTGTTGTTATGGCTCACAAATCTAAGAGC +CCCTATCTTATGTATCCTGAAAAGGAACCTTTTCCCATATTAAATAAGCACTCTCACTACGACCACCTCT +TCGAGGAAATGTATGAACTCGAAGAGAAGGGTGAGATTCTCGTCTTCAGGATAACTGAAGAGTACAGACC +TAAGTACGTATACACCAGAACGGGAAGAATAAAGGTAATACCCACCAACAAGCTCTGGCACCACAAGTCC +TGCGGACAGTGCGGTAACATACCCGGATACCCTGCATCCATATTCTGGTTCATGAACAAGTTCGGACTCG +ACTACCTCAACGAACCTCACCAAACTTCCTGTACCGCATGGAACTACCACGGTTCCGGAACTTCAAACCC +TGTAGCACTCGCAGCGGTATGGCTCAGAAACATGCACCAAGCTTGGAAGACTGGATACTACCCGCTTATA +CACTGCGGAACGTCTTTCGGTTCTTACAAGGAAACCAGAGAACAACTCATCTTCAATAAAGAACTCAGAG +AGGCTGTAAAACCCATACTCAAGAAGCTCGGAAGACTCACCGAGGACGGAAGAATAGTAATACCCCAGGA +AATCGTCCACTACTCCGAATGGGTACACGCAATGAGAGACGGAAATAGCAGACCTCTACGGAAAAGGAAG +GAAAGCCCAAAGGAATAGATGTTTCCAACGTAAGGGTTGCTATACACAACGCTTGCCACACCTGGAAGAT +GATAGCTGACGACTACCCCTACGACCCCGAAGTTTACAACGGACAAAGACCAGCAGCTTCCACAGCTGTT +ATAAAGAAGCTTGGAGCACAAGTAGTTGACTACTCAACCTGGTACGACTGCTGTGGGATTCGGATTCAGA +CACATCCTCACCGAAAGAGAATTCACCAGATCCTTTGCTATACAGAGAAAGCTCAAGGTTATAGCTGAAG +AAATTAAGGCTGACGTTATCATAACCCACGACACCGGTTGTACTACCACCTTCGAAAAGAACCAGTGGAT +CGGAAAAGCTCACGGAATGTACTACCCCGTTGCTGTAATGTCCGACGTAATGTTCTCCGCACTCGCATGT +GGAGCGCACCCATTCAAGGTAGTACAGCTCTACTGGAACTGCTCTAACTACGAACCTCTCCTCGAAAAGA +TGGGTATAACCAACTGGAGAGAGCTCAAGAAGGAATGGGAGGACACCGTTAAGTACATCGCAGAGCTTGA +AAAACAAGGTAAGTACGACGAACTCCTCGAGTTCTTCAAGGAGTACGACCTCTACGAACCTTACAGCAAG +ACCTCCGACGGCTTCAAGCTCAGGAAGTCCGCTACCGCAGACCTACCCCTCTTCAAGTCATAAACACACA +TACATGGGGGCTCTTGCCCCCTTCTATAAATCCTTTTAGGAGGGAAAATAATGGCTAAAAGTGTGCTCGT +AATTGGTGGTGGACCTGCAGGACTCGCAGCAGCGAGAACACTCGGAAAACTTGGTATTCCTACCATCTTG +GTTGAAAAGGAAGGAAAACTCGGTGGTAGACCTATCCTCGAGGAGTATCACACCCTAATTCCCAGAAAAA +TGAAACCTCAACAAGTTCTCGGACCCTTTATCGAAGAAGTTCAAAACAATCCAAACATTGAAGTGAAACT +CAACACCGAAATTGAAGCCTGTGAAGGTGAAGCTCCTAACTTCAAGGTAAAGCTTTCCAACGGTGAAACC +GTTGAAGTAGGTGCGATCGTTGTAGCTACTGGATTCCAGCACTTTGACGCAAAGAGAAAAGGTGAACTCG +GATACGGAATCTACCCCGACGTTATTACGAACCTCGAACTTGAGCAAATGTTCTCAAGGGAAGGAAAGCT +CTATAGACCCTCAAACGGAGAACTCCCCAAGAGAGTAGCTTTCGTATTCTGCGTAGGTTCCAGAGACAGA +CAGCTCGGTGTTACAAATGTCCACTGCTGTAGGTACGGATGTGCACTCTCTGGACTACAAGGTTCCGAAA +TCAGGGAAAAGTACCCCGAAGTTGAAGTGTTCTGTTACTACATGGACGTGAGAACATACGGAACTTGGGA +ATACCCCTTCTACTGGGAACCGCAAGAGAAGTACGGTGTCAGGTACGTAAGGGGAAGGATTGCTGAAATA +ACTTACTCTCCTAAAGACGGAAGACTCAGGGTTAAGCACGAGGACACGATTGTTCAAAGACCTGCGGAAA +TACCCATGGATCTCGTAGTACTCGTTCTCGGAATGGAGCCCTCCGAAGGAACTAAGAAAGTGGCAAAGAT +ACTCGGACTCGCTCAAGACCCAGACAGCCAGTTCCTCATACCTGCAGAAGACAGCGGTTCAAACATAATT +TCAAACAGACCCGGAGTGTTCATAGCGGGTGCATGTAAGGGACCCATAGACATTGAGTCCTCCCTTGCGG +AAGGGGAAGCTGCCGGTGCAGAAGCTGCAACATTTTTAGGAGCGAAGGTTAGCGTATGAGTGAAAGGCAA +AACACGGGCGGCTTCAAGGCCGCCTCTCTTGATGAAGCTCTAATCAGGGATTACCTGATAAAGATACTAA +GTGAAGGTGAAGAGTTTTTACAGGACTTTTATCAGGATGTAAAAGCTAAAAGCGAGTTCTTCCAGAAGAA +ACTCTCCAAGGATAACATCAAGAAATTAACCGAAAAGGACTTAGAGGAAATACTTGACAAGATATTCGCG +GCGAGGAGAAAGAAAAAGAGGATTATAGAAGAAACCGGTGTGGAAAACCTCAAAGAAGCCATAAAGAAAC +TCCTTTACGGTGAAGAAGGCGGATTCTTAGGACTCGGAAAGAAGGAAGACAAGAGAACATGGGAAGAGAA +GGTAGAAGAATTTGCACGCTCAATAAGGGGTGTTGACAAAAGGGCTGCAAAGGATATAGCGGCGGAACTT +CTTCACTTTACCTTCCCCGACAAGTACATACTCTGGACGAGCTGGGTCTGGGATCCGGAAACAGAAACGG +GTGCGATAGTCTTCCTGAAAGAAGAACCTCCCACGGGCGGAAAGGGAAGGAAGATGTACGGAGAGACTTA +CGAACAATTTGAACAAGTCTACAAACAGATAATGGAAAAGCTGCACGAGTTCGGAGTAAAGGTAAAGGAC +TACCTATTCGTTGACATATTCCTGGCGATGATTTACGCAACTTACGTGGATTACATGACCCTTTCTACTA +TGCACAGTGCTAAGGGTTTCTTCCCTCCCGCTGGAGTTATGGCGAGGAGGTTGCTCGGGGTTCACGCCCC +GATTAGGTATACAGACGTTGAAGAAGTATCTTAGAGGAGGTGTGAGAGATGGCTATTCACGAGCGGTCTC +TTGTAGAACCGGAGAGAATTTTAAGGAAGGATAGATTAGTTATAGACGGTATAGACGTTTCAGGAGACTG +GAACCTTATAATCCTTCCCAGAACCATAGAAGATTACGACCTTTCCCTTCTCGACGAAATACTCCAGCAA +CCGGAAGGAAAGACTATACTCCAGTGTTACCAGTGCTCCTACTGTACCGCATCCTGTCCCGTTCACAATT +ACTGGGACGAGAGGTACAACCCCAGACACTTCATATACCTCGCAAGACTCGGACTCGTGGACGAGCTTCA +GAAAAGGGCGGACGTAATGTGGAGATGCGTCTCCTGCCACAAGTGTACCCACAGGTGTCCCAAAGGTGTT +CTCGTAGAAGAAGTTCTCAAGGCTATATTGAAAGTTCTCTCCAAGAGGGGACTCATAGAAGAGTATCCTT +CCAAGAAGTTTGACAAATTCTTCCTTGAACAGGTTTACGAGTACGGAAGGATTGAAGACGGAGACCTGCT +CTTCGGATGGATAGAAAAGCAGGGTTACAAAGTGTTCAAAGATCCAATACTCAAGAAGCCCATACCCCTC +TTCGGTGAAATTCCCGAGTGGCTCAAAACACTCGCTATAAAACCCATAAAGAACATGAACATAGACTTCC +TCATACTCAACGCAAAGCACATGCTCATACACCCCAGAACTAAGAACTGGAGCAAGATGAAGCAAGTTCT +CAAGAAAGTATTTGAAGAAGAGGGCGTTACACTTCATTAAGGAGGTTGAGAGATGGCAGTACCGGTTCAG +TTTAGAAAACCGCCTATGGGCGGTATAGGAAAGAAAGTTGCTTATTACCCTGGTTGTTCTCTTGAAGGTG +CTGCAAGGGCTTACGACGTTTCCACCAGAATAGTAGCCAAAGAACTTGGTCTTGAACTTGACTACTTAGA +AGACTACAACTGCTGCGGTGCTATGGAAACCAAGAACGTTTCCTTCTGGGGCACCATGCTCCTGAACGCA +AGGAATATGTCCCTTGCAAGGCGACAGGGACACAACGTAATCGTAGCACCCTGTAACGGATGTTCCTTCT +CACTTCAGAGAGTGGAGTACTTCCTCGAAACCGATAAGAATACCTTGGATAGGATAAATCAACTCCTCCA +GGAAGCTGGAGAGAAGCCCCTTGACAACATACCCCACACCTATCACATACTCGAGTGGTTCTACCACGAA +GCAGGACCAGAAAAGGTTAAAGAAAAAACCAAAAAGCCCTTAAGAGGTCTCAAAGTAGCAAGCTACTACG +GATGTCTCTACACAAGACCTCACTTCTACGCGAGAACTTACTCCCACCTCGCACCTGAAGACGAAGAACA +GGCAAGACCCAGAAAGAGAGAAACCGCGGACGACGACGAACACCCCTACTACATGGAAGCTCTGCTTGAG +GCTGCAGGAGCTACTTCCGTTGAGATAGAACCCATGCACACTCAGTGCTGCGGAGGACCTCACTCCCTTT +CAGACGAAGAAGTTTCCGAAAAGTTCGTGATGATGATACTCCAGACCGCGAAGAGAAACGGTGCGGATAT +AATAGCAACCGAATGCCCGCTCTGTCATGCTTCACTCGAAATGTACAGACACAGACTCATGCTTAAAGGT +GTACCCGACGTTGACGTACCAGCAGCTTACTTTACGCAACTCCTCGGACTCGCATTCGGATACAGCGTAA +ACGATGTAAAACTCAAGGACAACCTCTCAGACCCTATTCCCGTTCTGAAGAGACTGGGACTTGCTTAATG +TCTTTTGCCCGCCTTTTGGCGGGCTTTAAAAATAAAAAAAATTAATGGAGATATAAATAGAGGTAAAGGA +AAATGTTGGAAAAGGAATTGAAAATAGTAATACTGATGACGAGCGGGCCGAAAACTCCTTGGCGTTGTGC +TACGCCTTTTTATATAGCCACTCTTATGGCTGCTCAGGAAGCCGACGTGGAAATATTCTTCAACATGGAC +GGAACAAACCTAATAAAGAAAGGTGTTGCAGAAAAGATATGTCCTTCTCTGGAGGGGAACTGCTTTTCCG +CCAACGGGCAGAAGCCTAAAACGGTTTACGATTTTATGAAAGACGCAAAACTGGCGGGTGTAAAATTTTA +CTCCTGTAAGCAGGCGGTGGACTCAATGGGGCTCACGGAAGAGGACCTCATACCGGAGCTTGACGGTATA +GTGCCCGCAAGCGAGTTTGCACTGAGGGCTATGATGGCGGATAAGCTTATAACCTTCTAGTTTCAATAAA +TTTAAGGGAGGTGTGCTATGGCAGAAGTAAACGGGTGCCAACTGCCCGAGGATAGACTCTACTACATCAA +CCCAGATAAGAACGCCTTCATTTGGGCAAAGGAAGAGGACGGGGTGTTTACCATCGGGCTCACTTCAGTT +GCAGCCGCTATGGCGGGAAGACTCGTCGCTTACACGCCCAAGAAGGTAGGAAAGGCTGTTAAAAAGGACA +AGAGCGTGGCAACCATTGAAAGCGGAAAGTGGGTTGGACCCGTACCTTCTCCCTTTGACGGGGAAATCGT +TGAAGTTAACGAAGCTCTAAAGGGAAATCCCGCTCTCGTGAACGACGATCCCTACGGACAGGGCTGGATA +GCTAAGGTAAAACCTGCAAATCCCGAAGAAGCTAAGTCCGTTCTCGTTGACGCGAACAAAGCGGCTGAAC +TTCTCCAACCAATAGTTCAAGAAAAAGGAGTTAAGTGCGGTTAATTCCCCTTCTCTCTCCTTTTAAAACC +TTTTGAGGGAGCGGTAATGAATGTATTCGGTGTAATACAGGAGCTTGACGTAGAACTTAATGAAAAATTA +GTGGAAAAATTAATAGAAGGTTTTGAAATAAGAAAAAAGAATTTTGGAGATAAGGTATTCTTCTACTCCC +CGGGTTTCAAACATTACGAAGTTGAAGACTTTTCAGTAAACTCCCCTCCCAAGTTCGTTGACATATCCGT +TACGGGGAGAAATTGTGAACTTATGTGTGATCACTGTGCTTCTAAAATCCTGTGGCACATGATACCCGCA +ACGACTCCAGAAGAACTCGTGAAAGTTGGGGAAGATTTAAAGAAAAAGGGAATAGAAGGAGTTCTGATTT +CAGGCGGTTCGGACAAAAACGGATTCGTTCCTCTCTGGGACTTCTTTGACGCTATGAAGTATTTGAAAGA +AGAACTTGGTTTTCTCCTTACCTGCCACGTTGGACTCGTTGATGAAGATTACGTGGAAAAATTAAAGGAA +GCGAACGTGGACGCTGTACTCCTTGACATTATCGGAGACAACGAAACTATAGCACAGGTCTACAAGCTTC +CTCACAAAAGTGTTGAAGATTACGACCGCTCCCTTAGACTTCTGAAAGAAGCGGGACTCAGAATAGTTCC +TCACGTGATTATCGGACTTCACTACGGAAAGATAAAGGGTGAATATAACGCCATAGATATGATCGCAAAG +TATGAACCTGATGCCTTGGTACTAGTTGTGGTCATGCCCTACTACGGAAAGGCTAAGTTCCAGCTCCTTC +CACCGCCTTCCAGTGAGGAAAGTGCACAAGTAATTCTCTACGCAAGAAAAGCCGTTCCGAATTCACCCGT +GGTTATAGGCTGTGCAAGACCGGCGGGTGCGGACAGGGTAAAGCTGGACGCTTACTCGGTTTTAGCCGGT +GTAAACGGTATAGCCTTCCCGGCTGAAGGAATAGTTACTTACTCAAAATCCCTCGGACTCGAACCTGTGG +TATCACCCAACTGTTGTTCTACAGTGTACTCCATGGTTTTCCAAACTATGGAAACTCAGTGATAAACTTA +TTCTGGTTATGAAATTAGGAGTTCTCGGTTCTACGGGTTCTGTTGGCTCTCAAACTCTTCAGGTTTACGA +GAATTTCAGGGATGAAATAGAACTTGTAGGGATACTTGCAAATAGAGCATCGGAAAAGCTTCTCCAGCAG +GCAAAAAAGTATAAACCCAAGTACGTGGTTTCTTACCAGGAGCCTGCAAAGGAGTGGCTGGAGAGTCTGC +CCGAAGGCGTTAAATACCTCAAGGGTGACGAAGGACTAAAAGCGATAATAGAAGAGTCAGAAAGGTTAAT +GAACGCAATTTCGGGAATTTACGGCATAAAACCCGCCTACGAAGTTATAAAGGCTGGAAAAACATTACTC +GCCTCCAATAAGGAGTCTATACTCTGTCTGGGTGAGATTATAAGGAAGAACAGGGAAAGGGTTATTCCCG +TGGACAGTGAGCACAACGCCCTGTTTCAGCTTCTTAGTTCTGTCAAAAGGGAAGAAGTAAAGCATGTATA +TCTGACAGCTTCCGGTGGTCCTTTCAAGGACAAAAGCCTTGAGGAACTGAAAACAGCAAGTGTTGAAGAA +GCACTAAGGCACCCCCGCTGGAACATGGGGGCGAAGATAACGATTGACTCTGCAACGCTCATGAACAAAG +GTTTTGAAATGCTCGAAGCCCACTTTTTATTTGACTTTCCCATAGAAAACATAAAGGTGGTTATCCACCC +GCAGAGCTTTGTCCACGGGATATTGGAACTCATTGACAACAGCTTCCTGATGCACACGTCCCAAACGGAC +ATGAAAATCCCAATAATGCACGCTCTATTTTACCCAAAGAGGAAAGAGTATCCCTTTAAGAAAGTTTCAC +TTCTTGAACTATCTCCCATAACCTTTGAGAAGGTTGATACTACAAAGTTTAAAGCCATTGACTTGGCTAA +GTGGGCGGGTTTTATGGGTGGCGTGTACATTCCAGTGCTCGTGGGAGCGGATGAAGAAGCCGTGAACCTG +TTTCTGAATAAGAAAATCGGATTTCTGGACATAGTTGACCTTATAGAGCAGGCTTTAAGTGAGGTTAACA +TCAAAGACCCTCAAAGCGTTGAAGAAATATTGGAAGCGGTTGAGTGGGGAAGACAAAAGGTCAGGGAGAT +TTACGAGAGAAAGTATGCAGGTAAAGGATAGAGAGGACGCCCCAAAAGGCAGAGGAAAGCAGTAAGAAGT +TGTGAACTATGAAGCCTATCTTGAGTCCTTCCTTTACTTCAAGACCAAGAAGCTTTAAAGGAAGTAAAAA +TCCGGCTTCGTAGGTTCCGTATCCCATAAAACTGTGGAGTGGTAGAATAGAGGAGAGCTCACCGCCGAGA +AAACCAAGGGTGTATTCAAACAAGTTCAGTCTTACAAGGGATTCAACTAAAATGTATGTTGAAAGAGCTT +TAAGAAAGAAGGAAATCCCTGATAAGGTAAAAAGGTAAAGGGAAAGTTTTACACTGAGTTCTCTCCTTAA +GAAGTTCTTTAAATCCGTTAATTTCCATATTTCGGGAATTAGATTTACGAGGAAAGGAATTAAAAGGGCA +AGGAAAAAGCCTACAAAAAGTCCAAGAAGGGCAAAAAATGTCCCTTCTTTTGCGAGCAAATAACTTATAA +AAACTACGAAAATTAATGCCAGAAGGTCGTAAAGCCTCCCTATAGTGAAACTCCAGAGGGAGTACTTGAA +GTTTATCCCGAGTTTTTTAGCGTAATAAAACCAGCTTAGCTCCCCGCTTCTTGCGGGAAGTACGTTGTTC +AAAAACAGATTTGCAGAATTTAAGAAAAAACTTTCTTTTAAAGGAAGGGAAAGGAGGAGACTCCACCTCA +CACTTCGTGTGAACTGACTCAGAGAATATAGCAAAAATGAGAGAATTAAGGTTTCAGTTTTTATACTTTT +CAGTGAGATGAGAAGTTCATTTAAAGGGAGAAAGTAAAAGATTAAGGAAAGGAATAGGAGACTTATGAAA +AGGGAAAGGAAAATTTTCACTTTTCTTTTGGAACGTCGTGAATGACGATGGGTTTACCCGCCCACTCGGA +AAGTATGTTTATCGCTACCTGAACTCCGCTTCCCGCCGCGGCGGTATACATGGAACTGACTCCTGCGAGG +AGTCCGGCTACGAAAAGCCCTTCTCTCACCTTGTAATCCCCGTCGTGTTTTACCATTACCCTTCCGGGTT +TGGGAGATTTAGGATTGTCAACGACTTCCACACCTTCACACTCTATTTCAAACTTGTGAAATCCTGATGC +CAGAACCACGTACTCGGCTTCAAAAACCTTTCCGCTCTGGGTGTGTACCTTAAAGTTCCCCTTCTCCCCT +TCTACTTTTGTTACTGTGTCTTCCAGAAATTCAACGCTGTCGTTGGTAGCCTTTATCTGTTCCCTTATCT +TTTCAAGGAGTTCCGGTCCAAGCGTTCCCATGGGTATTCCGGGAACGTTATTAAGCATAGCCTTGTTCAG +GTCTGACCTTCCGTTATCTATCACTAAAAACTTCTTGCCTTCCGCCCATTCCCATCCTCTACCCTGAGAA +GATGCAAGCGTAAGGGCGCATGCGAGTCCTGCGGGTCCTCCTCCTACTATTACAACGTCGTACCTCATAG +GGTATAGTATAAACTAACCTGAGAAGGCTTTTCTTTCCTTTAAAAATCGCTTTCTAACTCTCCTGAAAAA +TTCTCTCACTTCAGGGTGTCTGTAATCCCTGTAGGTCCAGTAAATGGGTCTAAAGTCCCTGTAAACGAAA +AGGAGTTCTATTTCCGCGTAAATACCACTGCCGAGGTAAACCCTAGCACCCCTCCTTTTGTGAGAGGCGA +GGATTAATTGACTCTCGTCGAGATATCCGGGATCCAGGTTTACGCTTCTCTTTCCTTCTTCCGAGAGTTC +TTCTTCTAATTCCATAGCTTTTAACTTAACTTCCACAAGTTCTTCCTTGTTCTTTAGTCCCTTCAGAGAA +AGGTATATCTTCTTTAAAGGCTTTCCCATTTCCCTTCCATAGTAGTTTTCCAGAAAGGGAAAGTAGAACT +CCTTAGAGACTTCTTCAATTTCCCCAAATTCTTTCTCTATTCTTTTTAAAGCCTGATCAAGTTTATCCCT +TTTGTTTTTATTAAAGAGAATGGAGAATATAAACTTCGCTAGGTCCATAAGAATTTGTATATAGCCTTCC +TCACAGGAATACCGTTCTTTACCTGTTCCTGTATAAGGGATTTTTCCGTATAGACAAGCTCGTGGTCTAT +GTCCACATTCCTGTTTACAGGTCCCGGGTGCATGTAGAGCTTTACCTTTTCAAACCTTTCTTTTGTTAGA +CCGAATTGTTTGAAATAACTGCTTTCTGAAGGAATATAGTTTTCCTTCTGTCTTTCCTTTTGAAGTCTAA +GCCATATGACCACGTCTGCCCAATCTATGCCTTTATCAACGTCGTCAAAAACGTCTACTTTGAAAACTTC +CACGTCCCTCGGTATCAACGTTTTTGGTCCGCAAACTCCTATCTTTGCACCAAACATGTTCAAAAGAGGA +GCTCCTGAACGAAAAACTCTGCTGTGTTTGATATCACCCACGTAAAGGACTCTTAAGTCTTTTACTTCTC +CGAAGTGCTCTTTTATTGTGAAGAAGTCTATAAGTCCCTGAGAAGGGTGCTGGTGAGTTCCGTCCCCTGC +GTTTACGAGTCTCAAGTTCAAGGATTTAACGATTTCTTTGTAAGGGAAAAACACGAAAGGCACTCTGAAC +ACAACGTAATCAAATCCGAGTCCCTCAAAAGTTTTCAACGTATCAAAGAAACTCTCTCCCTTTACCGTAG +AACTTTCCGAACCGCTAACTAAGTAAGTTTCAATCCCCAGTTCCCTTGCTGCCTTTTCAAAGGATAGGCG +TGTTCTCGTGGAGGGTTCGGAGAAAAACAAAACCGCGGACGCTTTTATGGTTTCTTCTTTTCCTTCCTTG +AACTCCTTTGCGTATTTTAGTATTTCCTCTACTTCTTCCCTCGTCAGGTCCAAAGAACTTATCAAGCTCC +TCATCCCTGAGCCATTTTAACGAATTCTTTAAATAAGTAGTAAGAGTCATGAGGGCCGGGAGAGTTTTCG +GGGTGGTACTGAACGGCGAATATGGGAAGGTGCTTGTGTTTTATTCCTTCAACAGTGTTGTCCAGGAGAT +TTAAGTGGGTAACTTCAACATCTTCCGGCAAGCTTTCAGGGTCAATTGCAAAATTGTGATTCTGAGCGGT +TATCTCTATCTTTCCCGTTCTTAGGTCTTTTACAGGATGATTTCCTCCGTGATGCCCGAACTTGAGTTTA +TAGGTTTTCCCGCCGAGGGCAAGACCGATAATTTGACAACCCAAGCATATCCCCATTATGGGTTTCTTTT +CCATGTACTCGCGAGTGAGTCTTATTCCTGATATAACTCTTTCTGGATCCCCAGGACCGTTTGATAGAAA +TATAGCGTCTGGATTTATCTTCTCAATGGCTTCTTTTGCATTTTCGGGAGGAACTACGACAACCTTTGCC +CCTTCACTAACGAGTCTCCTTAAAATGTTAAACTTTACACCAAAGTCTATTACCGCTACGAGAGGTTTTT +CATTTTCTCTGTATAGGAATCCTCTCCTCGGGTCATAATCTCCCTGATTCCAGTAGTAAATATCTTTAGC +GGAAACTTCTTCCACGAGGTTCTGTTCAGAAATGTCAGGCAGTTCTCTTGCCTTCTGAACGAGCTTTTTT +GGGTCTTTTTCCACCGTTGAGATAACACCTTTCATACTCCCCTTTTCCCTTATCTTTTTAACAAGTGCCC +TCGTGTCTATCCCGTATATTCCGACTACGTTGTTTTCCTTCAGGTATTCGTCTAAGCTCTTTTTTGCCCT +CCAGTTTGAGTACCTGAAGAAGGCTTCCTTTACTACAAATCCGTTCACCTGAACGCTTTTGCTCTCAATA +TCTTCATCGTTCACGCCGTAGTTTCCTATCTGAGTGTAGGTCATTACGACTATCTGTCCCTTGTAGGAAG +GGTCTGTGAGGATTTCCTGATATCCCGTCATGGATGTGTTGAATACGAGTTCTCCGCCTGTTTCTCCTTC +AGCCCCAAAGGAATAACCGACAAAGTAAGAACCGTCCTCAAGCGCCAAAATGGCAGTTTTCCGCATATTA +GAGTTTTTATTTTAATTTCTTTTTACAATCTGCGTTTTAACTCCACACGGTACATTAGAAACCATCTGCA +ACATATTCAAGTTCAGCTTCAAAACCTTGTTTTAACTCCACACGGTACATTAGAAACTTCGTCAAGCTTT +ACCTCAAAAGTCCTCTCAAACCTGTTTTAACTCCACACGGTACATTAGAAACAATAATCAACAACTCTTT +GATTTTGTGAAATGGAAGAAGTTTTAACTCCACACGGTACATTAGAAACAGAACTCTCAGAAGAACCGAG +AGCTTTTTCTATTAACGTTTTAACTCCACACGGTACATTAGAAACCCTGCGTGCCTGTGTCTAAAAAATA +ACGTTTTATCAGCAACTTATTAAACTTCTAACCTTCACGAAATGAATGTTAATTTCCGCTAACCTGAAGT +TCTGCAAACTTGAGTATACCTTTATAAAATTTCCATCCTTGATTTTCAATCCCTTTAACCCTATTGCATC +ATGATTTCATTTCATCACATCATCAAAGCATCACTCACTAAGACCTATCCACCCTTATTCAATTGCCAAG +GAGCCCGAAAGCCCTCAGCAGGGCCTTATTTAAACATTATAATCATAAAACATATATGGTCTGTCCAAAA +GTTGTTATTCTTTCCGAAGGTGCGGATCTCGACAGCCTTTCCGCAGCTTACGGAGTCCTGAAACTTTACC +CTGACGCATACTTGCTAAAGCCCAAGCACTTGTCCAAAAAAGCGGGGGAAGTTTTTAAGAAGTACAGGGA +TAAGTTCAGAGTAATAGAAGACCTGCCAGACTGCTTTGAACTCGTGCTCGTGGATACACACTTTCTTCCG +GAAGGTTTACCAAGAGAAAGGATTAAAAGAATTATCGTTTACGACCACCATCCAATAGGGGACGTGAAGG +AATTTGAGGGGAAAATTGAAAAGGTTGGGGCGGCGACCACGCTCGTGGTGGAGGAAATTAAGGAGAAAGG +TATAGATATAAATCCACGAGACGCTACACTTCTCGCCTTCGGGATATACGAAGATACGGGAAATTTTACC +TACGAAGGGACTACACCAAGGGACGCTTTGGCTTTAGCATTCTTGCTTGAAAAGGGAGCAAACCTCAGGG +AAATAAGGGAAGTCGTTATGGAAACCTATACGCCCGAGCAGATAGAGGCGGTAGGGAAAATCGTCCAGTC +TATAGAAAAGGTGTTCATAAACGGTAGGCAAATAAGTTTTGCAACTGCCGTTCTGGAGAGGTATCAGCCG +GATATAAACACGCTCCTTTACGAAATAAAAGACCTTAAAGAGTCTGATGCCTTCTTTGTGATAATAGAAG +CGGAAGGAAAGACTTACGTCTTCGGTCGTTCCCAGAGCGAAGATGTAGATGTAGGGGAAATACTTTCACA +CTTCGGCGGTGGTGGGCACAGGGAGGCTGGAGCGGTAAAGCTCGAAAACGTATCAGCAGAACGGATAAAA +GAGTTAATAAAAGCCTTTTTAAAGAGAAAGTATGTCAAACTTAAGGTAAGAGACATTATGAACACACCGC +CCTTCGTTTTAGAAGAACACGTAAGCGTAAAAGACGCACTCACAGAACTCAGTGAAAGGGGGATAGCGAA +CGCACCCGTGATAAACAGGGAGGGAAAACTGGTAGGGATAATCTCAAAGAAGGCGTTGCTCAAACTTGTG +AAACTCTATCCCGATGAACCCATAGAGCTCTTCGTCAACAGAGATTTTTACACCCTTTCACCTGACGCAC +CTGTATGGGAAGCGGAGGAAATCCTCACAAAGTTTGGACAGAAATTAATCCCCGTAGTGGAAGACGGAAC +GGTTGTAGGAGTAGTTACGAGGCTAGACATACTCCAGGCGGTAAAGGAGGATTTAGAAAAGTTAAAGGAA +AAGAGGAGAAAGATAAAAGTTCCCGAAAACATAGAAGAAATAGCGAGGGAAGTGGGACAGATAGCAAAGG +AAATGGGCCTCAGGGCTTACATAGTGGGAGGAGTTGTGAGGGATATTTTACTCGGTAAAGAGGTTTGGGA +CGTTGACTTCGTAGTTGAGGGGAATGCCATAGAACTTGCAAAGGAACTCGCGAGGAGGCACGGCGTTAAC +GTCCACCCATTCCCCGAATTCGGCACAGCTCACCTGAAAATCGGAAAACTGAAACTTGAATTTGCAACAG +CACGGAGGGAAACTTACCCAAGACCCGGAGCCTATCCGAAAGTGGAACCAGCCAGCTTGAAAGAGGACTT +AATAAGGAGGGACTTCACGATAAATGCCATGGCAATATCCGTAAATCTCGAGGACTACGGAACACTCATA +GATTACTTCGGAGGATTAAGAGATCTAAAAGACAAAGTAATAAGGGTTCTTCACCCTGTAAGTTTTATAG +AGGACCCTGTAAGGATTTTACGTGCCCTAAGATTTGCGGGAAGACTCAATTTTAAACTCTCAAGAAGCAC +GGAAAAATTGTTAAAACAGGCTGTGAACCTCGGACTCCTAAAGGAAGCACCCAGGGGAAGGCTCATAAAC +GAGATAAAACTCGCCCTCAGGGAAGACAGGTTTTTAGAAATTTTAGAACTCTACAGGAAGTACAGAGTAT +TAGAGGAGATAATTGAAGGTTTCCAGTGGAACGAAAAGGTTCTCCAGAAACTCTACGCCCTCAGGAAAGT +GGTGGACTGGCACGCTTTGGAGTTCTCCGAAGAGAGAATAGATTACGGCTGGCTATACCTCCTTATACTC +ATATCTAATTTAGATTACGAAAGGGGAAAACACTTTCTTGAGGAGATGTCCGCTCCCTCCTGGGTTCGGG +AGACCTACAAGTTTATGAAGTTCAAACTTGGTTCACTTAAAGAAGAACTCAAAAAAGCGAAGGAGAATTA +CGAAGTTTACAGACTCCTCAAACCTCTTCACACTTCCGTTCTATTACTCCTAATGCTCGAGGAGGAATTA +AAAGAAAAGATAAAACTCTACCTCGAAAAACTCAGGAAGGTAAAACTTCCCAAGGAAAAGATTGAGGAAC +TGAAAAAGCAAGGTCTTAAAGGAAAGGAACTCGGAGAGAGGATTGAAGAACTGAAAAGGGAAATTATGAA +TAAAATTTAGTTGTGCTTGAAGTCAGGGAAGTAGAAAAGAGCTTTAAGAAGAAAAAGGTTTTAAAGGGGG +GTTCCCTTTCCGTTAATAAAGGTGAAATAGTTGGTCTTCTAGGACCAAACGGCGCGGGAAAGACTACACT +CTTTAACTCCATAATTGGTTTCATAAGCGTGGATAAGGGAAAAGTTCTCCTTGACGGTGAAGACGTGACT +CATCTTCCCCCCTTCAAGCGTGCACAAAAGGGACTTGCCTTTTTGCCTCAGGAACACACACTCTTTGAGG +ATTTGACGGTTCTGGAAAACCTGTTAATATTTCTTGAATTCTTTACGGATAGCAAAGAAGAGGCGATCAC +GAAGGCGGAAGCCCTTCTTGAGGACTTCGGACTCCTTGAGCTTAAAGATCAAAAGGCTTACGCCCTCTCA +GGAGGACAGAAGAGGAGGCTCGAGATAGCGAGATCCCTTATAACTACGCCCAAGTACGTGCTCCTCGACG +AGCCCTTTGCGGGACTTGACCCCATAATAGTTTCCGAAATAAGGGAAATAGTGAAAAACTTGAAGAATAA +CGGAATAGGTGTTCTTATAACTGATCACAACGTCAGGGAAACCATAAAGATGGTGGACAGGGTGTATATA +ATTTCTGAAGGGAAGGTTCTGGCTCACGGGAAACCCGAAGAGGTTGTGAACAACGAAGCTGTAAGGAAGA +CATACCTGGGGGTGGATTTCAAATTATGAGCGTGGTGATAATAGGTGTCGGGCGTTACGCAAGGGAAGTT +CTGGAGATAGTAACCGCTATAACAGAAGTCTACGTTATAGAAAAGCCCGGAGAACACATACAGAAGTTTG +TGGAAGAAGCTAAAGGGCTGGAGAAAGTGAAGTTCGTTTTTGAAAGTGCCACGGACGTGGAAACTTGGAG +GGAGAAGGTAAACCTCTCCGAGGTAGAAGCGGTAATATCCTTCCTTAAGTTAGAAAGCACGCTGGAGGTG +GCAAAGCTCCTTAGGGAATTTTTCAATTACGAGGGAGAGATAATTTACGTTGCGAACGAAAGACCAGAAA +ACGAAGAACTCCAGAAGCTCAAAGTGGACACGGTTTCCATTCCAAACGTACTCAGGGTAATCTTCAAAAA +CCTCCTGATCGGCAAAGGAATAATAAGGTATCCCGTGGGTATAGGTCTAGAAAAGGGTGAGATAGTGGAA +ATTACACTTACGGAGTACTCACCTCTCGTTTACAAAAGACTCAGGGATATTAAGATAAGGAAGGCAAGGG +TAGCCCTCGTGTATAGGAACGGAAAGCTTTTACTTCCAAGGAGTAACTTAAGGCTCCAGAGCGGAGACAG +GCTTCTGGTAGTCGGAGAACCTTCCTCTGTAAACGTATTTATACACACTGCAACGGAAGGAATTTCGGAC +TTTCCCCTGAACTGGGGAAGTGCAGGCGTTTACTGTTCGGGAAACGAGAAAGAATTCAATTACCTGAAAG +AGAAAGTTAAAGTAAGGGAATGGTTAGAGGATTGTGAAAAAATACAGGAGATTGAGAACTTGGGGCTTAT +AGTTCTTGAAAAGAAGGAAAGCGGTTTTCTTAAAAAGGGAAGCGTTGACAGGGCTTTTGAAGAGTTTTCT +GTTCCTTCCTTTCACCTGAAGGGTACTTACCCTTACGAGAAGGTTCTCGCTTCCGCGAACACAGATGCGA +GGGAAGTCTTGCTCTCCACTGCGGTTGATATAGCTGTTCAGTTCGGTTCAAAGCTGTTCATACTCTACGT +AAAGCCCTTTGAAAAGATGATTTCCGAAAAGGAAAAGGAGGTAATAGAAGGGCTAAAGAGCTTCGCAGAA +AGGGTTAGAAAGATAACGAAGATAAACCTGGAACTCGTGATAAGGGAAGGAAATCCCGTAAGGGAAACCT +TAAAGTTCATGGATGAAGAAAGCTTTAATCTCCTCCTAATAGGATACAAGGTGGGAAGAACTACGAAATT +ATTCTCACCTTACTCACCTCACCTCATAGCGAGAAAGAGTAAACTCAGTACTCTCCTTGTGCCGGAGGTT +GTCCTTGAGCAGTGAACTCTTCCTCATAATCGTATTCCTTTCCGCCTTCCTTGCACCACTTTTTTCAAGA +ATCCTTAGAATGCCCGTACCCGTAGGTGAACTCATTTTCGGTATCTTAATCGGAAATTTCTTCGTAGGCA +TTCAGGTTCCCGAAATACTGAACTTCCTGTCAGACTTTGGTTTCCTCCTCCTTATGTTTCTCGCGGGACT +AGAGCTCGATTTCAACCTAATAGAAAAGGCGGACAAGAAACAGAACGCCGTTTACATCTCGTACGTCCTC +CTCATATTCTTGAGTGCTTTTGTCTTTGGAATTTTGCTGGGAATAGGAACAGCTCCCGCTATAATTCTTT +CCCTAATTTCCCTCGGTCTTATGGTTGCAACCCTGAAGGACATGAGCGTTCTGGAAGAGCCCTTCGCAAA +GAAAGTTTTACTGATAGGTGTCTTCGGGGAAATTATCAGTCTCCTTGCTTTGACCTTAATGGAAAAGCTC +CTACACTTCCACGGTTTTGTAAGCTTAATAAAGGAACTCGGAGTAATTTTTGTCTTTTTCTTCAGTTTCT +TTTTAGGATTTTACTTAACTAGACTCCTCGTCTGGTGGTATCCCGAGATAGTGAACAGACTCACCTACGA +AGAGGATCCGAGCGCTTTAGGGATAAGGCTCAGTTTATTTTTGATGTTTACTTCCTCAATCTTTGCAAAG +CTTGCGGGAATAGAGAGCGTTCTGGGAGCCTTCATGGCGGGAGTGGTGTTTTCCTACTTCATAAGGGAGA +AAAAGGATCTTGAAGAAAAGCTCAGTTCAATAGGTTACGGGTTTTTAATTCCCATCTTTTTCATAAAGAC +CGGAATGGGAATGGAAGTTGCAGGTTTAAACCTCGCTATCCTCTTTAAGGTGTTCATATTTCTCGCCTTT +ATGCTCTTTGTAAGGTTAATTCCCTCCTTCGTCCTTCTCCTCGCCGGATTTTCCCTGAAAGACTCTTTTA +CGGCGGGTCTTCTCTTGTCTTACCCTTTCACTCTTATGGTTGCGGGAATAGAGATAGCGAGGAGGGGCGG +AGCTCTGGACGAGGAAACAGCCCTAGCACTCTTTTTAACCGCAGCTTTCTCTTCTCTGGTATTCCCGTGG +AGTGCAAAAATAATTCTTTCTAGAAGATGAACTATATTCTGTAATTATGGAATTTGTAACGAATTACACG +CTAGAAGAGCTTAAAAAACGCTTCACCGAACTGGGACTCGAACCTTACAGGGCAAAGCAGGTATTCAGGT +GGGTATACAAGAAATTCGTAACGGACTTTGAAAAAATGACGGATTTAGGGAAAAAACACAGGGAGCTTCT +AAAGGAGCATTTTGCCTTCCACCCCTTGGAAAAGCTTGACAGGGTGGAGGCTCCCGACGCTGTAAAGTAC +CTATTCAAAACAAAAGACGGACACATACTTGAGACGGTTTTGATAAAGGAGAGGGATCACTACACCCTTT +GCGTTTCCTCTCAAATCGGTTGTGCGGTTGGATGTACCTTCTGTGCCACGGCTCTTGACGGCTTGAAGAG +AAACTTGAGCACCGCGGAAATTATAGATCAGTACCTTCAAGTTCAGCAGGATCTGGGAGAGGAAAAAATA +AGGAACGTGGTTTTCATGGGAATGGGAGAGCCCCTCGCTAATTACGAGAACGTGAGAAAGGCTGTGGAGA +TTATGGTCTCTCCCGAGGGACTCGACCTTTCAAAGAGGAGGATTACCATATCCACGAGCGGTATAGTGGC +TCAAATAAAGAGAATGGCTCAAGATCCCGTAATGAAGGAAGTTAACCTCGCCGTTTCCCTGAACGCGGTA +AGCCAGAAAAAGAGGGAAGAGCTCATGCCCCTTACAAAAACGAACACCTTAGAAGAACTGATGGAAGTTC +TCAAAAACTACCCCCTTCCCAAGTACAGGAGGATTACCCTTGAGTACGTACTCATAAAGGGAGTAAACGA +CTCTCCTAATGACGCGGAAAGGCTTGCAAAATTAATAGGAAGGCACAAAAAGAAGTTTAAAGTGAACTTA +ATTCCCTTTAACCCGGATCCTAACCTTCCCTACGAGAGACCCGCCCTCACCGACATCATGAAGTTCCAGA +AGGTTTTATGGAAATATGGTATCTCTAACTTCGTTAGGTTCAGCAAAGGCGTAGAGGTGTTCGGAGCCTG +CGGTCAACTTAGAACTCAAAGGCTACAGCTCCAGAGAGTATGAAAGTGGTAGAACTAAAAAACGTTAAAA +AAATTTACCCCGACGGAACAATTGCTCTCAAAGGCGTTTCACTTTCCGTTGAAGAGGGGGAATTTTTAGG +CGTTATGGGACCTTCTGGTTCGGGCAAAAGCACCCTCCTTCACTTAATAGGGGGTCTGGACAAACCGAGC +GAAGGAATCGTCAAGGTATTTGGGAAGGAGATAAATCACTTGGACGAGGACGAACTTGCGGAAATGAGGA +AGAGGAAAATAGCCTACGTTTTCCAGTTTTACTATCTACTTGAAGATTTTTCCGTTCTTGAAAACTTAAC +TCTTATAGGGGAACTTGCGGGGATAAAAAATCCGAAAAAGAAAGCCCTTGAGCTTTTGGATTTTTTGAGA +CTTTCCCACAGGATAAACCACAAACCTTACCAGCTTTCGGGTGGGGAACAGCAGAGAGTTGCAATCGGCA +GAGCCCTTATGGTGGAGCCAAAACTAATACTTGCGGACGAGCCCACGGGAAATCTGGACTCTAAAGAGGG +TTTCAGAATTTTTGAACTTTTTAAAGAATTGAATGAAAAGGGAATTACGTTTGTAGTTGCAACTCACAAC +GACTCCCTTAAGCCCTTCTTCGGCAGGATAATAAACTTGAGGGACGGAGAAATCGTCACTCAACGGTGAG +GAGTTCAATCTCGCCTTTCCTGTAAATCCTCACCCTCACGTTGTACTCTTTCAGTTCCTTTTTCTCCACC +TTCACCCCTTCCGTAGAGCCAAGCTTTACCTTTGAGTCCAAAACCCTGAAAGCCTCCCATTCCTCCTTTA +AGTTCTGAAGGTAAGCGGAACTCTGGGAAAAGAGCGAAAAGATTACGGTGAGGGAAATGCCCAGGATAGT +TAAAGCTATAAGAACCTCAAGAAGGGTAAACGCCCTCAAAGGTCCCAGACGCTTATGTCGTCTTCCGTTC +CCTCAATGCCGTCTGGTCCCACCGATTTAAGCTCATAGGGTTTATTACCCGCGGGGGAGACGTAAATAAA +GTCGTTTCCCCACGCGTCTTTCGGAACTTTTTCCATGTACTGCTTCCAGTTTTTGGGCTCCGGGGGAGTG +GTAGGCTTTTCCACGAGGGCTTTCAGCCCTTGCTCCGTGGTGGGATAAAAGCCGTTGTCCAGTTTGAACT +GCTCCAGAGCGTTCTTTACAGCCTTTAACTGAAGCTTTGTGGACTCTATCCTCGCCTCATCCACCCTTCC +CGTGAGTTTGGGAACTATGAGGGCGGCGAGGAGCCCGAGAATAATGAGAACTACGAGAACCTCTATTAAA +GTAAATCCCCTTCTCATTACACCATCCTTAAAAGTCTCTTTATGGCCTGCTCAACCATTTCCTCGGTGGG +AATAAAGTCGTGGCGGTCGAGCTCCATCGTGTCCCTGAAGTAAAGAATCGCCGGGAAGTTAAAAATACCG +AAGTCTTCAAAGGAAGTGTTCTTCGTGACGTCCATGTAAAAGAAGTCTATTTTGTCCCCGTATAGTTTCT +GGTACTTTTCGAGTATGGGCTTTATCTGCTCGTTTGCCGGGTTGTTCGGGTCCGTAAAAACAACAACGGA +AGGTTTAGGGTTCATCATAACAGCCTTGTAAAAGTCTTTATCGGTAACCTCCTTAAAGCCTTCAAACATT +ACGTACCTCCTTCGTTTTCTTCTTCGTCTTCATCAAATTCTATAAAGTATCCGCCGAAAGACCCTCTTGC +GTTCAAGGCGGTCAATTTCAAAGCGTTCAGATAATTAATTATGTCTTCGTACTTCTTTATAGAGTTCTTT +ACTTTCCTGTACTCTTTAGGGCTCAACCTTTTGTTCCTCAGTATATTCCTTAAAGCTATCCTCGTGAGGT +TTGCCCTGTTGAACTTTTCCTGCCACTCTTTCCAGAACTCTTTGGAGTTGAGCGGTGCGGAGATGTTGTA +GAAGTCTATCTCGGAGAGTTCTCTGATAAGTTCTAATTCAAGGTTATTTTTTCTGAATCTTTTCATAAGT +AATTATTCTATATCTAGAATAGTTTTTATGGACAGGCTTGAAAAAGTATCACCCTTCATAGTAATGGATA +TCCTAGCTCAGGCCCAGAAGTACGAAGACGTAGTACACATGGAGATAGGAGAGCCCGATTTAGAACCGTC +TCCCAAGGTAATGGAAGCTCTGGAACGTGCGGTGAAGGAAAAGACGTTCTTCTACACCCCTGCTCTGGGA +CTCTGGGAACTCAGGGAAAGGATATCGGAGTTTTACAGGAAAAAGTACAGCGTTGAAGTTTCTCCAGAGA +GAGTCATCGTAACTACCGGAACTTCGGGAGCGTTTCTCGTAGCCTACGCCGTAACACTAAATGCGGGAGA +GAAGATAATCCTCCCAGACCCCTCTTACCCCTGTTACAAAAACTTTGCCTACCTCTTAGACGCTCAGCCG +GTTTTCGTAAACGTTGACAAGGAAACGAATTACGAAGTAAGGAAAGAGATGATAGAAGACATTGATGCGA +AAGCCCTTCACATTTCCTCGCCTCAAAACCCTACGGGCACACTCTACTCACCTGAAACCCTGAAGGAACT +TGCGGAGTACTGCGAAGAGAAGGGTATGTACTTCATATCCGACGAGATTTACCACGGACTCGTTTACGAA +GGTAGGGAGCACACAGCACTTGAGTTCTCTGACAGGGCTATTGTCATAAACGGGTTTTCTAAGTACTTCT +GTATGCCAGGTTTCAGGATAGGGTGGATGATAGTTCCGGAAGAACTCGTGAGAAAGGCGGAAATAGTAAT +TCAGAACGTATTTATATCTGCCCCGACGCTCAGTCAGTACGCCGCCCTTGAGGCTTTTGATTACGAGTAT +TTGGAGAAGGTAAGAAAAACCTTTGAAGAGAGGAGGAACTTCCTTTATGGGGAACTGAAAAAACTCTTCA +AGATAGACGCGAAACCTCAGGGAGCTTTTTACGTATGGGCAAACATAAGTGATTACTCCACAGATAGCTA +CGAATTTGCTTTAAAACTTTTAAGGGAGGCGAGGGTGGCGGTAACGCCCGGGGTGGACTTTGGAAAAAAC +AAAACGAAGGAGTATATAAGGTTTGCTTATACGAGAAAGATAGAAGAACTTAAGGAGGGCGTTGAAAGGA +TAAAGAAGTTCTTAGAGAAGCTTAGCTGATCTAAAATACTCTCTATGGAAGAAAAGGCTTTAATAGGGAT +AGAAGACTTTTTAAAAGTAGATCTCAGAGTAGCAAAGGTTCTGTCCGCCGAAAGGGTAGAGGGTTCCGAA +AAGCTCCTGAAGCTCACACTTTCCTTGGGAGATGAAGAGAGGACGGTTGTCGCAGGTATAGCGAAGTACT +ACACACCCGAGGAACTCGTAGGGAAGAAAATCGTTATAGTTGCAAACTTAAAACCAAGAAAGATTTTCGG +TATAGAGTCCCAAGGAATGATACTCGCCGCATCGGACGGAGAGAACCTCTCCGTTATAGTTCCCGACAGG +GACGTGAAGGAGGGGGCTAAACTCAGTTGAAGTACTTCCACTTCACTGAAGAACACCCCTTTTCCCTTGT +TCTCCCCTTAATAGAGGAGGGAAAGTTAGACCCCTGGGAGGTGGACATAGTAGAGCTCGCAAACCTCTAC +ATGGAAGAATTAAAAAAACTAGAAGTTCTGGACCTGCGTGTGCCTGCGAGGGCTATCCTCGCCGCTTCGT +TTTTGCTCAGGAAGAAGATAGAAACGATATTCCCAAAACCTCCGAGAAAGTACACAAAAAGGAAGTACAC +GCTACAGGAAATAGTTGATATGTTCGAAGAAGAGTACAGGGAAGTGGAGGAAGATATAAAGGAAAACGTT +GAAAAGATAAGGAAGATAGTAAAGAGGAAAAGGGCAAGTGCAAAAAGAAAAAGGAGGGAAAAGAGAAAGG +AAGTTCCCCTGCACGTTGCGAAGTTTGAAGAAGTTCTAGAAGAGCTTTGGAACTCCTTCAAGGAACTGGA +AGTGGGAACGAGGCTGAGTTTTTTTAATTTTTTAAGCAAGAAGGATTTAGTTCCTCAGTTTATGGCACTC +CTTTATCTCGACTACGAGAGTAAAGTAAGACTCTTTCAGGAAAAGCCTTTTGAAGACATAACTGTGGAGA +TATTAAAAACCTAGAACCTTTACTACCTCGTCAAAATCCGGAGGTACTGTTATAGGTTCTTCACAAACTT +TTATAGCGGTATCGGGGTCCTTTAAACCGTTTCCGGTAAGTGTACACGTTACCACTTCTCCGCCTTTAAA +AAAGCCTTCCCTTACGAGTTTTATCAACCCTGCCACGCTCGCGGCAGAAGCAGGCTCGCAGAAAACACCT +TCCGTTGAGGCGATGAGTTTGTAAGCATAAAGGATTTCGCTGTCACTTACCGCATCTATTTTCCCACCAC +TCTCCTGAGCGGCTTTCAGGGCAGACTTCCAGCTGTAGGGATTTCCTATCTTTATAGCCGTAGCTATGGT +CTGGGGATTTTTAATCGGGTAGCCCTTCACTATAGGAGCAGCACCTTCCGCTTGCCAGCCCATCATCCTA +GGGAGTTTCGTTATTTTCCCCTCCTCGTAATAAATCTTAAAGCCCTTCCAGTAGGCGGTTATGTTTCCTG +CGTTCCCGACTGGGATAAAGTGATAATCTGGAGCCTCTCCCAAGGTATCGCATATCTCAAAAGCGGCTGT +CTTTTGCCCCTCTATTCTATAGGGGTTGACCGAGTTCACAATTTCCACGGGAAAATTTTCACCTATTTTT +CTCACTATGTTCAGGGCATCGTCAAAAGTTCCTTGAATGGCGAGGACTTTAGCCCCGTAAATCATAGCCT +GAGAGAGCTTTCCTATGGCGACAGCACCCTTGGGTAGCAGAACGTAAGCCCTGAGTCCAGCCCTTGCAGC +GTAAGCCGCGGCGGAAGCGGAGGTGTTTCCCGTGGATGCACATATCACCGCTCTTTTACCCGCTTCCACT +GCTTTCGAAATGGCAAGGGTCATCCCCCTATCTTTAAAAGAACCAGTCGGATTTAGTCCTTCGTACTTCA +GATAAATCTTTCCTTTAAAACCTATCGCCCTTGCGAGGTTGTCCGCCTCTATGAGAGGAGTGTTACCTTC +GTAGAGGGTTACGATGGGTGTGTTTTCGTCAACGGGGAGGTACTTTTTATACTGTTTAATTATTCCTTGC +CACCGATTCATAAAAACTATTTTCTCACGTATACTCTTTATTTCCAGTAATTTTCTAAAAGGTCGTAAAA +CTTATTCACCGATTTCTTGACTAGGAAGTAAGCCTCTCGCTTGTTTTGAAGTCCGAAGTCCTTCTTCACA +GTGTCCAGAGAAGCGTCGTAGTACCTCTTCTTTATAACTGTTCTGTAGGGCTCTTCCATCATGTCTATGA +TCCTCTCCACGTCTACGGTGTATATCACGTATCTTGTGAATTTGGCCTCCTTGTTTGGTAATTTTTTCTT +CCTCGAGAGTGCGTTAACCATACTGCCTTTAGAGAGTCCGGATATAAACTTCGCCTCCTCAGCCACCTCG +TACTTATCCATAACTTGGCGCACTACGCTCAGCTTGTACTCAAATAGATTCATTACTTCCCTCCCTGTTC +TCAGATTTCTCTCGAATCTATTATAATGGTCACGGGTCCCCAGTTTTCTATAAAAACGTCCATCATAGCC +CCGAAAATACCCGTTTCTACTTTAAGCCCGCTTTCTTTTATTTTATCCACGAATTTTTCGTAGAGTTCTT +TTGCTCTCTTAGGCTCTTCGGCCTCTTCGAAACTGGGTCTCCTTCCCTTCTTTACGTTGGCGTACAGCGT +AAACTGAGAAACCACTAGGATTTCGCCTTTTATATCGAGCACGGAGTACTGAAACTTTCCCCTTTCGTCC +TCAAATATCCTGAGGTTAAGTATCTTATTTACGAGTTTCTCTATATCCTCTTCGGTATCGCCTTTCCTAA +CGCCGAGGAAAACGTTCAATCCCTCGTTTATGCTCCCCACTACCTTCCCGTCCACTTCCACCCAGCTCTT +TTTAACTCTCTGAATTACCGCTCTCATATTACCAGACCACTATTTTATCCGCCTCTTCTATTAGTTTAAT +GATATCTTTGTAGCTTATAAGGACCTCTTCCTTGAACTTTAATCCTCTCGCTTCGGCATCCTCTTTACAA +ACGTACCACCCCTCCCTGGAAGGGTACCTCAGGACTCCGTCCTGAATCAAAACCACTACATCGTCCTCGC +CGAGGTAATCCGAGGAAAAGTCTCCCAGTTTCCTCACGAGCCAAAGCGTTTTAACACCCATGGTAAAATT +CTACCAAGGGGTGGATAAAGTGTGGAACTAGATAAATACTTAGTTTTAGGTTTTGCAACTCTTTACGCAC +TCTTTATGTTGCTCACGAAAGACATCTTCGTTAAGTACCTGTCCTCCCTTTACGCGGTTTCCTTTATGCT +CATTTACATGTCTTACTACCTCGAGGGTGTTAACTTTCCCAGACTTTACGTTTACGGATTCAGGGTTGTC +GGGTTTATAATGCTCGCTTACACTTTCTTCGAGAATTATAAACTTATAAAACTCCTCAGAAATCTGGAAA +AGAGAACGTACATAGATTCTTTAACGGGTGTTTACAACAGGAAGTTTCTCGAGGAGATTTTTAAGCTCGA +GAAGGAAAAGTACAGGACTTTCAGGAAGGAGTTCTGCATAATTTTCATAGATCTTGATAACTTCAAGGAA +GTCAACGACAGGTACGGACACATGGAGGGGGATAAGGTTTTAAAACGGGTTGCCGAATTGATCAAGAAAA +GCGTAAGGAAGGAAGATTACGTCATAAGGTACGGAGGGGACGAGTTCGTGATAATAACGGAGGCCCCGAG +GGGAGACGTCCTGAGCATAATGTCAAGACTTCAGGACGTCATAAAGATAAAGTACAAGGAAGTTGAGGTA +ACAGCCTCTATAGGAAGTGCCTGCTTTCCGAACGACGGAAAAGAACTGGAAGAGCTGATAAAGAAAGCTG +ACGAAAGGATGTACAGAATTAAGAAGATGAAGAACGAACTACTCAAGCTTAATAAAGGGTAGTATTTCTT +TAAGGTCTATGTACCTGTCGCAGGCATTCACAAGTTCTATGGAAGAGCTTTCCTTTGTGGAGACGCATAT +AACCTCTTTTCCGAAGTTTCTGAGTACGTAAACGAGCCTTTCAAAGTCGCTGTCCCCTGAACAGAGGATA +GCCGTGTCGTAATTGTCCTTCGTGAGGAGCATGTCTATAGCTATGTCCACGTCAACGTCTCCCTTCAGGC +TTCCGTCCTTGAGTTGTTTTACGGGTTTTTTCACTACGGTTATACCGCTGAAGGCAAGGAGTTTAAAAAA +CCTCTCCTGCTTTTCGTCCTCTTCCTTGTAGGCGAGGTAAAAGAAGGTGTTGTAAATGTCGTAAAACTGC +TTAAAGTAATTGACGAACTTCACGATGTCTATCTTGGCGTTGAGGAAGTTCTTCTGGATAAAGTAGAGGT +TCGTGCCGTCCACGAATATCGCGGCCCTCCTCCTCATTCCTCGTCTCCGACTACGTACCACACCCTTATC +CCTGCGGAGACGTGTGCGTTTCTCTGCCATATCGTTTCCACGTTTATTACCTTGACCTTGTTTAACTTAA +TCCACTCGTTTACCTGCTTATCGAGGAGTTCCTCCAAAGTCTCGTCTATAAAAGGAGCGGTCTTTCTATA +AAAATCTTTAAATCTTATTTCCATGGCAAATACCCCTTTAAGTTATCTCTTCCCCTTCTTCTTCTTGAGG +CGGAACAGCTACGGCTACCCTTGCGGGTCTGAGAACCTTGTCGTGTATGTAGTAGCCCTTTCTTATTACC +TTTACGACGGTATTGGGCGGATACTGATCCGTTTCTACCTTTTCCACGGCTTCGGCGACGTAGGGATCAA +ACTCCTTTCCCTCAACCGGTATTTCCCTTATTCCGTACTTTTCGAATATCTTTTTCATTTCCGAGTAAAT +CATTTCAATACCGAGGAGTATAGACTTCACGTCTTGTGCCTGCCTACCGTATTCCAGCGCCCTTTCGAAG +TTGTCCATAACCTCAAGGAGGTCGTAGGCGAACTTCTCATAGCAGAACTTCCTCTGTTCCTCTAAATCCC +TTCTGTAGCGTTCTTTGAGGTAATCTATTTCCCTCTGGAGTTCGGCAACTCTCAGGTTTGAGTTCTTGGC +GATTGTTTCAAGTTTTTGAATTTTTTCTTCGAGTTCTTTTTCCCTCTTTCTTAATTCTTCAAGTTCTTTT +TCAATTTCTTTCTGATTTTTTTCCATCTTCTTCCTCCTAGTTTAATCATAACATACTCCATTTCATGGCT +CTCTTTACAGCATCCTTCCACTTGGAGTAGTAAAGCTCCCTTTCCTCTTTTTTCATTTCTGGACTGAAAG +TTAATTCAACTTCCCTTGTATCCTCAATGAATTCCTCTTTACTCTTCCACATTCCTGAGTATATACCTGC +AATTCCAGCCGCTCCCAGAGCTGTAAGTTCTACATGCCTAGGTCTTTCAACAGGTATGCCAAGAATGTCA +GCCTGAAACTGCATTAGGAAATTGTTCTGAGAAGCTCCTCCATCCGCTTTTAAGATTTTTATCTTCACTC +CCGTTTCCTTTTCCATTTCTTCAATTACATCCCTTGTTTGATACGCTATTGCTTCTAATGCAGCTCTTGC +TATGTGTTCTATTCTTGTCCTTCCCGTAATCCCTATTATTATTCCCCTTGCTGACGCATCCCAGTAAGGA +GCTCCAAGACCCGAAAAAGCTGGAACGAAGTAAACACCTTCATTTGAGCTGATGGATTTTGCCAGGTATT +CCGTATCGGCAGCCTGCTTTATTAATTTAAGCCTGTCCATTAACCACTTTATACAGGCTCCTCCGGTCAG +TACACTTCCTTCAATTGCGTAATTTACCTTACCATTTATAACCCAGGCTACTGTTCCAAGTAACCTTTCG +GGTATTATCGGTTTACTTCCCGTTAAAAGCATAAGGAATAAACCTGTTCCATAAGTGTTTTTAACCTCCT +CTAATTCCCTTATTCCGTGAGCGAAAAGTGAGGCCTGCTGATCACCCAGAATTCCTGTAATAGGTATTTC +AACACCTGTAATACTTTTATCCGTGTATCCGAAAAGGGAAGAACTTTCATTCACCTCCGGGAGTATATTT +TTAGGTATCCTGAATATTTTTAACAGTTCATCATCGTATTCAAGTCTTTTAATGTTGAATAGAAGGGTTC +TTGAAGCGTTACTCGGTTCAGTTTTGTGAACCTTTCCTCCTGTTAAGTTCCAGAGAATCCACGTATCAAC +TGTTCCAAATATTACCTTTCCCCTCTCAATGTCTTTCTTTACCCCGTTTACGTTTTCTATTATCCAGTTT +ACTTTGCTTGCGGAAAAATAAGGATGTAAGAGAAGGCCTGTATTTTCCTTTATGTATTCAGAGTATTCGG +AGAGTTTTCTACATATATCCTCAGTTCTTAAATCCTGCCAGAGTATTGCGTTGTAAACCGGTCTTCCGGT +TTCCTTATCCCAAAGGATAACAGTTTCCCTCTGGTTTGTAATTCCAATTGAATTTATTTCCTTTAACCCA +ACCTGTTGAATAACCTCGCTCAAAGACTTTCTAACGGCTTCCCAAAGCTCAAGAGGATCTTGTTCTACCC +ATCCAGGTTCTGGATATATCTGTGAAACTTCCCTGTCAGAAATTGCAACTATTTTTCCATTTTTTGAAAA +TGCGATAACTTTTACTCTAGTTGTCCCTACATCTATTGAAATAACAACACTCATCTTATCTTATTTACAA +CTTCCCACTCGGTAATGAGTTGTTTTCCCCTTACGAAGTGACTCCTTAATCTTAAATGTAGTAAGTTTTT +GAGTTTTTTGAATCCTTCACCTCCCACTAAGGTGGGAACGTTCTCACCGCCCACTATGACGGGCAGGTGA +ATAAGCCTTATCTCGTCCACGACCCTTCTTCTCACGAACTCCCAGTTTATGGAAGCTCCCCCTTCTACCA +TTAGTGACTTTATTCCCCTTCTGTAGAGTTCGGGAAGGAGTTTATCAAAGTCCACGAGTTCGTCCCCTAC +GACTATTACCTCAGCTCCTAGCTCTTTTATCTTTTCGAGTCTCTCCTTTGGAGCCCTTTCTGTCGTCGCT +ATTATCGTTGGAGCTTCCTTTGTGTTTAAAACGTTCGCATCTAAAGGTACGTTTGCGGTAGAGCAGGGAA +TTATCCTCACGGGGTTTTTACCTTTTGCGTATCTGACCGTGAGGCTGGGATTGTCCGTCCTTACCGTTTC +ACACCCTACCATTATCCCGTCAACCTTCGCCCTTATTTCATGGAGGTACTTGTAAGCCTCTTCATCCATC +AGGCTCATGAGCTCCTTGGATGAGGCACCCCTGTAGAGGGTGAGTTTTCCATCCACGCTTACTTCGGAAA +CTATGATGACGTATGGTCTTTCCATAAGCAAAATTGTACAAAAATTTGGAGCGGGCGACGGGACTCGAAC +CGGCGACCTCCTGCTTGGGAAGCAGGTGCTCTACCTCTGAGCTACGCCCGCTTTTTATTATTAAATTTTA +TAATGGTGTTTTAAGGAGGTTGATATGTCCGAAAAGGTGAAGATTTACATCGACGACGTTGAAATAGAGG +CGGAAAAAGGAAAAACTGTCTTACAGGTAGCCCTCGAAAACGGGATAGACATACCCTACTTCTGTTACCA +CCCGAGACTCTCCATAGCCGGCGCGTGCAGGATGTGCGTGGTTTACTGGGAAGACATAAACAGACTCGTT +ATTTCCTGTAACCTCCCCGTTCAGGAGGGAATGAGAGTAAGGACGCACAGAACGAGCGAAATGGTGAGAG +AACAACAAAAGTACCTCCTTCAGGCTTTAATGACTAGACACCCCCTTGACTGTCCGATATGCGATAAAGC +GGGAGAGTGTGACCTCCAGAACCTCGGAGCCATTTACGGACCTCAGAAACAGATAGTCCCCATATCCGCA +CTTGAAAAGGAGAGGGAAGAACACGACTGGGAGAGCGATTTTCTGGAGTACTACTCAAACAGGTGTGTTG +TTTGTTACAGATGCACGAGGGCGTGCGACGAGGTCGTAGGTACGAGAGCCCTTTACGTTGAAGACAGAGG +ATTTCACTCAAACATAGTTCCCGCCGTAAGACCTATGGACACATCTACGTGTGAAATGTGCGGTATATGC +GTGCACGTTTGCCCCGTAGGCGCTATTATTTCAAAACCCTTCAAGTATTGGTCCCGTAGCTGGCTTCTGG +AAAAGGGAAGAACCGTATGCAACCTCTGTCCCGTGGGATGTGAGATACAGATAGAGTACGGAGTGGGAGA +CTGGCGTTCAAAGAGAAAGGTTTACAGAACGAAACCCACGGACGAGCTAAATATCTGCGCCAAGGGCTTT +TTTGGCTATGATTCCATAAATCACAAAAGACTTTTAAAAACTAAAGTGGGAAAAAGGGAAGAAACTCCCG +GTAACGTCGTAAACCTCCTCACAACTATCCTCACCGAACACGGAGGGAAAACTGGAATAGTCTTTTCCGC +ATACCTACCCAAAGAAGTAATAGACGAAGTTTTAAGGATAGCAAAGGCCTCTCAGGCTTACGTCACGGCT +CCCCAGAGTGTGGATTTATTCAAGTTTTTAGATGAGCTGGAAGAGTATGACTTTCCGACTGTAAAAGAAT +TTGAAAAGGCGGACGCTTTCGTGTTCATAGGCGACGACATAACTTCCGTGGCTACCGTTCTTTCTTACTA +CACAAAGAAGAAGGTTTACAAGATAGGAAAGAGCGTAAGGGACGAAAAACTCCAGCCCGAAGAGATTACC +TACGAAGATCTCCAGAACCTCGAAGGAAACGTGTTCGTCCTAGTGACACCCCACGCCTTAAACGGTGAAA +TCAAGGAAGTTGCAACGAAACTAAAAGAGCTTAAAAGGGAAAAAGGCTTTAAGGTAATCCCCGTGCCAAA +AGACGCAAACGCACTCTACCTCTACGAAGTATTGAAAGGTATATACTCCGACCTTCCCGCGGTAATGGAA +GCCTGCGAAAGGGGAGATATAGAAAACCTCATAATTTTCGGAGAGGACATACTGGAGTTTTACGAAGATA +AGGTATTCGAAGAATTAAAGGAAAAGCTCGAACACCTCGTGGTTGTGAGCCCCTACGAAGACGGACTGAG +CGAATACGCCCATATAAAGATACCCATGTCCTTAATGGGAGAAAATGAAGGAACTTATAAAACCTTCTTC +GGTGAAGTTAAAGGAAAGAAGTTCCTTCCTTGGGCTTTCGACGACCTCGCCTTCTGGAAGTACCTCGGTG +AAAACTTCAAGGAAGAAAAAGGGCTAAAGGTTGTAAAAAGCTCATCGAACCTCAGGAGAAGGTTCGAACC +GCATCTCTACAGGAACAACTGGATTACACAAAGGAGCCAGAACCTTTCAAGACTCTATGAAAAGAACAAA +GATATAACGGTTTACTACGAAAGGAGTGTTTAGTCTTTCCTCTTTCCGTACTTCTTCTTTACCGCTTTGA +ATTGAATTTTCCAGTAAAGGAAGAGAACTATCCAAGGGAAGACAAGGATGAAAACCAGACTTAAGAATTC +TCCAACACTCACTTTTTCCACTCCCTTATAGCTTTTCCTATATCGGCACGTGTTATGATACCGATAAGCT +CGGAACTGCCCTTGTGCTTCACGACGGGAAGTCTACCTATTCCCTTTGAGGAGAATATCCTCAGAACTTC +AGCAAGACTTTCCTCTTCCGTAACGGTGATGAGATTAGTACTCATAACATCGTAGACCCTCTTCTTTTCC +CTGAGTTCGGAAGGAACTTTTTGTATGTCGCTTTTCGTTACTATTCCCACGAGTTTTCCTTTCGCAACTA +CGGGAAGTCCTCCTATTAGGTGTTTGGAAAGTATTTCTTCTACTTCCTTCAACGTCTGATTTGGAGAGAC +AGTTATGGGATTTGGAGTCATGTAATCCCTAACACAGAGTTTTTCAAGTATGTAAAAACCGAACTCGTCC +ATGTGAGCTGGGGAGTCGAGCCTTGTGTTTACCTGACTCGGGAATATGCTCTTCTCACCGCTAAGGAAGT +AGGAAACGAATACCGCTATCATCGCGGGAACGAGGAGTTCATACCCACCCGTCATTTCGGCGATTAGTAT +CAAGGTGGAAAGGGGAGCCTTTGCTGCTCCTGCAAATAGAGCTACCATACCCACGATTGTGAAGGAAGGA +ACGTGGAGGTTTAGGGAGTACTGGGCATTTAAAAACAAACTGTAAGAAGCTCCGAGCAGTCCACCAATCA +TAACGGATGGACCGAAAACCCCTCCCGAACCGCCCGAACCTATCGTGAAGGAAACTCCCAGCATCACAGC +TACCGCACTGAGGAATATCTGAGCGTAATCGTTCCACTTACCGTCCAGAATTAGTTGAAGCCAGCCGTAG +CCGTTGCCTATCGCGGCGGGAAAGAGCATCCCTATACTTCCCGCGATAAAACCACCTATTGCGGGCTTTA +TGAAGTCCTTTATCTTGAGTTTCCTAAAAAAACTACTTATTAAGAAAAAAATGTTCACGTAAACCCTCGT +AAAGAGTGCGCAAATAACTTCTAGACCCGCGTACGTAAAAGAATTATTAAATCAACTTCTTTAAATGGCT +GGACGTTTGAAGAAAATATCGGCTGAAATCCGTAAACGGAACCAAAAACGCTGTAAGCTACAACTGAGGC +TATAAAGCTCGGGATCATGGTCTCAATAATAGAAGTCCCTTTTGAAAAAGACCTCCGCACTGATAATTGC +CCCGGCGAGAGGAGCTTTAAAGATAGCTGCTACTCTGCCCCGAGCCTATTGCGAGTGCCTTCCTCTTTTC +GGACTCCTTTAGCTTAAACCAATCAGCCACGGAAGAACCAAGCCCCGCACCAATTAAGGCTATTGGGCCT +TCCCTTCCCGAAGTCCCGCCTGTTCCTATAGTTACAGCGGAGGTTATAAGCTTTACTATAGAAGACTTCA +AAGAAAGCTTTTTTCCGTGGTGGTAGGCATATATGGCGGCATCAGTACCCACGCCTGCGGACTCAGGTGC +AAAAAAGTAAGCGAGCAGTCCCGAAATAAGACCGCCTAGAGCTACAGTAATAGGAAGGAGATACGGTTTC +AAAGGCTCCCATGTGAAGGTTTCCCTATGCCCTTCGCCTCCAGGGAGAGGCTGGTAATAACCTACAACTT +GTTCAAGAACTAAGTGAGTAATAACTTCCAATGCTTCTACAAAGAGTATTGCAAATAAGCCCGCAAACAA +ACCTATGATAACGGGGAGCCAGAAATACTTTCTGAGCATTTAACTTTATTATAACTTTCGGGCGTTATAC +TAAATTAACATGCACGTCCTTTTAATCGGACTCGGAAATATGGGAAAAAAATACTTAAGAAAAATAAAAG +AACTGGGACTGAACCCCGTCATATGCGACATAGACCCTGAAAAGGCAAACGTCTGTAACGAATGTCCCTT +TTACTGCCACATAGGGGATATAAAGGAAGAGGTTCAGAAAGTAATAATAGCCGTTGATCCGAAAGATCAC +GTAAGACTCGCGAAAGAGTTTCTGGAAAAGGGCATTCCCGTTCTCCTTGAAAAACCCCCGGCACTGACGA +GTAAAGAGTTTGAAGAAATAGTAGAGAACCCAAACCTTGAGATATCCGAAATAGAACTTTACTCCGAAGC +CGTAAAAAATTTTCCAACGGATGTAGAACCTGAGGAAATAGTCATAGAAAGACTGAACAAAGGAAGTGGT +TACATAAACCCTCTCTGGGATCTCGCCTGGCACGATCTTTACGTACTTCAGTACCTCTTCGGTGATGTAG +AAGCCGAAGAAGTAAATAGGAAAAACGGTATTTGGGAAATAAAGGGAAAGGTAAAAAACGTTCCCTTTAC +CCTGAGAGTTGCGTGGAATTACCCTGAAGAACAGAAGAGAGTCTGGAGGATAAAAACTAAAAAGGGAGAA +ATTTTAATGGATTTCATAAAAGAAGAACTCGCTTACGGAAATTACAAGAGACAAAGGCTTTACGGAGACA +AACTCGGTGAAATGGTTCGGGATTTCCTGAGCGGTGTAAGGAGAGAAGGAAGCACGAGAAGAGCTTTAAA +TAATTTAAGGATTTTGGAGAGTCTGAAAATTTAGTTTCTCTCCGCGGTCAAAACGATATTCTTCGGAGAG +ATTACTTTTTTATCCCTCTTCATTTTGACCTTCAGATTTTCATCAAACTTATCCTTCAGGTAATAACACC +AGGCTTCGTAAACACCGAGCTCGTCTATTAAGAACTGGTACTTTTCCCTAGGGAAGTTTCCTTCACAGCA +TGGCATTAAAACCGCAAACTTTACATTCTCGTTATTGTTCACAAGTTCTATAAACCTCTCCGACAAGTCC +CTGCACAGGTGTATTCCCGTAAGGATTACTTTATCTCCCGCCTCTTTTATCAGTTTTTCAACCTCTTCGC +TCATTATATCTGCCTTTACGAACTGAGCATTTTTTAAGTAAGTAAAGTGCTCCCTGTCAGCTCCCTCATC +TATGTCCACGGCTATCACTTTGGTTTTTGGATGCATCAGGGCAACAAGTGTGCTCAAAAAACCCTTTCCC +GAGCAGAGGTCAATAACGACATGATTGGGATCCCTTATAAGGTGGTCCTTAATCCTCTCCCTCACTGCCA +TGGCCTCGGATATCTCCTTCCAGAAGGTGTTTTTCCTCCTGAGCTTCTTAAACTCTTCCCTGTTCTCAAA +TAATTTCGCTATCCTTAACTTCTTGAAGCTTTTTACGTAGGAGTTTTCCTTGATTTCCATCCCATCAAAT +TAATTTATACAATCCTTCTCCTGTCCCACCATGCGAAGGCTATGACACTCACGGTCAACATTTTAGATTA +AACTCTTCGATTAAGATATACTCTATAACCTGAAGGAGGTTAGCAAATGCTTCTGAACCTGGATGTGAGA +ATGCAACTAAAGGAGCTGGCACAAAAGGAATTCAAAGAACCTGTTAGTATAAAGCTGTTTTCTCAGGCTA +TTGGATGTGAGTCCTGCCAAACCGCGGAAGAACTTCTGAAGGAAACCGTTGAGGTTATCGGAGAGGCTGT +GGGACAGGATAAGATAAAGCTCGACATATACTCTCCCTTTACTCATAAGGAAGAAACGGAAAAGTACGGA +GTTGACAGGGTTCCGACAATAGTTATAGAAGGAGACAAGGATTACGGAATAAGGTATATAGGACTTCCCG +CGGGACTGGAGTTTACCACACTCATAAACGGTATATTCCACGTTTCTCAAAGAAAGCCTCAACTTTCTGA +AAAAACTCTTGAACTCCTTCAGGTAGTTGACATTCCAATAGAGATATGGGTTTTCGTTACGACTTCCTGC +GGATACTGTCCTTCTGCAGCGGTAATGGCTTGGGACTTTGCGCTGGCAAACGACTACATAACTTCTAAGG +TTATAGACGCTTCAGAGAATCAAGACCTTGCCGAACAATTCCAGGTTGTAGGTGTCCCTAAGATAGTCAT +AAACAAGGGTGTGGCGGAATTCGTGGGAGCACAACCGGAGAACGCCTTCCTCGGTTATATAATGGCGGTT +TACGAAAAACTCAAGAGGGAAAAAGAACAGGCTTAATGCGTTTCTTAGATAGATTCTTCAAAAAGAAGAA +GAAAGAGGAGGCTCTATGGACAAAGTGTCCGAACTGTAAAAGCCTCCTCTACGTTCCCGACCTGGAGAGC +AACCTGAAAGTTTGCCCCAATTGCGACTACCACTTCACCCTTTCCGCCCTTGAGCGTATAAAGTACACCC +TCGATGAGGAAAATCCCGAACTCCTATTTGAAGAAATACTACCCGCGGATCCTCTGAACTTCAAAGACAC +GAAAAGCTATAAGGACAGGATAAAGAAAGCACAGGAGGAGACGGGACTGAGTGAAGCAATAGTCATAACG +GAGGGGCACATAAAGGGGAAAAGGGCGATACTCGCGGTTATGGACTTTAACTTCATAGGCGGAAGTATGG +GCTCTGTGGTCGGGGAGCGGTTCTTCAGAGCCTGTGAGAGGGCTGTAGAGACTAAAACTCCGTTGATATC +CTTTGCAGCGTCGGGCGGGGCGAGAATGCAGGAAGGAATACTCTCTTTAATGCAAATGGCAAAGACTACC +TTCGGAGTGGGTTTACTAAAGGAGGCAAACATACCTTACATAAGCGTTTTGACCAATCCCACAATGGGTG +GCGTTTCTGCAAGTTTTGCCTTTCTGGGCGATTTAATATTGGCAGAACCAAAGGCGTTAATAGGGTTCGC +GGGACCGAGGGTGATAGAACAAACTATAAAGCAAAAGCTTCCCGAGGGATTTCAAACTGCGGAATTCCTC +CTTGAAAAGGGACAGATAGACATGGTAGTCCACAGAAAAGAATTGAAGGACAAACTCGCCTACTTTTTAG +AGGTTATGTACTACGCAAAGCGGTGAAGGAGTACCTAGATATCTTCTTTCTTGAAAAATATCCCTTCCCT +TTATACGAGGCTTTTTTAAGGATAGTATTTGCGGCACTGCTGGGGGCACTTATCGGTCTTGAGAGGGAAA +GGAGGAGACAGCCCGCAGGACTCAGAACACACGCGGTTCTTGCAATAGGTTCTGCTTTGATAACCCTCGT +GTCCATCTACACGAGCTACACTTACGGGGGGATAACTGCGGACCCTTCAAGGATTACGGCTCAAATCGTG +AGCGGTATCGGATTTCTAGGGGCGGGGGCTATTTTGAGGTTCGGCGTTACGGTAAAGGGACTCACAACCG +CAGCGAGCCTCTGGAGCACTGCGGGTATAGGAATAGCCGCTGGAACGGGTATGTACGTTCTTTCTCTTTT +CACCACTCTTATACTCCTCTTGTTTTTAACCTTTGTTAGCAAGGTAGAAAGGGAAATCCTCGGAAGCAAA +GGCACGGTAAACTTAAAGCTAACCCTCACGGATTTCCCCGAAGGCATTTACAGGGTTCAAAACATACTGG +AAGAAGTAAAGATACAAAAGGTCGTTAAGAAAAAAGAAGAAGTGGAAGTGCTTTTGAGTATTCCGAGATA +CGAAGACCTCACCGAGAAACTGGAAGAAGTCCTGAGACTCAAGGAAGTGAAAGAACTTGAACTTATGTAA +AATCTTCGTTATGAAAGAAGTACTCATGAGGATATACTCCTCAAAGGAGGAAAACCTCGAAGACTATATA +AATAAACTATTTGAGGGAGGAATAAGGGGTGCGGTTGTTCTTCAGGGAATAGCGGGGTTCGGAAAGGGAA +GAGAGTTTCACTCCGAAGAGATAGAAGTCCTCTCTTATGAACTTCCCGTGGTAATAGAAGTAGTAGAAGA +CAGGGAAAAATTACTGAACTTCCTGAAGGAAAATAGAGAGACTTTTAAGAATTGCTACATCACTTTTGAG +AGGGTGAAGGTATGGGAGTAGTTTTCGCGGTGGCCCTCGGAGGTGCTATCGGCTCCGCCCTTAGATTTTT +ACTCTCAAAAGTCGTTCAGGAACACTTCGGGATAAGCTTCCCCGTGGGAACGCTGTTCGTAAACCTGGTT +GGAGCCTTCTTTATAGGGTTCTTCTTCGCTTACCTCGTGGATAAACTCGCTGTAAACCCTCACGCGAGAG +CACTGCTCATTACAGGGCTTCTGGGAGGACTTACTACCTTTTCAACCTACTCTTATGAGAGCTTTTCACT +TCTTCGCGAAGGAGAAACCTTAAAGTTTTTAGCCTACACCTTAGGAACAAACGTACTCGGTATTTTCTTT +ACTTTCCTTGGCTACATCTTGGGGGAGAGCTTATGAGAGTAGTAAAGAAGAAGCTCCTCAGGATATTCAC +CTCTGAAGACGAAAGTTTTGAAGGAAAACCTTTTTATAAGTACTTGCTTGAGAGGGCAAAAGAAAGAGGA +CTTGAGGGTGCAACGGTTTTCAGGGCGATTGCAGGATACGGAAAAACGAAGGAAATAAGAAAACACAAGT +TATTTCAGCTGAGGTCCTCCCTTCCGGTTGTCGTTGAAATAATAGACGAAGAGGAAAAGATAAAGAGGTT +TTTGGAAGAGATAAAGGGAAAACACAACGGGCTTATAACCCTTGAGGATGTAGAAGTCATATACCTTTAA +CCTACGAGGTACATGGTTTCCGCTTCGTGCTTTCCTTTTCCGTCTTCGAGTATCATGTCCTTGTAAGACT +TTCCTGCTGGAACCATTGGGAGAACGTTTTCCTCCCTGTCTACCCAGAAGTCTATAATTACGGGTCTGTC +GTCTATCTTTCTTGCCTCTTCTATAACTTCTCTTACTTCCTTAGGCTTTTTAGCCCTCATACCAACCGCG +CCCATCGCTTCTGCGAGCTTTACGAAATCCGGCTGGACTGAGAGGTCAACTTCGGAGTACCTCTTGTCGT +AGAAGAGTTCCTGCCACTGCCTTACCATCCCGAGGTACGCGTTGTTAATAATAGCTACCTTAACGGGAAC +TTTATACTGAACTGCGGTGATTACTTCCTGCATGGTCATAACGAAGGAGCCGTCTCCGTCCACTACCCAA +ACTTCTCTGTCCGGTCTTCCTATCTTTGCCCCTATTCCCGCGGGCAGTCCAAATCCCATAGTTCCAAGTC +CGCCCGAATTTATAAACTGTCTCGGATATTTGAACTTGTAGAACATCGCAGCCCACATCTGGTGCTGTCC +AACGCCTGGAACGATTATGGCTTCCCCGTTCGTGGCTTCCCAGAGCTGTTCTATAACGTACTGAGGCTTT +ATAACCTTGTCAGAATTTCTGTAAGTCAGTGGATGGAGTTTTTTCCACTTTTCTATTTGCTCCAGCCACT +TCTTCCTCTCTTCTGGATAGAGTATCTTTGCTCCCCTTTTCTTTATTTCGTTTATGAGCTTCCTGAGGAC +TATCTTCACGTCCCCGACTATGGGAACGTCAACGGTTATGTTCTTGGAAATAGAAGCTGGGTCTATGTCT +ATGTGAATTATCTTTGCTCCCGGTGCGAATTCATCTATCTTACCCGTAACCCTGTCGTCAAATCTCGCAC +CTACAGCTATGAGGAGGTCCGAGTTGTAAACCGCCATATTTGCGTAATATGTTCCGTGCATTCCGAGCAT +CCTGAGGGAAAGAGGGTGTGTTTCGGGGAATGCACCTTTACCCTGGGTGGTGGTGGTTACGGGTATCTGC +ATTAATTCAGCGAGTTCAATTAGTTCCTCCTGAGCTTCCGAGTTTACAGCTCCCCCGCCAACGTAAAGAA +CAGGTCTTTTTGCGGACATTATGAGCTCTGCTGCCTTCTTTATCTGCTGGGGATTTCCCTCAACGTGGGG +CTTGTATCCGGGAAGGGCTGCCTTTACCTCTTCGTCAGAGGGTATTTTTACGTCCGCTATTTGCTGAGTG +ACGTCTTTGGGAAGGTCCACGAGAACGGGTCCGGGTCTTCCTGTTCTCGCTATGTAAAAGGCCTCCCTTA +AGATGAGGGGAAGCTCCTCTATGCTCTTAACTAAAAAGTTATGCTTGGTTATGGGTCTCGTTATTCCTAC +GATATCAACTTCTTGAAAGGCATCGTTTCCGATAAGGTGGGTGGGTACCTGTCCCGTTATTGCGACAAGC +GGAACGGAGTCCATATATGCGTCCGCTATGGGTGTGACGAGGTTTGTGGCTCCCGGTCCTGATGTTACCA +TTACAACCCCTACTTTTCCGGTTGCCTTTGCGTACCCTTCCGCCATGTGACCGGCGCCCTGTTCGTGCCT +TGCGAGTATGTGTTTTATCCCTCCGAGCCTGTAAAGGGCGTCGTAAACTTCCATTATCGCTCCGCCGGGA +AGCCCAAAAACAACCTCAACGCCTTCAGCCTTAAGTGTTTCAATAACTATGTCAGCTCCTTTCTTTGCCG +GCATCTCTCTTCAATACCTCCGGTGCTTTTGATATTTAAATAAATTTGTAAACTTTATATTAATTTTCAA +TGTTTTAGTCTATGTCTTCACCCCTCAAGAGCCTCTGAGCGTAATTCACGCAGGCAAGAACCATAAACCA +GAGGGCGTGGTAATCCGTTTTATCAAAGTTTTCCTTTACAAAAATTGTCCCGTCTTCCTTTTCCACAACG +CTTATGTACTTGAAAGCTTCCTGAGCCAGAGCCTTGTTTTGAACCTTCTGGAGTATTCTTTCTTTCACCC +AGTCGGGCAGAGGTTTTTCCACCATATTTCTTAATTTACTTTACAGATAATTCAGTTCTATGAGCTTTCG +TACCTTTCTATGAACCTCGCACCTACAAGGAAGAGAAGAAAGTTAAAGTTGAGCCACAAGAAGAAAAGGA +CAATTGTACTAAGAGAACCGTATAGAACACTTCCCTTGAATACGTACACCGTGTAAAGTGTAAATATGTA +CTGGAGGAGAGAGGCAAAGAAGTAAACGAGAAATGAAGAAATCAGAAGGGAAATTTTTCTGTTAATTTTT +ATAAAGCTCCAGTAAAGGGATATCACTAGGAAAAGGAGCGGAAGTGAGGAGGCAAGATTACTTAAAAACC +CGATGCCTTTGAAGTATGTCTTTAAAAGAATTGATACATAAAAAGACATACCGGTTACGAAGCTAAAGAG +TACGAGTAAAATGGGAAAGCCTACCCAGAAAAATACTTCGTGGACGTCTCTCTTTTTCCTTTCCACAACG +TAAGAGAGACTTTTGGCTATTTTCTTTACGAAGTTGACCGAAAAGAAGTAGGAAACCAGCAGGGAAATCA +GGGAAGCGGTTTTACCCTGCTCTTTTGCCTTCAGAATTTCCGCTATTACCGCGTGAGTTTGTTTCGGAAA +GTGTTCCCTGAGAACTTCTTCCAAAAGATCGAGCTTTATAAATCCTAGGTATGAGGATAGTGCTGCGAGG +AAAACTATGAGAGGTGCGAGTACAAGGAGGAGTTGAAGAGTAAGGGCCGAAGCGTGGTAGGAGTAGTCAT +ACCTGAAGGCGTCCCAAAGGCAGAGAAACAAAGCGTTTAAGAGCTTTCTCAAGGTTCCCATACTTCCGTT +ACTTCGTATTCTACGACCTCACCCGTGAAACTTTCAAACCAGAACTTATTACCTTTCCTTTTCTTTACGT +AGTTGGGAAGAAGAGGAACCTTACCTTTCCCTCCCGGGAGGTCCACCGCGTAAGTGGGTATCCCGAAACC +GCTCAGCCTTCCCCTCAAATATCTCATTATTTCAAGTCCTTTGTCTATCGTAGTCCTAAAGTGAACCGCT +CCCTTTATCGGGTCGCAGTGAAAGAGGTACTGGGGCTTTACCTTTATCCTTAAAAGTTTTCTAAAGAGTT +TTAGCATAACTTCAGGGTCGTCGTTTACGCCTTTAAGTAGGACTGTCTGGTTGTTCACGGGAATGCCCCT +TCTCAGGAGCCTGTCCACCGCTTCTTCCGCGTACTCGGTTATCTCATTCGGATGGTTGAAGTGAGTGTTT +ATCCATATGGGGGAGTATTTTTCCAGTATGTCCAGAAGTTTATCGTTAAAGAACCTCTGGGGTGCAAGAA +CGGGAAGCCTCGTCCCAAAGCGTATAATTTCCACGTGTTTTATTTCCCTTAACCTTGAGAGTAAGTATTC +AAGTTTTTCCAAGGAAAGGGAAAGTGGCTCACCACCTGAAATTAAGACATCCCTTATCTCTTCGTGTCTC +TTTATGTAATCAATCATCGTGTCTATTTCCTCTTTAGTCCTTGCCCTCTCACCCTGAGAGAATATCCTCT +TTCTCATACAGTGCCTGCAGTAAACCGCACAAAAGGTAGTGACGTTTAAAAGAACCCTGTCGGGATACCT +GTGTGTAAGACCCGGAATATCTCCTTCTTCTTTCAGAGCGTCTGGTTCTCCCGCAGACTGAACCTTTTCA +TCAACTTCTACAACGCGGGGGATTGCCTGAAGTCTTATAGGATCCTTCGGGTCCTCTGGATTTATTAAAG +AGAGGTAGTAAGGTGTTATCGCAAAGGGATAAAGCCCTTGAGTTCTTTTAATTCCTTCTTCCTCCTCGGG +AAGGAGTTTTAAGTACTTTTTTATCTCCTTAAGAGTTTTTATCCTGTTTTGTATCTGCCACTCGTAGCTC +CTCCAGAGGTTTTCCGGTACATTCTCAAAAAAGCGACGCATAAATAAAAAGGTAAAGGATAAAGGGGAGA +AATTAAGGAAAGAGAATCAGATCCTCCATGAGTGGCATGAATACTTTGTAGTAGGGCGGTATGTGGGCAA +GTGTCGTCATAACTTTTTCATCGTGAACTTTCTTTATTTTGGGATTAACTGCGGTAAGTGCTGGGCCGAA +CATTGCAGACTCAGGACGCGACCACTCCATGTGAACTATAAACTCCTTGGGATGTCCTGCAGGCTCTAAT +TGAAATTCAGGTTTTCCGTACTCTCCCCATATGGTTTCTCTGGTTTTAGGAGGCACTGCTCCCCTGCTTG +CCACTACTTCCCAGAACTCAGGAGGTTTTATCTGGAACGTTCCGTACGGGCTTTCCCCGATCTTTTCAAG +AATCATCCAACCTATCATTCCCGCAGAGTACTTGTTGAGAAGTTCCAGTGTTTCAACAGCTCCCTCTATA +AACTTCTCCTCCATTCCTTCCTTAACTTTGTGTATCCCTACTACTGCTATTCTCTGGGTCAGGAGCCTAA +CTTTCGGGATTCCTCCCTTACCCTGCATAGCCTGCATCATAGATTCACCCAAGACTTTCGGAACATCGGT +AAAGTCTATGACAGGGGGCATGTTGGCTTCTCGAACTACGTATATAGGTTCGTTCGGTCCTTCAACTACT +TCTGTGAAACAACCCACGCAAAGTTCAAAAATCCTGTCGAATTGCTGGTAGTGCATTTCTTCGTGATCTT +CCCACTTTTCCCACACCGTATACTGCCATAGCTCTAATGGGTTGTACTTTATAGCTGTAAGTCCTTCCCT +TTGAATAGCTTCAAGACTATCCGCATTTATAACTTTAGCCGCTCCAAACCTGCCACCGAGCGGATGAGCA +CCCACCTGAATAAACGCGTGAAAACCCAGAAATCCTTCGTGCATAGCTGTAGTTATGCAGACCTTAGGAC +CCACTTGGTACATTAGCTCTTGAAAACGAGGCGTGTTATTTACTTTGGCTTTGTTAATAGCTACAGCAAC +GCCTTTTTTAATATCTGTCAGCATGGCTCTCACATCCCTTTTTATCTTTCAATTTAGGTTTTAAATGTTA +AGAAGGTTAGGAGGCAGGATTGGTTAACATAATTGCCATTATGTTAACATTTTATTACCGGAGGCATCCA +GATGAAAGAATTCTTGATAAAGATACTTGTACTGCTCGGGCTTGCCCAACCGGGCAACGCTATACAGGAA +GGTCAACCTGCTTACCTTTTTAGTTTGAATAATCACGAAGACAAAGTTGTAAACCTTTCCGACTACAAGG +GCAAGTGGGTTGTGCTCTACTTTTATCCTAAGGCGGACACACCCGGTTGTACTACTCAGGCAAAGGAGTA +CACAAAACTGATGCCAGAATTCGAAAAACTGAACGTTAAGGTGTTTGGAATAAGCACTGATAGTGTAGAA +AAGATAAGACGCTTTCGGGAAAAGTACGGGCTTACCGTGGAATTCCTTTCCGATCCGGAGGGTATAGTTG +CAAAGGCTTACGGAGTTACACTCATAGCAGGTCTTTGTTCAAGGGATACCGTAATAATAAATCAGAATCT +TATAGTGGAAAAGATCTACAGAGGAGTAAGTCCTTCTGCGGATCCCCATAAGGTTCTTGAGTACATAAAA +CAAAGAGCTTCATGAGTTTTATAAAATAAACTCCATCGTGGGCTATATTTACATCGTTTCTTTCGGAGAC +GTTGAAGACAGACTTTTGCTTGCGGATGCCTCCAATGTAAAGGAGATATTTGATCTGGAAGTAAGGGTTT +CCACTGTAAAAGCGGACATTGAAGAAGCCTACAACCCCCAGAGAAACCAGTACCATGCAGGAACGATTCT +GAGCTACCTCTCAAGGGTAGTTTACCCGGATATGGTGAGGCTCGTAGCTCTGGTAAGTTTCGACCTCTAC +GAGGAGGGACTTAACTTCGTCTTTGGAGAAGCCCAGTACGGGGGAAAGTACGCAGTTGTGAGCACTTACA +GGCTTTATCATCCCGACGAGAGGGTATTCTTCGAAAGGGTTTTTAAAGAGACGAACCACGAACTCGGGCA +CACTTTCGGACTCAAACACTGCCCCGACCCCTACTGCGTTATGAGTTTTTCCAATTCAATAGATGAGGTT +GACAGGAAATCACGTGATTTTTGTCCTAACTGCAGGAGAAAACTGGACTACGTTTTATCCTATTACCGAT +GATAGGAAGAGTTTTCAGGATTTTCAGAGAAAAGGGAGGAATTTTAAAGGCTCTCGGCCTTTGGGAGTGG +TACGAAAACCTGCCGCACAAGTACCAAAAAAAGGTAAAACATTACTACTCTTTAAAAACTATAAAGAGTA +TAAACTTCCCTTACAAAGCCAAGCACTTTGATACGGGAGAAGTCGAAAACGTCCTCTACACAAAGAGAAC +CTTTTTAGGCACGATAGCCCAGACTGCACTCCTTGAAGGTGACCTCGAATTTGCGGAATGGCTCTACAAC +GAAGCTCTGAAAATGGAAGGCAGTCCTTATGAGGCTCATCTCATTTTAAACGACCTCGTTTTGCTTGCCC +AAAAACAAAGAGATTTGGAAAAGGTTAAAAAGTACGTCCTTCAGGACGTGGAACTTTACCCTGAGTACAA +GGAAGAGTTAAAGAGCAGGTGGGGGGGAACCCTTCCCCAGATAATGGCTTTTGAGATTTACGTTTACCTT +TTGGAGAGAGAAGGAAAGATAAAGGAAGCCCTTGAACTCGTGGAGTGGATAAAAAAAGAGGGGATAACCT +ACCCCTATTACGACCAAGTAAAGGAGAGACTACTTCAAAAACTCAAGTAGAATTTATTCTTATGAACGAA +AAGTACGAGGCTGTAATCGGTCTTGAAATACACGTGCAGATGGACACAAAGACTAAGATGTTCTGTGGTT +GTAAAGTGGAATTCGGAGCGGAGCCAAACACAAACGTTTGCCCCGTATGCCTCGGAATGCCCGGAGCACT +TCCCATTGTCAACAAAAGGGCGGTTGAGTACGCGATAAGGGCTTCTCTGGCACTGAACTGCGAGGTTCAC +GAAGAGTCCGTATTTGCGAGAAAACACTACTTTTACCCGGACCTCCCTAAGGGATACCAGATATCCCAGT +ACGAAAAGCCCCTCGCCACGAACGGATGGGTGGAGTTAAACCTTCCAAACGGTGAAAAGAAAAAGGTAAG +GATAAGGAGACTCCACATAGAAGAGGACGCGGGCAAGAACATACACGAGGGTGATAAAACGCTCGTTGAC +CTAAACAGGGCTGGAACTCCCCTTATGGAAATAGTAACAGAGCCCGACATAAGAACACCCGAAGAGGCGA +GACTCTTTTTAGAAAAACTCAGGAACATAATGAGGTACGCGGGTGTTTCTAAAGCGGATATGGAAAAGGG +ACAACTCAGGTGTGACATAAACGTTTCCATCAGACCGAAGGGCAGTAAAGAGTTCGGAACGAGGGTTGAG +ATAAAGAACGTAAACTCCTTCAGGTTCGTCCAGAAAGCCCTTGAGTACGAGATAGAAAGACAAATTAATG +TGGTTGAGGAGGGCGGAGAAGTCGTCCAGGAAACGAGAACCTTTGACCCTCAAACGGGCAAAACCTACCC +CATGAGGACAAAAGAAGAGGCGGAAGATTACAGGTACTTCCCGGACCCGGACCTCGTTCCCCTGAAGGTA +AAAAAGGAGTGGATAGAAGAAATAAAGAAGAACATGCCCGAACTCCCGGACCAAAGGTTTGAAAGATTAA +TAAAAGAGTACGGACTTTCTGAATACGAGGCAGGAATACTCGTAAACCACAAGGAAGTGGGAGACTTCTT +TGAAGAAGCGGTAAGACATTTCAAGGAACCCAAAGGGATAGTAAACTGGCTCATAAACGACCTTCTAGGA +CTCTTAAGGGATAAAGGCATCTCAATAGAAGAGAGTCCCGTAAAGCCCGAGCACTTAGCTGAACTCGTAA +AACTCATAAAGGAAAAGGTTATATCCACGAAGATAGGAAAAGAAGTTATAAAGGAAATGGTTGAAACCGG +AAAAACGCCTTCCCAGATAGTTGAAGAAAAGGGACTAAAGCAGATAACCGACGAAAACCAAATAAAGGAG +CTCGTAAAGAAGATATTTGAAAAACACCCCAAGGAAGTGGAAAGATTAAAACAGGGTGAGGAAAAACTTA +TTGGCTTTTTCGTAGGACAGGTAATGAGGGAAACAAGAGGAAAGGCAAACCCCCAAGTCGTGAATAAAGT +CATAAGGGAACTGGTAAAAGAAGTGTAAAATAAAATTTAAATGAACAGGCAACCTATGTTCTTCATACTT +ATTGTCTTACTCTTTACCGTTTTCTCCTTAAAAGAGTTTATTCCTAATACCTTCTGCATACACCCCAAAG +AAGGCATAATACATCTTGAAAAGGAACATCCTAAAACCTTCTGTGAAAAAGATGAAGTTCATGTAAAGGT +TCTTTCTGAAATTAAGAACCTTAAAGTTCAGTTGGATTTAGATAAAAGTTTTTCATTTACTTCTCCCTTC +CGTATCTCCCTTAGCTTCGTAGTCTTAAAAAAACAAAATGCACTGCCTGAAAAATCTCCCCGCCGAGAAA +GTCCCATAAAGACAGTCCGCCTACTTATTTGATTTTCCTCCCAAACTACAACCAGAATTCCTATTAAATC +CCGGAGGTGAGAGTATGTTTTGGGTTCTTTTAATTGTTGTGAGTTTGAGTTTTGGAGTGAGTATTGAGGA +AGCGGTGAGAACTGCTATAAAAAACAATCCCGAAATTAAGGCACTTGAGGAAGAGATGAAAGTTTTCAAA +GGAAAAGCAAAGAGTGCAACAGCCTTTCCGAACCCGGAACTGAGATTTGAGAGCGGTTTTATCACGAACG +ACGAAGACGGAAAGCCCAAAGGAAAGGCACTTTACCTCTTTGAGTTTAATCAACCTATCCCGATGTGGGG +TATAAGGGAAAAGGCGAGAAGCGTAGTTAAAAAAGAAGAGGAGTCCTTCAAGTACTTCACAGATGCATAT +AAAAGACGGATAATCGCACAGGTTTACAGGAGCTTTTACAACTCACTTTTTCTAAAGGAGTGACCAATAT +ATGGAAGAAAAACTACGAAACCGCAAAGGAAGTAGAGGAATTCGTAAAAAAAGCCTACGAACTGGGTGAC +GTGACCGAACTGGAACTCCTAAGGGCAAAGAGGGAAAGAAGCATAGCGGAGGTAAAGCTAAAGGTAAGCC +GTTCCAAGTACGAGGCGAGCCTAAAAGAGCTTTCCAGACTTCTAGCAAAGGAAGTGAGGGACGTTGAAGG +AGAACTTTCCGCAGGAGTAGCCATGAAGGAAGTGAATATAGACACGCTTCCCGTAGTTCTATCTATAAAG +AAGAAAATAGAGGCTATAGACAGGCAGATTCAGCTGGAAAAGGCACTCGCAAAACCAAAGCTTGCAACTG +GCTTTGTTGTAGAGGAGTCAGAAGAGGGATATTACGGTCTCAGGGGTTCCCTTACCTTGGAACTCCCCCT +CTTTTACCGCAGGGAAGGAGAAATACTTCAAAACATCGCCATGAAGAAAGCCCTAAAGAGGAGACTTGAG +GCGGAACTCCTGAAGGTAAAAAGCAGACTTGAATCCGTGAAGATAAGGCTTGAAACACTTCAGAAAGAAC +TTGAAAAGCTTGAAAGGGAAGTCATTCCGAGAGCAAGGGAAGAGCTTGCCCTTGCCATAAAGAGTTACAA +GCTAAAGGCTATAACTCTGCTGGAACTTTCCGACGTGAGGAGAAAATATTACGAGCTCTTAATAAACAGG +GCTGAATTGCTCTTAGATATCCACAGGACCTACTCTGAGTTCATAGAAATAGGAGGTTGGAGGAGATGAA +AAAAATTCTCATTTATTTAATAACTCTTTTAGCCTTTTCCTTTGGAGGTGAAGAGCATGGGCATGAAGAG +GAAATACACCTTACAGATAAACAGATAAAACTGCTCGGGATAAAACTCTACGAAGTTAAAAGAGAACCTG +TGGGAAAGATTGTAAAGATGCCCGCTGAAGTAGAAGAAAATCCCCTTCTCAATTACGTGGTTTACAGTCC +CGTTGAGGGAATTGTGAGGAAGCTCTACAAGAAAGAGGGGGACCTCGTGAAAAAGGGAGAACCGCTTGCG +GAAGTATACTCACCCGAGCTTGCGAACCTCATCGGGGAAGTTCGCACCGCAAAGGTAAGGATGGAAAGTG +CGAGAAAGCTCTACGAGAGGTATAAAAAACTTTACGAACAAAAGGTCATAAAGTACACGCTCTTTTACAA +CGCCATGGTGGAGTATGAGAGGGCTAAGGGTGAGTATGAGGCACTCCTTTCTAAACTCAAGAGTTTTGGA +GAAGTAAAGGGCTACAACTTAGTCCTTCGCTCTCCCGGTAAGGGTTACGTTGTAAAGCAGAACGTCGTCC +TCGGAGAAAGCGTGGGGCTAGACAACTTCCTCTTTAAGATTCACTCCCACGAGGTGGTTTGGGTTTACGG +CTGGGCGGATGAAAAATCCGCAAAAGACATAAAGGAAGGGATGAAAGGCACGGCTCTCTCTCACGAGGAT +AGACTTCCGTGTCGTGTGGACTACATCGGTCACGAGGTGGACAGAAAGACGAGAAGGGTAAAGGTAAGGT +GTGTAGCTCAAAACAAAAACCATGTGCTAAAACCGGGGATGTTCGTGGAACTCCTCGTAAAAACACAAGG +AGAACCTGCAATACTCATTCCCAAAAATGCAGTTCAGGAAATTGAAGGAAAGAAAGTAGTGTTCGTCAGA +ACCGAGGAGGGATTTGAAGCAAGACCAGTAACTATACTTAAAGAGCTCAACGGCTACTACGTCGTCCTTG +AGGGATTAAAGGAAGGAGAGAGAATAGCGGTCACGGGAACGGTATTCCTCAAAACTAAGCTCGTAGGAGT +TGAAGAAGGAGGACATGCTCACTAATCGGAGGTGGCGGTATGTTCAGAGCGGTTTTAAAGTACAGGCTTT +TAGTTCTTATAGCCCTTGTAGGCACGGTTATATACGGTGTTTACAGTTTTAAAAAGCTCCCGATTGACGC +TTTTCCGGATCCGACTCCCGTTCAGGTGAACATATACACGGAAGCTCCCGGACTTTCCGCGGAAGAAGTT +GAAACGCTAATAACTATTCCCGTAGAGTCCGTGATGAACGGGATAAAAGACGTAGAACTTGTTAGGAGCG +TCTCCCTTCCCGGACTCTCCTACGTTTCCGTTTACTTTAAAGAGGGAACGGACGTTTACTTTGCCAGAAG +GCTCGTTATGGAAAAACTGCCCGACGCAAAGGAGAGAATTCCCGAAGGCTTTAACCCGGTCATGGGACCG +AACTCAACGGGTCTCGGAAACGTTCTCGTGTACGTTCTGTACGACACGAGCGGTAAGTACACTCCTCAGG +AATTAAAGTCCATATTCCAGCAGTGGGTAGCCCGTCCCCTGATAATGAGTGCTGGAGGAGTTGAAGAGAT +AGTGCAGTTCGGTCCAGAGCTCGCCTACGTGATAGTTCCGGACTTTGAAAAACTCATAGCTTACGGAATA +ACTCTGGAAGATCTTCTGAATGCCCTTGAGAGGAACAACCTGCTCGTGGGCGGTGGCTTTTACCAATCCG +CGGAAGGAGACCTCGTGGTAAGGGGACTCGGAAGGGTTTACTCCAAGGAGGACCTATTAAGAATTCCCGT +AAAGGTAGACGAAGAAAAAGGGGTGAGCGTTTACCTGAGGGACGTGGCAAAGGTGGTAGAGGGAGAAGTT +CCCAATAGAAGAGGGGCTTTCACGATGAACGGACAAGAAGTCCAGGGGAACATAGTCGTCAAGAGGATAT +ACGAAAACACCAAGGAGGTTGTGGACAAGGTAAAGGAAAAACTAAAAGAAATACAGAAAATACTCCCAGA +AGGTGTAAAGATTGAACACCTCTACGACCAGGCTTACCTCACGGAAAAGGCAGTGTCCACGATACAGAAG +GCACTCTTCAGCGGTATGCTCCTCGTTGCTATTGTCACTGCCTTTCTCATGGGCAACTTCAGAACCTCAC +TCATAGTCATTTCCTCCCTTCCCTTAACCCTGCTCATCGCCTTTATAGTTATGAAGGAAACGGGTATGAG +CGGAAACTTAATGACTTTGGGAGGTTTGGCTATAGGTATTGGTATGTTCGTGGACTCCTCCGTCGTCGTT +GTGGAAAACGTATACAGGCATCTCACGGAAAACAAAAGTGCCACTAAGTTTTCCATTATCCTTGACTCTT +TAAAGGAAGTGTGGAGACCCGTTCTCTTTGCGGTCTTAATAATAGTCATAGTCTTTTCTCCTATATTCGT +TTTTGAGTCGGTTGAAGGTAAGTTTTTCAAACCTCTGGCTATGACCCTCATAATAGCCCTGCTCGCCTCA +CTTTTCGTAGCCTTCACATTCATACCCGCTCTCAGCTACTACTTCCTGAAACCCGGAAAAGAGACGTACA +GTAAGTTGATGAGGGCAATACACAAGGTTTACGAGAAGGTTCTCGATTTTACCTTCAAACTGCGCACACT +CCTCTACTTGGGCGTATTCATCTCCTTTGTATTCAGTCTCTTTTTGCTCACGAGAATAGGAACGGAGTTC +GCTCCTGAGCTTGAAGAGGGGGCGGTGATAGTGAAGGCTTTCCTGGACCCAAACGTTTCCCTGGAAGAGG +GGAAAAGGGTTGCCACCGCGATAGAAAGGGAAGCTATGAAATTCCCGGAAGTTATAAGAACGTTCTCTAC +AGTCGGAAGGGCTGAAAAAGGTGAAGCCGCTGACGTGAATTACATAGAAACGTGGATACTCCTTAAACCT +CAAAGTGAGTGGGAAACTTTCAAAACGAGAGAGGAGTTTAACGAAATCCTCAGGAAGAGGCTTGAGTGGC +TTCCCGCTTCTTTAGGCTTTACGCAACCGATAAAAATGAGGATAGACGAACTCCTTTCGGGTGTAAGGGC +GGATATAGCTATAAAGATATTCGGTCAGGACCCGGAAGTTCTGAACGAGCTCGCGGACAAGGTAAAGGAA +ATCGCTGAAAGCGTCCCCGGTGCGGTTGACGTCCAAAAAGAAATACAGGCCGGAAGGCTTCAACTCAGGA +TTTACCCTAAGTGGGAAGTTCTTGAAAGGTATGGAATTACCGTTGAAGAAGTTCTTGACGTAGTTAAGTA +CAACTTGGGCGGAGCACCCGTTGGAGAGCTTCAAAAGGATACCCTTCTCTTTCCGATAGTTATGACCCTT +CCCGAAGACTTTAGAGGAGATGTAAGTAAACTTGCGAAAATTCCCCTCTTTGAAAGACACGGCAAAATCC +TCACATTTGGAGACGTTGCAGATTTAAAGGTAGAGCCCGGACTTTTTGTAATAAGGAGGGAGAACAATAT +AAGGTTCGCTCTCGTAATGCTCAACGTAGAGGGCAGGGACACGGGAAGTTTCGTAAAGGAACTCCAGAGC +AGGATAGAAAATGAAGTCAAACTACCTACGGGATACTTCATAACTTACGGCGGTCAGTTTGAAAACCAGC +AGAGGGCTATGAAAAAACTCTCAATAGCTGTTCCCGTATCCATCTTCCTTATATTCGTAATGCTGTATCT +CAACTTCAACTCTGTAAGAGACGCTCTCGTTGTTATGCTGAACGTGCCATTTGCGGTAATAGGGGGAATA +ATAGCACTCTACATCTCTGGATTTAACCTATCTGTTCCTTCCGCAATAGGATTTATAGCCATATTCGGTG +TGGCGACTTTAAACGGTGTGGTTCTCGTGAGTTATATAAGACAACTGCTTCAGGAAGAACTCGAGATCAG +AGAAGCGGTAAAAAGGGCTGCAATACTCCGTATAAGACCCATACTCATCACCGCCATAACTACATTGATA +GGACTCATTCCTTTACTCGTTATAAGAGACATAGGTTCAGAAGTTCAAAGACCCTTGGCAACAGTAGTTG +TGGGCGGGATATTCACATCTACTCTACTCACCCTTATAATTCTTCCTTCTGTTTACGAGCTCGTTTACAG +GAAATTTCCGAGAGCATAGGTAGGAGGTAAAGGCGGTGAAGGAAGAAAGGGAGAAGAAAGAGGAAGTTTT +TGAAGAGGAAGAGTTCGGAGAGCTCCTGAAATACACACTTGCAGGTTATGCGGGTGGTCTTGGGCTCGGG +TGGCTTCTTGACAAACTTGGTTTTCAGCAAAATCCCATAGGCGAGTGGCTCGTGAGAACCCTGGCGGGCG +AAGGGGAGAGCATTCTGGAGGGTATATTCGCCGTAAAGAAAAGGTTAACCGGTGCGGTCTCTTCCCTCGC +TCAGGCTTACGGATGGGGAAAGCTCATAGGTATGACGGTCCCGTGGTGGATAGACCTCTTTAGCAGACTG +CTCGGAGTTAACGTTTACGGTTGGGAGGGCTTTTACATACCCTATTTTTACGCCATGAGCGACCAGATAG +GGGCAAACGTCTCTGGCTTTATCTATCTATATAAGAAGGAGGGAAACTTTTCTAAAGCCGTGAAACGCTA +CTTTACGAACCCCGTAATGCTAACCAGCCTTCTGGTAATACTCCTCGTCCCGATAGGACTGCTCGTAGCC +AGACTTCTTGGCTTTTCTCCTACTACGAACTTCTACGCGGCCCTCGAAACTGTGGCGGCGAACCTCTGCT +GGCTCCCTCCCTTGGTGGGAATGCTTGTGGAAAAGAAAAAAGGTTCAGATTAAAACCCTCACGAGCTTTC +CCACTTCTTTGTACCCTTCCCTTTTTATATCTATGTAATTTTCCGTAAGGAGTCTGTTTTCCTCTATCAC +AAGAGCCCTCAGCTCTTTTCCCTTATTCTTCTCGTAAAACTCCTGCCTCTTTTTCTGGTCTAGTTCCTTT +AGTATCCTTACCCTTTCCTTTTTAATCCTTTCGGGTAATTTCGGTTTTAGCTTGCTCGCTTTAGTAAAGG +GTCTGTCCGAGTAAGGGAATATGTGCATGTAGGATATGGGAATTCTTTTTAAGAATTCGTAAGTCTCTTG +AAAGTCCTCCTCGCTTTCCGTGGGAAAGCCTACTATAACGTCTGTCCCTATTGAGGAGATGGGTCTGTTT +TCCACTATGAAGTTGACAACTTCCTCGTACTCTTCCCTCGTGTAGCCCCTGTCCATAAGTTCAAGAATTC +TGTTTGAACCGCTCTGGAGGGAGAGGTGAAAGTGTGGTGCTATCTTTTCTTCCGAAACTATGAGCTTTAA +AAGCTCTTTATCCATCTCCTTGATGTGCATGGAGGAAAGTCTTATAAGTTCTATGCCTTCAATCTTTATA +AGTTCTGTGAGGAGAGTGTAGAGGTTGTAGCCCTTGTCCCAGCCGTATTGAGAGAGTTGTGTTCCCGTTA +AAACCACTTCCTTAAAGCCCTTTTGTGCGAGGAGCTTTACCTGATGGACTATTTTTTCTAAATCAACGCT +CCGTACTTTTCCCCTTGCGTAGGGAATTACGCAAAAAGTGCAGAACTTATTACAACCCTCCTGAACCTTT +AAAAAGGGCCTTACCCCTTCAAAGTAAAGAACCGTGTCAAAGTTCCTGACTTCCTTCTCCCTGAAGATTT +CCCCTACGACTACCTTCTTTTCCCTTCTTTCAAGATACTCCTCAAGGATTTTTAAGAGCTCTGACTTGTG +CGTGTTTCCGACGACGAGGTCAACTTCCTTTAGCTTTGCAAGCTCCTGGGGGTTTACCTGAGCGTAACAG +CCAGTTGCAACTACAATCGCCTTTGGATTTCTCCTCTTTGCCTGATATATGGCCTGTCTTGAGGAGCGGT +CCCCTCCCACTGTTACCGTGCACGTGTTTATAACGTAAACGTCAGCCATATCTTCAAATGAAACTACTTC +GTATCCTTTTTGTATGAACTTGTTCTTAAGGAGGTCCGTGTCAAACTGGTTCATTCTGCAACCGAGAGTT +TCAAAGGCGACTTTCATAAGGAATATAAATTATAATTCTCGTAGGGAGAGGTTATGAAAGAAACCAGAAT +AATAAAGTACATAAAGAGTCTCATAAGGAATCACAAGTACCTCACAACTGAGGACATAATGCTACTCCTC +GAAAAGTACTACAAACTTCCCATAAACGTCCCGTCCGTTTACTACAAGTACAAGAAGATAATAAGGGAGT +GCAGGCAAGAGGTTTACAAGGAGAGGAGGAGGGCTAAGTATAAAAGACGTGAAGGTGGAGATTGAACTTA +TCCCTTAACCTCTTTGCAACGTCGAGCATAAAGTCAACAGCCTTTTGCTTTTCATCAAAAAATCCTATCC +TGAACCTGTCGAAAGAAACTCCGAAGGGTCTGCTGGGGTCATTGGGGTTTTTGAACTTTGGTTTGTTGTA +CTCGTATATGTCCGCCCACAGGTTCATGGGACTTATCAGAACCACATAGCCCCTTCCTTCCATCTGCTCG +CTCAGGTTCTCCTTCACTCTTTTGAAGACTTTAACGTCCTCCGCGTCAAAGAGTTCCTCCTTGCAGAACT +CCTTTAAGGGAGTGCCGTAGAAGTTTAGCTTCTCATCTGCCTCAAGTATGTAAAGGTCTATTCCCTTTTC +CTTAGCCTCTTCGCAAAGTGCCTGAAGTACTTTCCCCCACGCTTTCATAGAAAAGATTATACACTTATGA +TTTAAACAGCTTGCCTTATATTTTTATTAGCATATTCTTAATTAATCTTGGAGGAGCCGAATGCTGAGGG +AAATGCTCAAGTCCAAAATACACAGGTTAACGGTAACGGATGCGGATCTTCATTACGAGGGAAGTCTGTC +CTTAGACGAGTATTTAATGGAGCTTGCGGACTTAAAGCCCTTCGAAAAGATAGACGTTTACAACATTAAC +AACGGTGCGAGGTTTCAGACTTACGTTATCCCCGCCCCGAGGTATTCGGGAGAGGTTAAGTTAAACGGTG +CGGCCGCAAGACTCGGGCACAAAGGCGACCTTATAATAATCGCCTCTTACGCCCAGTACACGGAGGAGGA +GCTAGAGAACTACGCTCCCAAGCTCATTTTCGTTAACGAGAAGAACCAGCCTGTTGAAGTAAAAGAAAGT +ACGGAGGTGAAGTGAGATGTTTATGAACGTTCCGGAAGTTACACCAGAAGAAGCTAAGAAGATGCTTGAG +GAAGAAAAGGATAAAGTTGTACTTTTAGACGTTAGAACTCCGCCCGAACATTTTCAGGTGAGAATTCCAA +ACTCTATGTTAATCCCTTTAGACGAGCTCAGGTACGCCTTCCAGAACCTGCCCAAAGATAAGAAGTACAT +AGTCTACTGCAGGATCGGAGAGAGAAGTGCATTTGCAACCTACTTCTTGAGACAGATGGGATACGAAGCT +TACAACCTTGCTGGCGGAATACTTATATGGCCCTATGAAAAGGAAAGCGGAGCACCTGCTAAATCTTAAT +TATCCTCTCCGCCTTTTCCTTTGCTTCCTTGGCTACTATTACTAAGTCTATTTCCGGAATTCCCAGTTCC +TGTGAAAGTTGCTGAGCGGTTTTATCGAGCTCTTCGGGGGATGAGTTTACAGCCTCTTCAAGTCTAGACA +CAACTTCTAGCAACTTGTGAAGAGAAGAGCCTTTATCCTCAAAAGCCTTTACAACTTCCTCGTCTACGTT +CAGTTCCCTTAAGAAGGTGGGTATATCCACTTCGAGTATTTTATCGAGCAGGGAAAAGAGACCTACCAGG +AAAGCCTTTTCGGAAACTTCGGGAGAGTACCTGTTTGTCAACTCCTCTGCTATGAATGCCCTCGTTAAGG +ACTTCCTCCAGAGTTCCGGGTTTTCCACCTTCAGGAACTCGTTCATACTGACAAGAATCACGAACTTCTT +TATGTTTTCCATTCCCACAAAGGAAACCGCGTGCTCTAAACTCTCTATCTTTTTTCTGCGGGCAAAGTAA +GCGGAGTTTACAAACTGGAGGAACTTTACCGCGAGACCTACATCCGTTTCTATTATGTCTGCTATCTCCT +TAAGACTCCTCGCGATACTTATTGCGTTGAGCAGTCTAAGGAGAGTTACCTTTAAAAACGGGGCCAACTT +TGTCCTTTTAACTATTTCCGGCTTTGCAAAGTAAAAACCCTGAAAGTAATCCGCTCCGTACTCCAGCGCC +TTTTTATACTCTTCTTCTTTCTCAATCATAGAAACAAGAACTTTCTTTCCGTATCTTTTTGCACTTCTTA +TTTTATCTGGCGTTACGCTTTTAAAGTAAAACTCAACGATGTCCGACAGGTTTATCAATTCCTTATGCTC +ACTCGAGTAGAGTCTTTCGTTTAGTATGAAACTGACGCCTTTTCCCTTATAGTCCTTTAGTTTTTGAAGA +ACCTTTTGCTTGAGTGTTTCTCCCAGAGGGACTTCTGGAGGGTTCAGGTCAAAAATAACTTTATCTGGAG +GAAGAAGTTCAAGAGACTTGTTTAAAATCGCCTCTAAAGAGACGTTTATTACTGCCTTTTTGCCGTTCGC +CAGCTTTTCAATACCGCTCTCCACGAGAATGTCAGTAATTATGTAAACAGCGCGGGAAAAGGGGACGTCC +TCGGGGTATTTTTCTTCGTCACCTTCCCTTCTCAAGAAAAACTCGTAGGCGAATACCTCTCCGTTTCTAT +CAAAGATCGGTTGCCTTGCCACTACGAAGCTCATCTATTCTCCTCTTGAGTTCCGGATATAAAGGAAAAG +TTTCACACAGCTCTCTTACTTCCTGCCTTACTCTCTGTATGGTCTTCTCGTCGTCCATGTTTGAAAGTAC +TTCATTTATCCAGCCTGCTATCTTTCTCATTTCGTCTTCCTTCATCCCCCTCGTTGTGAGTGCAGCCGTT +CCTATCCTTATCCCGCTAGTCTTTGTAGGCGGTAGAGGGTCAAAAGGCACCGCGTTTTTGTTTACCGTTA +TTCCAGCCTTTTCCAGAGCCTTTTCCGCGTCTTTTCCGATAATGTTTTTATTCCTGAGGTCAACGAGGAC +TATGTGAGAGTCCGTTCCTCCCGTGACTATCTTAAACCCGTACTTTTTCAGTTCTTCGGCGAGAACCCTT +GCGTTTTCTACAACCTGTTTTGCGTACTCCTTGAACTCTTCGCTCATAGCCTCTTTAAAAGCTACAGCCT +TTGCCGCTATAACGTGCATTAATGGACCACCTTGAATTCCGGGAAAGACGCTCTTGTCTACGGCTTTTGC +GTATTCCTTTGTAGTTAGGATAAAACCGCTCCTTGGTCCCCTGAGAGTTTTATGGGTCGTTGAGGTCACA +AACTGGGCGTAAGGGACGGGATTGGGGTAAACGCCTCCCGCTATGAGACCAGCGTAGTGTGCCATGTCGA +CCATAAAGAGGGCACCCACTTCGTCCGCTATTTCCCTCATCTTTGCCCAGTCAAACACGCGTGGATAGGC +CGAGGCTCCTCCCACTATTAACTTCGGTTTGTGCTCCTTTGCCAGTTTGTACAACTGGTCGTAATCTATG +AGCTCCGTTTCCGGATTTACACCGTAGTGGATTACGTTGTAGAGTTTCCCGCTGAAGTTTACCTTGGCTC +CGTGGGTTAGATGTCCTCCGTGGGCCAAATCCATTCCCATTATGGTGTCACCGGGGTTTAGAACGGCAAA +GTACACCGCCATGTTCGCCTGAGAACCCGAGTGGGGCTGAACGTTTGCGTGCTCCGCTCCGAAGAGTTTT +TTTGCTCTTTCTATGGCGAGATTTTCAACTACATCTACGTACTCACAGCCTCCGTAATACCTCTTTCCCG +GAAGTCCTTCCGCGTACTTGTTCGTGAGGACGCTTCCCGTCGCTTCCATTACCGCGAGGGAAGTGAAGTT +CTCTGAGGCTATCATTTCCAGGTTATAAAACTGCCTTTCGTACTCCTTTACAACAGCGTCAAAAACCTCG +GGGTCCGTTTTCAGAAGGTGTTCCATTTTGAAAATTATAACTTAAACTCTCCCGAAAGCCTTTTCCTGAC +CCTCGGGTCTATGTAGGCAAGAAGCAGGTCCGCTATCAAGTTTCCCACAAGGAGCATTATAGTCCCTATG +TAAAGCCCTCCCATTACCAGGAAAAGATCCTGCGAGAGAACGGCGTTCAGCATTAGCATACCCATCCCGG +GCCAACCGACTATTATCTCAATGAGAGCAGCTCCGGAGATTAAGCTCGCTATCTCGTAGCCAAGAAGCGT +GGTGAACGGGTTCATGGCGTTTTTCAGAACGTGCCTCACAAGCGTAAAAGTCCCCACTCCCTTTGCCTTT +AGCATAGTTACCATAGGGGAGCTCAGAATTTCCAGAACGGAGCTCCTCACAAGCCTCGTCAAACTCGCAA +GGGAGACGAGTCCCAAGGTAAGGGAGGGAATAATTAAGTGCTTTAAGATGTCCAGAACTTTTTCTGGTAT +GGACAGCTGTTCAAAATTTGGACTCTGCATCCCTCCCACGGGAAGAATTCCTGTCTTTGAGGCGAAAAAC +AAAAGCAAAAATGCGAGAAAGAAGGAAGGCACGGACATAAAGGTGTAGGAAAACCCTACGACGAACCTGT +CAAAAAGGGAATTTTCTTTAAAGGCTGCGAGGGTTCCGAGCGGAATTGAAAGTAGCCACGCAAAGAGTGC +AGAACTCACCGAAAGGAGAAGGGTGTTCGGAATCCTCTCCAAAATAAGTTCCGCTACGGGGGCGTGGTAC +TGAAAAGAATAACCGAGATCAAAAAAGAGGGCATTTTTTAGCCACAGGAAGTACTGAACCAAAAGGGGTT +TGTCCAATCCGTAAAGGTGTTTTAGTCTTTCAATAGTTTCGGGAGAGATTTGCGGATTCAATCTGAGCTG +ATCCAGATAATCCCCCGGAGCGAGCTTTATTATCAGGAAAGAGAGAAATGTTACCCCGAGGAGAGTCGGA +ATAGCCTGCAGAACTCTGAATAAAATAAACTTAAACATTAAAAGTAATTAGCTATAAAGAACTTCGTTTC +CTTAAAGTACCTGTCTATCTCCTCTTTGTGTTTTTCCTTCACGTACTTGATTACCTTGTAGTCGTCCCAG +TATCCTAACATGGGAACCCAGTCGGGTATCCTGTCCTTTTCTTCTATGAAGTACCAAAGAGCTGCTGTAA +AATCTTCCCTTGCCTCCTCACTCAGGTCAAAGTTAGGGTCGGAGAGTATCCTGAAGAGGAGTTTGGCGTC +CAGAATCAGGTTTCTGACGTACTCCATGGTGGGAGGGACTTTTGCGAGTTTCCTTCTAAATGCGTTCTGT +AATTTATAGAAATCCCTGTATTCCTCTCCTTTGAACCTTTCCAGGTACTTTTCCATAGTAAGATAGTATA +CATGTCAAGGATAAAAAGGGTTCACGGAAGAGAAGTTCTTGACTCCAGAGGAAACCCTACCGTTGAGGTG +GAGGTGGAATTAGAGAGCGGAGCCCTCGGAAGGGCTATAGTCCCGAGCGGTGCTTCAACGGGTGAAAGGG +AGGCTTTAGAGCTCAGGGACGGAGACCCCAAAAGGTATCTGGGGAAGGGAGTTTTAAAGGCGGTTGACAA +CGTAAACGGAGTTATAGCAAAGGCACTGGTGGGACTTGAGCCCTACAACCAGAGGGAGATAGACCAGATA +CTTATAGAACTTGACGGAACGGAGAATAAAAGCAAACTTGGGGCGAACGCCATCCTCGGAACGAGCATGG +CCGTGGCAAGGGCTGCGGCAAACGAACTGGGAATTCCCCTATACGAATACCTCGGAGGGAAGTTCGGTTA +CAGACTTCCCGTTCCCTTGATGAACGTTATAAATGGTGGAGCCCACGCGGATAACAACCTAGACATTCAG +GAGTTCATGATCGTTCCGGTGTGCGGAGGAGCTTTCAGGGAAGCCCTGAGGGCAGGAGTGGAGACCTTCC +ACCATCTCAAGAAAATACTGAAGGAGAAGGGATACTCAACGAATGTGGGAGACGAGGGCGGATTTGCTCC +GAACCTAAATTCCTCCGAGGAAGCTTTAGATATACTAATGCAGGCTATAGAAAAGGCGGGCTACAAACCT +GGTGAGGACATTCTCCTCGCACTTGACGTTGCATCTTCAGAGTTTTACGAAAACGGAGTTTACAAGTTTG +AAGGAAAGGAAAGAAGTGCTGAAGAAATGATAGAGTTCTACGAAAAGTTAATACAGAAGTACCCGATAAT +TTCAATAGAAGACCCGATGAGTGAAAACGACTGGGAGGGCTGGAAGGAGATAACAAAAAGACTCGGGGAT +AAAGTTCAGCTCGTGGGAGACGACCTCTTCACTACAAACCCGAAAATCTTGAGGAAGGGTATAGAGGAAG +GAGTTGCAAACGCAATCTTAGTGAAACTGAACCAGATAGGGACTGTTTCTGAAACCCTGGACACGGTAAT +GCTCGCAAAGGAAAGAAATTACTCAGCAATAATCTCCCACCGTTCCGGAGAAACAGAAGACACCTTCATC +TCTCACCTTGCGGTGGCGACGAACGCGGGTCAGATAAAAACGGGTTCTGCTTCCAGAACGGACAGGATAG +CGAAGTACAACGAACTGTTAAGGATAGAGGAGAGACTGGGAAATGGAGCAGTCTTCTGGGGAAGGGAAGA +GTTCTACAGGTTCACTTCCTAAGAAAATTCTCCAGACCTTTCTCTTCCTTCTCCTTATAAACACCTTTGT +AAACCTGTTTTTAAGCAAACCGACGATTTTTGACTTAATAAAACTTAAAAAACTAAGAGAGGAGCTTTCT +CAAAAAACTAAGATAGAACTTTCAAAAAGGAGAAAACTTGAATTTTTAAAGAGTGAACTCGAAAGAAATC +CGAAGGAATTTATGGAAATGTTGATAAGGGATTACTTAATGAAAGTTAAGAAAGGGGAAAACGTAATACT +CATAAAGGAAAAGGAAGAGGGAGAGGGGATTACTCGTTGAGAACCTCTCCCACTCTTCCAACGAGTTCTT +CTGAGGGTTTTAGTGTCTTCTTACCGGGTTCCCACTTAGCGGGGCACGCTTCTTCAGGATGGGACATGAG +GTAAACGTTAGCCTTCATCTTTCTAACGAGTTCGTCCGCATTTCTTCCCACGTTGTAGAAGTTAACTTCG +CTTCCCACGAGTACGCCTTCGGGATTGATTATGAAAGTTCCCCTGAGTGCGAGTCCTGTGTTTTCGTCGT +AAACTCCAAAGAGTCTGGAAACCTGTCCCGTGGGGTCAGCTCCCATTGGGTACTTTACGTTCTTGAGAAG +GGGTTCGTCCCTGTGCCATGCGAGGTGGACGAACTTGGTATCCGTGGAAACGGATATAACTTCGCATCCC +ATTTCCTTCAGTTCATCGTACTTTTCAGCAAGGTCTGCGAGTTCCGTGGGACATACGAAGGTGTAGTCCG +CGGGATAGAAGAAGAGTATTACCCACTTCCTTTCTTTAAGAAGGTCCTCAAGAACTACCTTTCCGAACTT +GCCGGTGGAGGGGTCGTAAGTTTCCATTTCAAAGTTGGGTACTTTTTGACCCACCCTTACGGGGCAATCA +GTTATAATTTTCTTAGCGATTTCCTTGACGTCCATGCCTTTCACCTCCTTTTGAGAAATTTTTTCAATTA +AATATTATACACAAAATCTCAGATAAGTTCCTTAACCTTGTTCACGACTTCGTCGTAGTTAGGCTCTTCT +GTTATTTCGGGAACGAGTTGAACGTAAGCTACTTTCCCTTCCTTGTCAATTATAAACACAGCCCTCGCGA +GTATTCCCTTGAGAGCCCCTTCTCCTATGAGAACGCCGTACTTTTCCATATCCCTGTACCTGAAGTCCGA +GGCAACGGTTACGTTCTGTATGTTGAAACTCTCACAGAACCTCTTTTGAGCGAAGGGAAGATCCATAGAA +ACTACGGTGACGTCTACTCCTTCCATACCTGCCATTATCTCGTTGAACTTTTTAGTTTCAGTCTCACAAA +CGGGTGTATCCAGGGAGGGAACGGTGATTATTACCTGAACTACGTCCTTCGCACCGCCCACTATCTTTTC +CTGAAGGTCCTTTGTAACTACAACGGCCTCGGGTGCTCTATCTCCTACTTTTAACTCTGGTCCCACAAGC +GTAACAGGGTTTCCTTTTAGGTTTACGGTTCTGGCCATAACCACCTCCTTCCTTTTGTGAGGATTATTTT +ACGATGAGAAATTTTTTCAGTTAATGATATGAGTCATCAAACTACAAGTTTTTCTAAAGCCTTTTTATCA +ATTATCTCTATATAGCCCCTCTCAGTGTTTATTATTCCCTGCTTCTTCCACTTGCTCATAACCCTGATAG +TGGTTTCCACCGTTGTTCCCGTCATCTCGGCTATGTCCTGCCTCGTAAGAGGAAGCCTTATTATTATCCT +TCCGTCCTTCTTTTCGCCCGCCTTTTCGGCGAGTTCAAGTAAGAGCTTTGCTATTCTCTCCTCCACTTTA +CCCGAAGCTATGCTCTTTAAAACTTCATAGGTCTGAAGGAGGTTGTGGGTAGCGTCGCAGGTGAGTTTTA +TAGCTATAGCGGGGTACTTTATGGCGAGGTTTATAAAGTACTTGTTAGATATGTATAGTATGGTTGAGGG +CAGGGCTGCCATTGCCGTGTACTTGAACTTGGGAACACTCTTTCCCCACTCAATCCAGCCGAAAACCTCA +CCGGGGAATACGAGCCTTACTATTATGCTCCTTCCGTCGGAAGTTTCTTTTATTAACTTAACGAGACCTT +CAACGAGTATGAATATCCCCGGTTCTGCCTCCTCTTCGAAGAAGATATACTCTCCCTTCATGTAATTCCT +GACTTGTATGTACTTTGCAACTTCTCTTAATTCCTGAGGACTCAAATCCTCAAAGAGGTGCGTTTTCTTG +AGGAGATCTATTTTTAAATCCTCTGGAGTTTGCCCTTTGCTAAAAGCTCCTTGCGCCATCCTTTTCCTCC +TACAACAACAGTTGGTTCAAAAACTACGTAATCTGTGTGAAAGGGGACCTTGTTCTTACCTCCGAAGGTG +TGGTTGTCCCCTATTGCTACGTGGATAGTTCCATAATCTTTTCCGCTTCCAGAATGTTGTCAGCCCTTCT +AGCCTTCGGATTTGTTCCCACACCAAATTCCGCAATGTAGCGGGCGTTAGGGTAAGTGTCGAAAACCCTC +TCCAGTTCGTACCTGTAATCTTCAAAGCCCTCTATTCTCTCAACCGCTCCGTCTTTAAAGTAAAGGGTTA +TCTCCCTTTCTAGTTTTCTGTTTGGAGCGTACAGAATTACGAGTTTTCCGAAGGCACTTTCCTCAATGGG +TGCTATGAAAGCCTCTCCCGCCGGAAGGTTTCCGTAAGAGCCGGGTTCTGTCAGGAGCCCCGTATCGGGA +ATCCCCTTCCTTCCCTTTATAGAAAACTCTAAGTTTACGCCGTAAGGACTGCTGACCTCAACGTACTCAC +CTTCCGTCAGTACTTCCGCTATATCCGTGCTCAGCTTCGCAACGTAATCCCAGTCAACGTCCATCGGTCC +TAAGAACATCTCGGGTTCAAAGAGAGGCATAGACGCGTATCTCGCTTTAAAAACGTCTGTCAATACTTTT +CTGTAAGTTGTGTGAGTGGTTGAGTAGTGGGAAAGGGCGATTACAACGTTCGGAACTTTTTCGGAGTAAC +TTTTTAAAATTTCTGCGAGTTTTTCGTAATCGTAGGGCTCTTTATTCAAAACCTTTTCAAAAATTCCCTC +TTCCTTTAAAACTTCTACAGCCTTTTTACCGAAGGTTTCAACCCACAGAACTTCTGGAGGTTCTTTACCG +TGCTGTCCCGTAGAGGGGAAAACGATAGTTTTTACCTCCGGAGTTATACCTTTTGCTACTTTTTCAATTT +CCTTTAAAACCTCGGATAATTCCTTCCTGTAGTCGTCCGTGAACGCCAGTAAGTACTCATTACCCTTTAG +GGCTAAATTGATTGTAAGAAGCTTTTGTATCTGAGGTTCAAACATTTCTAATTAATAATAATAAAAAATT +TTTATCGGATTGGTACTCCGATTCCTCCGAGGAGGTACTTGAGATCTTCGTCAACAAACTCCAGACCTAC +ACCTCCAAAAAATCCCCTTAACTTCGAGTTTAAAAGATCGTCCCCGCCGAATCTAACGTACAGGTTCCTG +TTTATGTACCAGTGAATGCCGATTTGAAGGTTCGGTTTCAAATCCTTATCCTGCGGTCTGTCCTTTCTCC +CGAAGTCCCAGAGATCCGCAAACAGGTACTTGTCCCTGTAAATGTAGTAATCCGCTCCTACACCTCCGGT +GTTTTCTTTAAGCCCACCCCTTAAAGTTAATGTCCTTCCGAAAAGGGAGAAGTTTCTGGCGTACTGGAGC +GTAAACTCTGGCTTGAACTCCTTCTTCACCACTTCCCTTCCGTCGAGGTACTCTTCTCTGTAAACCCTTC +CTCTTGAATCTCCTACAACTTCCAGCAAGTAGTACTTATCCCTGTCTGGAACAAGTCTGACGGAAAGTAT +TCCCTTTGAATCCCCTTCCCTGTAGAGTTCTCCCCTGAGTCCTATGTAGAGCTGCGTCTTTTCCACAACC +TTTCCCGCCTTTCCTAAAGCTTTAACACCCTGATTCACGTTCTCGTAGAGTTCTTCGTCTTTCAGGAGTT +TCCCGAGTGTTCCTTTTCCGCTTTCAAGATCTGCGAGTATTTTATCCAGTTTGTAGGAAGCCCTCGAGAG +GTTTTCCGTAGTCTTCCTCAGGGAAACGAGCGTTTTGTTTATGTTTACTTTGTTGTTCTTAACAACTGTG +TTCAAATTAACCGAAAGCTCCTTTAAGTTTTCAACCAGAACGGGAAGGTCGTCTTTTACCTTTTCCATTA +CTATTGAGAGGTTGTAAGCTATTTTTCTTATATCCTCTCTGTTTTCAAGGAGTATTCTGTCCGCGTCCGA +GGAGAGCTTATTCAAAGTAGCGAGGAGAACGGGCAGATCCCTGTTTAAAGATTCTGTCAATTGTTTTAAA +TTCTTCAGAGCTAAGTTTATGTTTTCCCCTGTTCTGTTCCGTGATCTCGTTTAAGTTCTTTATCAGGTAG +TTTAGGTGAGCTATAGTTTGTCTTAAGTTTTCCCTGTTTTCAAGGAGTATGGTATTTAAGTTTTGGGCTA +CCTTTTTAAATTCTTCCGCGGTCTGAGTCAGGCTCGCTATTAATTTATCCGTGTCGCTCACGGTTTTTAC +GTTCTTTATCTCACTTCTCGGTGGGAGTTCTCCGCTCTCGGGACTACCCGGCTTCACCGCCAGGTACTTG +TCTCCCATGAGTCCCAAGGTTCCTATTGAGGCAATGGCGTCTCTGTATATGGGAATTTCCTCCTTTACTT +CAAAAACTACCTTAACCTTCCCCCTCTCCAGGATTATTTCTTTAACTTTGCCCGCTCTTACACCTGATAC +CCTCACCTCCGCTCCCTTTGAGAGTCCAGCAACTTCGTCAAAGTAAACGAGGTATTCCTTCATTTTGGGT +TGAAAGAAAGGGATTTCACCGAAGGTTAAAACCAGAAAGGCAAAAGCCAAAGAAACGGCTACTACAAAGG +CTCCGAGTTTTAATTCTGTAGTGAGTCTCATTCTATGAGAATAGTTTATAATACTAAACATGCTAAAAGA +AGGAGATAAGGTTCCCAGTTTCTGCCTTCCCGGGATAGACGAGGAAGTAAACGAAAGGGAGATTTGCATA +GATGAGTTTAAGGGAAAGAAAGTAATCCTCTACTTTTACCCCAAGGACAATACGCCCGGTTGCACACAGG +AAGCCTGCGACTTCAGGGATAACCTGAACCTTTTAAAGGAAATGGGATACGTCGTGATAGGCGTAAGTCC +TGACAGCACAGCATCCCACAAAAAGTTCAAGGAAAAGTATGGACTGAACTTTATACTCCTTTCGGACAAG +GATAAAAAAGTAGCCGAAATGTTCGGGGTTTACGGGGAAAAGAAGGCTTACGGCAAGGTAACTAAAGGGA +TTATACGTTCAACTTTTCTTATAGACGAAGAGGGGAGGATAATAAAGGAATGGCGAAACGTAAAGGCAAA +GGGACACGTAGCGAAAGTAATAGAAACCTTGAAGAGCTTAGAAGAAAAGCAGTAGAAATAGTAAAGAGAC +TAGAAAAAGTTTACCTCAACCCGAGGCTCGAACTGGAGTACGAAAATGCCTTTCAGCTCCTCGTTATGGC +TATACTCGCAGCCCAGGAAAGTGACAAAGTCGTAAACAAGGTAAGTAAAGAGTTCTTCAAAAAGTACAAA +ACTCCTCAGGATATAGCAAGGGCAAATTTAGAAGAACTGGAAGAGGACTTAAAACACATAAACTTCTACC +GAAGAAAGGCAAAGCTTATTAAAGAGTGCTGTGAAAAATTAATAGAGCTCTACAAGGGAGAGGTTCCCAA +AAGTGTGGGAGAACTAGTAAAACTGCCGGGAGTAGGGAGAAAAACCGCAAACATGGTAATAGGTGGAGCT +TACAACCTTCCTGCGATAATAGTTGACAGACACGTCCACAGAGTGGTTGAAAGGATAAGTCTGAGCAAAC +AAAAGAACCCTGACAAGATGGAGATGGAATTAAGCGAAATAGTCCCTCAGGAGCTCTGGACAAAGTTTTC +CCTTTTGCTCCTAAACCACGGAAAGACTATATGTAAAGCGAGAAATCCGGAGTGTGAAAAGTGTCCGATA +CTTGACCTTTGTGAATACGGACAGAAGAACCTCAAAGGCAGGAAATGAAATCCTCTGCAAATTCTGGAAT +AAGGACTCTGTCATCGTAAGTCAAAACTTCCTTTTCTTTTTTCAATAGAGGTTCTGTTTTTTCCCAGAGT +ATCTCCGTCTCCTCTGCGTCCAGAAAGAGCGTCTTGTCTCCCCTTATGACGTCCAGAAGGAGGGACTCGT +AAGCTTCGGGAATTTCTCCCAGAACGTCTTTGAGGGAAACTCTCCAGTTAATACTTTCCGTACACCTCAA +AAAGCCAAGTGGAGATATAACGTTTACCCTAAAGGAAACTTCCTGCTCTGGATAGAGTTCAAAAACGAGT +AAATTTCTCTCAGGAACGCAGCCGAGAAGCCGTTCAATCTCCTTCGGGAAGTTCTTAAAGTGGATGCACA +CCCTCGTCAATTTTTTCTTTAACTTTTTTCCCGTGGCGAGTACGAAAGGCACTCCGGTGAAACGCTCGTC +GTCAAAGTGGAGTTTTACAAGGGCAAAAGTGGGAGCTTTTCCTTGATAACTTTTGTACTTTCCGAGTATC +AAGCTCTCGGACTCAAACTCGGCACGCTTTAAGGCGTTCTTCAGCTCAAAGTGGAAGTCCTCCGCCCTTG +GAGGGAGTCTCATAACGATTAAAGAGGAGAGGAGCAACATGTGATTCTGTAGCATGTCCCTTATGACTCC +CACTTTCTCGTAATAAGCTTTTCTGCCCTCTACTCCCACCTCTTCAAGGGCAATTACCTCCACCTTCTCT +ACAAGACACTTGTTTAAGACTTCGGAAAACACGTAATTTGAGAACTTAAAGGCGAGTATATTTTGAACCT +GCGGCTTTCCGAGGTAGTGATCTATTCTGAAGATTTCTTCTTCTTTGAAATAAACGGAAATTATTTTGTT +TAAGTCCTTTGCGTGCTTTAAGCTGAGGCCGAAAGGTTTTTCAATAACAATACGTTTTTCTGGAAAGTTC +AGGTATTTTCCTACGTTTTCTAGAATTTCCTTGAATAGGTCGGGAGGTACCGCAAGGTAAAAAACTTTTA +AAGATTCTTTTCCTAAAATACTTGATATATTTTTATAACTCTCTTCCCTCTCCGCGAGGAATTCTACGAA +CACGAATAACTCTGAAAAATCCTTAAACTTTTCTTTTATTTCTTCAAACTTTTTCCTATTCCTGCCTAAA +ATGTAAATCTTCTTTAAATCTATTTTGTCTTTCAGTTTCAGGATTGCGGGAATTAATTTATTTCTGCTCA +GATCCCCGGTTCCGCCGAAGATTATAAATTCAATCCTTTTTCTTAACTCTGTGTCTCCCGAACTCATACC +TCAAAACTGCCAAAACTTTGTTTTTAAATAGATCTTTCTCCCTTGATGAAAACCTTTCGTAAAAGGATTG +AGCTATTACGGGAATAGGGGCTCCGAGTTCTACGCTTTCTTTAACGCACCACCTGCCCTCTCCGCTGTCC +TCAACGTAACCCTCCACGTCTTCAAGGTCTCCGAAGTCTTCAAAGGCTTTAACAAGGAGATCAATCAAAA +AAGAACGTATTACGCTTCCCTGCGAGTAAACTCTCGCAACTTCTCTCAAATCGTAATCAAAAGGAGACTT +TTTTAGGAGCTCAAAGCCCTCTGCTATCGCTTCCATAATTCCGTACTCAATACCGTTGTGAACCATTTTC +GCAAAGTGCCCCGCACCGCTACTTCCAAGATAAGCGTACCCCTTTTCCTCGTAGGCCAAATCCTTAAAGA +GCTTTTCGTGTTTTTTAAAGACTTCTTCATCTCCGCCTATCATAAAGGAGAAGCCCGTATCCTTTCCGAG +AATCCCTCCGCTTACTCCAACATCCAGAAAGTTTACATCTACTTCCTTTAGTTCCCTATACCTCCTCTGG +GAATCTTTATAGTAAGAATTTCCTCCGTCTATTACCGTATCTCCCTTATTTAGAAAAGGTTTTAAATTTT +GGAGAACCTCGTCCACTGCGGTGTGTGGAACCATTAGCCACACAGTTTTAGGAGAAGGGAAGTTTTTTAG +ATTTTCATAAGAGTTTAAAACCTTTATCCCTAGGTCCTTTTTGGCTCTTTCTCTGGTTGTTTGTGTGCGA +GAATAGCCGTAAATCTCCCAGCCTCTGTTCTTGAGTCTGTAGGCGAGGGCAGAGCCCATGCGCCCCAGAC +CTATGAGGAAAAGTGTTTTCATTACGTTCCCTGTGTGAGGCCGAGTTCCTCAGGTGTGAGTTCTTGAATA +GCCTGTTTGAGATTGTCAAAAACTGTGTAGAAGTCTTCCCCGAGAAATCTCACTCCTTTTCCGTAGAGCT +TCTGGAAGGCGTAGGAAACGATCTTGTGCTTTTCGTAGGACATGGTAATTCCGAGCTCTTCCGCCTTTTG +ATTTAGAACTATTTTTACTTCTTCCAGTTTTCTCGCCCTGTTTTCCCTCTCCTTTTCCGCTTCCTTCAGA +GGCATGTCAAGGAATTCGTCCACTTTCTGGAGTATCCTCTCAAAGTAAGAGCCCGGGAACTTTCTGTCTC +CGAGCCTTTCAATAACAAAACCTATCGTTATGTAGAAGGGGTATTCAATAAAGGGTTCAAGTTCGTACTC +CTTCATGTCTGGATTTTGCTGAAGTTTTTCCATAAACAAGTTGTAAGCTTGAATGGCTTTTTCTTTGAGT +GCAGGAGCTTTTTCAATGTTAAAACTCAGGATGTAATTTCTGAGCTCCTTAGGAAGTACAAAGGCGGGAA +CCTTTTCAAGTCCGACGATCTTAGCTGCTTCCAGTCTGTGTTGACCATCAATTACTTCGTAATACCCTTC +CTGTTCTTCCGGAACTACCATTATGGGATCTATAAAACCGAGTTTTTGAATTGAGCTGACAAGCCTCTCT +ATTAATGTTTCCGAAAGGGGTCTTTCTATGGGCGGGATAACGACTTTGTCCGTTTCCACTTCCTTGAAGA +TAATTTCGTATCCCTTTACCGGTTCCGTGTATTTGCATTCGTTCATTTTCACACCTTCCTTTTTAAACTT +TTTAAGTTCTCTTTTATAAAATTTATATCTTTTAAAGGAAAAGGCAAAGAAAGGGATGGAGAATTACCAC +TGAGGAACGATTTTCTTCTTTCCACTGAGGAACTTATCCACCGCTAGGGCCGCTTTACATCCCATTGCCG +CGGCAACTACCGCCTGCTTTACCTCGTTACAGAGCACGTCTCCCGCCGCAAAAACTCCCGGAACGGAAGT +CATCATCTCCTCGTTCACCACTATACAATCCCCCTCCGTCATCTCAACCTGACCCATTAAGAAATCAACG +GATGGCTTCGTTCCCCCGAGAAATATGAACACACCGTTCACCTCTAAAAGCTTTTCCTCTTTCTTTTCGA +GATCCTTGAGTTTTATTCCCTTAACCACCTGATCTCCAACTATTTCGATGGGTCTGTGTCTAAGGAGTAT +TTCAACGTTGGGGAGTTTTTCAAAGTGTTCTATTACCTCGGGAGGTGCTTTTATCTTGCTTCCGGGAACA +ACGAAGAAAACTTTATTTGCAAACCTCGCTATAAATTCCGCCTCTTCTATGGCGTAGTCGTCGTCACCGA +TGACCGCAACGGGCTGGTCTTTAAAGAATGCGGCGTCACAAACTCCGCAGTAAGAAACTCCCCTTCCGAG +AAACTCCTCCTCTCCCTTGAACTTATTAGCCCTTTCCATAGCACCTGAAGCAACTATTATGGTTTTGCCC +CTGAACTCCCTTCCGTCTATCGTGTAAACTTTTTTAGGATCGCTGTTTAAATCCGTAGCTATCACTTTTC +CCCTTACGAATTCAGCTCCGAAGCTCTTCGCCTGTTCTCTCATAATCTTTAAGAGCTCGTATCCCGAAAG +CGGACCCGGAACGCCTGGGTAGTTTTCTATCTTCTGGGTAACCCCGAGGGCTCCGTCAGCTTCCGCTCTA +TATAAAACCAGCGTTTTCCAGCCAGCACGTGCCGTGTATATGGCTGCAGTCGTTCCCGCAGGTCCCGCAC +CTATTATTATCACGTCGTAAACTTTATCGGGTTGTTGCATCAGGCTTACAGCCATTTTCGTACCTCCTTG +CGACAGTTGAAAATTTTACAACCTATATCAATATGTTAAAAGATAGAAAATTGCATAGCTTAGAGGGAAC +ATATAGATGAAGAGAGATTTTTTAGAGGTGGGAACTTGGGTTTAAAGAATTTGTTAATTATTTTAAGAGT +TCTAAACCCTTCTGGATAATCTTTTCCACCTCTTCCTTGGTTGGAGTTTCTGCGTAAACCCTTATTAGCG +GTTCCGTTCCCGAAGGTCTCATAAGAAGCCAAGAATCGTCCTCAAACACAAACTTAACACCGTCTATAGT +TTTCACTTCCCTTACCTTAAACTCCCCTATCCTTTCCGGCGGATTTTCCTTCAGCTCTTTTATTCTTCCC +TTTATCTTTTCCTTAACTCTCAAATCCACCCTCTTGTAATACGCCTCTCCGAAACGTTCGAATATCTCCG +CAACAACCTCCGAGACTTTTTTGTCCTTAAGATAAAGGAGTTCTAAAATGTTCAGAGCAGAAAATATTCC +GTCTCTCTCCGGAAGGTATTCAGGTATACCGTAGCCTCCTGACTCCTCTCCTCCGAATATAACTCCTCCT +TCTTTAAGGATTATTTCGTTTATGTTTTTAAAACCGACTCCGACTTCTATTAACGGAACTCCAAACTCCT +TACAGATCCTGTCCGCCAGATAAGTTGTTGAAACCGTCTTTACCACTTTTCCCCTCTTTCCCTTATTTTC +AAGAAGGTGGAGGAGGAGCATTGCGTATATGAGCTGGGTGTTTACGTAATTTCCCTTATCGTCCACAAGT +GCTATCCTGTCTCCGTCCCCGTCGTTTGCAATCCCGAGCTCCGCACCAAGAGCCCTAACTTTCTCTTTTG +TAATTTCCATATACTTCTCTATCGGCTCAGGTGGATGTCCCCCAAAGAGAGGATCTCTATCCTTCCTTAT +GTTTATTACGCTGACCTTCGTATCCCTGAGTACAAAATCGAGAAGTCCAGAAGACGTGCCGTGCATGGAA +TCGTGAACTACAAGCGTTTTCTTCTCTTTGAATAAATCCATATCGAAGAATTCCCTTATTTTTTCCACGT +ACTTTTTCCTGACTTCCTGATATTCGGGCTCGAACTCTTTTATCTCTACACTTTCTATATCCTTGACTTT +TTCTTCAACGTTTTTTACAAATTCCGGAGTTGCGGAACCTCCGAAACTTTCTTTAATCTTGTACCCGTTG +TAAGCCGGTGGATTGTGAGAAGCCGTAATCATAACCCCGTTTTCATATCCGAGATACTTTACAGCGAAAG +AAACCATAGGCGTAGTACAGGCACTTCCAACTAGTTTCGCCTCAAGTCCCTCACTTCTAAATACGTCGTA +AACAGCTTTAGCAAAATCTTCAGAACGAAAACGCCAGTCGTACCCGACTATTACACGTTTTACCCCTTTT +TCCTTTAAAACTTCCGCGTGCGCCTTTGCAACTCTCCTTACATTATCAAAGTTAAACTCTTCCGCTATCC +TTGCCCTCCACCCATCCGTCCCGAACTTAATCATAATGGAATATTGTATTATTCTTTTTCTGCTGCATTC +TGCTTTACATAGAAAGGTAATTTTTCGTATATCTTTCTGTAAAGGTCGAAGGGTCTTCCTGCTAATTGTC +CTATATCCCTGCTCCAAGGAGCTAAAGAAAAAGAAGCTATTTGTTTTACATCTCTTAGATTAAATATTCT +AAGTGGTATACGTACAAAAACCCCTTTGTCGTGGTAATTTTTATTAGGTCCCGTAAAGTCTGAAGTGTCT +GAGTATGTATACCAGAACCCAACTTCAAAACCTTTGACTATTCTTGATACTTCTATTCGTACACCTTTAT +CACCGGCTAGAAATCTACCCGCTTTCACACTAAATAACAGTTGAGGTTTTCTCGTCATATAGTAAGCCGA +TACGTAGAAATCGTAAAAATCCCAATCTTTTCTAATCCCTAAAAACACGTCTGGCTTCCTTTTCCAGACG +TAATCTCCCCCTATCCCCAAAGCAAACCTGCTGTCTCCGAAAAGGTGTAATACATCTCCCTACTTTAAAT +AATACACATGCATTAAAAATAGGAAAAAAGCAACTACAACTTTGTTATAGTGTAAACAGTTAGCGCTGAC +TGGTATATTATCTGGATTACATCACGTATAAGCGGTCTCCACATGGTTGGTATTTTTATCTTCGTGGGTA +CTATTATTGCATCACCAGGCTCGAGCTTGTAATTCAGAATATCGTTATAAGCCCATCCCCAAATGAACCT +TTTGCGTTCAGAATCCCATTCTATAAGACTTTTTCCGCTTTCCTGAGATATTGCTATTCCATTTGCCTTG +ATTATGAATACGTTGTCTACGTCGGCATCTCTTGTAAAACCTCCGCTTAAAGCTATGTAATCCTTTACCT +TCAGACCGGGTTTGTAAAGAATTGCTGACGGATTCTGTACCTCTCCAAATACAAGTACAGCGGAAGGTTT +TCTCGGCACGTAAATCATATCTCCATCTTCCAAGATTATGTTGTAGGGAGAATTCTTAAGAGCCTATATA +TCGGGGGGTATATTAAGACCTACGAGCCTTCCCGTTACCTGTACTTTTTCCATTTCCTGAAGCAATCTTC +TTTTTGCCGCAAAAGCCTCTTTGTAAGCTTCCTTTTGCTCTTTTGGCAATTCAGCCTGCATGTATCCGGC +AATTTCCTTTTCCAGTTGGGCTTTTAGGAAAACCATCGCCTTGTTTAGCCTTTCTCTTTGCATTTGAGCT +ATAGATTCTCTCAGTATTACTATTCCCTTAGGATATGCCATGGGTTTGAAGCCACCCGCTGCCTTCAATA +CATCATAAAGGGTAGTCCTTTCACCTATCTTGTAAACACCCGGCTTCCATACTTGACCATAAACGTAAAC +CTTTGTAACCGTTTCATCCTCTTTGACTCTTTTTACTACAATTTCCGTTCCTGGTTTTAATTTCACAAAA +CTCAAAGGAGAAGGATGTTTCCTTAAATCGTTGAGGTAGAAAACTTCAACCTTTTTATCCTGTTTCACTA +TAACTTTCAACTCTCCCAACGGGTACTTAAACTTAACCTGTGATATTGCTTCCTCGAGAGTTAATCCCGG +TTTATAAGTAACCCAAAGTGGTCTTTCCACTTCACCGCTTATTCTTACAGGTTCGTATACAAACTCCGGA +TAAAACACTATCCTGTCCCAGGATTGGAGTTTGATATCTTTGGAACCGTTCAATACTTCAATAGGTTTGA +ACTTTATTATTTCCTCCCTTTGAAGCGTTTTCGGATTAAAGCGTTCTATCTCCGCATAATTCAGGTTCGT +ATCTTTAAGAATTAGGTCCTTCTGGAGGATTTCGGAAATGTAACAATCATCGGAACAAGCTACAGGACCT +GTATACTTGTAGTATCCTGAAACTAAAACGTAGTTTTTTACCAAATTCAGATTTATTTTCTTTCCTACGC +TTTGTCCTAATTTAAAGAATATTAACCTATCGTAAGGCTTCAGCTCCATATCTTCCTTTCCTGTAAGAAC +TTTTTCAGGTGAAAAGGCTATGTACTTCGGGATGGATCCTTTGGGATATTGCCTTACGAGAACGGCAAAT +TTAAGGTTTGTATCCTTAAAGAAAAGATCGGGGTTCAGGATATCAGATAACTTTAAACCCTCCTTATACT +CGTACACTCCCGGGAGTGTTACATAACCTTCTATACTGTACGAGTTTTCAGGTATATCAGCCGACTTTTT +GATCAATACTAAATCCCCGTCTCTTAAATTTTCGTTCATAAAGGCTTTATTGGTTAGGGAATCCTCTATT +ATCCTCAGTTTTCCATTTTCGTATCTCTGGAGTATAACCTTGTACTGGTACGAGGAAGGAAGAAGACCAC +CTGCAAGTTCTATAAGATCCTTGATTGTTTCACCACCTTTTATCTCATAGATTGCAGGTCTTTTAACCTC +ACCAGCTATAGCAACCGTAGGGCCTATTGGTTTAACTAGAATAGTATCACCATCTCTCAACGTAAGATCT +ATAGGTTTCCCTTTTATGAATACATCGTACAGGTCTATGTTATAGGTTTTCAAACCAGAAGGTGTTTTCC +TTGTAAGGATGATATTCCTCAAAGATCCTGTCTTTTTTACACCACCTGCAATAGAAAGAGCGTCTATTAC +TGTGTTTACAGCCGTTGCTACGTGAGTTCCCGGTCTGTTTACTTCTCCTGCAACGTAAATCACAAAAGTT +CTGATTTCCCCGACCGTTACCTTTAGATCCAGACCAAGTTCCTGTCTAAGGAGTTCCTCAGTTTCTTTTA +ACGTAAGTCCCCATACGTTAAAAACACCTAGGTTAGGAATGGAAATATTTCCTTCTCTGTCAACAATTGT +CTTTATTACCGGGGGGATTTCTTGATTAGATGGAAGACCTACTATGTATATGATTACTTCGTCTCCTGGG +CCAAGCTTGTAATTTTCGCTGACGGGAAGGACTAACTTTGATACGTCTAAAGGAGTCATAAAAAACTCGT +ACCCAAATTGTCTGAGAGGCGTACTGTTTCTGGAAGAAAACTCCTTTTCTATTTTGGATATCAAATTTTT +ATACTTTGGAAGTTTCTTAGGTTGAGGTTTATCTTTTGCGTATACAAATAAAAAAGCCGCAACGAAAATA +AGGATAAGTGATCTAAGAAACACTTTCATTTTCCTGTCCCTCCACATTCTCACTGTATCTCTTCCTTGCA +TTATTTAACCACTCCTTAAAGAATGCTAAGAATATACCTGTAAAAAGACCGCTTACAAAGGAAACAGCTA +AGATTAAAGCTTTTTTAGGCTTTGCCGGTTTTTGAGGAATATAAGGAGGATCTATGATCTGGAATGATAC +GGATTCCTTCACTTCGTTTGCCTTTGCGATCTGATACTGCTGGAATAATGTGGAAAGCAGGTTTTTGAGT +ACCTCAAATTGCCACTGGAGTTTCTGGTAATTGAATTGGTACTCAGGTAAATTTCTATTCATTCCCTTAG +CTATTGGTATATTCCTTTCTAAGTTTTGCTTTAAATTACCAGGAATATCAAATTTATCGTTGTTCTCGTA +ATTTAAACTTTCTTTGAAGATTTTACTTATAAACCTCTCATCAACAACTATCGGTACTTCTTTTATCTCA +CCCTTTATAAACTTGAGGTAAACCTCTTCCAGAACCTTTTGTTTATTGAGCACTTCCTTTATCTGGTTTT +CAAGAAATATCCTGTGCTTCTTGGCTAAAGACCAGCTTTTTTCGTTCAGTATCTTATAAGCCTCTTCCAA +GGAAACCTGTGCAATTTTATACGCCATATGCGGATCTTCTGGAAATTCTACTGAAAAAGTTATAGTTCCT +GTTTTTTTATTTGAGGAAACAGAAATTAAGTCTTCTAACAATTCGGCTCCATCTAGAATTGTGGGAATAT +CTTCTGGTTCAAGATCTTGTCTCCAAGTATTCCTACTTTCGTCCCATAAATCCTTGAACAAGACAGGCAT +AAGGTTTAATTTCTCAATCACTCTTTCCCTTAAAGTTCTGCTTTTTAAAACGGACTCAACGGTTACTTTA +TCTGCAACAGATGGTAGGGGTACTGGAAGACCTTCCAGTATTGAGGGTAAATTTGTTTTTTCTCCGCCTA +TAGGAAATATCACAGCTTCGGTTTTGTAAACCGGAGGAGCTATGAATACATATGCAACCGCACCTGCAAT +AAAGATAACTAGAGTAAGCAGTATAACCCTGAACCTTTTTTTAAGTACAACCCAGAGCTCATATAGATCT +ATTTCATCTTCCTCGTACATCGGATATCCTAACTTCTCACTCTTCCGATCAATACTCTTTTCTTCCATAC +TGGATATCATTTTATATGATGCTAAATTGAGTGTCCGTATAAATTTTAAACTTACAATGGCAAAGATTGA +AACGATAGAAGATCTCAGGAAATATATAGAAGATTTTTTCAAACGGAGAAACAAGAAGGTAAAGGTTATA +CTTTTTGGTTCCAGAGCACGGGGAACGCATACATCATATTCAGATGTGGATATTGCTATTTTGTCGGATG +AAAATATAGATAACGATCTGATACTACTTAGAGAAGAAATAGAAAACTCATTGTTGCCTCAGAAAGTTGA +TATAGTCGGCTTTTCAAAACTTGAGGAGAGTTTTAAAGAAGAAATCCTAAAAGAGGGAAAAGTGTGGATA +GACTTAACAAAATCCTAAAAGACTTTTCTTCAGCGGTAAATAGATTAGAAAAAGCGATAAATAAAGCAAA +AGAATTTAAAGGATCAGAGGAGTACTCCTTTTACAGAGATTCTGCCATACAAAGATTCGAGTTCACGTTT +GAATTAATGTGGAAAGTACTGAAAGTATTTCTCGAAAAAGAAGGAATACTCTGTAGATCGCCTAGAAGTT +GTATAAGAGCTTTCTTTAACGCAGGCTATTCCACAGAAGAAGAAACAAGACTTATGCTAAAAATGGTAGA +GGATAGAAACTTAACCGTACACACTTACAACGAAAAGCTTGCTGAGGAAATATTCAGCAGACTTGAGAGC +TACGTAAAGATCTTTCGAAGCATTTATGAAACAATTGAGGATGGATCACATTAGATATGAGTCAAGTATT +GTTAACCTCAATTTACGAAATACTTGTTGCTTTTTTTATTTGCTTTAAAGTACAATATTTGAAAGCAAGG +GATTAGTTTACCTGAATGAATGATGAGCTTTTTAAAAGCTACACACTGCAGGATTATATAAGAATGGTTG +GAGAAGCTGTAAGTAAAGCTCTTGAAAATAAAGACAGCTTTATCATATTCTTCGGTAAGGAAATCTGAGG +AGGACTTCCGACATAGATGTGGGAATTTACTGCGGAAAGAAACTTGACCTTTGACTTACGTGAAGATACT +GGAAGAGATTGAAGCTCTGCTGATGCTGAGAAAAAAAAAGAAAAGATTTATAAGGCAATAAAGAAAGTGC +GGGTAGCTTTTAGAAAAGAGATAAAGGGAAAAAGTGATTATGGGAATTGAGGAAAAACTTACTACTGCTT +CTAAGATTAAAAGCCTTCTTAACATTCGGGAACAGGAAAAGGTTTTAGATGCATTAATAAGATCCTCTTT +TATTAATATATTAGCAAGAGGTTTTGGCTATTTAAAACACGTAACAATTGCAGTTGTTCTAGGGTTTAAC +CTTCAAACTGATGCTTTTTTTATGGCATTATCACTTATAGGTATATTTCTTATTTTTGCGGATGTTTTTG +ATTCCATAGGTGTTCCAAATTTGGTTGACGCAAGATTAAAAAGTCAGGAGGAGTTTAAGAAATTATCTGG +ATTGCTTTTTACCTTTACACTAATATTAACTTTTTTAACAGGATTCTTAGCAATAGGTTTCTATCCATTC +GTTCTTAAAATTCCTGTAGGATTTAATATGGAAGCTTTATCATATACGCAAGTGGCATATTTTTTACTAC +TTCCATACTTGCTTTTTAATTTTCTATTTCACCACTTTGGTGCTGTTCTCAGAAGTGTAAGAAGATTTAC +AGTTTACTTTGTAGGGGAATTTTTATTTTCCTTTTTTAGTTTTTTATTTATTTTCTTAGGTTTGATTTTT +TATAATAAATGGCTTGTTTTACCATTGTCAATTTCATTTGCACAAATAATTGCCACACTTTATATGTTTT +ATGTAGGAAGAGAATTTATTCATATAAATTTTTTTCTAAATCAGACTACGAAAAAAATTTTAAATCATTT +TTTTTATCTTTCAGCGTTATATGGAGTGCTTCATTTGTTTATTGTTATTGATAGAGCATTTGGTTCATTG +CTTGGAGAGAAATCAATTTCCGCTATTCATTACGGTTTAATAGTTGCCAGTATTCCAAGAGGAATAATAA +GGCTTGAAAATATCGCTATAACTTCACTTTCTGAATCAAAAGGAGACATAAAAAAGTTGAATTTTTATAT +AAAAAGAATTTTAATTGTTTCAGGAATATCATTATTATTTTTCTTTGTTTTTGCTGAAATTATTGTTAAA +CTTCTTTTTGGATATGGTGCTTTCACTCAAATGGATTTAATTCTTACAGTAGAAGCAACCAGATTTTACT +CTTTAAGCCTTCCTTTTATGTTTTTATGGCCAATTTTATACAGAGTTTTCCAGATAAAGGAAAATTTGAA +ACCAGTGTTTTTTATAGCCATATCAGGAATAACTGTAAACGGTATTTTAAATTATTTTTTTGTGCTAAAA +CTTAATTATGGTATAAAAGGTATAGCACTTGGAACTTTAGGAGCGTATATTGTAATATGTAGTTTAAGTT +ATATAATACTTTATTATAAATACAGGAGAAATTAAATGGTAAAAAGTGATTATACAAGATGCCCAATTTG +TGAAACTCAGAAGAATGTGAACCAGTATATAGACACTTACATTTCTCCTTTTAATAATCAGGAATATAAA +CTCTACGAATGCTCAAATTGTAAACTCCAGTGGTGGGAACCATTAAAAATTATTCCTGAATTTTATGAAA +ATGAAGTTTTTGACTCCTATATTTCCTTCCATGAAGGTATTAGAAGTAGAATAGGCAAAAATCATGAAGC +TTTTTTCAAGTATGTCCCTAAAAATGTAAAAGGGAAATTGTTAGATATAGGGTGTGGAGATGGAGTTTTT +CTTAGAGAAGCTCAAAAATATGGATTTGAAGTGTGGGGAATAGATTTTGATAAAAAAAGTGTTGAAACTG +CTAAAAAAAACTTAGGGGTTAAAACTATTTATGCGATGAGTCTTGAAGAATTTCATAAATTTGCTAAAGA +TAATAATATAAGATAAAGAGTATTAAAGTAAAAGAAATTAATGAAAAATTTTTAGTGGAGGCATTTGCTG +GAACTCCTTTAAAGGATTTAATAAGGTTTAGTGTAAAGGAAAATATAAGGAATTTCTACAAACTTCTCGG +TTTTCCGGCAAGTGTCGGGGGAGCGGTCAGTATGAACGCGGGAGCTTTCGGAGTTGAGATATCGGATTTT +TTAAAAGAAGTTTACTTCGTGGATTGGGAGGGGAAACTCCAAAAAGCAAAAAGGGATGAACTGAGTTTCT +CTTACAGAAAGTCACCTTTTCCGGAACTTGGAATAGTTTACAAAGTGGTTTTTGAGCTTGGAAAAAGTGA +AGAAAATATACTTCCCAAGTACGAAAAAATAAGAAGAATAAGGAAAGAAAAACAGCCTATAAACTTTCCA +ACCAGCGGTTCTACCTTCAAAAATCCTAAAGGTAATTTTGCTGGAAAACTTCTGGAAGAAGTAAGTTTAA +AAGGTTTTAGACTTAAAAACGTGGGATTTTCCGAAAAACACGCTAACTTCCTTGTGAATTACGGAGGGGG +AACATTTTCGGAAGTGGTGGATTTGATAAACATTGCAAAAGAAAGGGTTTACGAAAACTTCGGTATAGTA +TTGGAGGAGGAGGTAAAACTGATTGAGAGTAGTGGTTCTGATGGGTGGAAGGTCCTCGGAGCGTGAAATT +TCCCTGAAAACGGGAAAGGCGGTTGCCAACGCATTGAAAGAACTGGGGCACGAAGTTTACGAGCTTGACC +TTGACAAGGAACTTCCCTGTAAACTCCTCGAGATAAAGCCCGATAAAGTATTTATAGCCCTTCACGGAAG +GTACGGGGAAGACGGAACCGTGCAGGGAATCGTGAACTATAAGCGCCTCCCTTTCTTTGAATAAATCCAT +ATCGAAGAATTCCCTTATTTTTTCTACGTACTTTTTTCTGACCTCCTGGTATTCGGGTTCGAATTCTCTT +ACTTCTACGCTTTCTAAATCCTTAACCTTTTCTTCAACGCTCTTTACAAATTCCGGAGTTGCAGAACCCC +CGAAGCTTTCTTTGATCTTGTACCCGTTGTAAGCCGGTGGATTGTGAGAAGCCGTAATCATAACCCCGTT +TTCATATCCGAGATACTTTACAGCGAAAGAAACCATAGGCGTAGTACAGGCACTTCCAACTAGTTTCGCC +TCAAGTCCCTCACTTCTAAATACGTCGTAAACAGCTTTAGCAAAATCTTCAGAACGAAAACGCCAGTCGT +ACCCGACTATTACACGTTTTACCCCTTTTTCCTTTAAAACTTCCGCGTGCGCCTTTGCAACTCTCCTTAC +ATTATCAAAGTTAAACTCTTCCGCTATCCTTGCCCTCCACCCATCCGTCCCGAACTTAATCATAATGGAA +TATTGTATTATTCTTTTTCTGCTGCATTCTGCTTTACATAGAAAGGTAATTTTTCGTATATCTTTCTGTA +AAGGTCGAAGGGTCTTCCTGCTAATTGTCCTATATCCCTGCTCCAAGGAGCTAAAGAAAAAGAAGCTATT +TGTTTTACATCTCTTAGATTAAATATTCTAAGTGGTATACGTACAAAAACCCCTTTGTCGTGGTAATTTT +TATTAGGTCCCGTAAAGTCTGAAGTGTCTGAGTATGTATACCAGAACCCAACTTCAAAACCTTTGACTAT +TCTTGATACTTCTATTCGTACACCTTTATCACCGACCAGAAATCTACCTGCTTTCACACTAAACAACAGT +TGTGGTTTTTGAGTCATGTAATAAGCCGATACGTAAAAATCGTAAAAATCCCAGTCTTTTCTAACACCTA +AAAACACGTCTGGCTTCCTTTTCCAGACGTAATCTCCCCCTATCCCCAAAGCAAACCTGCTGTCTCCGAA +AAGGTGTAATACATCTCCCTACTTTAAATAATACACATGCATTAAAAATAGGAAAAAAGCAACTACAACT +TTGTTATAGTGTAAACAGTAAGTGCTGACTGGTATATTATCTGTATTACAAACCAAAAACATATCAAAAA +CTTGCAAATACGCTCGGAATATCAAGAAACACATTCTATAAATGGCTAAAAAGATATGAAAAAGATGGAC +TTGCAGGTCTTTACGATAAACCTAAAGCTCCAGTAAACACAAGAAAACCAACCATAAGAAACAAATGCAA +AGAAAGGGTGGATAAAGCTTTATATAACCTTAGACCTTAAGAGGAGAAAGTAGTGGGGCTTGAGGTAACG +GATGATAGAGTACATGAGGGACAGGTTGATAAGGCAGATAAGGAGGGGAAGAGGAAGTGGAAGGAGAAAG +TGGTGTATGGCAACAGATGGCTTATTGAGAGCTTCTTTTCAACCTTCGAGCGATGGTTTGGAGAGTATGT +AGTGAGCAAAAGGCTTGGTAACATAAGGAATGAGCATGTGTTTAAAGTTGGGATAATGATCATGATGATG +AGGTCAGGTGGTATGAGAGATGGCTGTGGTGGAGTTGATGTGGACGAGAAAATAATCAGGTCAGGGAGAT +CATAACAGATTTATTGGACAGAGCATGGAATTTATAACCCTCTGGGTGATTTTTAACTGAATACCTATAA +ATTCAAATGATTATAAATATTATGGAGCGATTGATTATGAACAGTATCTACATTGACGGACTATTTTATA +AAGGCTCCGGGATAGGAAGATATTATGAGTTTTCGATTCAAGAATTAAGCCAATATGCAATCATTTATAT +ATATGTTCCAATGAAATTTAAAAACGAATTTTATCAACAATTCGGCAATAATGATAAAATTGTTCCAATA +TCCACCAAATATGAAAAATTTTCCTTAAAGGGACTCCTTATCCAATCTAAAATTTTGAAAAGTCTTGAAA +ATAAAGTTTATTTGTTTTTCTTTCCTCACATAAATCTACCTCTTTATATATCACAAAATACTGTTGTAAC +CGTTCATGATCTAAGACCTTTCACAGAGTATTGGGATAGAGGAGAATTCAAAAAACTTATTATTAAAAAG +CTTTTTTTTGATAGAGCAATTAAGTATTCAAAGGCTATAATATCTATATCAAAAACAACTAAAAACGACT +TACTAAAATTTTATTCCGAAGTTCAAAATAAGATTGTGGTTATTTATGAAACATTTAGTATTAATAAAAA +ATCAACAGAGACAAAACAAAATATTGTTGGGGATTATCTGCTCTATGTAGGGCAGTTTAAAAAACATAAA +AATTTAGATAGATTGCTTAAAGCTTTTTCTATGATCAAAAATAAAATTAAATGCAAGCTTGTAATAGCAG +GAAAAAAAGATAATATAGATATCTATAATTCTATCAAAAGCCTCAATCTTGGTGATCGTGTTGTGGTTAT +AAAAAATCCTTCCGATGGCGAGTTGATAAATTTATATAAAAATGCTAAATTTTTCATTTCTCCTTCTTTA +TATGAAGGTTTTGGTTTACCACCCCTTGAAAGTTTAAATTATGATGTCCCTGTAATATTGTCTGATATAC +CAGTATTTAGGGAAATATACGAAGATATAGCAATTTATTTTAATCCTTTTTCAGAAGAAAATATTGCTGA +AAAGATAATTTTTGCACTTTCCAATTATAATAGCATAAAACAAAAAACTGTATCTGAAAAAGATAAAATT +TTCAATAAATTTGAAAAAAGAAAAATAGTAAAGCAGTATCTGGAGCTTTTTAACAAAATTATAAAAGGTG +AATTAGCGTGAAAGTCTTACATCTTGGGAAGCTATGTCCTCCGAATGAAGGAGGAATAGAAGTTTTTTCA +TACGACTTACTTGAATACTTAAACTCAAAAGGTATAAAAGCAGATTTACTATGTTTTGGAAATAGAACAT +TTAATGACGCTTATAGAGGTTTTAACTTTTTTTCCTGCAAAATGAATGTCAAACTAAATTCGGCTCCACT +TTCCTATGACTTTGTAAAAACTTTTAAGAAAATAGAAAAAAACTATGACATAATACACGTTCATTCTCCT +AATCCATTGGCAGAAATTTTGTCTCTTTTTTCTCATAAAAAAGTGGTGGCTCACTGGCACTCAGATATTG +TCAGGCAAAAATTTACATACTTTTTTTATAAACCATTTCAACATATGTATTTGAAAAAAGCAATTAGAAT +AATCTGTACATCTCCACAATATTTACAAACTTCAAAGCAATTAGAAGGTTTTAGGAATAAAGCAGTAGTA +ATTCCCTTAGGCTTAAATCCCAAAAGATTGATGAGCGACTACGTAGATGAAAAATTTAAAGATTTTATTG +AGTTGAAAAATAAAGGAAGAAAAATAGTTCTCTCAATAGGAAGACTGGTAGAGTATAAAGGGTATAAATA +CTTAATAGAAGCTGCAAAATATATAAATAACAACATCTCAATAGTTATCGCGGGTTCGGGACCTTTATTT +CAATCATTAGAAGAAAAAATCGAAACATTGAATTTAAAGGAAAAGGTTTTTCTATTCGGAAGAATTAATA +ATGTGAGCCTTTACATGAAAAATTGTGATGTATTTTGTCTACCTTCTATCACCAGAAACGAAGCTTTTGG +TCTGGTATTAGTAGAAGCATTATACTTTGGTAAACCTCTTATAACTACAGACGTTGAAGGCTCCGGTATA +AGCTATGTTAATCAAAACGGTATAACAGGTTTAGTAGTAAAACCAAAAGACCCAAAAGCACTGGCAGAAG +CCATTAATAAAATTTTAAAAAATGAAAATTTATATAAACAATTTAGTGAAAATGCTAAAAAACGTTTCAA +AGAATTTGAGATATCAAATATAGGAGATAAAATATTAAATTTGTACGAGGAGGTTTTAAAATGATTATCC +GATATCATGCTCCTTTGGGACTTGGACTTGCAGTGGTGTAACTGATCTAAGTCCATTATGAATGGGAAGG +CCGGTGCAAGCAGTAAAGGTGGAAATTTTGTGTATACAATAATTCGCAAAGCTAAGGCAGGAGAACCGCT +AAGGGTGGTTGATGATATATACATGTCTCCTACCTATACCTTAGATGCTGCAAAAGAGATATGGAAAATT +TTACTTGAAAATAAACCTTACGGTATATACCACGTTACAAACTCAGGATACTGCTCATGGTATGAGTTTG +CTGTCAAGATACTCGAATACTCTGGATTGAAAACGGATATAAAACCTGTAAGACATACAGAATTTAAGAC +TAAAGCAAATAGACCACTGTGGAGCCCTTTAGCAAGTAAAAGGGGAATAAAACTGAGAAACTGGGAAGAA +GCTTTAAAGGATTTTATAAATGCTATTTCCATTAATAACCTTTCTTATTAGCTTCTTTCTCTGTTTTCTA +TTCATAAAGTACATTAACCTAAATCTCTTCCACGATACTCAAAAAGGTGTTCAGAAATTTCACCACAGGC +CTACACCCAGAATAGGCGGCCTTGCTATTTATTTATCCGTTCTTTTAGTATCAGTAATCTTCATTCTTTT +AAATAAGCCTTTTTCAAAAGAGTTTTTTCTTTTTATAATGTCTGCCTTCCCCGTTTTTTTCAGCGGACTT +CTTGAGGATATAACAAAAAAAGTTTCCCCGAAATGGAGATTACTTATAGGATTTATTTCGGGAATACTTG +CGTTTTATTTGATTTCCGCAAAAGTAACAAGAGTAGATATTCCTTTTGTAGATAGCCTCCTTTCCATACC +TCTTATTTCTCTTTTATTTACTGCTTTTGCTCTGGCAGGTGTTTCCCATGCTTTTAACATAATTGACGGT +TTTAACGGTCTTGCCTCGGGTGTTGCAATGCTCGTTTTTGGAGCTTACGCTTACGTGTCTTTTTTACATA +ATGATCTTTTCCTCGTTTACTTAAATCTTCTTCTTATCGCTGCTACCTTAGGATTCTTTCTGTGGAATTA +TCCCTTCGGGCTTATATTCCTCGGGGACGGAGGAGCTTACTTTTTAGGTTTCTGTGCGGGAGCCATAGGA +GCTATTCTAGTAAATAAATATCCTGACATTTCTCCCTGGTTTCCCATGTTGCTTGTTATTTATCCTGTAT +GGGAGACTTTATTTTCCATATACAGAAGAAAATTTCTTAAAGATTATCCACCACATATGCCCGATGCACT +TCATTTCCATCAATTGCTTTACAGGAGACTCCTTAAATTTACTCTAGGTTCAAACATAGAACCTTTTAAA +AGGAATTCATACACTTCACCCTTCCTGTGGGTTATGGAACTTATATGTTTAGTTCCAGCGGTTCTATTTT +GGGATAATACTCCTATCTTGATGCTTTTCACATTTGCTTTCATAGTTTTTTATACATGGCTTTACTTCAG +AATAGTCAAGTTTAAAACTCCGAAAATCTTTAGAATTAAATAAATGCTCTTCCTAAAGAACGTTCCCCTT +CAGAACCTTACGACTATAAAAATAGGGGGAAGGGTATCCTTTTACGCAGAGCCTTCCGATCTAAAGGAAA +TTTCCCTATGTATTGATTTTTCAAAATCCCGAGACATTCCTCTTTTTGTTTTGGGTAACGGTTCTAATAC +TATTTTCGGTGACGTAAGAGGGCTCGTTGTAAATTTAAAAAACTTAAAAGGTTTTAAAGTAAAAGAAATT +AAAGGGAAATTTTTTGTAGAAGCTTTTTCCGGAACGCCTTTAAAGGATTTAATAAGGTTTAGTGTAAAGG +AAAATGTAAAGAGTTTTTACAAACTTCTCGGTTTTCCGGCAAGTGTCGGGGGAGCGGTTAGTATGAACGC +CGGGGCTTTTGGGGTTGAGATATCGGATTTTTTAAAGGAAGTTTACTTCGTAGATTGGGAGGGGAAACTC +CAAAAAGCAAAAAGGGATGAACTGAATTTTTCTTACAGAAAATCGCCTTTTCCAAAACTTGGAATAGTTT +TCAAAGTAGTTTTTGAGTTTGAAAGAAGTAAAGAAAATATACTTCCCAAGTACGAAAAAATAAGAAGAAT +AAGGAAAGAAAAGCAACCTATAAACCTTCCAACCAGCGGTTCTACCTTCAAAAATCCGGAGGGTAATTTC +GCGGGAAAGCTTCTGGAAAAAGCAGGTTTAAAAGGTTTTAGACTTAAAAACGTAGGATTTTCCGAAAAAC +ACGCTAACTTCCTTGTAAACTACGGAGGTGGAACTTTTTCGGAAGTGGTAGATTTAATAAATATTGCAAA +GGAAAGGGTTTACGAAAACTTCGGTATAGTATTGGAGGAGGAGGTAAAGCTGATTGAGAGTAGTGGTTCT +GATGGGTGGAAGGTCCTCGGAGCGTGAAATATCCTTGAAAACGGGAAAGGCCGTTGCAAAGGCATTAAGA +GAACTGGGGCACGAAGTTTACGAGCTTGACCTTGATAAGGAACTTCCCTGTAAACTCCTCGAAATAAAGC +CCGATAAAGTATTTATAGCCCTTCACGGAAGGTACGGAGAGGACGGAACCGTGCAGGGATTGCTGGAGAT +TTTAGACATACCTTACACGGGTTCGGATACGATAGCTTCCGCTGTATCTATAGACAAGGACTTTACAAAG +AGAATAGTAAAAAGCCTTGGTATAAACACACCTGACTGGGAAACGTTCATTTCGGAGGGAGATGTTCTAA +ATACAGAATGGAATAAATTTCCCGCGGTGGTAAAGCCGGTAAGAGAAGGATCAAGCGTTGGGCTGAAAAT +AGTGGAAAGTCTTGAAGAATTAAAAGAGTACGCCTTAGACCTCCTTAAAAAAACCGAAAGGGTTATGGTT +GAGGAATTCGTGGAAGGGAGGGACATGACTGTAGGGATACTGAAAGGGGAAGCCCTTCCCGTTGTGGAAA +TAATACCTAAAAAAGGAGTTTACGACTACGAGTGTAAGTACACAAAAGGTATGAGCGAGTACAGAATTTT +AAAAGATGAAAAATTATCTAAAAAACTCCAGGAAATCTCCCTCAAAATTTCTAAATTTCTCTCTTTAAAG +GACTTTGCAAGAATTGACTTCAGAGTGACAAAAGAAGGTAAAATATTTTTCTTAGAGGTAAATACCATAC +CAGGGATGACTGAACTCAGTCTCCTTCCTATGGCAGCGAAAGAAAAAGGTATGGACTTTAAAAAATTAAT +ATCTATAATTATCACTTAAGGGGGGAATATTGAGGGGTATACTTGGACTAGTATTCGGAAGTGTAATCCT +CATATATTTAATCTCTCTGTTCCTTATGAAGCATCCCTTTTTTCAGATAAGGGAAATAAAGGTCAGTGGA +TTATACGTGGAGGAAATAGAAAAAATTGAGAAGGACATTCACGCACTAGGGAGAGGTTTGTTAGTAATTC +CCGAGAGCAACATACTTGAGCTCTTCAACGAGAAACTCAATAACAGGTTTCAGGGAGTAGAGATAAATAA +AAGGTTTTCAACGGAAGGCATAACAATTGAAATGAACTTCCAGAGAAGGAAAGCTATATCTTTTGTAAAT +ATAAACGAAAAAAAATTCCTGATGGATATGGAAGGTATATTCTTTTGGGATGAATACCAGAAACCAGATA +AAACTTTATTCATTTACTCTAAAGAGGTTTTTCAGTTTTTCAAGCAAAAAATACTCAAACTTTTGACACA +GGGAAACTCCGTTAAAGTTTATAAGGATAAAGTAATGGTGGATATAGGTGGAAAGAGATTTATACTCCCA +CCTTTAGAAGATATCAACGAAAAAGAGATACATTTAATGAAAAAGCTTCTAAAACTTCACCCGGATGCAA +AAATATTTGATATCAGATATAAAGGCTTTATACTTTTAAATGAGGGGTGATGAAACGACTAGCTGCATTA +GACATTGGTAGTCAAAAAACAGTATTTGTTATAGGTGAAAGGGACAGTTACGGAGATATCCACATAATAG +GATTCGGAGAAGTCCCTTCCAGAGGTATAGTAAAGGGAGTTATAAACGACCTTTCAGAAGCAAAAGGAAG +TATCCTCAGAGCCATGAAAGAAGCCGAAGCAATGGCAGGTTTAAAGGTAAGGGAGGTGGTTTACAACGTA +TCGGGGGGAACTACGAAGAACGGAACGGTGAAGAGCCAGAACGTAAAGGATACGATAAGTATATCCACAA +AATCGTCAGAGATAGAAGAAAGTCACATTCAGAGACTTCACGAAAGGTGTTTGATGAAGGCGAAGGAAGA +GGGGTATGAAATAGTCTACACAGCACCCAGAAAGTACATTCTGGACGACCACACGGAAGTGAAGAATCCT +TTAGGGCTCGTAGGCTCAAAACTTTCTGTTGAAATGCACGTCGTCAAAGTGAGCACAACTATACTCAGGA +ACTTAGAAAAAGCCATAAGGGAAGTGGGGTTAAATCCTGTGGGGAGAACGGTGAACGCCATAGCTTCAGC +GGATTCAGTTTTAACACATGACGAAAAGGAAGACGGCGTTCTTTTACTCGATATGGGAGCGGGACTTACG +GATTACTCCCTGTATACCGAGGGAAGACCGTACATTACCGGAGTCGTTCCCTTTGGAGGGATTAATATAA +CAAAGGACTTGAGTTACATGCTTAAAATAGACACAGAAACCGCAGAGAGTGTGAAGGTAAACCACGGTGT +GGCTTTTGAGAGTTTAGTTGACGATGAAGATGTAGTGAAGATAAAGCCGAGGGGAGAAGACAGGGAAATC +CCTATACAGAAGAAGCAGGTTGCGGAAATTATACAGAGCAGGGTTGAAGAGATAGTGGAAAAGGTTTTTA +AAGAAATAAAGGCAAGAGGAGTACCGCTGAATCAGATAAACAGCGGGATTGTTGTAACGGGAGGAACAGC +TAATTTAAAAGGAATAAGGGAATTGATAGAGCACATGACGGGGCTTCCAGTAAGGATAGGTTTACCTCAG +GGAATAGTGGGTTTGAGGGAAAAGATAGAAAACCCGAAGTACGCTACTGTTTGTGGACTTTTAAGGCAAG +CTTTTGTAAGCGGGACAATAGATATAACTGAATCTACAAACAGTAATACAGGAAATTTCTTCAAAAATTT +ATCGGAAAGATTTAAGAAATGGTTTGAGGAACTCTTGTGAAGGAGGGCTAATATGGAGGAGTTCGTGAAC +CCCTGCAAGATAAAGGTGATAGGCGTAGGCGGAGGGGGAAGTAACGCTGTAAACAGGATGTACGAGGACG +GTATAGAAGGAGTTGAACTGTATGCGATAAATACGGACGTGCAGCACCTGAGTACTCTTAAGGTTCCAAA +CAAGATACAGATAGGGGAAAAGGTAACGAGGGGGCTCGGAGCCGGGGCAAAACCAGAAGTAGGAGAGGAA +GCGGCTTTAGAAGATATAGATAAAATCAAAGAAATTTTGAGAGATACGGACATGGTGTTTATCTCAGCCG +GACTCGGTGGAGGTACGGGAACGGGAGCAGCTCCCGTAATAGCTAAAACCGCCAAAGAAATGGGAATACT +AACCGTTGCGGTAGCAACTCTGCCCTTCAGGTTTGAAGGTCCAAGGAAGATGGAAAAGGCTCTAAAAGGA +CTTGAAAAGTTAAAGGAGTCTTCTGACGCTTACATAGTAATACACAACGACAAAATAAAGGAACTCTCAA +ACAGGACACTGACTATAAAAGACGCCTTTAAGGAAGTAGACTCTGTCCTTTCAAAAGCTGTCAGGGGTAT +AACGAGTATAGTTGTCACTCCCGCTGTCATAAACGTGGACTTTGCGGATGTGAGAACAACGCTTGAAGAA +GGTGGACTCTCGATAATAGGTATGGGAGAAGGAAGGGGAGACGAAAAGGCGGATATAGCTGTAGAAAAGG +CTGTAACGAGCCCGCTTCTAGAAGGAAATACGATAGAGGGTGCGAGAAGACTTCTCGTTACTATATGGAC +CTCCGAGGACATACCCTACGACATAGTGGACGAAGTCATGGAAAGGATCCACTCAAAGGTTCACCCGGAA +GCAGAAATAATATTCGGTGCTGTTCTGGAACCCCAGGAGCAGGACTTTATAAGGGTGGCCATTGTAGCCA +CGGACTTTCCCGAAGAGAAGTTCCAGGTAGGTGAAAAGGAAGTTAAGTTCAAAGTTATAAAGAAGGAGGA +AAAGGAAGAACCGAAGGAAGAACCTAAACCTTTATCCGATACGACCTATCTGGAAGAGGAGGAAATACCC +GCGGTAATCAGAAGGAAGAATAAGCGGTTGCTATGAGAACCGTAGACATAACGACGAAGATAGAGACCTT +AAGAGAGGCGAAGGCTTACGGCAGGATAAGGTTAAAGCCCGAAACCGTAAAACTGATTAAGGAAAACAAA +GTTCCAAAAGGAAACCTCGTAGAAGCCACAAAACTGAGCGGTATATTCGGGGCAAAGAAAACGGGAGAAC +TCCTTCCATTCTGCCACCCTATTCCCTTAGACTTCGTGGCTCTTGAAGTGAAAGTAAACGAAGATAATCT +GGAAGTATTCTCAACGGTAAGAGGGATAGCAAGGACGGGCTACGAGATGGAAGCCCTGACGGCGGTCACA +ACTGCACTTCTTAATGTTTACGATATGTGCAAGGCTCTTGACGACTCCATGGTAATAGAAGAGGTGAAAC +TCCTCGAAAAGAGCGGTGGAAAATCTGACTGGTTTAGAAGGCTGGACGGAGTGAAGGTGAACCTTCACGC +GGAAAATGAAGGATTAAGGAAAATCGCAGAAGACTACCTGAAAGAACTTGGAGCAACCTTTGCCGAAGAG +GCAGAACTTTACATCTCCATCGGAGATAATCTTCCTATAAACAAGGAAATAAGGTCCCTTGAGCGTGTGA +TTTCCCTTTACGACTTTCGTAGGAATCCGAAAGAGGTGGGAAAGGAGATAAGAGTAGGGTGGTCCGACGA +TGCCCTGATAATAATCCTTCCCGAAAGCGAAGAAAAAATCAGGTTCTTCTTTGAAACCTTCGGAGGTATC +ATAGGAAATCTTTTATGCAGAAGATAGCCCTCTGTATTACGGGTGCAAGCGGAGTAATATACGGGATAAA +ACTCCTGCAAGTATTGGAGGAGTTAGATTTTTCAGTAGACTTGGTAATTTCAAGGAACGCAAAAGTAGTA +TTAAAGGAAGAGCACTCTTTAACCTTCGAAGAGGTTCTTAAAGGTCTCAAAAACGTCCGTATTCACGAGG +AGAATGACTTTACCTCACCTCTCGCGAGCGGCTCAAGGCTTGTCCATTACAGGGGTGTTTACGTAGTTCC +CTGTTCCACGAATACGTTATCCTGCATAGCAAACGGCATAAACAAAAACCTTATTCACAGAGTAGGGGAG +GTGGCCCTGAAGGAGAGAGTTCCCTTGGTTTTGCTCGTTAGAGAAGCTCCGTACAACGAGATACACCTTG +AAAACATGCTAAAAATTACGAGGATGGGGGGAGTTGTAGTTCCCGCAAGTCCCGCCTTTTATCACAAACC +ACAAAGTATAGACGACATGATAAACTTCGTTGTGGGAAAGCTTTTGGACGTTTTGAGGATAGAGCATAAT +CTTTATAAGAGATGGAGAGGGTGAAGTTCAACAGTACGGGAATAAAGGACAAAGAAAAGATTTACGAAAT +ACTGAGAAAGGAAGGGTATTCAGTTTACGAGTGGTACGATTCTCCCGGAACTTACTACCCGACTCACACT +CATCCAGACAGGGAAATCAGGTGGGTGATTGAGGGAGAAGTTGTGATCGGAGCTGAGGGTAAGGAGTTCG +TGTTGAAAGAAGGTGATATGATAGAGCTTGAGCCGAACACTCCCCACTGGGCTAAAACGGAAAAGGGCGT +AAGGTACATATGCGGTTCTAAGTAAAAAAGGAAAGAAAGGATTGCCCCTGCAGGGGCCGTGAGTAGGCTT +CAGAAGGTGTACGAAACGGAAAGATAATAAGTCCTTCCGGGCTCGGGAACCTTTACACCCGTTCTGAAGG +GATTTCTCAAATAAGAGAGGTGCGTATAGTAGAGTTTATCAAACAGGTTGTTAATTCCCGCAACAACCCT +CAGGTTCCTGTAATTAACCCCACCCTTCAAGTTAATTATTCCGTATCCTGAGGTCTTTTCCTCCTGAAGG +TCACTATCTACGTTGTCCTGAGTTGCGGCAAGCACTCCCTCAACCTGTCCAAAGTACATGCCTGTGTCGT +ATCTGAGGGCTAACCTCGCGGTGAGCGGCGGTATTTCTGCTATATCTTTGTCCGTTATGTTTTTTGCAGG +ATAAGTATCGTCCTTCCTTCCCCTAGTGTACGCTACGTTTCCATCAAAGAAGATTGTATCCGTAATCGCG +TAGCTTCCGCTCAGTTCAAAGCCGTAGAAGTATGCGTCTATGTTTGTGTAGGACATGGCTTTAGTGTTCT +GGTTCATCATGTTTCCGCTGGACGGTGCGGTTGCCCTGTAAACGTATATGTAATCTTTAACGTAACTGAG +GAAAGTTCTCAGTTCCCCACTGTACCTTTCTCCAGTTAGTTTTATTCCGAGGTCAAGTTCGTTGTTCCTC +TCTGGGTCCAGTTTGGGATTTCCCACCCAGTCTCCCATCGTATTTTCCATTTTTCCCATCCTGTCGAGGG +CAAAGTAGCGTTCCTGAGGATCGGGAACCCTGACCGCCGAACCTAACCCTGCAAAGAGCTCAATTCCCTC +CTTCAGTTCGTAGAACACCTGAACGTTTCCCGAGGGATACACGTCAGTTTGAGAAGTGTCGGTGGTGTTG +TGGTAATGTCTGTAGAGGTTTATATTTGCCTTTCCTGAATCCGCTTTTGTCTTGGACCAGTCAAGTCTGA +GCCCTGCGACGAGTCTAAGCTTCGGAGATAGCTTTTTCCTGTATTCCCCGTAAAGTCCGAAGTTGTAAAC +GTCAACGTCGGGAATCGTGTTCTGAGTTCTGTACATTCCCATGTTTCTCATGTACATGGTTGTTTGTGCT +TTCCAATACCTGTAAAAAGTATCAATACCGAAGCTGAAATCTCCGAAGCTGTATTCGCCTTTAAAGCCGT +AAACCTTTGACTTTGCGTAGGTTCCCATTGTATACCCGCGGGGTGCGTTCTGAGATATTACCCTTTTTGG +GTTTGTCATCCAGTGTCTGACGGAAGAACCGTATAGTTGGGCCTTAAACCTCTTCCCTTCAAGTCCTAAG +TTTACCCGGTCCACCTCGTCATATATTCCATCCATCATAAGGTAGGGGTAGAGTACGTCTGTAGCCCTCT +GGTGTGCGTAATCAAGCTTAAACTTCACACCATCCGTAATCTTGTACCTGAGTTTTGCCCATGCCGTGTG +TATGTTAAAGGCTGTAGAATCCCTTTCGTCCTGAGAGTAAGCTGAAGGGTTGCCCGAGGGGTATATCTCC +GTTATCTTTCTACCTTTTCCGTCTTCATAGGGCTTTCCGAACCTGAAAGCGTATCCTATCAGGAATGAGA +GTCTGTCTTTTCCGTAAGAGAAGTAAAAGGAAGGGTTAATAGTGCTCCAGTTGTCCGCGTAAGTGGTTAT +CCTTCCTTCCATTCCCTCTTTGGGTTCTTTGGTTTTGACGTTAACCGTTCCTCCTACCGCTCCGTAATTT +CTAACGTCAAAGGGACCTTTTATGACTTCAACACTTTCAACTTCAGAAAAGTCCACGTGGAATATTCCCG +GATCCATCCTGTTTGGACAAGCGTTGTAAACCCTTGCTCCGTCAAAGAGCTGGTTTACCTCGTCCTTTTT +AAATCCCCTGATTACAACGTCGTTCGCTATGGCACCCTTTCTTACTTTCCAGACTCCGGGAATGTTGTAC +TCAAGTGCTTCTCCCACGTCCTTCGCAGGCAGTTCCCTCACCACGTCTTCGGTCAAAACTTCTCTCTTTC +CGATAACTTGAATTTCTTCAAGGTTCACTTCCTGAGCAAAGGCAACCGAAAACAGCGCTCCTAAAAGCAG +AGTTCTCTTCATATCCCACCTCCGTTCATCTTATGTTAATTTTAACAAATTTTTAAACATAATTTAACGT +TAAATTTAACATTGATGGGAGCCAAATACTCCTTCCTCGGATACTTGCTTTCTGGTCTCCTCCACGGAGC +CCTGTTATTTTCCTTGACACACGCAGGTTTAGAAGTGCGCGAACAAAAATCAAAAGAACCCGTAGGACTT +TCCCTGAAAACCTTGCAGATCAAAAAGGAAGAGCCAAAGACGGTAAGTACGATTAAGAAATCTGAGAAAA +AGACAATCAAGAAGGAACAAAAAGTTGTGAAAAAGCCCAAAAAAACTTTTAAGAAAAAATACAAGAAAAG +ACATAGAAGAAAAATCGTAAAACCTAAAAAATACGCTGTTAAGAAAATACACAAAACGGAAAAAGTAAAA +AATGTAATTGCACAAAAACCAAAAAAGGTTACAAAATTAACAGAAAAGAAAGTTATTCATGAAAACAATT +TAGGCTTACACGGAAAAACTAATGTACTGGAAGGGAGTCCAGTAAAAAGAATAAACACTTATGAGCAAAT +TACAGTCGCTAAAAAGACAGAATTTTCGTATAAAAAAGAATTTTTGAAAATCAATTTTGAAAAAATCAGA +AATTACGTTCAGGAAAGGATAAAGTACCCTTACATAGCGAGGCGTATGGGGTGGGAAGGGAAAGTAATCC +TTGAGATTATACTCTCAGAAAAAGGGTGTGAGAGCGTAAGGGTTGCCCACTCAAGCGGTCACAAGGTTTT +GGACAGAAATGCGGTGGAGACGGTAAAGGCTCTTTGTGGGAAGTTTCCAAAACCCAGAGAAAAGATAAGG +TTAAGGCTTCCAATATCCTATGTGCTCAGATAACCTGTTTCTGTAGCAGGGAAGTTCTTTCTTCATCGCG +TACCTGAGTTTTTCTTCCGCCATCACCAGGATGGGCTCGAGTTTTTCGCGAAGAGCTATCAGCACTTTCT +CATCGGGTTTTTCCTGCATGAGTTCCAGAGAAACTGCGTTAAAGAGGGCTTCTGCCATGCCAAAATCAAA +GGGAGCACAGTACTTTCCTTCGTGATTTCTTAAAAACTCAACTCTCCTTTTTAGGGAAAAGTAATCGACG +AGTTCTATAAACTTTTCCTTTTCGTAATGCTTTTCGTAAAAACATTCATCCATAATACCATCGCAGTACT +CTTCGAAGTAAACCCTCGGTTCAAAAGTTATTAACTCCGTTAAGGGTTCTCTCTCCGTGTAAGCACCCCT +CACCGCCTTTTTAGTGTTCTTACTCATTAACGTAAACAAGGTCTTTATCCTGTCTTCTTTGTATTCCACC +GCGTAAAGCTTTATCGCTTCGTAATACCCCTTTACCTTCCCGTAGAGGTATGGTGTTTCCTCCTTTGCGT +TTGCATCTTTCAATTGAGAAAAGAGCGATTCGGCTCTGAGGAGGTAATCGCTTACGAAAGAAAATGAAAT +TCCGAACAGGATAATTAAAAGTAGAAACCTTTTCATATCCACCCCCTTAAATTAATCTATCACGATAGCG +TGCAGACACTTTAAGTAAAGGCTTTCGGGAAAAGTAGGTAAGTAAGGGTGGTCTATCGGCTGGAGGTTCA +GGGATTTTATTATTATCCTTCGTTTTACATCCGTTGAGGCGAGTCTTACCTGTCTAATCATCTCCTCAGA +ACTTATTTGGTAGGTACAGGAGCATATAAAGAGGCTTCCTCCCTTTTTTAGTTTCTGGAAGGAGTAGTAA +GCCAATTTCCATATAGCCCAGAGGATGCTTTCCTTTTCCTTTTTCGTTTTCGCAATTGCTGGCGGATCCG +CTATTATAAGATCCCATTCCTCTTTACTTTCCTGTATAAAATCAAAGGCGTTTCCGAGTACAAAGTCTGC +TTTTACGGAGTTCAGTTTTGCATTTTCCCTTGCGAGTTCAACAGCCCTCTTGTTAATGTCAACCCCCACC +ACCTTAGCGCCCCTGTTTGCACAGTAAACGGAAAATCCCCCCGAATAACAAAAGAGATCAAGAACTCTAT +CCCCTTCCTTAACTAGGTTCCTTACATACTCCCTGTTGTCCCTCTGATCCAGATAAAAACCCGTTTTTAG +CCCCTCCACTACGTCAACGAGAAACTTAAACTCTCTCTCTTCAATAATCAGTGGATTTTCCAGCTTTCCG +TAGAGGAGTCCTTTAAACTCTTTTAGTCCCTCCTCCCTTCTCCCTTTAAAGTCGCTCCTCTCGTAAACAA +ATGCGGGATTGAATTCCTCCACGAGAGTCTTTAAGACTTTCTCTTTTAAAATCTCCATAGGATAACTCCT +CACCTGAATTACAAAGGCGTCTCCGTACCTGTCTATTATTAGTCCGCTCAAGAGGTCGCTTTCCGAAAAG +GCAAGTCTGTAGGCGTTTGAAGGAATGTCTCTTCTCAAAAGTTCACTTTCCCTTAAACGTCGTTTAAAAA +ATTCTTCATTGACTTCTTCCCTTTCGTAGGAAAGAACCCTAAAGGCTATCCGTGAGTAGGGAGAGTAAGT +TCCCAGAGCAAGAAAATTACCTTCACTGTCGTAGAGTTCCGCTACTATCCCTTCTCCTTCAATTTTCTCT +ACTTCATCCCTGAAGACCCAAGGGTAGAAGTGCTTTACTTTCTTTTCTTTTCCCTTCTTTAAAAACACTT +TCATGATGTCATTAAAAAAGTAAATTTTAAATTATGGACGAAGGTGTTAAGGAGAAATTTATCGGTGCGG +TTCTCGGAGCTGCTGTGGGAGACGCCCTCGGAAAAAGCGTTGAAGACATAACAGAAGAAGAGGTATTTGA +GTTTTACGGTGACAGGATAAGGGACTTTGTAACTCCTCACCCTTCCAGTCCTGCGTACGGACAACTCCCG +GAAGAGACCTCCGACGAGACCACGATATTCAGGCTTTTACTCGAGAGCCTGGTTGAAAAGAAAGCCTTAG +ACGTCAGGGACTTTTTAAACAGATTGATGGAGTGGTACGACAGGGAGGAAATGCATAGATACCCTGACCC +TATGCTTCTTACCGCCATAGACCTCCTTTCCAGAGGTATAAATCCATCCACTCACGGACTTACTTCCTTT +TCCGTTGAGGGGATTTTAAGGAGCGTTGCCCTCGGACTTTATCACTACTACAACCCGGAACTTGCAGCGG +AAGGGAGTAAAGTGGTTTCTCTCCTAACTCATAGGAGTGATGTCATTTCCGACGCTTCCGCTATTTTGGG +AGCTCTGATAGCCCACCTTGTGAGGGGAGATTTTTATCTGGAGGACTTTCGTGAAAAGTTAAGACTTATA +GAAACCTTAAAGGATTACGCGAAGGAAGAAAAACATAAAAAAATTCTCGACAGAGTTGCGGAACTCCTTA +TGGAAAGTGCGGACTTAGAAACCGCCATAAATACGCTGGGAAACGGTACCTTTGCTTTTGAAGCATTTCC +CTTAGCACTCTACATATTCCTTTCCAACGTTGAAAATCCAGAAGAGGCTCTCTTTCAGGCTGTAAACTCT +TACGGGGAGTTCGGGGGAGATACGGACGCGATAGGATTTCTCGTAGGAGCAATGCTCGGAGCATATTACG +GCGAGGAGGCCATTCCCTACCACTTAAGAGAAAACGTAGAAAACTCCCAGAAATTGAGGGAACTTGCAGA +AAGGCTCTACGAGGTAGTGGAGAAACAGGTGGGCTTTAGCCAATAAAATTAAAGTATGGAAACCACTCTG +GGCGAAATAGCAAGGATTATCAAAGGAGAACTGAAAGGAAACCATAATATAAAAATCAAGGGCATTTCCA +CACCCGAAAACCCAAAAGAAAACACTGTAGTGTTTTGCAGAAACATGGAAGAAGTGGAAAAGGCGAAGGA +GAAAGCGTCCGCGGTTGTAACTCAAGAAGAAGTTAAAGACTTCCCGCACATAAAAGTAAAGGACGTAAAA +CTCGCCCTTGCTGAGTTTCTTGAGCACTTCTTTCCAGAAGAGCATCCCTGGGGATTTCTCAGAACGCCAG +CATCGGAGAAGGAGTTGAGATAGGAATGGGGAGTTTTATCGGAGACTTTGTCGTGATTGGTAAAAACGTA +AAAATAGGAAGGAACGTAAAGATTTATCCCTTTACTTACGTAGGAGATAACACCGTTATAGGTGATAACA +CGGTTATATTCAGCGGAGTGCATATATACAGGAACACGGTTATAGGCAGAAACGTCAGGATTCACAGCGG +GGCTGTTATAGGAGCGGACGGGTTTGGCTACCACATAACTCAGGAGGGGATTAAGAAAATTCCTCACATA +GGCGGTGTGATAATAGAGGACAACGTGGAGATAGGGGCAAACACCACGATAGACAGGGCGTTGATAGAAA +ACACTTTAATCGGTAAAAACACGAAGATTGACAACCTCGTTATGGTGGCTCACAACTGCAAGGTGGGAGA +GAATAACATACTCGTTTCTCAAGTAGGTCTTTCAGGAAGTGTAAAAACAGGAAAAAACGTAATTCTTGCA +GGACAGGTGGGAGTAGCGGATCACGTGGAGATAGGGGACAACGTCATCGTCACAGCAAAGTCGGGAGTGG +CGAACAACCTCGCTCCAAACAAAACTTACGGTGCTAACCTGCCGGCAATTGAGTGGAGCAGGTGGAAGAG +GATATACGTCTACCTTTTAAGACTTCCAGAACTCTTCAAGAAGATAACTACCTGAAATGTTAAGGGCTTA +CATATTTTACAGGCTTGTAAAGAACACCTTACTGACCGCCTTTATACTTTCCTTAATACTCCTCACACTT +CAGCTTACCCGTCTTAGTAATGTGCTTTTCGGTATTCCCTTTAAAGACTTTATGGGCTTTCTTGTGGTGT +GGAACGCTTACTACACTTACTTTTTCATACCAGAAGGTGTAATACTTTCAACCTTTTTCCTGATGAAACA +CTTCAAGGACAAGAAATTACTCCACGTCTTTTACTCCTTCAGGATTTCCGACTTCAGGATTTTCCTTTAT +TGTTCTATCCCATTTTTAACTTTTTTCCTAATAAGCGCTTTGCTTTCCAACACGCTTTTGGAAGAAAAGG +TAGCCTTTACGCGTAAGAACATGCTCTTTAAGCTCCAGGAGAAGTTTTTTAGTGAAGTTCCCGCGGGAAC +CTTCGTCAGCTTCGGAGCTGTAGTTCTGCATGCGGAAAAGAGGGAAGGAAATACCCTAAAAGAAGCCTTC +TTTAAGTTCGGCGATATTACGGTTCTTTCAGAGTATTTGAAGTATAAGGGAAACGGAGTGTTTGAATTCA +GAAGAGGAACGGTGATAACAGAAGAGGAAAACTACTTTGTCGTAAAGTTTAACGAGTACACACTCAATTT +AAAGCAATTTCAGAAGAAAAAACTCCGTGAAAAACGTCTTAAAGAGAGCAAAGTAGTTAATTACGTAAAC +GTTGCTACACTCCCCTTATTCTTTTTCCTGAGTTTTACAGTAGCCCTGAAGTTCTGCCACGGAGGGCTTT +CTTACTACGCATTCGCGTCTCTCTTCATAGTTGTACACCAGTTGATAATTTTTGTGGTGAAATTAATGCT +TTAAGAGGTTTTTGAGGCCATCTACCACGAATTGAACGGATATAGCCAGAAGGAGTATGCCCGAAATTCT +CGTGATTAAGTTAATACCGGTCCTTCCGAGCACTCTGTAGAAGAATGTACTCAGAGAGTAAACAACAAAG +GCGGTAAAGGAACTCAAGAAAATGGCACAGAAAAGGGCTACTTTTCCCTCCAAAGTGTTTAAGTACCCCC +TCAGGACGAGAACCGTAGTTATGGAGCCTGGTCCAGCAAGTAGAGGCATGGCGAGGGGAATGAGGGCTAT +GTTATCTCTGCGAAGGGCAGCCTCAATTTCGTGAGCTTTTCCCTTTTCTTTTGTAACCTCTCCCTGAACT +AAGTTAAGGGCTATAAGAAAGAGTAAGATACCACCGCCTACTTTAAAGGCTGGAAGGGTAATCCCCATAA +ATCTGAAGAGTAAATCCCCGCTTATTAAGAAAAAGGTGAGTATGAAGAAGGCGTAAACACTCGCCTTCAG +AGCAATAACCCTAATTTCTTCCTTTGAATACTCGTTCATCAGTGATATAACGACAGGAACGCTGGAGAAT +GGGTTCATTATCGCGAGCAAAGATAGGAAAGCTTTTACGAAAAGAACCCCAAATTCCTCCATCCAGGTTA +TTATCATACATATGGAGGATTTTGAAAAAATTCTCCTGGAACTTGAAAATGATAACGTAAGGCACCTGCC +CTACTACCTTTGCAGGGACATACTCTCCGAGGTCAAGTTTTACCTGGAAAACGGGAGCGTAGAACTCAAA +AAGGTGGAGGAACTTCTCTACCTCCTTTCTCTCAACCCTATGGCGAGGGAGGAAGTAGGGGAAATCCTTA +GGGACTTTCTCTTAAGATAAATACTTATGGACGTAATAAGTGAACTCGTAAAGAAAAACGGTTCAAAGAT +TCTCCTAATAGTTCTCGACGGTCTCGGAGGTCTTCCTGTAAAGGAGGGAAAAACGGAACTTGAACTAGCT +AAAACTCCCAACCTTGACAAACTCGTGAAAAACTCAGCTACGGGACTCCACATTCCCGTGGATTGGGGAA +TTACTCCCGGAAGCGGGCCAGGACACCTCGGTTTATTCGGATACGACCCCATAAAGTACCAGATAGGAAG +GGGGATACTGGAAGCTTTAGGATTAGGGATAGACGTAAAAGACACGGATATAGCTGTGAGGGGAAATTAC +GCAACCGTCGAGTACAGGAACGGAAAACCGATAGTGGTAGACAGGAGAGCGGGCAGAATCCCCACGGAAG +AGAATAAAAGAATTACCGCAAAGCTCCAGGAAGCTATAAAGGAAATTGACGGCGTTCAGGTAATAATAAA +GCCGGGAATGGAACACAGACTCGCGATAGTCTTCAGGTTTCCCGAAAAACTGTCTCCCGGAAGCGACGCT +ATAAACGACACCGATCCTCAACAAGTCGGGAAAGAACCATTGGAACCCAAAGGTGAAAACCCAAATGCCG +AAAAAGTTGCCGAAGTTGTTAGGAAGTTCATTCAAAGGGCAACGGAAATCTTAAGAAACGAGCCGAAAGC +CAATTACATACTCCTCAGGGGATTTTCCCAAAAACCTGACATTCCCACGATGGAGGAAAGGTTCGGAGTC +AAACCCTGCTGTATAGCTGTTTACCCCATGTATAAGGGACTAGCGAGCCTGGTGGGAATGGACGTTATAG +AGTTTGAGGGAAGTACCATACAGGACGAGATAGATACCTTAAAGAAGGTCTGGAACGAGTACGATTACTT +CTTCGTCCACATAAAGAAGACCGACTCCTACGGTGAGGACGGGAATTACGAAGGAAAGGTAAGTGTAATT +GAAGACTTTGACGCTCATCTTCCCCAGTTTCTGGAATTAAAGCCAGACGTTCTGGCGATAACGGGGGACC +ACTCAACGCCCTCTATATTAAAGGGACACTCTTGGCATCCGGTACCTCTCCTCATACACTCCCCTTACGT +GCTGGGAGGAACTTCCGAGAGGTTCACCGAGAGAGAATGTCTCAAAGGGGAACTCGGAATAATCCCCGCG +GTGAAGATAACACAACTCCTTCTTGCAAACGCTCTTAGACTCAAGAAGTACGGAGCTTAATATGAAGGAG +ATAAGGGGAAAGAAGTTAAAACTTCTCTTGAAGGAAGAGGACATAAAGAGAAGGGTAAAGGAACTCGCTA +AAGAGATTGAGAGCTCTTATTCCTGGGAGGAGCCCATAGTCGTGGTCGGGCTCCTCAAGGGCGCTTTTAT +ATTCTTGGCAGACCTAGTCAGGGCTTTTGACAGGTTCGTGTTCGTGGAGTTTATGCAAGTCTCAAGCTAC +GGTAAGGGAATGAAGAGTTCTGGAACGATAAAGATAGTAAAGGATTTAGATATGGACATAGAAGGAAAGG +AAGTTCTCCTCGTGGACGACATACTAGACACCGGACTCACTATGAAAGAAATTCACGACTACCTTCTGAT +GAAGAAGCCGAAAGTTTTAAAGACGTGCGTGTTTTTAGACAAAAAGGAGAGGAGGAAGGTGGATTTTAAC +GCGGACTTTGTAGGTTTTGAAGTTCCAGATAAATTTTTAGTGGGATACGGATTGGATTGGGGAGAATACG +GGAGAAACCTCCCCGAAGTTTACATGGTAGAAGATTGAAAAAAATCAGCCCGCGAGGGCAAGATGTCCCT +CACTATATCTTCTTGAAGGGTCTTGAAGTCCTGCCTGATTTCCGAGAACTTTTCAAGTAAATCCAAGTTC +AGTTTTACTTGGTCTCCCTCCTTTATAAAGAGGTCGTAATTCTGAGCGAAGTTGTCTATCTCGTCGTAGT +ATCCTGGGTTCTTGTAAAGGTAGAAGATTTCGGGAAAGTACTTAGATAGTGTAAGGAATATCTTTTCCAT +GTCAACGTGTTTGTGGTTAACGTCAACGTCTATGAAGCCCCTCTTTTCCTTAATCCTTACCCTGTGCCCC +GCCTTTTCTACCGCCATTAAGCTCGCAAAAATGAGGGCTATTGTATCCACTAGGTCTATGTTTATAAAGT +CGTCCCCGAGGAGGTCCCTCTTGAAGGCGTAAGTTATGTCTCCTTCTTTTTCGTCGTAGTAGTAAATGTG +GTTGAGGCCTTCGGTGAAGGTTCTGTAGTGTTCGTACTCAACGTGGGCAATTCTCTCACCCGTTCTTCCG +AAAACGCTAAAGTGAGTACTGGAAAGAAGGTAAGTTTGATAAGCTCCGTGTTCCGCCTTTATGTACTCGC +CTTCGTAAAAGCCGTTTGCGAGCGTGTCAAGCTCATCCGTGAAGTAAATTACCTTATCCTCTGTTATTAC +CACCGGACCTTCATAATCCGCGAGAACCTTCCTCACATCAACGAGAGCCTTTTCCATAACCTTTTCGCCG +TCTTTCCTTATCTTGTAGAGCCAGTTTCCAGCACACACGTAAAGATAATCCTCTATCATGTCGAGGGTTT +TTATAGGCTTTTCAAGAATGTCTGAGACCGCAAGCCTTTCTATTTTCGCCTTTTCAAACCTCTCCGCGTC +CAGTTTGTATATACCCTCGTGGGTTATGAAGTAAACGTCCCTCAGATCGGAAGTAATATCAACGATCTCT +TTTTCAAAGTCAATTTCCTCTGTCTGCCCGCTCCTCCTGTCCATTCTCATCAAATAAGTGGCTCCCGCAC +CGAAGAGGTAAAACCTCGTGTTCGTTAAAAGCGTAGGTGTTTCTGAGAGCTTTGCGGATTGCCACACTAC +CTTCTTTTCACCTTTCTCTATCCAGTCCTTCTTGGATATACCTTCCACTCTGTAGTTTCTCGAGATAAAA +ACCCTTTCTCCGTCCGTGTACATCTGCATTCTTTTGCCCCTCCTTGTGGAGTTTTAGGACTTCTTTTATT +TTAACGTATATTTTTATTTCTTATGGTTATCAGGGAAGCGGTGAAGGAGACTCTCAAAGAACTCATAAGG +ATTCCGAGCGTATCTGGAAAGGAAAAGGGAGTGCTGGAGTACGTAGAAAACAGACTCAAAAGCCTTGGTA +TTCCTCTAAAGAGACAGGAAATAGAAAAGGACAGGTATAACCTCGTTTACGACAACGGTTCGGAGTACCT +GATTTCAGTTCACGTAGACACTGTACCGCCTGCAGGTTTCAGGGACGCTTACAGGCCGAAGGAGGTAAAC +GGAAGGATTTACGGGAGGGGAGCGAGCGACGTTAAAGGCGCAATAGCGAGCTTAATTACCGCGGTTGAGT +GGTTCAAAAAGGATTTTCCCGAAAAGGAACTGCCCGTTTCCCTTGCTTTTGTCGTTGACGAGGAACAAAA +CACGGCCCTTGGTTCTGAAAACTTGCCAAAGTGTCTAAACGGAAAGAGGAAGTGTATAGTCCTTGAACCC +ACTTATGGGCTCGTTTGCACGAAGCAGTATGGAGCTTACGAGTTTTCGGTAAAGATAAAGTGCAAATCCG +CCCACGGTTCTGAGTTCGAAAAGGTTGAAAATCCCGTAAAGGTATTTATAAAACTCCTAAACAAACTCGA +AGAAGTCCTGAAAAGGGAAGTAAACGTAATAATGGTAAGGAGCGGCACGAAAGTCTACACCGTTCCCAAA +ACCTGTGAAGCTCTCCTAGAGTTTAAGGTTTTTGAAGGGGAAAGGAAGGAAGAGCTTGAGAAGAAGGTTC +AAGAGGTGGTGAGTGCTTTAAACACAGAGTGTGAAATCACTGTAAAACTGGAAGGCTTTGAGGAGTTTCA +GGAGTTCAACACGGACGGACTATTAGATGTGGTTAAAAAGGCTCTTTTAAAAGGTGGAAGGAGAAGCAAA +AGGAAGGGATAATGCCTTCCTGGACTCATGCGAGCAATTACCATAAGGCGGGATACACTGCCTGGCTTTT +GGTTACCGGAAGCCTTATAGACAGTCACACGGACAGGGAGAGTATATCCTTAGATGAGCTGGAAAAGTTT +ACGAAGTTTTTCTACGAGCTCTTTAAAGAGTTATCTCCTTAGCTCTTTTCTCCTCACTACCTGCAGAAGG +TTGTGGGCGAGTCTCGTTGGCTCGGGAACTCTGTACTTGGAAGTTTTGAGAACGAGGTCAATAGCTGTTT +TCAAACTTATCCTGTGGCCCACGGAGACGTAAACGGGTGCTGTGTTGTCTTTTGTCCTCACAACCGCTCC +TATAATCTTTCCTTTGTACTTCAAATATGTGTAGCTTCCCCTTTGAGGAGCTGGTTCTTTTGCATATCCG +AAGAGCTTTGATTTAGCAACACCTACGGTAACCTCACCCGTCTCAACTCCGAAGTGTGAGGCAATACCGC +AACCCCTCGGGTGGGCGATCCCCTGACCGTCTATAAAGTAAACGTCGGGCTTTACCTTTGCGGTTTCGTA +GAGTTTTAAAAGAAGGGGCATCTCACGAAAGGCCAGAAATGTAGGAATGTAGGGAAAGTCTACAATGTCT +TTCACAACGTGCTGGTAAACGGGTTTTAGCGTTTTTAACTCAACTACCACGAGGCTTGCCCAGGCACGGG +TGGGGTTTTCGTTTATCTTTTCAAAGGTGAGATCCATACCCCCTATTGTTTCTACCTTCTCAAAGTCATC +CCTAGCTATTACCTTTTTCGCACACTCTAATTGTATTTTCTTTAACTTTTCAAGTAATTCAGTGTTTACT +TCTTTACTAATTTCCTCTCCTCCGCCAGTTCGAGGAAGTTCTTAAGGATTTCCATTCCGTGTTCCGAGAG +CACAGACTCGGGGTGGAACTGAACCCCGTAAACGGGGTACTCTTTGTGCTCAATACCCATGATTTCTTCA +TCGTCGGACCAAGCGGTTATCTTTAATTCCTCAGGAAGAGTATTTTTATCTATAACCAGGGAGTGATACC +TTACCGCGGTAAAGGGGGAGGGAAGGTTCTTGAAGACTCCTTCTCCCGTGTGGAATATCTGCGAAGTCTT +CCCGTGCATTAATCTCTTTGCCCTCACTATCTTCGCACCGAAGGCATAACCTATGGACTGGTGTCCGAGG +CAAACCCCGAGAATAGGGTATTCTTTGTAATAAGTTTTTATCAAGGGAACGGATATTCCCGCTTCCTTCG +GAGTGCAGGGTCCCGGAGAAATTACTATGGCGTCGGGGTTTATTTCCCTTACTTCTTCGAGTCTTATCTG +GTCGTTTCTCCTCACGATAACATCTGCACCCAAGGATCCTAAATACTGAACCAAGTTGTAGGTAAAGCTG +TCGTAATTGTCTATCATTAAAACCTTCATCTGTCCGTTTCTCCCACAACTGGGTCAATGCTTGCAAGAAT +AGTCACCGCGTCGGCCACGTACCTGTCCTTCATAAGGTGAGGGTATATACACAGATTGTAGTAAGAGGGT +GGTCTGATTTTTACTCTGTAGGGAGACGTTCCGCCTGTAGAAACCACGTAAAATCCGAGTTCTCCACGCG +GGTTTTCTCCCGAGGAGTATATCTCGCCCACGGGAGCTTTCACACCTATCCCGTCAAGGGAGAGTTTTAA +CTTCTTTCCTTCCCCTTCGTAGAAGAAGGGCTCGTTCTTGGACATCTTCTCAAGCTTTGCCACACACTGC +TCAATTATCCTTATACTTTGCTTCATCTCCTCTATACGAACGAGATACCTGTCGTAGCAGTCCCCTATCT +CGCCCACGGGAATGTCAAACTCAACCTCGTCGTACGCGTCGTAAGGTTCAAACTTTCTTATGTCGTAGGG +AATTCCTGAACCCCTGATTACGGGTCCGGTGACGCCGTGGAAGTAGGCGTCCTCTTTTGAAATTATTCCC +ACTTCTTTGTTCCTCCTGAGCCATATCCTGTTTCTCGTGAGTATAGTCTCCCAATCTTTTAGTTCTTCGG +GGAACTTCTTTATGAAAGCCTTTATAACTTCAAGGGCTCCCTCCGGAAGGTCCATTCTAACCCCGCCTAT +CCTCGGGTAAGAAATAGTGAGCCGTGCCCCCGTTATTCCCTCAATTATGTCCATTATCTTTTCCCTTTCC +TTGAAGGCGTAGAGGAATATGGTGAGAGCTCCGAGGTCCAGGGCATACGTTCCGAGCCAGAGCAGGTGGG +AGTTAATCCTCTGGAGTTCAGACATCATTGTTCTTATGTACTTGGCTTTCGGCGGGACCTTGTCGTGTAT +GCCCATGAGCCTTTCTATGGCAACTACCCAAGCCTGATTGGAACAAAGGGCGGACAGGTAGTCCATACGA +TCTGTGTAAACGAGGAACTGGTTGTACATCTCGTGCTCTGCGAGTTTCTCAACACCCCTGTGGAGCTGTC +CGAGTATTACGTCGGTCTGAACTATTCTTTCACCTTCAAGGTCGAATAAGAACCACATAGTTCCGTGGGT +TCCTGGGTGAAGGGGTCCCCAGTTGAGAACTATCTGAGCCTTTTTCTTGAGTCTCTTCTTTTCCGTAACC +TCAAGGTCTTCAAGCGTAGGAACGCGGGTGTGCATCCTGTCGTAATTCATAAGTCCTTCGAGGTTGTCTC +CGAAGACTACTTCGTTCAGAGATGGAAGTTCCTGCTCGGGTATTCCTTCAAGGGGGAAGTCTTTTCTTAA +GGGAAAGTAAGGGTATGTATCCCACATAAAGGCACGAACGAGGTTTTCGTGTCCCTCGTACTCTATTCCG +AACATGTCGTAGCATTCTCTTTCCGCCCACTTGCCCGCAAACCAGAGTTTTTCTATTGTGGGGAGTTTGC +CGTTCGTTCTCGTCTTTACTATTACCCTCTTCCTTTCGTCCACGTTGTAGAGTATGTAAAAGGCCTGAAA +ACGGGATTCCCTGTCTTCGGGAAATGCTATGAGGTTTTGTTTGACTACCTTGTTGAACTCCTTCTCGTTT +TCTAGTAAATCCTTTAGATCAACCACGGAGTGATCCAGGAATAGTTTGTACCCTAGTTTTTCCTTTAAAT +ACTTGAGGACATCTATTAGAATATCCTTAGGAACGATAACGCTTGTGGAGTTCTGGAGTTCCACTACGCT +TGCCTGCGGAAAGGCTTTTAAGAGTTCCTGAAGGTCTCCTTCCTTAGCCCACGGCATTCTCTTCCTCCCT +GAAATTAAACCTTTATTAATAATAACGACTTTAAAACAAAACTTCTATGGCTTCCTGAATGTGGGAAACA +GGGTATATCTCCATTCCATCTATCTCTATTTCAAGACTCTTAGGAATTAAAGCTTTTTTAAAACCAAAGC +GTTTTGCTTCTTTGAGTCTGAGGTCTCCGAAGTGAACCGCCCTTATCTCTCCCGAAAGTCCCACCTCCCC +GAATATTACGAAGTCTTTCGGCACTTCCTTCTCTTTCTTTGAAGAGACTACCGCCATGGCAACGGCGAGG +TCCGCAGCGGGTTCCTTTACGCTCATTCCTCCCGCAACGTTCACAAAAACGTCCTGGTCTCTCGTGAAGA +TCTTCGCCTCCTTTTCAAGAACTGCAAGGATAAGGGCAAGTCTGTTCGGGTCAAAGCCTTGAGTTCTCCT +TTGAGGAGTTGTGTAGAGGGCTGGAATTACGAGGGCCTGAACCTCTAAAAGCACGGGTTTGCTCCCTTCT +GTGTGGGGAAACACAACACTTCCGGGGGCGTTTGCCTTTTCGCTTATAAAGAAGGCTGAGGGCTCCGGAA +CTTCTTCTAAGCCTTTGTCCGTCATCTTAAATACGGCAATTTCTCCCGTAGAACCGAACCTGTTTTTAAT +TACTTTAACTATCCTGTAGAAGTTGAACCTCTCTCCCTCAAACTGTAAAACGGTGTCCACTATGTGCTCG +AGAACCTTAGGACCCGCTATACTTCCCTCTTTCGTTATCTGACCCACGATAAAGGCGGGAACGTTTTTCT +CTTTACAGAATTCCGTTATCCTGTAGGTGACTTCCCTTACTTGACTAACAGAACCTGCGGAGCTCTCCAA +CCTTTCGGAAAATATTGTCTGAACGGAGTCAAGCACCAAAAGAGAAGGCTTTTCCTTTTCTAAAGTTTGC +AAGATTTTCTCAAGGTTTACCTCGGGGTAAACGAGGAGGTTTTCGTTGTTTATTCCGAGCCTTTTTGCCC +TGAGGGCTATCTGTGTTCCCGATTCCTCTCCCGACACGTACAGGACCTTCTTCCCGTTTGCAACCCTGTC +AGAAATCTGGAGGAGTAGGGTTGACTTCCCTATTCCCGGCTCTCCCGCAATGAGTATTACCTGACCCTTT +ACGAGTCCTCCTCCGAGGGCGTTGTCAAGGCTTTCAAAGCCAGTGGTCTCCCTCTCGTGTTCTTCCTTTT +CCCAATCGGTGACGGGAAGGACTAAAGAGGGTTCCTTTTTTACCAGAGAAAAACTTTGAGGTTCGAATTC +TTCCACTAAGGTGTTCCACTCACCGCAAGAAGGACACTTTCCGAGCCACTTTACGGACTTGTAACCGCAC +TCCTGACATACGTAAGCGGTCTTGTTTTTTCCCATTAGAAGGTTTAAGATATTTCGCTTTTCACAAGCAT +CAATTCCCTTATAAGTGTTGCAGGCTCAACTTCCTTCGGGCACGCGTTGTTACACTTGTTACACGAAAGA +CAGTGGTAAAGGTGTCCTTCAAGGGCTTCTTTTATCCTGAATTCTTTGTCTTCTTCTCTTGGGTCCTCCA +AAAACCTGTATATCTTTGCAAAAAATAAGGGACCGGCGTATTCCTCTTCCAGAACCTGAGGGCAGTAGGA +CTGGCAGGCGGAGCAGAGTATGCAGTCCGCCCCCTTTTCTATCTTTTTATTGACTTCGGGTGGTATTCTT +ACCTCTCCCTGATACTCCTTTATCCACGTTCTGAACTTCTTCATTCTGTTTATGACTTCTTCGTTGTCCA +CGACGAGGTCCCTTATCACCTCGAATTTATCGAGAGGCTCAACGGTTACAATTTGTTCCGAAAGGACGTA +AGGGAGCGTTTGCTCTTTGCAAGCAAGCTTTGGAAATCCGTCTATAAAAACGGTGCACGTTCCGCAAATT +CCCGCTCTGCAAAAAGCCCTAAAAGAAAAGCTCGGATCTATCTCTTCCTTTATCTTTTGAAAAGCCCTTA +AGAACGTCATTCCTTCTTCGTATGGAACTTCAAAGTAATCGTATTTCCTCTCTCCCGTTTCGGGGTTATA +CCTGAAGACCTTCAACTTCAAATGCATAAATAACATTTTTAGTCTGGGGGATAAATTTTTCAAACGGAAT +TTTAATTTTGAGGGTTGTACTTAACGAGGCGTTTAAGTTCTTTTACTTCTTCTTCCGTCAGTTCTCGCCA +CTCTCCTGGCTCCATATTTTCGTCAAGTCTCAAATTTCCTACCCTCGTTCTCTTTAGGTAAACCACGTTG +TGACCTACGGCTTTAAATAATCTCTTCACCACGTGATGCCTGCCTTCCGTGAGGATTGCTTTCACGGTAT +CTCCCGAGAGTTTTTCTGCTTTAACAAGCTGAACAGGTTTTTCCTCGAGTTTCACTTCGTAGAGCTTTTT +TAATTCTTCATCTCCGATATCCCTGTCCAGTCTAACGATGTACTCCTTCTCTACCTTCCACTTAGGGTGG +GTGAGTCTGTGGGCGAGCTCTCCGTCGTCGGTTATTAAGAGTAGTCCCTCTGCGTCCACGTCAAGCCTTC +CCGCTGAAAAGAGTTTCCTGCTCGGAAAGTGTTCCCTTATCAGCTCCAGAAAAGAAGGATATTTCTTGTC +TTCTTCTGTTGTGGAAAGATAGCCTTTCGGTTTGTAAAGCATAAGGTAAACGTTCTTTTTAGGTTTTACA +CTCTTTCCCTCTACCTCTACCTCTTCTCCCTCTTTTACTCTGTACTCGGCCTGTTTTACGACTTTCCCGC +TTACCTTTACTCTTCCCTCTCTTATGAGTTCCTTCGCCTCCTTTCTCGATATGTGGAGGGACTTGGATAA +GTACTTATCAAGTCTCACAATTTTTAATATACAATCAAGTTTTATGAGGATTTTTTTACTTTTCCTGTTC +TTCGTTCTGTTTACCTTCGGTGTTGAGGGTTACGTAATAGAGGAGATAAACGGGAGCACGGGTCTTCGCA +TACACAAGGAGATAAAGAGAAAGGTTTACATAACGGAAGACGCCTTGATAACGGAGACGGAAAAGGAATT +CATGGTTCAGAAAATAGAAAACGGCCTTCCGAGAATATACAGAGTCATAAAGAGCTCAAAATCCTACATG +GACTTTTCAAAGATGACGCCTCTTTTCCTTGTGAGTCTGCCTTTTCTTGACTGCAAGCAAAGGGTTTGCG +TGGTAAACAGGGGTGCTTTCAGACCTACAAACGAATACAAAAAGATAAGGGGCTTTAAAGCGAGGAAAGT +CGTGGTAGAGTCCCACGCTCTGGGGAAGAAAACGACACTTATTCAGTGGTACACGAAAGAATGGAAAGAA +CTCGTTGAGGCAAACAGACTTGAGGATAAATTTTACGTAAACTTCATAAGGGCGATTATGAAAGAGAAAA +ACTTAAGCGAAGCGAACATTCCCTTAAAAGAAATACAAAACTTCCTGAAGGAGATAAACGAAAAGTTCGG +TGGGGTGGTAAGGACGCAGCAGCAAATGCCCTTATTTAACACTTATTCCGAAGTTATATCCGTTAAAAAG +ACTGAAATTCCAGATTACATATACAAACTACCGGAGGGCTACACTAAGATAAAGTAAGATGGAATACCTT +CGGGTTTATCAGAAGAGGGAGAGGGTTTTCAAAAGAAGGGTCATACTCTTCGTGATTTTAAGTTTTTTAG +CGGTATTACTCCTTTTAGGAAGGATTTTATATATAAACCTTTTTAAGGAAGATGCACTGAAAGGAGCCGT +AAAAGACGCAGAAGTAGTTCAGATCCAGACCTACCGCGGGAGCATAAAAACCTCTGACGGAAAGATCCTT +GCACTCAGTTATCCCGTCGCTTACGTCTACGCCAGCAAGTTCTATCGCTTTCGGGATACGGTAAAGAGGG +AGAAATTCATTAAGGAATTATCAAAATTACTGGGTGTTAGAGAAAGTGTTTTAAGAAAAAGGATAAAGGA +AAACGAGAGTAAGACCTTTTTTGAGTTAATAACCTTTCCCGTTCATTTGAAAGACGAAGTCAGAAAGCTC +ATAAAGAGTATAGATTACGACGAAGAGAGTAAAGAGTTCACAAAACCTTACCTCAGTTCCTTTGTGGGAG +TGGATGAGCGTTATAAGAGGTACTATCCACACGGGAATTTTGCCTCAAACCTCCTGGGCTTTGTAACGGA +AAAGGGCTACGCCGCGGAGGGTATAGAGAGGCTGTTTGACGAGTACCTGAGGGGAGGAGAAGAACCGATA +AAGTATTTAGTCTATAAGAATAAAGGAATAACGGTTGTGGAGTCTTTAGGAACGCAGATATACACACCGA +AGGACTTAACCCTCTCCATAGACTTCAGAGTTCAAGCACTTCTGGAAGAGGTTAAGAAAAGAATCGTAAA +GAAGTGGAGACCTAAAAAAGTAGTCCTCATAGTTATGGAAACTTCTACGGGAAAGGTTAGAGGCTACACG +ACCTATCCCGACTACGATCCAAATAAATACGAACGCTACCCTTACTGGAGGATAAGGAATTTCGGAGTGA +CGGACAGGTTTGAAGTGGGTTCCGTATTCAAGCCCTTTTTAGTAGCGTTCGCTCTGGATAGGAGAAAGAT +AAGGAAAGACACTCTTATAAACATAAACTACGGGAAGATAAAGGTTCATAAGAAGTACGTGAGGGACGTT +ACACCTTACTTGTGGAAAAAAGAGTACATAACTCCTAGGGAACTCTTAGTCCACTCCTCTAACGTGGGAG +CTATAAGAGTTGGTCTTATGCTAAAGCCGGAAGAGTATTACGAACTATTTAAAACCTTTAAACTTTTACG +TTCTCCCGGAGTTTTAGAAGGGGAAGTTAAACCCTCTATTTCTGATCTGAAGTATAAAGTAAACAGGGCT +TACGCTTCGATAGGACAGGGTGTGGCTTTTAACCCCCTTCATTTGATAACTTCCTTCAACGCTCTCGTAA +ACGGAAAGTACGTAAAGCCTTCCTTCGTGGAAGAAGAGAAAACGGAAGCAGAAAAAATTCAAATAAAACC +CTCAACCGTAAAGTGGATCAGGGACGTGCTCATAGAAGTCGTTGAGAAGGGAACAGGAAAAAGGGCTAAG +AGCGAGTATTACTTTGCGGGAGGAAAGACTGGAACAGCTCAGAAGTACGATTCAGCTCTTAAGACGTACT +CTAAGGAAAAGCTCGTAACTTACTTCCTCGGATTCTTTCCTTCAGAGCCGAAGTTTACGGTTCTCATCCT +AGTTGACGAGCCCAAGGGAAAAAACCTTTACGGCGGTACTGTAGCTGCTCCATATTTCAAAGAGATTATA +GAAAAAATCGGAGTTATTTACGGAGTGAAGCGGGATAGAACGTAGTCGGCGAGTCCAGTTCTGATATCTT +TTGGTAGTTCAACATCTTGAATTCTGGGAACTTTGTAAGGTTTTATCCCCGTCATTTCTTCTATTATTTG +AGGGTTTGTTCTCTCCGAGACGTCCTCACCCGTAAAGCCGTTCAGGATTATTCCGATGACCTCAAGCCCT +GTGGCTTTTGCATAGTACCACGTCAGGAAGGTGTGATTTATCGTTCCGAGTCCTGCTCTACCGACAATTA +GAACTTTCAGTTTCCAGTCCCTTGCAAGATTTGCGTAAGTGTAATTTTTCTTTATCGGAACCGCTATACC +GCCCGCTCCTTCAACGAGGAGAAATTTGTACTTTTTGGAGAGTTCTTCGTAATGCTTTCCTAATTCTTCC +AATGCAAAGTCCCTGCCTTCCTCGAGGGTAGCCGCATAGGGAGCTAAGGGAAGGGAAAAGCGAACGGGAA +CAATCTCGTTAACACTCTGTCCCGTTGCCTTTGAAAGGAGTGAGCCGTCTTCCGGAACTTCCCTTACGTA +AGTCTCTACCGGCTTGAGACACCCGACTTTGTAACCTCTTTCCTTTAACTCCTTTGCAAGGTTGTAAGTT +ATAAAGGTCTTTCCTACTCCCGTGTCCGTTCCGGTGATAAGGAGTCTCATACCTTACCCATCAGCATCAG +CATTCTCAGGGTTTCCTGGTAAGCCCTCTTTATGGATTCTGCTGCCTTTTTGACGTCCGCAAACCCGAGA +ATTCCTGAGGAAACCGCTATATTTCTGCACCCTGCTCTTACCACTTCAGGAACTCTGTACGGCATTATTC +CGCCTATGCAAACTATGGGTTTCTGGGAGATCTTCACGGCTTCCTTCAGGGCTTCTACACCCACGAGTTT +GTAGTTTTCCTTCGTAGACGTGTGGTATATGGAACCAAAACCTATGTAGTCTACGGGAAGTTCCTGCGCC +CTCTTGACCTCTTCAAGACTGTTTGCGGTGTATCCTATGTACATCTTATCTCCCACTATTTTCCTTACCA +CTTCGGGGGGAAGGTCGTCTTTCCCTATGTGGACGCCGTCCGCCTCTACCGCGAGTGCCAAGTCTACCCT +GTCGTTTACCACGAGGTCCGCGTTGTACTTTCTGGTGAGCTCTCTGAGTTTTACGAGTTCCTCGTACATC +TGTCTCGTGGTTTTGTTTTCAAACCTGTACTGAACTGCGGTAACACCGCCCTGAAGTGCTTGCTCTATAG +TATTGAAAAGGTCTCTGTCCTTGAAGTACTTGTCGTCAGTAATCAGGTATATGGTTAAGTTCATTGGCTA +CCTCCAGAAATTTTTCAGTGATTTAAATATATCACTTAAAGGCTTCAACGAGTTCTTTAGCACCTTCCAG +AGTCTTTTCACTCTTCATACCCATCAGTCTCGCAACCTCTTCTACTTTTTCCTCTTCCGAGAGTTCCCTC +ACTACTATGTATGGTATATCTCCGAGGAACTTCTTTTCGGTTTTGAAGTTCTTGTCTCCCGCTGCACAAA +GGGGTGCGGAGTGGGTTATGACTATCACTTGCATCTTTTTAGAGAGTTCCTTTAAGAATTTAGCTACTTT +AAAGGAAGTCTCACCGCTTATCCCGGCGTCCACCTCGTCAAAAACGTAAGTCTCGCTCGCGGGAAGGATT +AAGGAAAGTGCAAGGAAAAGACGCGAAAGTTCGCCGCCGGAGGCAACCTCTTCAAGAGGTTTAAAGTCCT +TTCCGTAGGAGGAGAACAAAAACTCTATTTTGTCCTTTCCGTACTTCGTGGGTTCACTCTCTTTAATTTC +CACTTTGAGCTTTGCCCTCTCTAAGTTTAATTCTTTCAGTATTTCCTCAATCCTTTCCTCAAGGTCCTCC +GCTTTTTTCCTTCTATCTCTTGAAACTTCTTCCGCGAGCTTGTCATACTCCTCCCTTAACTTTTCTACTT +CTTCCCTTAACTCCTCCTCCTTGAAATCCACAGAATTCAAGTTTGATAATTCTTCTTTGATTTCCTCAAC +TTCTTTTAAGATTTCTGGAAATGATTTTTTGTACTTCTCTTCAAGTCTCTGGATTCTGAAGAGTTTTTCG +TTAATTTCGTTTACTTCTTCCTCAGAGATTTCAGGCATTTCCTCCTTCAGGGAGTTGTAGAGTTCGTAAA +CTTCCTCTTCAAGGTTTGCTATTTTTTCTATCAATTCCGAAAATTTACCTGAATAACTTTCTACCTTTGC +GAGATTTTTCCTGATTTCTCCGAGAATTTCGTAAACGGAGTTTTCACCCTCGAGGAGTTTATATAGACTT +TCTCCTACCGCCTTTTTGACTTTTTCGAGGTTGTTTATTAAATTCGCTTTATTCTTCAGCTCTTCGTACT +CTTCAGAGCTTATTCCTATCTCTTCAACCTCCCTTACTCTGAACTCAAGGTAGTCCTTTTTCTGGATTAA +TTCCTCTTTTTTCCTCAAAAACTCGAAGAGTTCCTGTTCCTTTTTCCTCAGTGAGTTGTAAACTTTTTCA +AGTTCTTTTACTTTATCGTTCAAGTTTGCAAAGGTGTCAAGGAGTTTCCTCTGGAAGTCTTCCCTGAATA +GGTTTATAAACTCGTTCTGTCCCTGAAGGGAAATCTTTCCTTCTAAGAGTTCCAGAACCGTGCTCTTTGA +AGCTCCCTTTCCGTTGACGTAGTACCTGCTCCTTCCCTTCTTTACCTCTCTTCTTAGGATTATTTCTTCT +TCACCGAGAAGTTCAAGCTCTACCGCAGTTCCCTCGGGGTAATCGCCTTGTTTTCCCATGAGGAACTCTA +TTGCGGATATGGTCATGGACTTTCCTGTTCCCGTTTCTCCTGTTATGACATTGAGCCCCCTTTCAAACTC +CACTTCCACGTCTCTGATAAAGAAGAAGTTCTGGATGTAGAGCCTTCCGAGCATGGTGTTTGAGAGCCGG +CGGTGGGATTCGAACCCACGACCTCAGGCTTACGAAGCCCGCGCTCTACCGCTGAGCTACGCCGGCTGAG +TATATTAATTTAAACATTCATAATTTCCTTTTCAACACCTGAAAAATTCGGGAAATAATTTAAAGTATTA +AATTATTGTGAGACACAATTTATTGTTAAAACTCCTCGCTCTTTGGGGAGTATCCCTTACGATCCTACTC +GTATTCGCCCTTATCTTTATAAGAAAGTCCACCTTGAAACCTGCAAAAGACAGGGCTTTAACCACGGCAC +AACTCGTGAGGGATGCCCTCACCACTCTTATGGTTTCAAACGCTATGGACAAAAGGGAAATTTTCTTAGA +GGAAATTAAAAAGGTTCAAGGACTCAAAGAAATTCGCGTAATAAGGGGGGAGGCTGTAGTAAAGCAGTAC +GGTCCGGGACTTTACTCGGAAAGACCAAAAGATCCTCTGGAAAAGGAAGTTCTCGCCACGGGCAAGGTAA +AGGAGGAAATTCTGGAGGATATTAACAGAGTTTTGTACAGGGTTATAATACCTTACAAGGCGGAGCCTTC +ACCCATTTTAAACTGTATGCAGTGCCACAAAGTAAAGCCCGGAGAGGTTCTCGGAGCTGTCTCCATTACG +ATGGATCTAACTCCTTACAGGAATTTCGGCTTTTTCATTTTCTTCAGTCTCGGTGCTATAGCCCTCACGG +TGGCTTTCATTACTTTCCTTATCGTTTACGGAAACATCAAGAACGTCAGCACATTTATAGACGAACTGGA +CAAAGTCTTTTCGGCTTTTGAAAAGGGGATATTCTACGAAAGGCTCAGTTTGGAAACCTTAAAAGGTGAG +ATAAAAGATTTCGGAAAGAAGATTAATAAAGTACTGGACATACTTGACAACGCCTTTAAGGATATAAGGG +AAAAGGTTTACGCACTCCTTGGATACTCAATCATGGAAACGGAAAACGAACTGAGGGACACCGAGAAAGT +AATAGACGAGCTCGTGAGGATTTCTCAGTTCAAGAGAACGATAGAACTGGACAACTCCCTTGAAGAGGTT +TACAAGAGGCTTGAGAGCGTTCTTTCTAACTACATGAGTCTAGATAAGTTCTCTATATACGAAGTGACCG +ACGACAACAGGATTAAAAAGGTTGCCGTACACGGAAGAGAACTCTGGTGTTCGGAAATCATACTGAAAGA +CGCAAACGAGTGCAGGGCAAAGAGAACGGGGCAGGACGTGGACTCAGAAGAGTTCGAGTGTGTATGTCCA +AACTTTGCGTACTGCGCTAACGAAAACTCCAATAAAAAGTACTGTTACTACTGCATACCTGTTAACGTAG +GAGGAAAAATAGGAAACGTGGTTCAATTGGTTTATGAAAGGGAATTGAAGGACTTCGTGAAGCTCCTCAT +TCCTTACATAAAAGGGTACTTAAGGGAAGCGACTCCCGTTATAGAGTCCAAGAAATTAATGGAAAAGCTC +AAGATGCAGTCTTACATAGACGGGCTTACCGGGGCTTTTAACAGGCGCTTTCTGGAAGAAATAGCGGACA +AAATAGTGGCTCAAACTCTGAGGAGAAACTCAAACCTCGGCATACTTATGATAGACGTTGATTTCTTTAA +GCAGGTGAACGACACATACGGACACGACGCGGGTGATGAGGTCCTGAGACAAATAGCAAGGGTAATAAAG +GATAACATCAGGAAGGCGGATTACTTGATAAGGTACGGAGGAGAAGAATTTTTGGTTCTCCTTACAGATG +TAAAGGAAGGTTACGCTGAGAAGGTAGCAGAGAAGCTCAGGAAAATAATTGAAGAAACGCCGATAACACT +TCCCAACTGTCAGACTATCAGGAAAACAGTAAGCATAGGGATATCCGAATTTCCAAAAGATTGCGAAGGA +AAGTTCTGGAAGTGTGTTAAATTTGCAGACGTTGCCCTCTACAAGGCTAAGGAAGAGGGGAGGAACAGGG +TGGTCCGCTTCAAGCCCGAAATGTGGCAGGAGAAGGAGTATTAAAATAATCCCGATGCTATCCGAAGAAA +GGGTAAAGGAACTTCTTAAAAAACTCAAAGATTTAAAAATCCTCGTGGTGGGAGACGTAATCCTTGACAC +CTACCTTTACGGGAATGTGGAGAGGATTTCGCCCGAAGCTCCCGTTCCCGTTTTGGAAGTAGAAGGGGAA +GAGTTCAGACTGGGAGGAGCCGGAAACGTAGCGAAAAACTTATCTTCTTTAGGCGTGGAGACTTACCTTT +GCGGTGTAGTAGGAAAGGACGAAGCGGGGAAAAGATTAAGGGAATTAATAGAGGGAAATTCCATAAGGAG +TTTTTTAATTGAGGACGAGAGACCAACGACCAAGAAAACTAGGGTGGTATCGAGAAACCAGCAACTTCTT +AGAATTGATTGGGAAGACAGGAGCTACATTTCCGGAAAAGCCCTTGAGAAAATTCTGGACGTTATAAAGA +ACTTGCAGGTTGACGGGATAATCGTTTCAGACTACGCCAAGGGCGTTATCACGGAAGAGGTAATAAAGAC +TATCAGAGAGAAAGGCGTTTTTTACTCAGTGGACCCGAGACCAAAGCACAGGGAACTCTACAGAAAAGCA +TATCTTATGACACCCAACGAAAAGGAATTGAGAGAAATGTCAAAATTTGAAGGAAGTGTTGAAGAACTCG +GTAAAAAATTAAAAGAGGAGCTGGAACTTGAAACGCTTATAGTTACCCGCGGGGAAAAAGGGATGAGTTT +ATTTACGGAGAAAGGAGTTAAGCACTTTCCAGCTAGGGCGAGAAAGGTTTACGATGTCACGGGAGCAGGG +GACACGGTAATTGCAAGCATAACAGCCTTTAAACTCGCGGGGGCTACATGGGAGGAGTGTTGTGAACTCG +GAAACGTGTGCGGCGGTATAGTGGTGGGTGAGTTTGGAACGGCAACCGTCACACCGGAAAAACTCCTGAA +AGCCGTAAAACTAAATTCTTAATTATGTTCAAAAACTTAATCTGGCTCAAAGAAGTAGACTCCACACAGG +AAAGATTAAAGGAGTGGAACGTAAGCTACGGCACAGCTCTCGTTGCGGACAGACAGACGAAGGGAAGGGG +AAGGCTCGGAAGGAAGTGGCTCTCTCAGGAAGGAGGACTTTACTTCAGTTTCCTTTTAAACCCTAAAGAA +TTTGAAAACCTCCTCCAGCTTCCCTTAGTCCTCGGACTTTCGGTTTCTGAAGCTTTAGAAGAAATTACGG +AAATACCCTTTTCACTCAAGTGGCCAAACGACGTTTACTTTCAGGAAAAGAAAGTATCGGGTGTTCTGTG +TGAACTTTCAAAGGATAAATTAATCGTCGGGATAGGTATAAACGTAAACCAGAGAGAAATTCCGGAGGAA +ATAAAAGACAGGGCTACCACCCTTTATGAGATTACTGGAAAAGATTGGGACAGAAAGGAAGTCCTCTTAA +AAGTTTTGAAAAGAATAAGCGAAAACTTAAAAAAGTTCAAAGAAAAGAGCTTTAAGGAATTCAAAGGAAA +AATTGAAAGTAAAATGCTCTACCTCGGAGAAGAAGTGAAGCTCCTCGGTGAGGGGAAGATTACGGGAAAG +CTCGTAGGACTTTCCGAAAAGGGAGGAGCTTTAATACTTACGGAGGAAGGAATTAAGGAAATCCTATCGG +GAGAGTTCAGCCTCAGAAGGTCTTGAGATTTTTAATTCCATCAGAAGGGCGTTCTCACCGTCCGAATAGT +ATCCCTTCCTCTCGGTAACAACTTTAAAACCGAGTTTTTTGTAAAGGTTTATCGCTCTGAGGTTTGACTT +TCTCACGTCCAAAACCACCCTTTTCACCTTATCACCTAGCCTGCTTATTGCTTCCCTCAGTAGCTTCTCT +CCGTAGCCCTTTCCCCTGTATCCCGGAGCGATTGCAAAGGTCATTATCGTTGCCTCTTCCTTTACGACCC +AGAAAATTACGTAGCCCACCACTTTTCCGTCCTCTTCCAAAACGAAGCGTCTGGAAAACTTATTCTCAAA +GTCCTTTTCAAAGGAGAACCTGCTCCAGGCGTCCGTTGTAAAGCTCTCCCTGTTTATCTCGTAAACCCTC +TCCACATCCTCCCTTTCCATTTCCCTGACTTTTAACATTAAGATTTATTTTATGCTCGGAATAATAGGCG +GAAGCGGACTCTACAACCTCCCCGGCATAAAGGTAAAAGAAGAGGTTCAGGTAAAAACTCCCTTCGGAGA +GCCTTCCTCTCCCGTGGTAATAGCGGAGGTAGAAGGAAAAAAAGTAGCCTTTTTAGCGAGACACGGAAGG +GGGCATGAATACCCCCCTCACCTAGTCCCTTACAGGGCGAATTTATGGGCTTTGAGGGAAGTAGGTGTTA +AGAGAGTTCTCGGAATCAGTGCGGTCGGCGGTATAAACGAACTCTTGATGCCCGGAGATTTTGTGGTAAT +CCACGACTACCTTGACTTTACGAAGACCAGAAGGTCTACCTATTACGAAGGGAAGTTTTCCGTTAAGGTG +GAGGGAGAAGACAAGGTGGCTAAGCTCTTGCGGGAAGGGAAGGTGGTTCACGTGGACATGAGTGAGGCTT +ACTGTCCTGAAATGAGAAAAGTTCTTATACAAATCCTGAAGGAGAAAAATTTCAGATTTCACCCGAAAGG +TGTTTACGCCTGCACGGAGGGACCGCGGTTTGAAACTCCATCTGAGATAAAGATGTTAAAACTCCTCGGT +GCGGACGTTGTTGGAATGACAGGATACCCGGAGGTGGCACTTGCGAGAGAACTCACGATGTGCTACGCGA +GCCTTTGCGTGGTTGCAAACCCTGCTGCGGGAATAGCGGGATACAGACTGACCAGCAACGAGGTCATTCA +ATTGATGAAGAGGAAAGAAGAAGAAATAAAGGAAGTAGTGCTTAAATTCATAAAAGAACTTCCCGAAATT +AGAAGTTGTGATTGTGAAAAATCTCTGGAGGGAGCTGAGGTATGAATATAGAACAAATTCTTCATAACGA +GGCATTTAAGGAGTTCGGAACGGGAGCTTTGATAGGTTTTACGCTGGGCTACACTTTCAAAAAGTTATTT +AAGGTCTTCGTCTTTCTTCTCGGACTGTATTTAATAACGCTTATATACCTGAACAATCAGGGTATCGTTG +AAATTCAGTGGGACAACCTAGAGTCCTGGGTAAATTATGTGTTTGAGGGTTTCAGAAACTTTGCAAGAAA +CATTACGGCTCCGGTTGCTTCCCTCGGTGGGTTTGCGGTAGGATTTACCGCGGGACTGAAGTTCGGATAA +CCTCCTCGTAAAGACTCTCGTAATCTTTCAAAAATCTTTCACACCTGAAGACATGAGCCCTTTCCGGGGC +TTTCTGTGAAAGCTTGAAGTATAACTCGGGGTTTTGATAAAGCTTTAAGAAGGCTTTTTTAACGCACTCA +ACCTTCTCCTCACAGAGAATTCCTCCATCTCCTACGATTTCCGGTGCTGAACCTTCCTTTAAAGCTATCA +CGGGCATTCCCGTTGCCATGGCTTCTGCGAAGGAAAGACCAAAGGTCTCAGTCTTTGAAGTGTTTAACAA +AACGTCGTGAGAAAGGTAAAGCTCTGGAAGTTCCTCCCTTGGAACAAAGCCGAGAAAGTTTGCCTTTATC +CCGAGCTTCCTTGCTAATTTTTCGAGTTTTTCTTTCTCGTTTCCCTCACCTACGATAGTGTACTCTACGG +GAACTTCCTTGGAGATTTCGGCAACACACTTCAGGGCAAATTCTGGGTTTTTGTCCTTATCAAGCCTCGA +AACCGTAAGTATTCTGTTTCTCGGATTTCTGAGCTTTCTCTTCTCGGACACGAAGAAGTAGTCGGGAATG +CCGTTGTAAATCACCTTAACGCAAAAAGAATCAAGTTCTTCGTAGAGTTTTTTCTGGTACTTCGACACAA +AAACCACACAATCGGTAAAATTCCCGAAAAAAGAAACGAGCTTTTTCGCTATAACTCCGTTGTCTATCTT +TATCCCGTGGTAAGTGAGCTGTTTCGGGTGTATGTGTATAGTTCCGACGGTAGGAATTTTAAGAATTTTT +CCCATTAAAAGTGCCATCGTTCCCGCGAGAAAAGGGTCGTGGTAATGGATTACATCGGGGTTGAAGTTTT +TAAGTTCCTTCAAGAGTTCTACATTCGGAAGTGCTATTTCCACGTTGTGGTAGAAAGGGTACTTTATACT +GGGGAGTTTCAGAACTTTAAAGGGGGTTTCTTCCTCCGCAGTACTTCCCGTGATTACGAGGACTTCATAT +CCCTTTTTTGAGAGTCCGAAAGCGAGCTGGCGGGCTACCTGAGTCCCACCTCCGAGATCTTTTCTGAAAC +TGTCCGTAAAGAGTGCAATCTTCATAAATAGATTTTAAAGGGGAAGGGAAGCAGATTTCTTTCTGTACTT +TTCCCACTCCTCCGGGAATTTCTCAAGTGTTTGTCTGATAAGCCTTCCCGCAACAGCCCCGAGACCGCAT +ATAGAAGTGGGTTGAATGTTCCTGTTTACAAAGTCAAAACCTTCCCAGTCCTGCTCTGTAGCTTCACCCT +TGTATATTTTCTCAAGGAGGTTTGCCTGTTCGTAGCACCCTACCCTGCAAGGGGTGCACTGTCCGCAGGT +TTCGTGTTCGTAGAACTCTGCAATTTTTAGAGCTGCTTCCACTATGTCGTCCTCTTCCGTGAGCACTATA +ACCGTTCCCGTTCCGCCAAACCCGAGAGGAGAGTAGTCCATGGGAATGTCGAGTTCTTCCGAGGAAAAGC +AGTCAAGAGCCCCGGAAAATACAGCCTTCACCTTTTTGTTTCCGAGGGTTCCGCCCGCATACTTGAATAT +GACTTCCCTGAGTGTTGTGTTCATGGGAAGCTCGTAAACCCCGGGTTTTTTCACCTTACCGCTTACGGGA +AAGAGTTTTGGTCCAGCGTAGTCACTCGGGCCTATGTACCTGTACTCCTCCCAGCCCATGGAAATTATAA +AGGGAACGTTAGCTATGGTTTCTACGTTGTTCACTACCGTCGGTTTTCCCCAGAGTCCCTTCTGGACGGG +GTATGGGGGTTTTAACCTCGGGTGTCCCCTTTTACCCTCAAGGCTTTCTATCAGAGCGGTTTCCTCACCG +CATATGTAGGCACCCGCACCCCTTGCCACGTATATCTCAAGGTCAAATCCCGAACCCAAGATGTTCTTTC +CTAAAAATCCCTTCTTTTTCGCCTCCTCTATTGCATCCCTCAGTATGTAATAGCCCGCGGGGTACTCTCC +CCTTATGTATATGTATGCTTCGTTTGCCCCAATCGCATAGGAGGATATGATTATTCCCTCTATCAGGAGG +TGGGGATCCCTCTCTATTATTATCCTGTCCTTAAAGGTTCCCGGTTCTGACTCGTCCGCGTTGCATATAA +AGTACCTGGGTCCGGGGTTCTGAACCGCGAATTTCCACTTCTTCCCGGTTGGGAATCCTGCTCCTCCTCT +ACCCCGCAGCGTACTTTTGTCAACCCAGTCTATGATTTCCTCGGGGGACATGTTCAGGGCTTTTTCTAAA +GCCTGGTATCCCCCATCTTTTAAGTACTCATCTATGGAATGAACTCTGGGCTTTTTAGCCCTCTTGAGGA +GCATATTAAGGGTAGTTTCAGCGTAAATCCTAGGTATAGCGGGATAGGATCTCATTTAACTGCACCTCGC +TTTCAAATTTATACTCATCATCGTTTACCATAAACACGGGAGCTTCCGAGCAAGCTCCCAGACACTGAAC +GGGAACTATCTTAAACTTACCGTCGGGGGTAACTTCCCCTGGTTTTATACCGAGGATATTCTCAAGAGCT +TTCAAAAGTTTATTCGTTCCCATAAGGTGGCACACTATGCTCACGCAAACCCTTATCCTGTACTTTGCCT +TGTCCTCCCTGTCAAACATATCGTAAAAGGCAACAACTCCTTCCACGTGGTTTAGGGGAAGTTCCAGCAT +GTCCGCCAAGGGCTTTAGGCTCTCGGGAGGTATGTATCCGTAGTAATTTTGTATTTCGTGAAGACACAGA +AGTATAGCCTGTCTCTTTTTGGGAAAGTAATTTATGTGTTCCTGGAGCTTAGTTTTCAGCTCTTCGGGAA +ATTCAAACTCCGTTTTAAACATAGTTAATAATTTTAAAAAACTAATCCGTTTTTACAATTAAAAACACCA +TCTCCTTCCTACCACCTTTCTGGCGAGCCATATTTTTGAGCCTTTCCGCCCCCTTTTCCAAATCGCAACA +CGAAAGTGCCTCTTCTATCTCTCCTTCGCTTAAAACTTCCACAAACCCGTCGGAGGCAAGCAGGAACAGG +TCCCCCTCCTCGTAGTGCGATGAAAAGGTGTAAACTTCAGGGTTCCACTCAAGCCCAAGAACTTTAACCA +CTTTTTTGTTTCCCTTTATCTTCACCTGGTCCTCCGTTAGCCTGTACAGTCTTCCCTTCCTGAAGAGGTA +TATCCTTGAGTCCCCCACGTGTCCTATGTAAAAGTTCCTTTCGTTGAAGGAAAGGAGGCTTAGCGTAGTT +CCCGAAAGCACACTATCCTCAAGTTTTCCCAGTTCCTTTATTAGTTCCCTGTTAATCTTTGAAAAGTTCT +CCCTTATTTTCTCTTCCGAATTGTAGGGCTTGAATTTTGGTATTAAATCCACCGCTTTTTCAGCGGCAGC +GACCGCGCCTTTTCCTATGCCCATTCCGTCCGCAACAGCAAAAATTTCCCCGTCCGCCCAGAACCTGTCC +GCGTAGGTTCTCCTGTCCGAGTAAACTATCCCGGAAACCCACTTCAAATCAAGCCCTCCTTAACCATGTA +CTCTTTCAGTTCTCTTGCGGTTCTGAACCTCCTTTTGTAATCCACTTCCAGCATTCTCTCCAGTAAATCC +TTTAGTTTACCCGGAATTTCCTCGGGAATCTCAACCTCTCCCCTTTTGTTCTTTTCCTTTCTCTCTTTAA +AATCTTTCCCTTCGAAGGGAACCTTGCCCGTTAGCATGTAAAGGGTTAGACACCCGAGAGAGTATATATC +GCTGCTCCTGTGAATTTCTCCCCTGAAAATTTCGGGAGCTATAAAACCGATAGTTCCTTTCACATCTATT +ATAGAAACGTCGCCCCTTATCCTGACTAGGCTAAAGTCTCCGAGCTTCCACAAAACTCCACCCAGAACCC +TTTTACCGAATACGTTCTCCGGCTTGAGGTCGCTGTGGATGTATCCCCTTGAGTGGAGGTATTCAAGGGC +GTTAACGACGTGCCTTAAAACTTTCAGGGCTTCCTCAGGGGAGAGCTTCCCCTTTTTCTCCACGTAATCT +TTTAACGTCCCGAAGTCCATGTACTCGTATATGAGGTAGAGTTCCTTTTTATCCTTTTTGTAGAGATAAC +TCTGAAGGGAAACTATGTTCTGGTGGTGAAAGAGGATTAAGGTCTGGGCTTCCTTCCAGAGGTAGTGAAC +CGAGTAAGGGTTGGAAGCTACCTTCAGGGCAAAGACTTTTCCTTTATACCTCCCTTTCAGAGCTTCAACC +TTGTAAACTTTCCCGAAATTCCCTTCTCCTAGCTTTTCCAGAACCTTGTAGTAACCGAGTATAAGGTCTC +CCGATTTAAAGTCTTCCATAGGCTTTTTAATTTAAAATGTTTCTAACTCATGGTAGAAGTCTTAAGGAGC +TCCACGTTTCTTCTTTTAAGAAACTGGGAGTTTACCTTAGCTTGGATAGTCTTCTTTACAATTCCCCTAG +TTATCACTCCTCTCCCATACGTGGGTTTCTTAGCCTTCTTCTTTATACTTCTTTTCTTTAACTCTACGAC +ACAGTACTTCGTGAAAGTTCTCTCTAAAAATGAAAAAAGCTTAGAGATAAAAGAGATTTTCAAAATTAAG +AAACCCGTTTTTAGTTTTTCCCTCGGAGAGAGTGTTTACCTTTTTTTCACCGCCCTCCTTTACTACCTCT +TTACAAAGTTCTACGCGGTTTTGTTTTTCTGGTGGTGGTTTTACAAGCCTTTCCTTGAAAAAGAACTCTA +CTACGCCAGAACCTTTGAGGACGGCTTTAAGGCACTCCTTATACTCCTTCTAAGGCCAAACTGGAAGTAC +ATAAAACTGGGTCTTCGCTGGAGCTTTATAGGTCTGGTTTTATTAACGATAGCTGTTTTACTGGTTCTTT +CTATTGCTGGAGTCCTGCTCGCCTCTTTTGTTGTACTCCTTCTTTCCGTAGTCCTTGCGCACTTTACCGC +GGAGACTATACTCAGGATAAAGACATTAGCTTAAGACTTTCCTTATTTCCTTTATTACTTCTTCCGGATT +TTCCTTATACCTCTTTCCCAGCTCTATTGCCTCCTCCTGAGATAGAAAGCCTTCCCTCTTCAGGAGTTGC +AGGAACTGCCTCACGTTGGAAGGATTTTTCTTGAACGTTCCCCTGTCAAAGTCTATAACGAATACTTCTC +CTTTATCGCCCACGAGGACGTTTTTGTATATGTTGGAGAACTCGTCCCTGTTTATTCCCATTCTGTCCAG +GAGGTAAGCCTTTTCCAGAACCTCCTTGAGAAGTCTCTTTTTCTCTTCTTCACCGATCTTTAACTTCCCG +AAGGGCTTTCCCTCTATGAATTCGTAAACGAAGAAGTCCTCGCCTTTGAAGAGTATCTGAGGAAAACCTT +TAAGCCCTTTCAATTTTTCCAGTATTTCAGCTTCTTTCTGTATCGCCTTCACTTTATCCGGAGCTTTTGC +CACTTTTATGGCAACCTTTTTACCCCTCCAGTATCCCGTGTAAACCTTTCCCCTCCAACCTTCTGCGAGC +TCCTGTAAGTTTTGAACTTCCTTTATAAATTCTGAGAACTTCATACCTTATATTTAATAGAATGGTCAGA +GACATAGTAATTTACCCCAACGAAATCTTGAAGAAACCGACCGAAAAAGTTGACGTAATAGATAAAGAGG +TTAAGAACCTCATAAGGGATATGTTCGATACCATGTACGAAGCGGAAGGTGTGGGACTCGCCGCAAACCA +GATAGGTGTTCCCTTGAGCGTTATGGTCATAGATACCTCACCCAAAGAAGACGCCCCTCCCCTCAAGCTC +GTACTCATAAACCCCGAAATAAAGGAAGGAGAGGGAAAGATTAAGTACAAGGAGGGATGTCTTTCCTTTC +CGGGCCTCAGCGTTGAGGTAGAGCGTTTTCAAAAGGTAAAGGTAAACGCTTTAAACGAACACGGAGAACC +CGTTGAGTTAACTCTGGAGGGATTTCCAGCGATAGTTTTCCAGCACGAGCTTGACCACCTGAAGGGCATA +ACTTTTGTGGACAGACTCAAGGGCTGGCGAAGGAGAATGGCACTCGAGAAGTACCAGAAACTCCTCAAGT +CCAGAAAATGAGCACAAAGGAAATCATATGCACCCTTAAAGGGCAGTTTTTCCTCTCCCCGAGGGAAGAG +AAGTTTTTAAGACTTCTGGAGGAAATGGGCATACCAGAGGAAGATATACAGGAAGGCATAAGGGAGTGTT +TAAAGAGCGTAAGTCCTAAAAAGAGGAAGAACTTTCCCCTATTTAAGTGTTTTTCAAAAATTCTGGAAGT +TAACAAAGTAAGAGCCCTTGAGCGAGGAAAAAGGGAACATTTAGACTGGAAAAGAGTTTTTGAGAGGAAG +GTATCGGTTGTAAAACACCTTCTGGATTTCAATTACACCGAACCCAAAACTGAAGAGGAGGCTGAAAAGA +CACTCCAGGAAATAGAAAGGAAGATATTTAAGAAACTCTGGGAAAACTTGGACAAAGAACGGAAGAGAGA +AATATACAACAAGTATAAGGAAGTAAAGGAAGACGAAGAACTGTTTAAGGAACTAATAAAACACGAATTG +AGGAAGATTTTTCAGATTCCCGTGCTTTCCCTGTACGTGGATTGATTACTCTTCTTGGCTTTCCTCTGCA +ATTTCTATTGCCTTCATGAGCGCTTTTGCCTTGTTTACGGTCTCTTCCCACTCCTTTTCAGGAACGGAGT +CCGCCACTATTCCCGCTCCAGCTTGGACGAATATATCCCTGTCCCTGTAAACTGCAGTCCTTATGGCTAT +CGCCATGTCCATGTTCCCCTGAAAGGATATATAACCTACACTGCCCGCGTATATTCCTCTCCTTTCGTTT +TCAAGTTCCTCTATTATCTGCATAGCCCTTACCTTGGGAGCTCCAGAAACAGTTCCCGCAGGAAAGGTAG +CCTTCAAGACGTCTAGAGCGTCGTAGCCTTCTCTTAACTCTCCCACAACGTCGCTCACTATGTGCATAAC +ATGGGAGTAGCGTTCTATCCGCATAAAGTTTTCAACTCTCACACTTCCGGTTTTTGCAACCCTCCCTATG +TCGTTTCTCGCAAGGTCAACAAGCATTAAGTGTTCCGCCCTCTCCTTCTCGTCCGAAAGTAGATCCTCTT +CCAGTCTTTTATCTTCTTCTTCCGTTCTTCCCCTCTTTCTCGTCCCCGCTATAGGTCTCGTTTCAATCCT +TCCCTCTTCCAGTCTCACGAGGATTTCGGGAGAAGAGCCTATGACTTTTAACTGATCAAAATCGAGGTAG +TACATATAGGGAGAAGGATTTAAGAACCTGAGAACTCTGTAAATGTTGTCGGGATTACCCTTAAACCTCT +TTCTGAATCTTTGAGAAAGAACTACCTGTATCACATCCCCCTGCGCTATGTACTCCTTTGCCTTTTTGAC +TATATCCTCAAATTCCTCTTTTGTGAAGTTAGAACGCCAGTTTTTGAAATCCGGTTCTTTCTCTACAACG +TTTAAAAAAGTAGTTCCCCTTTCCTTTAGTTTTTTCACGGTATCCCTTATTAAGTTTTTAGCCCTTTCGT +ACTCTTCCTCAATTCCGTTTTGTGCGAAGATGGGAACAACGACCTTTATTTTTCCCGTAAGGTTGTCGTG +GATAACCACAACGTCCGTAAGCACGAGGTATATATCGTAAGTGTGAATCGGATCGGGATTTTTGTCTTCC +ACAGGTTCGTAGAACTTCACCACGTCGTAGGCAAAGTAACCAACTAACCCTCCCCAGAACCTAGGCAATC +TTTCATCATGATAAGGTATGAACTTCTTTACAACTTCCTTAATCTTTGAAAGAGGATCCTTCGTTTCAAA +GAAATTGACCTTTCCCCTTTCGTAAATCTCTCCGATATCTTTTCTCGTTCTCAGGTAAAAGGAAGATCCC +GTGATTATAAAGGAGTACCTTCCCCACTTCTCACCGCCCTCCGCACTTTCCAGTAAGATGTTGAACTGTC +CTTTTTCCTTTAACTTGAGGAAAATAGAAAGAGGAGTTTCAGTATCCACCAGAAGTTCCGTATATAAGGG +AATAACGTTGTAATTCTCTGATAGTTTTCTTACTTCCTCAAGGCTGAGGTTTAAATTCATACAAAAAATT +TTAAAATTTAATGGAGAGGGGACTATGGAAAATTCTTTGAATGGTTTAATGAAAGGACTCAGAGGGAAAA +AATACTACTTATAATTATCCCGTTAGTTTTTGCCTTCGTTTTATGGCTGAACTTCATACAACCTCTTTTA +AGCGAAAAGAGAAAACTGGAAGAGGAGCTTGAAAACTTAAGGGCAACACAATTCCTGATTGCGAAGAAGC +TTGCTCTGGAGAAGAAGATAAAAGAGCTTGAAGCACAAATTGAGACTAAGGATTTATCTCTTGAGGAATT +ACTAAATATAGCGAATAAGTATGGAATTTTTATTACAAAGTTCGAAGAAGTTAGTCCAAGGGGAATATCC +GTACAGAAAAGAGGCAAAAAGGTTGTATTCTATAAAGGCAGAAAAAAGAAAAATAAAAGGGGTATTAATG +TGGAATTTACAATATATAACTTGAATATATTAGCCCCAGAGGAAAAAGTAAAGTCGTTTATAGAACATAT +ATACACTAACTACCCGGCAGTATTGACAGGTTTCTATAAAGGATGTTTAGGAGAAAAGGAAGCTTTGAGA +AGAATATCTGTTCCCTTAGCGTGTAATACTGGAAGAGATTACGAAAATATAATCTGTAAAGATGCTGATT +TAAGTGGCTACGTTTATTTACTGAACCTTGTAACTATAAATGTGGAGGGGAAGAAATGAAGGTTATGCAC +ATATTATTCTTGATTATATTGGCTTTTGCCTTTGCTGAAGATACAATACCCATAAAAAATATCACGGGAA +GTGGAAGTATAAGTGTTTATAAAGATGGAAAAGTTTTTCACTATAAAATACTTGAGTATTTTGATGAAAG +AAAGAAAACTCTTAAAGCATACGTTGTACGTGAGAGTATTGAAGAAAAAAAATTACACTATGGTAATTTT +ACTATTATCAATGCCGATTTTCAAAACTTAAAGTTAGCAACTATTTTAATTTCTCTGTCAAAAATAGCTA +ATTTAAACATAGTATTCAGTAAAGAGCTTTGGAAAAGTAGACAAGAAAAGTTCGAACCATCGAAAGAATA +TAGGGAAGAAGAAGGTTCTTTACTACGGAAAGAAAAAGGTTTTTTACTCCAATTTTCTACACTTCCAAGA +AAAGTAAAAGTAACAAGAAAAGAACCTGTACAGGAAAAGGAAGAATACAGAATCCCTTCTTATCTTCTAC +ATAATGTCTCGCTAATTATTAACTCCCCTACGCCGGGTTATACACTTTTTACTCTTTTTGATACTTTATT +ACGGGAATACGATCTTATCGCTGTAAAGCTTTCAAATAATCTAATAAAAATATCAAAAAAGGAAACATTA +GCATTTGATGTAGAAGGTGTTGACCAATCTTCTATTAATAAACTGATTTCGAAGATAAAGCAATATACTT +CTCCTTCGGCGAAAGTCTTATACGACAAGGATTTGGGAAAAATCATGGTCATTGATATGGCAGAAAACAT +AGAAAAGCTAAGAGATTTGAGAGTAGATTTAATAGAACTTTTAATGTCTAGGGAAACTACCCCAGGTGAA +AAGGAAAAGTCCAAGGAAACTACCCCACGTGAAATTGAAACTAAGGTTTTTTACTTCAAGAATAAAAGAG +ATTTAGAAATAGCCTTAAGTAGATTGAAGGAAAATTTTTCGGGAGAAGTAATCCTAAATATAGACAAAGA +CTTTAATGCCATTATAGTAACAAGTAATAGATCGGTAATAAAATCTGTCGGCACTCTGCTTAAAGATTTG +ACGGAAAGTATCGATAAAGCTTATTTGATTACCAAGATTTTCTATGTTAGATATATTTCCCCTTACGAAC +TTAAAAAGAAAATAGAACCTATGCTTTCCGAGGTTGGAGAAGTATACACGTTGAGCGTTTCGAACACAGA +TGAAAAGAAAGAATTAATAAGCTATAAAAATACTCCTCCAGCTACCGCTTTTAACGAAGGAACTTTGGAG +AAAGAAAAAGCATTTTTTGTTCCGTTTAACAACGCAATTCTCATAAAGGATTACCCTGAAAGGATAGAAA +AAATCAGAGAAAAATTTAAAAAGTTTCTATCGGAAAAGCCTATAAAGATAAAGATAAGGGCAAAGCTCGT +GGAAGTAGAAAAGAGCTTACTGAGGGAGCTTGGAATTTCATGGAGAACGGTATTTTCAAAAGCTTACATT +CCAGAATTCTGGCAGGGAGAAACCGCATTCAGAACTGTTACTCCCGGACAACCACAAAGCGGTCTGCTAA +CATTTACCTTTCAGAGAAACAGATTGAACTTACTTGAATTTAAACTTCTCGCTTACGAACAAGAAGGAAG +GGCAAAGAATGTTGCAGAGTCTTACGTAATTACGGTTAACGGAGAACCTGCTGTAATATCAAGCGGTTTG +GAATTCCCGGTAACGGAGGTTTCACTTTCAGGAGGGATAGCAAATGTGGAGCCTAAGTACGAGAGCATCC +CTATAGTACTTATAACCACTCCCGTAGTGCTTCCCGATGGAAACATACTTCTGAGTGTTTACTTGGCGAG +AAGGCAGATAAATTCCGTTCAGGAGTTTCCGGTGACTCAGACTTTAACCCAAAAAATTCCTGTCTTTTCT +ACTTCACGGATAGACGTAAAGATACCTATTAAAAACGGTGAAACTGTAGTAATAGGTGGGGCTGTCGAAA +AGTCAGATTCAATAACGGAAAGCGGAGTACCAAAACTCAGAGAGGTTCCGCTACTTGGCTGGCTCTTCAA +AACGCAGACTAAACAACTCAGGGACAGGGAACTGTTAATCTTCATAACGCCGGAAATAATAGAGGAAGAT +TAAAGGGAGGAAAGTTTTGAAAGTATCTTTTCCCTCCACTTTCTCGCCTTTGCGAAAATTTCTTCCTGAT +CCACTGTTTTAAGTTCCCTCTTTTCCATTAAAACCTTTCCCTTACATATGACTGTGTCTATACACTCGCT +GTTTGCGGAGTAAACGAACTGAGAAATAGGATCGTAAAGCGGCTGAAACTCGGGAAAATCTGTATCTACA +AGTATTAAATCCGCTTCGTAGCCTTCCTCTACCTTTCCTGCCTTTATTCCCGCAACCTTAAAGCCGTTTT +CCGTTGCAATTTTTAAAGCTGTTCCGGCGTCTATCGCTTTTGCATCCAGGTTATAGCCCTTGTGGAATTT +TGCACAGGTGGAAGTCTCTTCAAGCATGTTCAAGTTGTCGTTGGAAGCGGCACCGTCTGTGCCGAGCGTG +ACGGTTATTCCTCTTTTCACATAATCGGGTACGGGAGCTATACCGGATGCCAATTTCAAGTTACTTTCTG +GACAGTGGGCTATTTTTACGTCTCTTTCTTTCAGTATTTCCCTTTCTTTTTCAGTGGTCCACACCATGTG +CGCACACAGGACGTTTTTGTCTAGAAATCCTATGCTCTCTAAGTGTTCTACGGGAGTTTTTCCGTACTGC +TCCTTTATCCTTTCAACTTCCTCTTTCGTTTCCGCAACGTGTATGTGGAGAAGCAATCCGTATTCGTCCG +CCAGTTCCTTTGCCATTCTTAACGTATTCGGTGAACAGGTGTAGGGAGCGTGAGGGCATATTACGGGAAA +TACGAGTTCTCTGTTCTTAAACTCCTCTGCAAACTTTCTGGCTCTCTGTATGTACTCCTCGGGTGTTTTT +GCCACTTTTGTCGGAAAGTCGAGGATTCCGAAACCGAGTCCCGCCCTTATCCCAACATCTTCACATGCCT +CCGCCACAGCCTCTTCAAAGAAGTACATATCCATAAAGAGCGTAGTTCCGCTCCTTATTGACTCCACTAT +ACCCAGGAGTGCCCCGTCTTTGACAAATTCAGGGGAAACGAACTCTCCCTCTAAGGGCCATATTACTTTT +TGGAGCCAGTCGTGAAGGGGAAGGTCCGCTCCAAGACCTCTCAGAAGAGTCATTGAGATGTGTGTGTGCA +TATTAGCAAAGGAAGGAAAAGCTATCTTGCCCTTCCCGTTTATCGTGTACTTTGCTTCGCCCACGATGTT +TTTCCCTATCTTTTCTATCTTTCCGTCTTTTACCGCTATGTCCCACTCTCCTTCCTTTTCTGGAATCAGG +ACGTTTTTTATCAAAAGATCGTACTTCTCCATAGGGGATAATTTTAAACTGCTAAAATTCTAAGTATGAA +AATACTTATACTGAGTGGGGGAAAGGGAACTAGACTGTGGCCACTTTCTAGGGAAAACTTCCCCAAGCAG +TTCATAAGGTTGTTTTCAAAACACTCCCTCTTTCAAGAAACCGTAAAAAGAGCGAAAAAGCTCGCAAAAG +ACGAGGATATAGTTGTTATAACGGGAGAAAAGTACGAGTGGATTATCAGAAGTGAACTTGAAGAGATAGA +TGCCAACGAAGTTCGGGTGGTGGTAGAACCGGAGGGCAGAAACACAGCTCCCGCCATAGCCTTGGGAGTA +AAGTACCTGATCCACAGCGAAACACCGCCTTCCGAGACCGTTCTAGTTCTTCCCTCCGATCACCTGATAA +AAGACACGGAAAAGTTCGTAGAAGCGGTAAAAAAGGGAGAAAAGTATGCAAAGGAGGGATACATAGTACT +CTTCGGAGAAAAACCCACTTACCCTGAAACGGGATACGGATACATAAGGCTTAACGGAAAGCTAGAAGAA +GGAGTTTACGAGATAGAGAAGTTTGAAGAAAAACCTGACTACGAAAAAGCTAAAGAGTACGTATCCGACG +GGAAGCACTTCTGGAACTGCGGGATATTCCTCTTCACCCTTGACAGAATAGTAAAAGACTACACTCAGTT +AATGCCCGAAATTCCCTTCCACGAGAAGTGGGAAGACTTTATTAAAGACTTTAAAAACTTTGAAGAAATT +TCCTTTGATTACGCAATACTCGAACGGACGAAGAAGCTCGCCGTTGTAAAAATGGATGCCGGATGGAGTG +ACGTGGGTTCCTGGAAGGCGGTTTACGACAACTTGCCCAAAGACGAAAAGAGGAACGTCCTGATAGGTGA +TGTAAAGGCTATGGATACTGAGTGTTCCCTCCTTCTCTCTCAAGGGAAAAACTTAATCGCGTGCATAGGA +CTTGAGGACTTCGTGGTGGTTGGGACTGAGGACGCCACGCTTATAGTGAAGAGGGATTACTCTCAGAAGG +TAAAAGAAATAGTAAAGGAACTCGAAGAGGAAAATGACGAGAGAGCAATAGAGCACGTGACTTCCTTCAC +ACCTTTCGGGAGTATAACCAAACTCGATAGAGGCGAAAGGTACAAGATAAGAAAAGTAGTTGTAAAAAAG +GATAAGGAAATACCTTTGAGGATGCACCACCACAGAACTGTTCACTTCGTCGTCCTTAAGGGAACAGCGA +AAGTAAAGGTAGGGGATAAGGAGGAGTTCGTCCACGAGAACGAGAGTTTCTTCGTTCCTAAATCAACACC +CTATAAAATAATAAACGTCGGGAAAATTCCCCTTGAGATGATAGAAGTTCAAAGCGGTGAATACTTAGGA +GAGGACGATGTTGAAACACTTGAGTGAAAAGTTCATCTACTACATGGCGGAGTACTTCTTTGAGTTTGAA +AAGAGGAAACACTACTACAAGCTCGCCAACAACCTTTACAACTCCTACCTGAAGGGCAAAAAGTTCAACA +GGAGTTTATTGAAGAAAGTAAAGGAGGACCTGAACCTCTGGATAGATAATCCGAACCAGATACAGGTTTA +CTCAAGGTTTTTAAACGAAGTAGAAAAGGAAGGAGTCAAGAGTTTCGGGGAAGGTTTGGCGATAATACCG +CTTATTAACCTCTACAGAGAGGTGTGGAGGGAGCTGGAAGAAGAACAGAACAAAGTGGAAAAACTCAGAG +AGTACATCTTAAAGCTGGACTCCTGTGAGATATGCACGAGAGGACTCGAAGGGGAAGAATTTTTTAACTG +CCTTACACAAAACGTGGACTTTTTAACAGCGACCCATATAGCGAACTTCTTCTTTGAAGAGGAATTCCTT +CCCCTGAATGAGGAAATCGCCCAGATTTTGAACATCAGTAAAGAGAATTACTTTGAAGTTATAAAGAAGT +TAAAGGGGGCAAACCTTAAAAACTTGTACGGAGCACTCTACGTTTTACTCCAGAGGGACAGCGTTAAGGT +AAACCATGTAAAGAGACTCCTCGGTATAAGCAGGGAGGCAGAACTACTGAAAGAAGCCCAATACGCGTGG +AATACGGGAGACTTTTACAGGGCACACGAAATACTGGAAGAGGTATGGGGATTATTTAAAAACGAGGAGA +TAAAGAAGTGCTACAGGGGGCTCATAAGGGCGGCTATTGCCCTACACAGGTTCAAGGAAGGAAACCCGCA +ATCAGGTGCAAACGTTGTAAAACAAGCCCTTCTTGACATGGCAAACTGCCCGGACAACTTCAGGGGGATA +AATTTGGGAGAGATAAGGGCTTACTTGGAAGAGGTGTTGGGAACCAAGGAGATTGGAAATCCGCCGGAAT +TGAAGTATAATATTAAATCTGAGGAGTAGGCGGCGTAGCTCAGCTGGTCAGAGCGGGGATCTCATAAGTC +CCAGGTCGGAGGTTCGAGTCCTCCCGCCGCCACCAAATCCTTTAAAATCTTTCTCATGTTCGGTCTAATC +CAGAAACACAAGAGAATTGCCGTAATAATAGTTACCCTTGCGTCTTTATCCTTCCTCTTCTGGATGTTCT +CGGTCTCGGACGTAAAGCAGATGCTCACAGGAAATCCTTGTGTCGCAACAGTAGGAGATGAGTGTATAAC +TCTCAGGGAGTATAGATTTGAACTCTTAAAGTACTCAAATTTCCTTCAGGACGAAAGAACTGAAAAACTC +GCAAGGAGAGTGGCTTTAAATTCTCTTATCACTAAAGAAGTTTTGTACTTAAAAGCTAAAGAACTCGGCT +GGTACGTATCGGATGAGGAAGTTGTGGAAGTAATTAAAAACGACGAAAACTTCAAAGAAAAGGGTAAGTT +TTCCGTGGAGAAGTACAGGGAAACCTTAAATAGATTTGGACTAACCCCTGCGGAGTATGAGGAAATCGTA +AGGAAAAGCTTAATGGCTCAGAGAGTTTTAAACTTTTTAAGGGAAGGCGTTTACGTTCTTCCCGACGAAC +TGGACATTCAGAAAAGGTTTTACTCCCTTCGTGTAGAGGGAAAGCTTTACCTGATAAAGCCTTCGGACGT +AAAAGTAGATTACGAGCCAAGCGAAGAAGAAATCAAAGAATATTACGAAAAGAATAAGGAAAAGTTTAAG +GAAGAAGAAAAGGAAGTTGTGTACGTCTGGAGCTTAAAAGACAAGGAAAAGGTGAAGGAATACTATGAAA +ACCTGAAGAAGGGAAGTATTCCTTCAGGCTACACGGAGTTCAACGAAAATCTCCCGCCAAAAGTTAAGGA +AGCAGTAAAGGAACTCAATCAAGAAAATAGGATAAAAGTGGTAAGAGTAGGCGAGAATTACTACCTCCTT +TACTACAAAGGAAAGGAAAATGCTGGCTACAAACCTCTGGAAGAGGTGAAGGAAGAAATAAAGAAAGAAC +TCGTAGCTAAAAAACAGAGGGAAAAATTGAAGGAGTTTGCACAGGAAGTGTTTAAAAACTTGAAAGAAGG +GAAAGAAGTCGGGGTAAAACCACTTGCATTCTCTTCCGCAAGCCTTGAGGAAATACAACGAATACTTATG +GTGGAGCAGAAGGATTTACTTAATTTGGTTTTCGGGAAAGAAAAGGTTTATGGACCTTACCCTTCGCTTG +CGGGGTACGGAATACTGGTAGTTAAAAACAGGAAGTTTGAAGAATTAAAACCTGAGCAGGTAAAGGAAAT +TGAAAGGGAACTTAAAGACAACAAGTTTAACGACCTTGCTGGGCTTTTCGTAGAAAAGTTGATAAAAGAG +TACGGAGTGAAAGTGAACGAACAACTGGCAGGGATTTAGTACTTTCTCTCTTCTGGTTTGTACTTTGTTA +TCCTTACGGGAATGTATTCAAGCTTTAAATTGCCGTTTTTGTCGTAATAGACGAGGGAGTGTTTTAAGAA +GTTTTTGTCGTCTCTCTGGGGATAGTCCTCTCTGGAATGTCCGCCTCTTGACTCCCTTCTGTGGAGGGCG +GAGTATGCAACCACCCTCGCGAGTTCGAGCATGTTTCTTAGCTCAAGAACTTCTATCAGGTTAGTGTTAA +AGACTTTTGCTTTGTCAACGACAGGTATGTTGTTCCACCTTTCTAGGAGTTCCGAGAGTTCATCGTAGGC +TTCTTTTAAGGACTTTTCATCTCTGAATATTCCCATTTTTGCCCAGGTTATTTCACCCATCTGGGCACGC +ACCTGAGCCAAGCTTTCATTTCCTTCCCTCTTCATCAATTCCTCTATAAATTCCTCAGATTTTTTTGGTT +CACTTTCGCTTACTGGGGCAAAATCCGTTTCTTTTACGAATTCCCTTACAGCCATTCCGCAGTACTTTCC +AAAAACTACGAGTTCAGTGAGTGAGTTTCCTCCGAGTCTGTTTGCCCCGTGCACGGAAACGCAGGCACAC +TCGCCTACCGCGTAAAGGCCCTTCAACGGAGTTTCAGAGGTTTTGTAATTCTCAACGTGAATACCACCCA +TACAGTAGTGGGCAGAAGGTCTTATCGGAACGAGTTCCTTTGCGGGATCTACACCTTCAAAGTCTATGGC +GAGCTGTCTTACCTGAGGAAGCCTTTCCTTTATTTTCTCTTCTCCTAGGTGTCTTAAATCCAGGTAAACA +TAGGCCCTCGCTCCTTCGCCGACTCCCCTTCCTTCTCTTATCTCTGTTTCTATTGCCCTTGAGACTATGT +CCCTCGGGGCGAGCTCCATTTTGTCTGGAGCGTATCTCTTCATAAACCTTTCCCCTTCTTTGTTAAGGAG +GTATCCGCCTTCTCCCCTGCAGGCTTCTGATAAGAGTATTCCCGTTTTTGCGAGTCCGGTGGGGTGGAAC +TGGATAAATTCCATGTCCTTCAATGGAACTCCTGCTCTCAGGGCTACCGCCTGTCCGTCTCCCGTGTTTC +CTATTGCATTTGTGCTCCTGAACCAGTAAATCCTTGCAAAACCCCCAGTTGCAAGAACTACAGCCTTCGC +TTGTAAAAATAAAACTTCACCGTTCCTGATATCGTAAATCGTTACACCCTTTACCCTCTCTCCGTCGTGG +ATGAGGTCCAGGAGAAAGTACTCGTTGAAAAAGGTAATGTTGTCCCTTGCAAGTGCCTGTTCAAATAAGG +TGTGAAGGAGAACGTGCCCCGTTTTGTCCGCAGCAAACACGGTTCTTGGGAAGGAAGCCCCACCGAAAGG +TCTCTGGGCAATTCTGCCGTCGGGCAGTCTCGAAAAGGGAACTCCCCACCTGTCCAGCTCGTATATAATC +TCCGGGGCTTTTTCGGTCATAAAGAAAACCGCATCCTGATCCGCCAAAAAGTCGGAACCCTTTATCGTGT +CGTAGGCATGAACTTCAGGGCTGTCGTCGGGGATTACGTTTCCGAGAGCTGCGTTCATTCCGCCCTGTGC +GGCTCCCGTGTGGGAACGGGTCGGGTAAACCTTTGAAACGAGAGCAACGCTTATATTCGGATCTTTCGCC +ACTTCTATTGCGGTTCTCAGTCCGGCACCACCGCCGCCGATAACTACTACGTCGTATTTCTTAATTTCCA +TAACAATATTTTAAGATACAGCGTCTAGCTACCTGCTGTTCTTTATTTGCCTGTTTACAAGGTATATAAT +CGTGCCTCCCACGATTAAGGAAAAAACAAGGATAAGTGTAAATACAATAAAGAGAGCTTTGTCAACTTCA +CTCATCTCTTTTTAATTTACCACCTAAGTTGATAATATTGAACTCTAGAAGTAGTAGTATCAAAGAAATT +ATTAATCCGTAGAGCATCAAACCAAAATTGGGTTTATTCGTAGCAAAAAGTATTTTCCTAATTCTGTGAG +AGCATCCTTACTAAATCTATCCCATTTCATCCCCAAAAACCTTTTCATAAACGTAATCCCTGTTCTTCAG +AAACTCCCATGGGTCCAGAGCCTTCTCTATTTCCTCCTCTGTAAGGTATTTCGTAACTTCGGGGTCCTCT +AAGAGTGTTTCTTTAAAAGTTTTATCGCTTTCCCAAGCCTTCATTGCACATCTCTGAACTATATCGTAGG +CGTAATCTCTTGAAAGCCCTTTTTGGGTCAGGAGGACGAGTATCTTTGAAGAGGCGTAGAGCCCTTTTGA +GAGTTCCATATTTTTTCTCATTCTCTCCTTGTTCACCACAAGTCCTTTCAGTATTTCGTAAAAGAGGTTC +AGGATGTAGTCAAGGGCTATGAAGGAGTCCGGAAGTATTACCCTTTCAACGGAAGAGTGGGAAATGTCCC +TCTCGTGCCACAGAACTACGTCCTCCATAGCGGGTATTGAGTTGGCTCTTATAACCCTTGCGAGTCCGCA +TATTCTTTCCGAGTGTATTGGGTTCTTCTTGTGGGGCATGGCCGAAGAGCCTCTTTGACCTTTCGTAAAG +GGTTCTAAAACTTCCAAAACTTCTGTCCTCTGGAGGTGTCTTATTTCCGTTGCAAACTTTTCTAAGGAAC +TCGCTATTAGTCCGAGGGTTGTTAGGAGCTGGGCGTGCCTGTCTCTGTGGACTATTTGAGTAGATGCAGG +TTCTATTTTAAGACCGAGTTCTTCAAGGGCTAACTTTTCAACCTCAGGTGGGATGTTGGAGTAAGTGCCA +ACAGCTCCTGAAATTTTCCCGTAAAGGACATTTTCCCTTGCAAAGAGAAGTCTCTCCTTTTGCCTCCTCA +TTTCGTCGTACCACACGCACATCTTGAGACCGAAAGTGTAGGGCTCTGCGTGAACTCCGTGAGTTCTTCC +CATCATTAGGGTATCCTTGTGTTCAAAGGCAAGTCTCTTTATCTCTTCCATTACCTTGTCTATATCCTTC +AGGATTATGTCAATCGCCTCTCTTATGAGGAGTGCGAGGGCTGTGTCAACAACGTCAGAAGAGGTAAGAC +CCATGTGTATGTACCTTCCCTCTTCTCCTACCTGCTCGGCGATTACAGAAACGAACGCCAGAACGTCGTG +TTTAAAAACCTTTTCCTTTTCCTTAATTTTCTCAACAACCTTTTTGTCAACGTAAGTTTTTTCTTCTATC +TTTTTTAAGGCATCTCGGGGGATCTTACCGAGTTTTGCCCAAGCCCTGCATACCGCTATCTCAACGTCCA +ACCACTTTTTAAACTTATTAACCTCACTCCAGACATCGCCCATTTCCTTTCTGGTGTAGCGCTCTATCAT +AGGGAATAGGATATCAGAAGGGAGGGAAAGGAAAGAAGGGATTACTTCGCAGCTTCTTCCATTATTTTCT +TTATCGTGTTTTCAACTTCTTCAGCCAGTTCTTTGAACTCATCAGCTTGATAAAGTTTCAAGAGTTCCGT +AGGTGCAATAGTGCTGAGAACCACCTTTCCGTCCTGTTCGTAAACGGAAATCCTGCAAGGCATGGCGGTG +GAAACCTCAGGTTTTTTAGAGAGAACCTGGCTTGCAGCTTTTGGCTGGCATATCTCTACTATCGTGCACT +TGTAGCTTATGGGCATTCCCTTGCTTTCAAGTATTTTGTGAACCTCGTGAACGGACATCACACCAAAGCC +GTTCTCCTTTGACTTTTCCTGAACGGCCTGAACTACTTGTTCAAAGTCTTTGGTGCTCTCCACGTTTATC +AGCATCTTAGCCACCTCCTTATAGATTTTTTAAAAATAGTATTCACTAACCATTCTATCATTTCTATGAC +TTTAAACATTAACCGAAAGGGATAAAATTTTTAATCGTGGGAGATGTTAAATCAGAGATTAGAAGTAAGG +CAAAAACTAAACTTAAAACTTTTACTGAAACAAGATCTTGAACTCCTCACTTATCAAACTCAGGAACTTG +AAAAACTCATACATGAAGAGGTTCTCGTAAACCCTCTAATAAAAGGCGTTTTCAAGAAAATACCGAAAAG +TTTTGAAGTAAAGGAAACGGTTCCCTACCAGATACCATACACACCCTCAGAACTGGAAGAACTCCAGCAG +AATATAAAACTGGAACTTGAAGGAAAAGAGCAGGAACTTGCTTTAGAGCTTTTGAATTATCTGAATGAAA +AGGGCTTCCTATCAAAAAGTGTTGAGGAGATATCCGACGTGCTACGGTGTTCTGTTGAAGAACTGGAAAA +AGTTCGTCAAAAGGTGCTAAGACTTGAACCTTTGGGAGTTTGCTCAAAAGACGTGTGGGAGTTCTTAGAG +TTACAGATTGAAGAAATTTACCCAGAAGAAGAGGAAATTTTAAAAAAAGCCCTTCGGGATTTAAAAAGAG +GAAAAAAGCTAAAACCAGAAATTAAGGGAAAACTCTCAAGGTTAAGACTCTTTCCTCTTTCCAGTTCAGC +GGAGAAAGTTTACACCTTTGCAAAAGTTGACGCAATTATAGAGGAAGAAAACGGAGAGTTTTTTATATAC +CTTTATGAAGACTTTATAGATATAGACTTAAACGAAGAGTACTGGGAACTTTACAAAAAGTCAAGAAATC +TCCAAAAGGAACTAAAAGAGGCCTTTGAGAGGTACGAAAGTATAAGGAAGGTTCTGGATATAAGAAGAAG +GAATTTAAGGAAAGTTTTAGAGAAAATCGTTGAAAGGCAAAAGGATTTTTTAACGGGAAAGGGAAGTTTA +AAACCGCTGACTTTGCGTGAAGTTTCAAGTGAGATAGGAATACACGAATCTACATTGAGCAGGATAGTGA +ACTCAAAGTACGTGAAAACTCCCGTGGGAACTTACTCCTTGAGAACTTTCTTTGTGAGAGAGTCGGCGGA +GGGATTAACGCAAGGTGAGTTAATGAAATTAATCAAGGAAATTGTAGAAAACGAAGATAAAAGGAAACCT +TACAGTGACCAAGAAATAGCCAATATTCTAAAAGAGAAAGGCTTTAAAGTTGCGAGGAGAACGGTTGCAA +AATACAGGGAAATGTTAGGAATTCCCTCCTCAAGGGAAAGAAGGATTTAAAAGGGAGAAAGGGAGATTAA +GCCACTTCTCCTTGTTCTTCTAGTTTCTTTATGGCTATGCTGAGTTGGTGAAGAAGGTCTGCAGGTGATT +CTACTTGTTCTACTTCCATTGCGTCAATTACCTTTTCAATGGGTACTCCTCTCCAGTAGAGTCCTGCGAG +TTTTTCCTTCAGTTTTTGCTTGTCCATGGGGAAGTGTTCTCCGTGTATTCTCTTGAGAACTTCCGCAGCC +CACCTTATTCCTTTTCTCGTTTCCGTGGGGATTTCACCTCTTTCTTCTAATTTGTGAACAGCTTCAGCTA +TGTAGTGAAGGACATCTCTGGGAGTGTCAAACTTATCCACCTCAATTTCATCAATTACTCTCTCAACGGG +CACACCTCTAATGGACATACCTGCAAGCTTTTCCCTGAGGGTATCCTTTGTGATAGGATAATTAATTCCG +TGGAGTCTCTTTAAAACTTCTGCTGTCCAACCAAGTGCTCTTCTGGGCATGGTTCCCACCTCCTTTTAAG +TTTTTTCTGACATTTATCAATATATACCTGTAAACTGTCATGTCAAGTCTTTTAAAAGCCAAATTTTTAA +CTAATTTTTCAAGGTAAATTTATAGATATGGATACGAGAGATGAAGCTCAAAAGCTTGCTAAGGAAGTTT +TAATAAAGCTTCTTGAGTGCGGGACTGAAATAGATGAGTATTACAGGAAGTTCAGGGAACTGCGGGTACT +GGAAGACAGGAGTCCCTCCTTTCAGGCTGCACTTATAAACGTTGAGCACGCCTTCTTTATGGTAGTACAA +TCTATTAATGTTCTCAGGGAACAGTTGAGGCTTCTGGAGGTGGCTTCCAAAAAGAAGGAAATTGAGTGAT +GGGACTCAAAGTTCTCCTATATGACCCTGATGGAGAGATAGCTCACTTTTTAGAAGATATATTTGAGGTA +ACGGGTCATACACTTTACCCTGCAGGTTCGGAAGAAGAAGTATTTGAGTACTTAAAAAACGAACCTGAAT +TTTTCTTTCTTCCTTTTTCCTTAAAGGAAGCATGGGTTAATTCCCTGAAAGAGCGTGCAACAATACCCAT +ATTTTTCCTTTTCTCGGAAGAGGAAGAAGAGAGAGCAAAAGGGCTGGGTATTCCCGAAGTAAACCTTGTA +AGAGTTCCTTTTAATCCCCTTGAACTCTTTGAAAGATTAGGGCTTTTACATAAAATGAAGCCTAAGGATT +TTCAGGAAATAGGACTCTTCAACACACTCGTAAAATCCCACCTTGAAGAAAAAGGTGTAAAGGTAAAGAT +AAAGGGCTCAGGCGGGGAGTGTCTCGTAAACACTTATCCGGTTTCACTTTCGTGCAGGCTGGAAGAACTG +AAGGAGCTTTTAAAGAAGCGATTACGAACTGGAAGAAGGTGAAGATTTTGAGGAAAAAGTTAAATTTGAA +AACCTCGGAGAATTTTTCAAGGAACTCTTTAAAGAGGAAGAGATTAAAAAGGAAAGGAAGACGATACCCC +TTGAGAAGTTTGAAACCATAAGGACTGTAAGCAGGGAATACAAAAGGGGAATTTTTAAGAAGAACTTTTA +CCTGCTTGGTCAAAACGCCATCACATTAATAAATCTCTCTTCCGTGGACACGCTCGCCTTCATAAACAGA +GCTTTGGTAGAAGAAGGATACTCTTTGAAAGATATAAAGCTTGTTCTTATCACGGACTTTGAGCCATCTT +CAGTAGAAGCAATTCGGAGACTGCTTGCCGTAAATCAAGGAGTGAGCTTCATAGGAAGGAAGTACGTTAA +GGAAGTCCTTGAGAAGTTCGGACTCAGGAACGTACGCTTCAGAGCTGTGGAAGAAATTCCTTCACTTGAG +TTCAAACTTCCAGAGAGCGGGACGGTAAAGGTACTTCCTTTTAGAAACTCACCTCAGGAGGCTTCGGCAG +GGTACCTTCTGGAAGAAGAAAGAATTCTGTTTTCGGGAAAGTTTCTGGGGAGTTTTGGAGAAAAAGGAGA +TACTATTCAAATTTTTCACAGGGTTTTCTTCCCGTGCAGGAACATACTTGACTACAACGTAGGTTTGCTT +GAAAGTATCGGAGAAGAATTTGAAGTTTTTCCCTTTTACGGAGAAAAACAGAAATTAAGTGCAAAAACTC +TGAAAGAATACTTTAACTACACGGTAAAAGGTAGTGTCCTTGAAAGGGAAGTAATACTCGGTTTGGTGAA +CGGTGTTTTACTGAACCTTTCCGACGAGGAAAGAGAAAATCTTTTGAGTTCAATAGGATACCTCGCGGAA +GTGGACGACAAAGTTATCGTAGATTTCTATACAGAACCGAATCTTTTCTACGAGGAATTTGTAAACACTC +TCCCAGACGCGGTTAAAAGCAAGGAAGAGTTTTACAGGATAGTAGAAAAACTCCTGGAGCACAATTTTTA +CGTCCCGCTAAGGGCGGTTTAAAATACTTTAAACACCTATTTAAAGGAGCAGGGAATGAAAGTACACTCA +AGCGTACTCATAGAAGGAGAGGTTGAAATTCCTGAAGACGTTGAGATAGGAGCTTATACCGTAATTCAGG +GAAACGTGAAGATAGGGAAGGGGACGAAAATAGGAAACAGGGTAACGATAAAGGGAAACGTAACCATTGG +TGAGAACTGCAAGATTTTTGACGGAGCGGTTATAGGAGAAGCGCCCCAGCACCTGAAGTACGAAGGGGAA +GAAACTTCCGTGGAAATAGGGAACAACGTGATAATAAGGGAGTACGTCACCATACACAGGGGAACAAAGC +TGGACAAAGGGAAAACGGTTGTCGGAGATAACGTCATGCTCATGGCATACTCTCACGTTGCGCACGATTG +CGTTGTGGGAAACAACGTGATTATGGCAAACTGTGCAACGCTCGGGGGACACGTTGTCGTCGGAGATTAC +GCCCTCATAGGTGGTCTTTCCGCGGTTCACCAGTGGGCAAGGGTCGGAGAACACGCCATGGTGGGCGGTC +TTACGGGTGTCTCTTTAGATATACCGCCCTACACGGTAGCCTCGGGTCAGCACGCAAAGCTTTACGGCAT +AAACATAATCGGTTTGAGAAGGAGGGGCTTTCCCGAGGAGGTCATTAAAGCCATAAGCAAAGCTTACAGG +ATTATTTTCAGGAGTCCGCTTCCGAGACAAAAAGCCCCTGAGATAGTTTTTCAGGAACTTGGACAGTACG +AGGAAGTGAGGAAAATGGTTGAGTTTATAAAGAGTTCCAAAAGAGGAGTGGCGAGACACCACAAGGACTG +ATAACATAACATTCATGCGTGCTGTAATTCTGGCTGCCGGACTCGGAACGAGGTTCAAGAGCGAAAAACC +CAAAGTTCTCCACGAAATACTCGGAAAACCGATGCTCTGGTACGTGATAACGAACGTAAGAAACGGAAGG +ATAGACGACATAGCTGTCGTGGTGGGACACAAGGCGCAGGAAGTGATGGAAGCCTTTAAAAACGAAAACC +TGAAATTTTTTATACAGGAAAACCCCAAAGGCGGGACTGCTGACGCTGTACTCGCAGCGAAGGACTTTTT +CTCTTCTTACGAGGGATACGTACTCATAATAAACGGGGACAGTCCCTTAGTCAGCGGGGAAACTATAAGA +AACATGCAACAATTCATTCACATGGTTCGGACTTACGAGGGGATAAAACTCGGAGGGGTTGTTTTAACGA +CCCACCTTCCCGACCCTACTGGATACGGGAGGATTATAAAGGAAGAGGGGACGGACAGAATTATCAGGAT +AGTTGAGGAAAAGGACGCAACTCCCGAAGAAAAGGCTATAACGGAAATAAACGCTGGAACTTACATCTTT +TACGCACCTTACCTCCTTGAAGCCCTATACAGGATAAAACCGAGTCCCGTGACAGGAGAGCTCTACCTGA +CCGACGTAATAGAGTACATGGTAAACAAAGGGTATGAAGTAAGGAGCTTTATGGCAAAAGAACCCACGGA +AGCCCTTGGTGTAAACACCCGCTGGGATTTAGCACTCGTAGAAAACGTAATAAAACTCAAGATAGCGAGG +TACTGGGCCGAAAGGGGAGTTACTGTTCATTATCCAGAAACCGTGTGGATAGAACCGGACGTTTCCATAG +AACCCGACGTGGAAATATTTCCCGACGTTATGTTGAAAGGAAAGACGAAAATAAAGAAAGGTTCAGTAAT +AGGAAAGGGAAGCGTTATAAAGGACTCACTCGTGGAAGAAAATGTAATAGTAAGGGAATACTCGGTAATA +GAAAATTCGGAAATTAAGAAAAGGGCTGTTGTCGGACCCTTTGCGAGGATAAGGAACGAATCTGTTATAG +GAGAAGAGGCTGAAATAGGGAACTTTGTGGAAGTTAAGAAGAGCAGTATAGGAAAAGGGGTAAAGGCAAA +GCACCTCGCTTACATAGGGGATGCAACTGTGGGAGAGAATACGAATATAGGGGCGGGTACGGTCTTTGCA +AATTACGACGGGAAGAGGAAATACGAGAGCTACGTAGGAAAAAGCGCCTTTATAGGTAGTAACTCCCTTT +TAATAGCTCCTATAAGGGTAGGGGATTGGGCTTATATAGCGGGGGGTTCCGTTGTAAACAAAGATATACC +GGAAGGGGCACTCGCGGTCTCAAGGCCTGAACTGAAAATTTTTGAAGGAAGGGGGAAGAAAAAACTCCAG +AAAGATTAAACTCTTGCAAGAACTTTTTCTTTGAAGTCTTTTAACGTCGGTTTTATCTTCACAGGTGTGC +TTAGTTTCCCTTCCAGAACTTCCATAGTTTTATAGCCGTTCCCCGTTATGTAAACAACTACGGTCTCTTC +GGGGGAAATCATTCCCTTTTCTACGTATTTCTTGAGAACTGCTATCGTTGTTCCTCCTGCGGTTTCTGTA +AATATGCCTTCGGTTTGTGCGAGGAGTTTAATACCTTCTATTATTTCCTCGTCCGTTGCTGTTTCCCACG +CACCGTTGCTTTCCCTTGCTACCTGAAGGGCGTATATACCGTCCGCGGGATTTCCAATCGCTATGGACTT +GGCTATGGTGTTGGGTTTCACAGGTTTTATGAAGTCCCTTCCCTCTCTCCACGCCTGAGCTATCGGGGAG +CACCCCTCTGCCTGAGCACCGTACATTCTCGTCTTTACTTCGTCTATTAAGCCGACTTTTTTTAGTTCAT +TAAAGCCTTTCCATATTTTGGTGTAAAGAGAACCCGATGCCGCGGGTGCTACAACTACGTCGGGAGCTCT +CCAGCCGAGCTGTTCAGCGACTTCAAAGGCTAAGGTTTTTGAACCTTCCGCGTAGTATGGTCTTATATTT +ATGTTCACAAAGGCCCAGCCGAGGTCGTTTGCAATCTCGGAACATAGCCTGTTAACGTCGTCGTAATTCC +CCTCAACTGCAACAACGGTGGGGTTAAAGACAAGAGAACCTATAATTTTCTGGGTTTCAAGGTTTGCAGG +TATAAACACGAAGCAGTTCATTCCCGCCTGAGCGGAGTGGGCCGCAACGGAGTTTGCGAGGTTTCCAGTG +GAAGCACAGGCCGCAGTATCAAATCCGAACTCTTTTGCCTTGGAAAGTGCCACGGACACAACCCTGTCTT +TGAAGGAAAGGGTAGGGTGGTTTACGCTGTCGTCCTTTATGTAAAGGTTCTTAAGACCGAGGACTTCTCC +AAGTTTTTCCGCCTTTTTAAGGGGCGTAAATCCCGCCGTAAGTCCTACCGTGGGGTTTTCTACGGGAAGC +AGGTCAACATATCTCCATAAACTCTTTGGTCCTTTTTCTATCTTTTCTCTGGAAATATTTTTCTTTATCT +CATCGTAGTCGTATACAACTTCAAGCGGACCAAAGCAAAACTCACAAACGTGTATGGGCTCGGCGGGGTA +TTCCCTTCCACACTCACGGCACTTTAATCCCTTTACCTTTGCCATAGATTATATACTACACATTAAACCT +GAAATAAACAACATCGCCGTCCTGTATTTCGTAGTCCTTCCCTTCAAGTCTTATCAGTCCCTGTTCCTTT +GCCTTTGCCCATGAACCCGCCTTTATAAGGTCCTCATAGCTTATAACTTCCGCGGCTATAAATCCCCTTT +CCATATCGGAGTGTATTTTTCCCGCGGCTTGGGGTGCTTTGGTTCCTCTCTTTACGGTCCATGCTCTGGC +TTCCCTCTCACCTGCGGTAAAGAAGGTTATAAGGTCAAGGAGTCTGTATCCCGTCCTTATGACTTTGTTG +AGTCCCGGCTCCTTCAGTCCATAGGCTTCCAGCATTTCCTTTTGCTCTTCCTCGGAAAGACCTGCAAGCT +GAGCTTCAAGCTCAGCACTAATTACAACGACTGGGGCATTTTCCTGGTTTGCCATCTCTTTTATTCTTTC +CACGTGTGGATTTCCTTCACCTTCAGGGAGGTCCTTTTCCGAGATGTTTGCTATGTACATTACTGGTTTT +ACCGTGAGAAGGAAGAGGGTTTTTTTGGCGTATTCCAGGGTTTCAGGCGGTAATTTATCAGCGTATTTCC +TGATAGGTTCTAAGTTTTCAAGGATTTCCTTCAGTGCGTTCAGATGCTCCATTTCTTCTCTGGCTTTTTT +GTCTCCGCCCTTTGCGACCTTTTGCACCTTTTCAATTCTCCTGTTTACGCTTTCCAGATCCTTTGCGATA +AGCTCTATTTCCACTATTTCCTTGTCCCTTACGGGGTCAACAGAACCTTCCACGTGGACTATGTTTTCGT +CTTCAAAAGCCCTGAGAACCATGGCTACTGCGTCAACCTCTCTGATATGGGAGAGGAACTGGTTTCCGAG +TCCTTCACCTTTACTCGCACCTTTAACGAGTCCCGCTATGTCCACAAATTCAATAAAGGTGGGAGTTATC +TTCTGAGATTTTTCAATTTCCGCGAGTTTATACAATCTCTCGTCTGGAACTTCTACGACTCCCACGTTCG +GTTCAATCGTACAAAAGGGATAGTTTGCCGCCTGAGCTTTCATGGTTTTAGTCAAGGCGTTAAAGAGGGT +TGACTTTCCTACGTTCGGCAGTCCTACGATACCTAGCCTAAATCCCATAAGAATATTAATATAGTCGTTA +GAAAAAGCACAAATACAAGTAAATTTGGGGAAATTTTATCACGATCCCTTACTGTTAGGGCGTAACGTAT +GCCTTATCGCTTATTAAGTATTATAAAGCAAAGTCGCAATCCCTTATTGTAAGGGCATAACATTGATTGG +GAAATTTTTTTAAATGCACAGAAAGAAATGTCGCAATCCCTTATTGTAAGGGCATAACATTGATTGGGAA +ATTTTTTTAAATGCACAGAAAGAAATGTCGCAATCCCTTATTGTAAGGGCATAACCCTGCACGCTTGTGT +ATTAAAAATAACGTTCTATAAACAACTTATTAGGCATCCCATATTCATGAAATGAATGTTAATTTCCGCT +AACCCGAGGTCCTGCAAACTTGAGTATACCTTTGTAAAATTTTTACCCTTGATTTTCAATCTGTCTAACT +ATATAACATCATGATATTACTTCATCACGTCATCAAATCATCACTTATTAGACCAACTACCTCTATTCAA +TTGCCAAGGAGACAAGTGGGCTCTCTTACAGAGCCCACTTAATATTATATACCATTATCTTTTTTTCCTT +CTCTTTATCCTTTCTATCCTTTCAAGGCTTCTATTCTCTTCTGGAGCTACTAAATTTACTGCTACGCCGT +CTCTACCCATCTTCCCGTTCTTCCTATTCTGTGAAGGTAAACTTCGGATCTTCCGGAAGGTGGAAGTTCA +CTACTGCTTCCACTTCGCTTATATCGAGCCCTCTGGAGGCTACATCGGTGGCAACGAGTACATTAATAAA +ACCTCTCCTGAACTTCTTAAGTATTTCTTCCCTTCTCCTTTGTGGAAGATCTCCGTGAAGAGCCCCAACT +CTAAAACCTTTTGTGGATAACTTTTCTCCTAAAAACTTGGCATCCCTTTTCCTGTTTACGAAAACTATAA +CTTTGTTGAAGTCCCTTAAAACGTCTTCAAGTAATTCTATTTTTTCCCTTATTGAGTAAACCCTGAGGAG +TCTCTCTTCAATTTGAGGTTCCAGTTCTCTGCTTTCCACTTTTATAAACTCGGGTTTTTTTGTGTACCTG +TGGGACAACTCCCTCACTTCTTTCGGGAAAGTGGCAGATACGAAGAATACCTGTTTTTCTTCGGGAAGTT +GAGAATAAATAAAGTCAATATCTTCCTTGAAGTTCATATCGAGCATTACGTCAACTTCATCGAGGACAAA +GTACCTGACGTCATCTGTCTTAAGTGCTCCTCTCTCTATGAGGTCTTTAATCCTTCCGGGTGTTCCGATA +ACTACGTCTACTTTTCCACCTCTGAGTACTTTAAGGTCTCCGAAAACCTTCGTTCCGCCGTAAAAAGCAA +ATGTTCTGACGTTCAGATACCTTGCAAAATCCCTGAAGTTGTCCCTTATTTGGAGGGCGAGTTCTCTGGT +AGGCGCAAGTATAAGAGCCTTTTCGCCTTCTTTAAGGGAATTCAGTATCGGAAGTCCAAAAGCTGCCGTC +TTTCCCGTCCCCGTTTTTGCCTGAATTAAGCAATCCCTTCCTTGAAGAGCTACGGGAATGGTCATTTCTC +GTACAGGTGTAGGTTCGTGAAAACCTATTTCTTTTAAAGCCTTTTGGATTTCAGGTTGAGTTGTGAAAAC +ATAATCCTCTTCTATTTTTGGGGAAGGAAAGACTTTTTATCTTTCCTTAAACCCAGTTTAGTAATTTAAC +CGAAATTTCAACAAAAAGCATCTAAATTTTTAGTATGAAAGAATACTTTTAGTCTTAGCCGTAGCGATTA +TCTCTTTACTGGCTGGAAGACTTATCAAGAGACTCCTCGAAAAGAGAATGGAAGGGAAGGAAGTTGAAGG +AATTGAGGATGGTGTGCTTTACTTTTACTCGCCAAATTGCGGTGTGTGCAAGGCTATAAGCGGGAAGTTA +AAAAACTTAAGAGTAAAGTAAACATAATTGAGATAAACGTCGAGGAAAATAAAGAACTTGTGAAAAAATA +CGGCGTTCTCGGAGTTCCCGCTTTCTTGATCGTGGAAAAAGGTAAAGTAAAGAAAGCTTTTTTAGGAACA +AAAGGTTTAGAGTATCTTAAAAAAGGAGGTAAGTAACTATGAAAAAGGCTTTATTCTTGGTAGGACTTGT +GTTCACGGCGGGAGTTATTTCTTCCTGCGGTGGAGTTTCTTCCCAGAGAACTTATGAAGGTGCCGCGGTA +GGTGCTGCTGTAGGTGCAGCTGCGGGAGTGCTACTCGACAAGGAAAACAGGTGGCGTGGTGGAGTGATCG +GAGCGGCACTGGGAGCAATCCTCGGAGGAACGATTACGGAAATAGCCCAGAGAGCTGCAAAGGAAGCGGC +TCAAAACAATAAACCAGTAGTTTACAGGGCTGAAGACGGTTCTCAAATGGTCAGAGCCGAACCTGTAGAA +AAAAGAGGAAATTGTACACTCGTAAAAACTAAGTACTACCAAAATGGAAAACTCGTAAAGGTTGAAGAGA +AGGAAGTTTGTGAGTAATTTCTCTTCTCTTTCCTTTATAATTCTGTAAGTATGAGACTGAAGAAATTACC +GATAAGAAGAAAAATGCCCATGGAACTCGCTTACATTGAGAAGCTCTTCCGTGAAGAGGTGGGGCTAGAC +ATTAAAGAACACAAAGACAAAGCTGAACAAATATCCGAAACTGTGGTTGAAATATACGAAGAACTTCTCA +GGAAAGGCATAGAAAACGCAAACTACAACGGAAGGGATTACGTCTCTTACTACGACCTTCCCATAACCGA +AGATCTCGAACGCTACATGAACAGATTTATACAGGACAGGGGAGAGGAAGTATTAAAGGCTTTCGTTGAT +TATCTGGCAAAGCTTGAAGAGGAACTCTTAAAAGCGGAAGAAGCTCTCCCGCCACTTGACGAAGAACTCC +ACCAAAAGAAGGCGGATATCCTCGGCGGTATCATGCTTATGTTTGCAAGTGTGGCTAAACAAATAAACGG +AGACAGAAAACTCTACGCGGAAAGCATACCCGTAACGAGAGAAGTCCTGAGGACGATGATTTAAAATTAA +GTTTATGAGAAAAGTACTCATCTTCTTAGAAGAACTCGTTGAAGACGTTGAGTTTATATACCCGTACCTC +AGGTTTAAGGAGGAGGGGTTTGAAGTAGTATCCGCTGCCCCGAAGCTCGGAGAGTATAAAGGCAAAAAGG +GAATGACTTTCAGACCAGATAAGACCATAAAAGACGTTTACCACCAGGAATTTGACTGCGTATTTATACC +GGGGGGATACGCTCCCGACAGACTGAGGAGGTATCCCGAAGTTCTACACATAGTTAAAAAACACTACGAC +AGCGGAAAGCTCGTTTGTGCGGTTTGCCACGGTCCGTGGGTTCTTATCTCCGCAAAAGTTGTTAAGGGAA +AAAAGGTAACGGGATTTTTCGCAATAAAAGATGACCTTATAAACGCAGGTGCGAATTACACGGGGAAACC +CGTGGAAGTTGACGGCAACCTTATTACCGCAACCGATCCCAAGTCCATGCTTGAGATGATGAAGGTGATT +ATATCGAGGCTAAAGTAATGAAGAAATTTTTAATAATCCTCTTATCCTTCGTTCTTTTCGTATTCCCTGA +GGATCTTATTCTCGTGAGCATTTATCCCTTTTACGACGTTGTAAAAGACATAAGCGGGAAGTATTACAGA +GTTGAGAGTTTAGTTCCTCCGAAAGCGGATTACCACGTTTACGAATTGACACCAAGAGAACTCATAAAAC +TCTACAGGGCAAAAGTCGTTTTCGTTAGCGGTGTTCCCTTAGGAGAGTGGGAAGAGAAGGTGGAGAAAAT +AGCCAAGGGCAAAGTTTACTCCCTGTCAAAAGGCATAGAGCTAATCACCTACGGACACGAAGAATTAGGG +AAGGATCCTCATTTCTGGGTATCTCCAAAAAGAATGCTAAAAGTGGCTAAAAACGTAGAAGAAGCCCTCA +CGGAAACCTTTAAAAAGAACTTTTCTGAAAATTACAAAAACGTTGAGCAAGAGCTGAAAAAACTGGATGA +AGCTTACACGAAAACGCTTTCCAAGTGCGAGTATAAAAAGTTCGGAGCAGTTCACGGAGCCTTCGGATAC +CTTGCGAAAGACTACGGACTTGAACAGGTACTCCTCAGGGAGGAGCACGGACACGGTGATATATCTCCAT +CTGAACTGAAAAAACTTGTAAAACTCATAAAGAAAAAGGAAATAAAGGTAGTTTTAATTCCTAAAGGTGT +GCACTCAAAGTTTGCAGAAATATTGAAGGAAACGTACAACATCACCGTTTACGAGGTAAACGTTAAGATA +ATCCCGGAAGAGGAGGGAGATAATTATTACAAAATTATGGAAAGGAACTTAAAAGTTTTAAAAGAAGCTC +TCAAATGCGGGTAATAGAAGTAAAAAATCTTACCTTTTCATACGACGGTAAACACAACGTCCTTGAAGAC +GTTTCTTTTTACGTAGAAAAGGGAGACTTTTTGGGGATAGTTGGCCCAAACGGAGCGGGGAAATCCACAC +TTCTGAAATTGATTCTCGGCTTTTTAAAGCCAAAATCTGGAGAGATATACCTCTTCGGAAAGAAAATAGA +AGAATTCAAAGACTGGAAAAGGGTGGGATACGTTCCCCAGAGACTTAGCGTGGAACACGCTTTTCCCGGA +ACTGTGAAGGAGCTCCTAAGCAGCGTATGCGAAGACAAGAAGGAAATAGATTACCTTGTTGAGTTTTTAA +AGTTAAAGAATATAGTTAACAAGCAATTTACAAAGCTCTCGGGAGGACAGCAACAGAGGGTTTTACTTGC +TATGGCTCTTTCCTACAATCCTGAACTTATACTCCTCGACGAGCCAACTGTAGGACTTGACGTACACGCA +ATAAACCACTTCATGAGTATTCTACTGGATCTCAATATGAACCATAAAAAGAGTATAGTGATGATTTCCC +ACGATATAGGAACACTCCTCAAACACGCGAGTAAAATACTGTGTCTGAATAAAAAGGTATGCTACTTCGG +AGAACCTGAGGGGGCAATAGAGTACATAGAGGAAGCCTTCGGGCTGAGGGGTTTTCTCCATGGAGTTTCT +TAGTTACGACTTCGTCCAGAGGGACTTATTGCCGGAATACTCATAGGTGTATCCACTGCATTGACAGGAG +TCTTTTTAATCTTGAGAAGGTACGCATTTCTGGGAGCGGGTCTCTCTCACGCTGCCTTCGGAGGCATAGC +CCTCAGTTTCTTGCTGGGAACCGACGTATACTTAACTACCGTTATCTTTACTATTCTGGTTGCGAACTTC +GTCCAGTTTCTGACTCAAACAAAGAAAGTTCCCGGTGACACCGCAATTGCAGTTATTTTCTCAAGCGGTA +TGGCGCTCGCCGTAACCATTCTGGGAATTGTCAGGGGATTCGGTGAAAACCTCTTTTCGTACCTTTTCGG +AAACATACTCATGGTTACGAAGGAAGAACTCTTCTACACGGCGGGTGTGTTTCTTATAACTCTGCTTTTT +ATAGGAATCTTTTACAAGAAACTCCTTCTCACAACGTTTTCCGAAGAAATGGCGAAGGTAAAGGGGATAA +ACATATCCTTCCTGAATTACTCCTTTGTTACGCTCACGGCTCTCGTTGTGGTCGCAAGCATAAAGGCAGT +AGGGGTAATACTTGCCTCTTCCTTAGTCGTAATTCCTGCGATGAGCGGTTTGATACTTGCAGGTTCCTTC +TTGAGCAGTCTAATAATATCTTCGGTTGTTTCTACTCTTTCCGTTGTCCTCGGGATATATATTTCCTTCA +ATTACGACGTTCCGCCGAGCGGTTCGATAGTGGGAATAGCGATACTCCTCTTTCTAGCTTCCTTCTTACT +GAGAAAGCTTCCTCTGAAGTAGAACCTTGAACCTGTCTCCCATAGAGATAAGCATGGTCTTCAGTCTAGA +TAGCCTTTCCACACTCTCAGCACTCTCCTCCCAGCTCAGTTTCTCGAGTTCGTTCAAGAATGTTGGTATG +TGCATCAAAAAGTCCCTCTGACTTTGGAAGAGAATAGTCTCAAGACCAAAGTCCCTTCCGTATTCCATGA +GTGCGGAAAAATTCACGTGTGCGGTTATGTCCGCGTTCCCAGCTTCCTTTAGAAAGTCCTTTACAACCTT +GTGTTCTTTGTAGGCTACTACAGTCCCCTCAGGATACTTTGTTATTTCCTCGGAAGTGTACCCGTAATCT +ATCACGAAATGATAACCTTCAACAAGACTCTCGGAAATTTTCTTCAGCATATCTATACAGTCGAGACAAA +CTTCCACAATCTGATTTAAGTTTTCGTAATTCATTCTCCTTAGGAATTCCTTTACCTTCTCGTTTTCTAA +ACTTAGCCACACTTCGCTTCCCTTTTCATCAACGTAAAGCTCCTTACCTCCCTTTACTATGTGAACAGGA +AGGGCGTCAAAAAACTCATTTGAGAACACTATTCCTTCAACCTTCGGTAGCTCTTCTACCCATTCCACGT +TTTTAAAGTTCTTTAAAACTTCTCTTTGCTTACTTATCAGGTAAGGACTGAACTCGTATATGTAATACTT +TAATCTGTTGAAAAGATCCGGATAATTTGCCCTGTAGTAATTAAGGATGTCGTAAGCAAGCAGCCCTCTC +CCGGCACCCAGTTCAACAAGGGCGGGTCTTTCAAACTCAGAAAGGTGCTGGGAAAAGAACTCGGCGAGTG +CTTCGCCAAAAGCCCTGTCCAGTTCCGGAGCCGTAAAGAAGTCCTTTAAAGCCCTCTGGGAGGAGTAGTA +ATCCTTTACCGCTTTTTCCATAAAGTCTCTGAAACTGATAAAAGCCATTATTTAGAATATATTAAATACT +TTACGGGAGAAGATGAAAAAGTTAGTAATAGGTATTTTAGGAATAGTTATAGCCTTATTTGTCGGACTGC +TTGTCTTCCTCATACCCATCTACAAAAACCTTCCCGATCCGAAACTCTTGGAGAGCTGGACACCGCCTCA +AGCCTCGGAGGTTTACGATGCAAAGGGAAGGTTGTACGGGACGATAGGCATCCAGAAGAGGTTTTACGTG +AGTATAGACAAAATTCCCGAACACGTTATAAACGCCTTCGTTGCGACTGAGGACAGAAACTTCTGGCATC +ACTTCGGGATTGACCCTGTGGCAATAGTAAGGGCTGCAATTGTGAACTACAGAGCCGGCAGGATAGTTCA +GGGAGGTAGTACGATAACCCAGCAACTCGCTAAAAACTTATTCCTAACTAGAGAAAGGACACTGGAGAGA +AAGATAAAGGAGGCACTCCTTGCCATAAAGATTGAGAGAACCTTTGACAAAAAGAAGATAATGGAATTGT +ATTTAAACCAGATATATCTAGGGAGCGGAGCTTACGGCGTTGAAGCGGCAGCTCAGGTATACTTCGGAAA +ACACGTTTGGGAACTTTCCTTAGATGAGGCAGCGCTCCTAGCAGCTCTGCCAAAAGCCCCCGCAAAGTAC +AACCCCTTTTACCACCCCGAGAGGGCACTCCAGAGAAGAAATCTCGTACTGAAACGGATGCTAGAAGAAG +GTTATATCACTCCAGAGCAGTACGAGGAGGCGGTGAATAAACCCCTGACGGTAAAAAAAGAAAACAAGTA +CAAATTCTCCGATTACTTCCTCGATATGGTGAAGAGTTACGTTTTTAACAAGTATGGGGAAATTGCATAT +AAGGGCAGGTTAAAGATATACACAACGATAGATTTGGACTACCAGAAAATCGCTCAAAAATCGCTTGAGG +AAGGTTTGAAGAGAGTAGCAAAGATTATAGGACTTCCTTTCCTTCCAAAGTCCGAAGAAGATATGGAGCT +CGCTTATGAGAAAGAAGCACAGTTAAAGAGATTAAAAAGAGGAAAGATCTACGTAGCTAAGATCTTGAAG +TACGACGGAAATTTCATGAAAGTAGAAATCCACGGCAAAAAATTAAAGGGAGAAATAAAAGGGCTTAACA +CCGAAGGACATAAGTATGTTTTCGTGAAATACCTCGGAGGAAATAGGGCGGAGATAATTCCTGACCTTGA +GGGGAGTTTAGTCAGCATAGACGTAAAAACTGGAGAAATAAAGGCTATAGTGGGAGGAAGGAGTTACGCC +TACTCTCAGTTCAACAGAGCTGTAAAAGCCCTAAGACAACCCGGTTCAGCTATAAAGCCCGTGATATACC +TGTCCGCACTTCTGAAGGGAATGACTCAAATTTCCACGATTGACGCTTCTTCCAAACCGTACTACGACCC +CTCAAAGGGCGAAGACTGGATTCCCAAAAACTATGACGAAAAAGAATACGGAAACGTTACCCTCAGGTAT +GCTCTTGCACACAGTATAAATACCGCGGCAGTAAACTTGCTGGACAAAGTGGGTTTTGAACTAGTCCTGG +AAGTTGGCAAGAAAGTAGGATTAGACAATTTAAAACCTTACTACTCTTTAGCTCTGGGAACGGTAGAGGT +CACGCCCCTGCAACTCACTGCGGCTTATCAAGTCTTTGCAAACCTCGGAACGGAGTGTAAACCTTTCTTT +ATAAAGAAGATAGTGGATGAAAACGGAGAAGTGCTAGAAGAAAACGTACCAGAGTGTGAGGAAGTCCTTC +CAAAGCCTGAAACGAGAGTACCCGTGGATATGCTCAGAGCCGTGGTGCTGGAAGGTACAGCGAGGAGGGC +GAGTGTACTGGACAGGATAGTAGCCGGAAAAACGGGAACTACCGACGATTTTCAGGATGCATGGTTTGTA +GGCTTTTCTCCATACATAGTGACGGGTGTATGGGTGGGGTACGACGTGAAAAAGTCTCTCGGAAAGCATA +TGTCGGGTTCAAGGGTAGCACTTCCAATATGGATAGACTACATGAAAGTTGTTACAAGGATGTATCCAAA +CGAGGACTTTGAACTCCCTCCTGAAAATATAGTAGTAAATATAAACCCTAAAGACCTTGTTCTCGCGGAT +GAGACTTGCGAAGGTGTCCCTATGGTTTTCGTAAAGGGAACAGAACCTCATATAACGTGCTCTGACTTGA +ATGCCATACTGGGACTCAGATGAGGTGGATTGAGGAGGAATTAAAGAGAATTAAGGAAGCAAACCTTTAC +AGGGAAAGGATACTCCTTGAGGGAGTAAAGGATTTCTGCTCCAATGATTACTTGGGACTTAGAAAACACC +CAGAAGTTGTAGAAGAAAGTATAAGGGTTTTAAAGGAAGCAGGACTAGGTTCAGGTGCTTCTCAACTGGT +TTCCGGATACACAAAGCACCACAGGGAACTTGAGGAAAAACTTGCGGAGTTTAAGGGAACTGAAAGCTGT +GTTCTCTTCGGAAGCGGTTTTTTAGCAAACGTAGGAACGATACCGGCCCTTGTGGAAGAAGGAGATCTCG +TCCTGAGTGACGAATTAAATCACGCATCTATAATAGACGGAGTAAGACTTTCTAAAGCTCAAAAAAGGGT +TTTTAAGCATAAAGATTACGAGGAACTTGAGGAGTTTTTAAAGAAAAACAGGAAAAAGTTTAGAAGAGTT +CTAATAATTACGGACACCGTGTTCAGTATGGACGGAGATGTAGCGGATTTGAAAAGATTAACACAGATAT +GTGAAGAGTACGACTGTATGCTTTACATAGACGAGGCGCACACAACGGGAACGATAGGAAAAGGCGGACT +TGATTACTTTGGAATAGAACACAAAGAGTACATAATCGTTATGGGAACATTATCAAAGGCTTTAGGAAGT +TACGGAGCTTTTGTCTGCGGAACAAAATTACTGATAGATTACCTTGTGAACAAAGCGAGGAGTTTAATAT +TCTCAACCTCTTTACCGCCTTCCGTGTGTGCAGGTGCTAAAAAAGCTATTGAGATAATAGAAGAAAATCC +AAAATTAATTGAGTTTTTAAGAAAAAAAGAAAAGGAAATTTTAGAAATTTTGGAACAATTTTCTTTAGAT +TACAAATATTACAGCACACCTATAATTCCCATAATGGTTTACGACGAAAAAGAAACAGTAAGGATAAAAG +AAGAACTTCTAAAGGAAGGTGTGTTTATTCAAGCTATAAGGTACCCCACAGTTCCTAAAGGAAAGGCGAG +GCTCAGATTAACAGCTTCCTTAAATTACACAAGGAAAGATTTAGAATTTCTGAAAAATGCTTTAGAAAAA +GTTTTAAAAGGAAGGGCTTAGAAAGCCCAGTTTAGCCCTACACCGATGGAGTGCTGAACCATTTTCGTAG +AGACTTCCCCGGCTCCCTGTGCGGCTTTAGCCGTAACAGTTTTGGGAAGAGCGTAAACGTAGGATAGATC +TATATTGAAGTTGGGAGTAATCTTCCAGTTTAGACCCAAGGTTAAGTGGTGTTCCGCAAAAGCTGGGAAA +CCAACTAAGTTAAACCAGTAAAGTTGAAAGTCTGAAAACCGTGTATCAAAACTGGGAACACTATTTTTAG +GTGTCATAGGATCTAAGTTATCCTTATCTCTTATGGGTGTCTTTCCGTAATTCCAACCAGCCCTGAGAGC +CAAGCTGTCCATAGGCTTGTACTCTACACCGAGACCGAATACCCACTGATCCTCCCAGTCAAAGTCTCCG +TATCCGTCAGCTCCGGACCAATCTATCCATCTTATATCCAAACCGAGCTTAAGATTTTCAAGCGGTTTTA +CACCTATACCGAGCCCAACTTCTTGTGGTTGCTGTAATTTCATATCTTCAAACTTTCCGTCTCCATTTGA +GTCAAATACATTTTTATACTTCATGGATACAGGAGACTGATACATCAAACCCGCGTATATAAAGTCTCCC +ATGTTAAAAGCTATTCCCAGAGAAACTCCAATTCCGAAGTCCTGAGACTGACCTCCCCCTGCATTCCAAC +ATCTTGTAGGACTTGGCATCATGTCTCCATCGGTATCTTCAAATTGGCACATTTCAGCCCCTACATCCAG +AGAACCCCAAGCTATGTGAAGTGCACCACCCACAGAAATCATTTCGTTAATCTTGTAAGAAACCGCAGGT +GTTATTCTCATGAACTGAAAGTTTGTATGCATCTTAGAAAGCGCATTAGTGTAATGTCCGGGAGGATTTT +CAATTAGCTGTTTATCCCTGAAGTCTACACCCATACCAGATACACCGAAAGCTCCTATACCAAGAGCAAG +TCTTTAGTTTACCTTATGAACTATTCCTACTTCTGGAACTATGAAGGTATCAGCGTCACTCTTTACCCTA +CCGTTGGTTTGGAAGTATCCACCTCCTCCGGAATTTCTTGGTTCAAAATCCATAAACATCTTGGAACTAA +CCTTTACATTAGGCATGAACAGGATTCCACCGAAGCTAAGGAAAAACCTTTTAGTGTTGAAATAGGACAT +CCATGCTGGGTTTCTGAATATTGAGTCTATGGGTCCGACGGGCATTCCCGTTCCTATTCCACCCATTCCC +CTGGATGCGGGGCCTATTCCTATCATGTTGTCACCGTTTGTAGCTAAAGCAAAGGGAGCAAGCGCTAAAA +TAGACCCAATTACTGCAAATTTCTTTTTCATCCCTCTACACCTCCTGTATTTTTCCTAACTTTTTATTAA +AAAGTTTTGAAGGTAAACGTTGACTTAGTTTTTTCTTATACTTTTTAAACCCCCATTTATATAAAAGTTT +TAGAATATTAGATTGTTCTTATATTCACTTTGTAAGAATTCAAATCGTATAAAATTTTTTGAGGAGGTAG +GAAATGGCGGTAATAGTGAGGATACCCACACCCTTGAGAAGGTTAACCAACGGTCAAGGTGAGGTTGAAG +TTGAAGCAAAAAGTGTAAGGGAAGCTATTGAAAAGCTGGAAGAGCAGTTTCCCGGTATAAAGGAAAGGCT +TGTGGACGAAAACGGTGAGCTCAGGAAGTTTGTAAATCTCTACGTAAACGACGAAGACATAAGGTTTTTA +AAGGGGCTTGATACAGAACTAAAAGACGGAGATACCCTCTCAATTGTCCCCGCCATCGCCGGCGGTTAAG +CCTCCTTTATTATTTCTTCCAATCCTTCATTTTTAAGGAAGAAAACCTCGGAAATACCTCCCCTTGCACT +CACGCCTACAATCTTATCCGCAAAGGAGGTCACAACTTCTCTTAAGGTTACCACTATAAACTGGGCTTCT +TTTGACTTTTCTCTTATCAACTCACCCACTTTCTTAGCGTTAACCTCGTCAAGGTGGGCGTCTACTTCGT +CAAAGTAGTAAAATGGAGAAGGTTTGTACTCCTGAAGGGCAAATATAAGAGAAAGAGCTGCTAAAGTTTT +CTCCCCTCCCGACATCGCTTCGAGGTACTGGACGTCTTTCCCCCTCGGTTTTACGGTTAACTGAACACCT +CCCGAAAAGGGATCTTCGGGATTGTCCAAGAACATCTGAGCTTTACCTCCCGGTGAGAGAAAAGAGAATA +TCCTTTTCAGGCTTTTATTTATCTGGTTAAAGGCTTCTAAGAAGACTTTTCTCTTTTTGTTTTCCGTCTC +TTCTATTAACTTCTTTATAGCTTTGCTCTCTTCCTTTAGTTTTTGTTGCTTTTCTTTGTAGTCGTTAAAG +CGTTTTAATTCTTCCGCGTAGTCTTCCTCCGCCCTGAAGTTCACACTCCCCAGCTTTTGTATTTCTTCCG +TAACTCTTTTTAACTTCTCTTTAAGCTTGGGAATACTTTCTTCATCCGCTCCGAGTTTTAAGTCCTCGTA +TTCTTTAAGTTCTTCGTTTAAGTTCTCTATTTTTTCTTCTAGTACCTTAAGGTTTTTCTCTTTTTCAAAG +ATTTTCTCTTTTAATTCTTCTTCTTTTATTTTTAATTTTCCGAGTTTTGATTTTAAATTAAGTATTTCCT +TCTCGAGTTCTTCCTTTTGTTTTATGTAATCGTAAACCTTTACCTCTGCTTCCTTTACTTCCTGTAAGGT +TTTTTCTTTAAAAAGGATCAAGTTTTCTATTTCTTTCTTTAGAGACTTTATTCTTTCCGTCAGGTACTCT +CTTTCCCTTTCTTTTTCCTGTATTTCTTTCTCCAAGTATTCAAGCTCGTAGGTTTTTTTATTCAGTTCCC +TTTCAATTTCGTTTAAAGACTTTTCTATTTCTGAAACCTGTTTCCTTACCTTTGAGTACTCCCTCCTCTT +TTCCTCAACCCCTTCTCTGGAGTAGTGCCTCTTTATATCTCCTTCTTTGAGCTTTAAATTATTCAGCTTC +TCCTCGTAGTACTCTATTTCTTCCGCCAATTCCTTTAACTTATCTTCTACATTTAAAAGCTTTTCTTCGA +GTATTTTTAAGTATTCTTTTGAATTTTCGAGCTTTTCTTTAAACTTTTCTTCGTATTGCTCTAAGCCTTC +AGAAGATAGTTCTTCTATTTTCCTTTCACTTACCTTTAAAAGCGCTGTCTTTTCCGAAATTAAGTTTCTT +ATTTCCCTTATTTTTTTCTGGATTATGCTTTCTTCATTTTTGAGCTTTTCCTCTTCTGCATTTAGTCTCT +GGAGTTCTTCTTCATAGTAGCGTTTATTGAGTTCTCCCGAAGGCTTTACGGCTCCTCCCGTAATCACACC +GCTTTTTTCAAAAAGCTCGCCTTCAAGCGTTACCATTCTGTAATTCCCTATACCTATTGCCTTTGCACTT +TCAAAGTTTTCAACTATCAGCGTGTCTCCGAAGACGAACTTAACGACTTTCTCAAACTTCGGATCGTACT +CCACGAGGTTTACCGCAAAGTCCACAGCCCCCTTTGTCCTCGGATACCTGAGAGGTCTTTCCTCAACCCT +GACTCTATTCAGGGGAATAAAACTAAACCTTCCTAAGTTCATTCTCTTTGCAAGTTGTATGCACTCCTTT +GCAACCTCTTCGTCTTCTACAACTATGAACTTTAGCCTTCCCCCGCCGGCTACCTCTATGGCGGTTATGT +GCTCTGGATTTTTGACCCTTATAAGTTCACTTACGCTTCCGTAAACGCCTTTAATATCTTTAAAAACATC +TGAAACGTCCGAAAAACTTCTTACTTCCCTTTCTATCGCACCCTTTTCCTTGAGTACTTCTTCAAGTTTT +TTCCTGACTTCGCTTAATCTTTTTTCGTAAATGTTGAGTTCTTGCGTGAGATTTCTTAACTCTTCTTCTT +CTTTCTTTTTAATTGCTTTTAGCCTTTTGATTTCCTGTTCCTTTTCCTTAATTTCCTTGATTTTCTCTTC +TCTTTCCGATATTAACTTGTTTATATCTTCCTTTATCCTTTCTATTTTGTTTTTTAAGTTTGCTCTTTGA +ATTTCTAACTCTTGTTTTTCTTTGTTAAGAGAGTTCAATTTTTCCGTTAATTTCTCCTTTTCTTCTTCAA +GTTTTTTAACCTCGTCGAAGGTTATCTTTAGTCTTTCTTCTTCTTCTTCAAGTTCTCTCAATTTTTCCCT +CTCAACTTCTTTTAAAGACTTATACTCTTCTTTGAGTTTTTCGAGTTCAAGTTGTAAAGTTCCTACCTCT +CTTTCAAGATTTTCCTTATCACTCAAAAGGTTGTTTATTAATTCTTCAAGATTTTTAACTCTATTTTCGC +TCTCTTTTAATTCCCTTTCTTTTTCCTTTATACTCCTCTCTGCGTTTTCAATTTCCGCGGTAAACTTTCC +CACTTTTTCTTTGAAGGGCATTATCTTTTCGTTTACTTCCTTTAAAAGTCTTTCTCTTTCATTTAATTCC +TTTTCATTTTCCTGTATTTGGAAAGTTATATCTTCCAAACTTTCTCTCAAGGAGCTGAGTTCGTTTAAAA +TTCTTTCCCTTTCTTTCAGGAGTTTTTCCTTTTCTTTTAGAAGTATTTTTGCTTCTGTTTCCCTCTTTAT +CCTTTGTAGTTCCTTAAATTTCTCAAGTTTTTCTTTTTCTTCCTTTAGTCTTTTCAATTGATTAGATATC +TCTTCGAGTATGAGGTCTATTTCCTTTATTTTCAGTTCTACTTCCGCGAGTTCTTCTAAGGCTTTTTCCT +TTTTCCTCTCGTATTCCCCTATTCCCGAAATTTCTTCAATTATTTTCCTCCTCTCTACGGGAGTCATCTT +AAGGAACTTGACGATGTCTCCCTGATACACCACGTTGTAAGCGGTCTCGTATATACCCGCTTTTGCGAGG +AAATCCTTCAAATCCCTCTCTCTTACTACCTGACCGTTTATTTTGAAAATGCTCCTTCCGTCTTTTGAAA +CCTTTCTGGATATTACAACTTCTTCATCTTCTACAGGAAACGCTCCTAGGTTTTTGAAGTGAACTTCCAC +GTAGGCGTGATCTGCTTTCTGACCGTTTTTGGAAAAAATTAAGTAACTTAAGTTCTTTGCCCTGAGTGCT +TTTGCACTGCTAAGCCCGAGTGCAAAGGATATTGCGTCCCCTATGTTACTTTTTCCCGCACCGTTCGGGC +CTACTACCGCTATAAATCCTTCACCGAGAGGTATTTCTTTCCTTTTTGTCCCGTAGGATTTAAATCCCTC +CACTACTATCTTTTCTATGTACGCCCTTTTTTCCATCAGATACGGATAAATTATACTTCGTAAATTCTGT +CAAGTAGTTCGTTAGCCTTTTCTTTGTCTAAGTTTCTCAGTTGTTTGTATACCTCCCTCGCTTTTTCAAC +TTTTCCCGCCCTTATGTAAGCAATTCCGAGCTTAAAAAGTAGTTCAGGATCTTTGGGATTTTTCTTTACC +TCTTCTTCCAGTTCCTGGGCTAACTTCTCAACTAGCCCTTCCGCCATTTTGCTGAAAACGCCTTTTTTGC +CAAACATCTTCACACCCCGTATTTATAAAACGGATACCTCGCACCTTGATATGTTCCCCTCCTTTCTAAG +GTTTCCCTTACCTTCTGTATTACCGCATTTTTGTACTTGAAAGTACACCACTCGGGAGCTATCAACCTCT +CTTCGTCCGTTTCTCCGGTAATTCTGTGAACTACCATATCGGGCGGAAGTAGTTCTATCACGTCTGCACA +GTACTCGGCGTACTCCTCAAGGGTAAGGGTTTTAAACTCTTCGTTTAAGTACTGCTTTTCCATGACCGTT +CCCTTTATAACGTGAAGCGGATGTATCTTTATGCCATCTATCGGAAGAGATGCTATGAGCTTTGCCGTTT +CTATAAAGTCCTCCCTCGTTTCTCCGGGAAGTCCGATAATCATGTGTGCACACACTTTGAGGTTTCTCTT +TTTCGTCCTAAGAACTGCATCCACGAAGTCGGAAACTCCATGCTGTCTGTTTATCTTCTTTAAGGTCTCG +AAGTTTGCACTCTGGAGTCCGTACTCCACCCAAACCTCCAAGCCCTTGTTTGCGTAATACTCTAAAAGGT +CGAGAACCTCTTCGGGAGCGCAGTCGGGACGCGTTCCCACGTCTATGCCTACAACGCCTTCAAACTTCAG +GGCTGTATCGTAAACTTTTTTAAGTGTTTCTATATCCGCGTAAGTGTTCGTATAAGACTGGTAATAAATC +GTAAAGTATATGTCCTCGCCGTACTTTTTCTTAGCCCTTTCAATACCTTCTTTTATTTGAACTTCTAAAG +GGATTACAGGAGAAAGCATGGAAGGTTTTGAGCCGTCGTAGCAGTACGTACAACCGCCCCTTCCCTTGGT +TCCGTCTCTGTTCGGACACGTAAAGGGAAGTGCTACGGTTATCTTCTGTACCCTCTTCCCGTACTTTTCC +TTGAAGTAGTCCTTAAGGGAGTAGTAGAGTCTTTGAGTCTTCACTTGAGCCATGATTTTATTAATTTAAT +TCTGTATGTTTACCCCAGAAAGGGAAAAGGAACTTCAGGAAAAAACACGGGAACTCCTGAGAAAGATTAA +GGACGTAAAAGTCCTGAGCTTTGAGGAAGCTAAAAAACTCGCGGAAGACCTCAGAGAAGTAATCAGGTAT +CACGATTACAAGTACTACGTCGAGGCAAACCCAGTAATTCCCGATTACGATTACGACAGACTCTTCAGGG +CTTTAAAAGAAATAGAGAAAAAATACCCCGAGCTTATCACTCCCGATTCTCCTACTCAGAGAGTGGCGAG +CGAAATAAGCGGAGAGTTTCCCACGGTTAAACACTACACCCCTATGCTCTCTCTGGACAACGCCTACTCG +GAAGATGAACTCAGAGAGTTTGACAGGAGGGTAAGACAGATTACGGGATTGGAAGTAGTAGAGTACGCGG +TAGAGCCAAAACTGGACGGTGCGGGTATAGCTCTTGTTTATGAAAACGATTTGTTCGTCAGGGGGGCTAC +GAGGGGCGACGGTGAGTACGGGGAAGACATAACGAATAACCTCAAAACTATTAAAACAATACCACTAAAG +GCGGAATTTTCCCGTTTCGGAATCAAACTTGCGGAAATCAGGGGAGAAGTAGTTATAAGGAAAGATGAAT +TTCAAAAATTAAATAAAGAAAGAATGGAAGAAGGATTGCCTCCGTTTGCCAATCCCAGGAATGCGGCTGC +AGGCTCCATTAGGCAGAAGGATCCTAAGGAAGTTGCTAAGAGAAATCTGGAAGCTATCGTATACCACCTC +TCTTACGTAGAACCCCCTGAGACCGAACCGCCAACCCACTACGAATCTTTGAAAATGCTCCATACACTCG +GTTTCAAGACGCTCTTTAAGGACACAAAAGTCTGCAAGGGCATAGACGAAGTTATAGAGTACTGCAAGGA +GTGGGAGAAAAAGAGGGACTCTTACCCTTACGAGATAGACGGAATGGTCGTTAAGGTGAACGACAGAAGG +TTGTGGAAGGTTCTCGGTTACACTTCCCACCATCCGAGGTGGGCTATAGCGTATAAGTTCAAGCCAAGGA +GAGCGGTAACAAAACTCGTTGACGTTGTCTTTCAGGTGGGAAGGACGGGAACGATTACACCTGTGGGTAA +GCTCGAGCCTGTAGAGCTGGGAGGCGTTACCGTTTCTTCTGTATCTCTATTTAACGAAGACTTTATAAGG +GAAAAGGACATCAGGATAGGTGACTGGGTGGTAGTTGAGAGGGCTGGAGACGTTATACCTTACGTGGTTG +AAGTCTTAAAGGAAAAGAGAACGGGTGAAGAGAAACCCGTGGAATTTCCAAAGTACTGTCCTTCCTGCGG +TTCTGAGCTCGTAAAACTTCCCGAGGAAGTAGCTATAAGGTGTATAAACATATCCTGCCCCGCTCAGAGC +GTTTTGAGGATTAAACACTGGGCGAGCAGAGACGCAATGGACATAAGAGGACTGGGAGACGCCACAATAA +AACTTCTATTCAACAGGGGACTCGCAAAGGACGTGGGAGACCTTTACTACCTAAAGTTGACGGACATTTT +AAAGCTTCCTGGATTTGGAGAAAAATCCGCTATGAACTTACTGAAGGCTATTGAGGAGAGCAAAAATAGA +CCTCTTGATAGAGTCCTTTACGGACTCGGTATAAGGTACGTGGGACAAACTACAGCAAAAAAAATAGCCG +AAATTATAAACAGTGTATGGGATTTAAAAGACATTCCCCTTGAGAAGTTGATGAGATTGGAAGGAATAGG +GTACAAGGTAGCAAGGAGTATAAAGGAGTTCTTCAACATACCTCAAAACCTTGAAGTTCTTAAAAAACTG +GAAAAGGCGGGTGTAAACCTCGCCAAGAAAGTCAAAGAAAAAGTTGCAGACGTTTTGAAAGGAAAAACTT +TCGTTTTCACGGGAACGCTCGATTGTTGTTCGAGGGAAAAGGCGGGGGAGATTGTTGAGATGCTCGGCGG +AAAGTTCTCAAACTCTGTGACTTCCAAAACAGATTACCTAGTGGTGGGTAAAGATCCCGGAGCTACAAAA +CTCAGTAAAGCTAAGAAGTACGGAGTAAAGACTATAACCGAAGAGGAATTCGTAAACATGATAAAAGATT +ACGTGGATTTGGAGAAAATAAAGAAGGAGGATAAGAAGGAAAAACCGAAAATAGGCAGACTATTTTGAAA +CCTTTTTCTTTACTTCCTTGTTTACTCCGAAGAGCTTTTTCAGTTCCTCCTCTATCTTATCCCTTATCCT +TCTGAGTTCGGGTATGGAAAGGTTTTTGGGTTCATCTATGTGTAGGTTTTCCCTCCTCTTGTGAGAAATC +TCAAAGGGACATTTATCCTTTATCTCGTTATCTAAAATCACGACAACGTCAAGACTTTTGTAGGGAATTT +TTCTTATGGGTTTAGGATAAAGACTTTTTGTAGGATATCCCTTTTCCTTCAGGACTTCTATTACTTCCCT +GGGAGTAGTTCTTTCGGGTTCGAGTCCTGCGGAGTAAACTTCAGCCTTTATGCCCATCTTCTTTAAGATT +TCCCTAGCTATGGCTTCCGCAAGCAGTGCCCTTACAGCTCCCTTTTTGCTTATGAATCCGATTTTCATAA +AATTAATTTTATGGTAGACAAAGAACTTCTCGAAATTCTCGCCTGTCCGAAGTGTAAGGGTGATTTAAAG +TATGAGGAGGAAAAGGAAATCCTTATATGTGAAAAGTGTAAGGTTTATTACGAAATAAAGGAGGGGATAC +CTATACTTCTGCCCGAGTCTGCGAAACCTCTTTCAGGATAATTTCCTTTAATTCTTCTTCCCGATCCGTT +GAGTAATCTGAAGGTATATCTTCTTGAAAGACCTTTTTAAAGTGAACGAACTTAACAGGTTTCCTGTACA +TCTTCCTGTAAGAGTAAACCATTTCCCAGTCCGCGTTGTTGTCACCGATGTAGAGTCCTTCCTGAGCACC +GAGCATTTCCATACAGAGGTGAAGGGGGTAAGGGTGGGGCTTCCTTAAGTTCGGGTCTCCCACCTCGTCC +TCGTCTATTATCGCTTCAAAGTACTTCCAAAGGTCAAACCTGTCAAAGAGGTACTTCAAATCCCTTCTCG +GTCTTCCCGTGACCACGCCATAACCACGCCATTTCTCTTCAAGCTTTCAAAGAACTCGGGTTTTAGTATT +AACTCTTCTTTGTCTTTTAATTTGTCGTAATAGCCTTCGAAAACTTCTACGAGTTCCTTGTAATCCGGCG +GTTTGTAGCCGAGGTTCTTTATTAATTCGTAAGTAACGTCCCAGTCGTTGTTTATTCCGTTTTTAAATTT +AAACTCCCGGATGTACGAAAGTTCCAGTTCTCTTCCGGTGAAGTGCTTTATGGTTTCCTTTATTGCGTGG +TGATAGGAATTCCTCACGTCTACAATTACTCCGTCCACGTCAAATATAGCTGCTTTCATACCGTGAGCTC +CACCTCTTTTGTTTTCTCAAGTAAGTACTGTATGAAGTTGCTCGCCAAGAAAGTGATAGTACTGTTTTTT +GGATAAATTATGTGGAATCTCCTCTTTATTTCAAAACCTTTAATCTTAACGACTACTAAATTTCCCGCTT +TTATTTCTCCGTTCAGTAATCCTTTAGACAGGAAAGAGCATCCGTAACCGTTTTTTACTATCTGTATTAT +GTTTCTGCTGCTTGTTGATTCGATTTTTATGTTCAATTTATCGAACATTATTCCGAGTTCTTCGAGCTTT +TCCCTCACGAGTTTCCTCGTTCCCGAGTGGGCTTCCCTCATAACGAGATCCAGTTCGTAAAGCCTTTCCG +GTTCTATTTCTCCCTCCTTTGCTATCGGGTGTTCGGGATAAGTGAAAAATACTATCTCGTCCTCTAAAAA +GGGAATATCAACGAATTTATCAGAAGGCTTTCTCTCTATTATTCCCACGTTCAGAACTCCGGAAACGAGT +CCTTCTTCAACGTCGTGAGAGTTTCCCGTAAATATCTTTATCTTGGAACTTGGAAATTCCTTGTGAAATT +CCGCTATTATCTTCGGGATTATGTACTCGCTGGGGGTTGCGCTGAGAACGAGGAATAGCGTATCTTTCAA +ATCTTTCTTTATCCTCGCTATTTCTTCCATAAGTCCTTCGTAACTGTTTAAAAGGAGTTTTGCTATTTCG +TATATTCTCTTTCCCTCTTCAGTCAGGACCATCCTTCCGCCCTGTCTCTGGAAGAGTTTGGCTCCTACTG +TTTTTTCCAGAGCTTTTATCTGCTGTGTTACTGCTGGTTGAGTTATGTATAAAACCTCCGATGCTTTTGA +AAAACTTCCCAGCTCCGCGACGGTAACAAAAGTCTTGAGCTTAGAAATATCAATCATCCTTATTAATTTT +ATACCTCGGATAAGAAATGTTTATGAGGGTTATAAAAAAGAAAAATGGAGAGAAAGATTACCAGGTGAGA +ACTCTTCCCGCCTGACCGAGCGAAGGAAGTGCCTGGCTGGGTGTTAAAAGCGGTACGTCAAAGGCTAAGT +CTTCCTTTGTCATTCCGTTGAGTTCTAAGGACTGGAGACATCCGACGAACTGAACACCGTTGTCCAATGC +GAGTTCCATAAAGTCCTTGATGGTATTTCCTTCTTCCATGGGACGTATGCTTTCCGCAACGCCTTTCTTG +AGAAGGAGTGTAGCTGGTCCGGTGAAGTACATGACCACGTTCATGTCAGCAGCAGCAGCGGTTGAAGCGA +GGAAGAAAGCAGATGGAAGTCTCTTAGGATTTTCGGGACCTGTTATTAATATGATTACAAGATCAGCAGC +TTGTTGTTGTTCGCTCATTCTTTCACCTCCTTAATAAGGAGTTTAATATATAAGAATGTTTAAAATCATC +TAAAAAGATTTAATGGTAGTATAAACGGAACTTATAAAATACTTTCTTTGATGAAAATCTACTTAATGGG +CTCGGACCAGAGGATAGTTAGGTGTGCGAGGGTGTCCTTTGCAAAGGACTCATATGTCGATGAAAAGAGG +GACAAAAGACTCATTCGCTACCTCTTCAAGCACAGGCACGCGTCTCCCTTTGAGCACAACATCATTGCCT +TTGAGTGGAAAAAGGAGAAGTGGATAGAACTCCTTTCAAAGCTGGAAAACCCTACCGTTCAGGTTTACTA +CTCAAATGGCTTTGTTTTTCTTAACTTAAGGAACGCTATCAACGTATGGGAACTTTTGCCCGACGCAGTC +AAAGAAAGGATAAAGGAGGCTTTTCCTACCACTTACGGAGTAATTCAGCGGAGAGGGGAAATTGAGGATG +AGGAACTTTATTCCCTTCCCTACACTAAAGATAAAGCTTACGTAAAGGAAAAGATTGAGACGAGTTCTGG +CTGGATCGGGCTTGTTGATAAGCTGGAACTGGAAACTGATATGGATTTTTACACTTTTGTGGTTGAATGC +CCTCTTTTTGTAGCCCGTCAGTGGATGAGGCACAGGTTCGGCTCTTACAACGAGGTTTCTAAAAGGTACG +TGGGAAAGGAGTTTCTGGAATTTTATCTCCCTAAATACATAAGAAAGCAAGCGGAGAAAAACAAACAGGC +TTCTGTGGATGAACCTATTTCTGAGAGTGAAGTTTTTATAAAAAAAATAGAAAATTTGATAAGCAAAAGC +GTAAAGCTCTACGAGGAGATAATAGAAAAGGGCGGTGCAAAAGAGCTCGCAAGGGGAGTGCTTCCCCAGT +TTATGAAAACGAGGTTTTACTGGACCGTTCCGAGGATTTCTCTTGACAACTTCATAACCCTCAGAACTCA +CGAAGGTGCACAAAAAGAGATAAGGGAATTTGCAGAAGCTATAAAGGAAATGGTAGGATACAGGGGAACT +GATAAGAAGAACGTCATTTAAAATTTGCTCTATCAAGAAATCCCTTGAGTTCTTACAATTTTCTCTTTTT +CGTCAACTTCAAAAATCTTTCCCAGAAACTGTTCACAAACCCATATATTTGTGAGGAGATGCCCGGTAAA +CTGAGGAACTCTTATCTCACCTCCGACCAGAGCCATCAGAGGTATCAAGTGGTCCGCAAGGTGTCTGTCA +ACGGTGGCACCGGAGCTCCAGTCTTCGTGTAATTTTTTTACGGCCTCTGCTCCCACAACCTCTGCAAGCT +TTCCCTTTTTACCCAGGTTATCCGCACCGAGAACGTTTCCTTTAGTGTCTTCAAGCCAGATGGTTATGCT +CGTTCCTATTGAGTTTGCGTTTGCGTACTGTCTGTAAACCTCTGGTTCAGGGTAGCCTAAGTTTTTTAGA +GCTTCTATAGCTCCCTTTGCCTGCCTTTCCGCCACTTTCCTTTCCCTTAACTCTTCGTGAGCCACGGAAA +ACACGTGAATTTTTCTAATCTCTCCTCTCTCAGTTCTGTAAAGGTTAACTTTATCTTTCAGGTATTCCTT +CACTTCTTGTAAGTTTTCCGGCTGTTTTTCTAATTTGTTCCTTACGCTTAATTGGACAATCCCGCCACCC +GCAGGGTAAAAGCCTCTCTTTAAAACTTCAAGTCTGATAAATTCGGGAACTTTGTAGATGTAGTGGAGAA +ATACGAACCTCACCCAGTCTATTGTCGGACTTTTTGGTACGTCCGTTCCACCGATAACCTTTATCACTAC +TTCTCCGGGAACGAAAAGGGAGAGCGGAAGAATGGTTTGCAAGAAAAGAGGAATAGAACCTGCGGTGTCA +AAGTTCACTTCGTAATAACCCGGTTTTAACTTTTGAGGTTTGTATTCAAGCTCAATAGAGCCGAGTTCGT +CTCCCTTCACCTTTGCCTTTGCAAATCTTTTGAGAAGTTTTACTATGTTTAGGTGTTGTCTCTTGAGTCC +AGGTTTTTCCCTTTTTGCCCTTATGTTGTAAATCCTTACGGGAACCTGTAGGAGTGTGCTTAAAAATAAT +GCCGTTCTTACTATCTGCCCTCCGCCTTCTCCGTACGAGCCGTCAAGCTCCAGAAACTCTCCCATCTCCC +TTAAATGTATCTTCCTTCACTTTCCATTATTACTCTTATAACGTTTCCCTCCTTTTCAATTTTAGAAACT +TTGTAGTCGTAGAAGTTTATCTTCTCAAGGGAATTCAGGTCCACGTTTTTCTCGACTATGTACCTCAGGG +TGTAGGCCCTGTGAGGCATAGGGTTTACCACCTTCTTACCTTTTCTTATGTAATCAAACCTCACGAAGGT +AACGTCTTCAGGGAAGGTTAGTGTTTCCCTCTGCTCTGTCGTTAAAAAGTCAAAAATTACAGAACTTTCA +AACATCTTTTTAGATATGTCCTTTAAAACCTCTTTCCAGAACTCCGTTAGCTTTTTTCCTTTGTACTTGT +CCTGAAAGGTTACCGAGTACCTCGGTATTGGGTCATTGACTCCGAGCATGCCAAAAAGCGGAGATATTAT +AATTCCCCTGTCTATTATGTTTTGTTGAACTTCGGGCGGAAGACACCAAAACTCAAGACTGTCCCAGAAT +TTCCCATTATACCTCCTCCACGCGGGAGCAAGGGGTTTAGTTTCTACCTTGAAGTACTCTATTAATTCCT +TTCTATAGGGATTCAGTTCAGGGAACCTGTTCTTTTCCCTGTTTTCCCATATTGAGAAGTAGTCCTCCTT +TACGAGGTCCATCGTGGACTGCTTTTTCTCCGAAGGAAGCAGGTAAAAAATCATGAGATTTATTTTAGCC +CAAAAGAAGGCATGTTAAAATTTCCCTAAGATGGAGCTTCACTTTGCGGATGAGCCATTAAAGGTAAGCG +AAGAGATAAATAAAAGTATACTGGAAACACTCCAAGAGAAAGAACAAATAGAAGTTCGTGGGGATTACAT +AATATTTAAAAACTTTACTGGAGTTGTAGGAGATTGTTTGGTAATTCCACGAAAACTCGCAGAACACTTT +AAGCTAATCAACGAAAGTGGTGAAAAAACGCAGAACTTTTACGAAAGGTATAAAGAATTATTTGGAAAAT +TCTTAAAGTATATCCTGAAAAAACTTGCTAAAGAGCACATAATTTATACCCTTAGCTTGTCCAGTTTTCC +CGTTGATGAGAGTAAACTAAACGAAAGTAAAATCTTTAAACTCCTGGTTCTCTTAGAGAAAAAAGAAGAA +CTTATAAATTCCCTGCGTTTAATTTTGTCTATTCCGCACAAAAACTTGGTTGAATACGAAACTTATAAAA +GTTTAAACGAGGTTAGTTATGTTGATTCAAATGTAATTATTGATATAGTTCAGAATCCGGAAAAACTTTA +CGAAACGGAAAAGGGGATAATAGAACACGAAGGAAAGAGGTATTCCCCTACCGCGGTTCTTCAATATGAG +TTTGAGGAAAGTTTTGATACTCCAGAAAACAGGTTCGTTAAACACTTATTAAAGGAACTTGAAATCCTTT +TGTCTGAAGAGCTAAAGGATTTCTTCTTCTTAGAAGAATTAAAAGAAATAAAAGAAGAAATAGAGTATAC +ACTCCGGTCGGATGTATTTTCCGAAGTGGGAGACTTAAACTTTTTCCCTTCAAATTCTCAGGTTTTGATG +AAAAAAGCAGGATACAGGGAACTCTTCCAGATTTACAGGCTCTTGCACCTGTCCTTTGTTCCTAGAATTT +TTGAAGATTTAGATTTAGCGTTCTCATTAAAAGATATGGCAACACTTTGGGAGTACTACGTTTTAATAGA +GATTTTAAGGGAATTTAAAGAAAAGTTTGGAACTTACAAAGTGATAATTGATTTTGAGGAAAAAGTAGAA +GGTAAAACGGTTTACGAAGAGGCACAGTTTAAATTTGAGAATGATTTAATCTTGTATTATCAAAAGAGTC +TTTATGCTTATTCTGGTTTACGCTTCAGACCGGATTTTTACGTGAAATTCAAAGACAACAGATTTATATT +TGATGCAAAATTCAGGATATTTGAAAATAATGAAAAGGATTTGCTTCAAAATATGCACTATTACAGAGAC +GGATTAAAAGTTACATCTGCCGTTGCTGTATGTTTTGGAGAAAAGAACAAAAGAGTTCTTTTTGGAAGAC +GGATGGAAGTAAAGAATCAATAAATTTATTTTCTGAATTAATAGAAAATAATTTTGACGGAGTAGGGTAT +ATTGATTTAAAATTAGATATGGGGGATTTTAAATGGAACTAAAACCTAAGTTCATTATAAAGATAACTTC +CAAATCATTGGAAAATTTCAGAAAAACCGTATTAGAAGGTATTGAAAAGGAAGGAGAAAAGAAGTATTTT +TGGAATATCTACAGTTATTGTGGAAATTTTAATTCAAATGATGTAGTATTATTTATTGCTGAAAAACATC +CAGCTGTACTCGGACAAATTATAAAAACAGCGAATGGTGATGAATTTTATAATGAACGTTTAAAGAAAGA +ATGGAAAGATAAAAAGGGTAGATTTAAAGCATATTTTGAATTTAAAAAAAATAAAAGAAATAAGTCTTCC +TGAGGAAATTACAAAAAGTCTGTTATCGGAACATCAAGGCAGGAGAGTGTGTAAAAAATTTGATCAATTT +TCAAAAGAAAATCAAGAAAAACTTTTAAATTTCCTTTCAAAGGAAATCTCAAATATGCAGGAAGCTACAA +GAATAGAAACAGGCCAACAGGAAAAAGGAACTTGCTTAAAAAATTCTTCTTTAAAGTTAGATAGTCATAT +CGTAAACTCTTTCTACAACGCCTTAAAGACAAAAGGTTTCGTAATACTTGCAGGACTTTCTGGAACAGGA +AAAACTAAGATTTTTGAAGAATTTGTAAAGTGTTTTCCCGAAAATCACAATCTCTTCTTCCCCATTCGTC +CTGACTTTAAAGACTCTAAATCTCTACTCGGATATTACAACCCACTAAAAGGAGAATACCATTCAACTCC +CTTGTTAGAATTCATTTTGGAAGCTTCAAAGAACTACCTAGAAAAAGGTAAAAATGCGGACACATTTTTC +GTATTGTTTGACGAAATGAATTTAGCGAGAGTTGAGTATTATTTTGCAGACTTTTTATCAGTTTTAGAGG +CAAAAAGATTTGAAAATAAAGATGAAGCAGTTAAAACTAATAGTTTTAATGAGTTTTTAGAAAGCTTAGA +AAAAGATTTATCAGTATTAAACGAAGAAAACTATAAATTTACATCTCAAAGCATAAAACTACACAACGAA +GATACAAAAGACGTTCCAAAAGAACTATTTTTACCACCAAACCTTTATTTTATTGGGACGGTCAATATTG +ATGAAACTACTTACATGTTTTCTCCAAAAGTTTTGGATAGAGCATTTACAATAGAGTTTGACGTCGGAAG +TTTTAAAGATTATTTAGAATTTTTAAAAGCAAATTCAGATGATGAGAATTCAAACATAGATGAAAATCTG +AAAGAAGATTTTATTAATAAAGGTGAGTTTGCAGTTATTGACAAACAAAAGATAAAAGAATTCTTTGAAA +ATGAAGAAAATAAAAAATATTTAAAAGATCTTGAGGAAATAAATAATACTCTAAAAAGGTTTGGTTTACA +TTTCGGATACCGTGTATTTGACGAGATTGTTATGTTCCTGTATAACTCACAAAACTCCTACTTTAAATTT +GAAAACTTAGATGAAGCGTTTGATTTGGCCGTTAAAATGAAAGTTCTTCCCAAGTTCCACGGAACAAGGC +AAAGATTAGAAAAGCCTGTTGTTGAATTACTCAACAAACTTGGTGTGAAAAACCCTGAAGAAAAAATTAC +AGATGGAATACCGCCAATAGATGAAATTGCTGAAACTCAATTCAAACACACAGTTCACAAACTCCTAGAA +ATGTTTTACAAACTGAAAACTCAGGGATTTGCTTCCTTCTTATGAAGATTAAGTGGTGTGCCCGGCGGGA +CTCGAACCCGCGACCTCGAGATTAGGAATCTCGCGCTCTATCCGCCTGAGCTACGGGCACTACCACTAAA +TAAATATTATATATCCTTTCGCCTACAGAAAAAGGAATTAAAATTTAAGGATTATGGAACTCCAGGTGGA +GACGGTCTTTCAAACGGTTAGAGATAAAGAGTTTTTAAGGATAGCGGATAAAGTTTTAAACGAAAAGCGT +ATAAATCAGGAAGAAGCTTTATACCTTTACAGGAGCAATGAGCTTACCGCCCTCGGACTGCTTGCGGAAT +ACATAAACAGGAAGAAAAACGGAATGTATGCCTACTTTATAGTGAACAGACAGATAAATCCCACAAATGT +ATGCATGTATCAGTGCGACTTTTGCGCCTTCGGAGTTAAGAAGTCGGATCCCAAAGCCTACGAGATGAGT +ATGGAAGAAATACTGAAAAAAGTGGAAGAGCTTTACCTCATGGGAGGCAGGGAAGTTCACATAGTAGGAG +GGATACCTTCTTACTGGGATTACGATAAGTACGTAAGTATAGTAAGGGAAATTAAAAAGCGTTTTCCCGA +GATAATAATAAAGGCTTGGACCGCGGTTGAGATACACCACATGGCGAAAATCTCCGGAAAGTCCTACGAA +GAAGTTCTGAGTGAATTAAAAGAAGCGGGACTTGACGCTCTTCCGGGGGGCGGTGCGGAAATATTCTCGG +AAAGGGTGAGGAAGATAATAGCTCCTTACAAGGCAAACGCGGAAGAGTACTTAGAAGTTCACAGAGTTGC +TCACAAACTCGGGATTCCCAGTAACGCAACGATGCTTTACGGACATGTGGAAACACTTGAGGAAAGGGTA +GAACACATGGAGATGCTGAGAAGACTTCAGGACGAAACGGGAGGCTTTCAGGTGTTCATACCTCTCGCTT +ACTGGCCTGAAGGGACGAGGCTCGGCGGAACGAGAACCTCTTCCGTAGACGACCTGAAAACTATAGCTAT +ATCGAGGATTTACCTTGATAACTTTGATCATATAAAAGCTTACTGGGTTACCTTGGGTGAAAAAGTAGCA +CAGGTTGCCCTGAACTTCGGTGCGGATGATCTGGACGGCACGATACAGGAGGAAAAAATAGTACACGCTG +CAGGAACCAAATCCGCTTACGGGCACTCCGTGGACAAACTCGTGAACCTCATAAAGAAAGCGGGTAAAAC +TCCCGCTGAAAGGGATACCTTCTACAGAGTTGTCAGAGTTTACGATTAAGAATTTTCTCAATTTCTTCTT +TTTTTACCTTCCCTTCCCTTAATATCTTTACACCTTCTGTTAGGTCCAGTATAGTTGATGGTTCTCCCTT +TATAACTCCCGCGTCTATGTATAGATCTACTTTATTACCGAAGTAATTGTAAGCTTCTTCTACGCTTTCA +GCTGGTTTTTTGCCTTCAGGGTTTACACTGGGTGCAACCACGGGTTTTTTTAATTCGCTTAATAAATCCC +TTATAAATCCTTTTTGTGGTAGCCTAACGGCTAAGGTTCCTTTACTTACGTAGTCCAGTTTATCGCAGGT +TTTTCTAAAAACTAAGGTCAAACCTTCCACTTTCAGGAGTTTTTTGTGTTCTTCCTTTACGTCAAGGCAG +AGTTTTTCGAGCCACGATTCATCGGGAAGGAGAACCAAGAAAGGCTTTCCCGAAGGTCTCCTGATTTTGT +AGAGTCTTTTTACCGCTTCTTCGTTCGTCGCATCTGCAAGTATGCCGTACAAAGTATCTGTAGGAGCTAC +AATTATCCCGCCTTTTTTTAGAATTTCTACCGCTTCTTTTAGGGCTTCCTTAGAGGCTTTTAAGATCATT +TCTTTTTAGAAAGATACATCAATGGGTTGTAAAGGTTGCCCTGTTTGTCCCTTATTTCAAAGTGCAGGGC +ACACCTTCCCTCATCTGGTTTTATCCCCACGTATCCAATGGTTTCGCCCTTCTTGACTTTTTGATCGGCT +TTTACGGTATTCCTCTCGTTGTAAGCATATACGGTCGTGTAAGTTCCGTGATCTAAGATAACTATATTCC +CGTAAACGGATATATCGTTACCGCTGTAGATAACCTTTCCGCTTTCCACAGCCTTTACCGGTTTTCCGCA +GTCCGTATAAATAGTCACTCCCCTCTTGTCCCTTACAACTTTTCCGTCCACAGGTAAAAATGCGAGACTT +ATCTTTGGAATTTTTGCGTACTTCTCTATGTAAACCCACCTGTAAACGGGAATTTTAAGTTTCTGTCCTA +CGCGTATTAGGTTACCCTTCAGTCTGTTTATCCTCTTTATTTCTTTTACACTCGTTCTGAAACGTTTTGC +TATTTTTATTAAAGTGTCTCCCCTTCTTACCCTGTATATAACTATTACTCTTTTCCTAACTCTTTCTTTC +ACAACCTTCGGGTACTTAGAAGTCGTGCGATACACCTTTTGTTCTTTCTTTACTGTCTTTACTTCTTTAT +AAACAGGTATCTTTAACTTTTGCCCGACGTAAATTCTGTTTCCCTTTAATTTGTTTACTCTTTTTATTTC +TTTTACGCTTACTCCAAATTTCTTGGCTATTTTTATTAAGCTATCTCCCCTTTTAACCCTGTAAACTACA +TAACTCTTTTTGTAGTTAGTTTTAGTTTTAGTTTTAACAACCTTTTTACTTTTGCTTATTTTCTTCTTCA +AACAAATTTTTTCACCGGGTCTTAAGTACTTTCTATTTTTGAGTTTAGGGTTTAGTTCTAAAAGTTTTCC +TATTGACGTTTTATACTCTTTCGCTATTTTCCACAGGGAGTCTCCTTTTTTTACCTTATAGTAAACACTG +CACTCGGAAGCGTATAGGGTGAGGGCACTAAGAATACCTAATATCAAAACCGTAAACGGGTTCATCGGAT +TGCTCCTTTATTATTTCTACTTTATCAACCCTTGCCGCGGGAGGTCCTTTGAGTATGTCCTTTATGAAGT +GTCCTATAAGTTCTTCGTCTCCCTCTACGAGTATTTCAACCCTTCCGTCGGGAAGGTTCCTGACCCAACC +GTTTAATCCGTAACTTTCCGCTATTCTCTTCGTGTAGGCTCTGAAGCCCACTCCCTGCACCAGACCTTCT +ACGAAAATCCTCAACTTCATGTTAATTATGATAAACGTAAATTAATCCCCTATTTCTATCTTTCCTTCGT +CTATCATCTTTCTGATGATGTTCACTACCTGCCTTTGAGCCTTTTCTATCTCTGACTTCTTCACAGGCCC +TAAGGCTTCCATGTCTTCTAAGAAGAGCTTTGCCGCACGCTTTGACATGTTTGAAAGGAACTTCTGTTTT +ATGTCTTCGGGAGCACCGAGCAGGGCTATCATCAAGGTGTTTTTGTCCACAACTTTCAGTATTTCTATGA +TATCCCTGTCCGAGAGTTTCCTTATGTCCTCGAAGGTGAACATCTTTTCCCTTATCCTTTCTTCGAGGAG +GGGATCTTCCTGTCCTATGCTCTGGAGAATGAGCTCCCTCGTTTCCTTGTCAAGGGTGTTTAAGAGTTCC +GCGGCAACCGCTGTTCCCTCCAGTTTTAAGGCTTCCTTCGCACCTAAGGAACTTATCTCTTCGAGGAGTA +TTTGAGCGAGTTCCTTCACGTACTGCACGTTTACGTTTTCTAAGGTGGCTATCCTCTTTACAACTTCCTT +TTTAAGTTCTTCAGGTAAGTTCTGGATTATCTCAGCAGATTTCTTCGGACTGAGCTGGGAAAGGAACAGG +GCAATTGTTTGAGGGTGTTCGTTTTTCAAAAGACTTGCGAGTATTCTGCTGTCTACTTTTTCTATTTCTT +TTAATATCTTCTCCGCGTCTCCGAGCTCCAGTATGCCCCTGAACTTCTCCGCAAGGGTGGGAGGGATTAC +CTTTTTAATGTTCTCTATAAACTCTTCGGGTTTCTTTATCTTTATTCCAGCTTTCTTTATTTCATCCAAA +AGCTCTTCCGCTATGTTCTCTATTTCCTCCTCCGGAACACTTTCCAAATCTTTGGCGAGTGCAAAGAGTT +TCTGGAGTTCTTCTTCTGAGAGTTCCTTTACTATGTTCATACTGACTTCTTCGGGTAGGGAAAGCAGGAG +TACTGCAGCCTTCTGAGCCTTCGATAGTGCACTCTTTTCTTGAGCCATTTTAGAATCCTAAAAATCCAAA +ATCTTGCTCCTTCCTCTGTATTAAACCACGTTGAACCATATTGTTCTCGAGAATCTTTATCAGGAGTTCG +GGGTTGCAGTCCTTGGGACAGGAAAAGGTACAGTTCTTGCAGTGAGTACAGCTCTGGATGTTCAGGGGAA +CCAAATCCTTGAGTTTGTCCAGACCTTTTTTATTCCTCTTGTCAAAGACAACTCCGTAAGCTTTCGTGAA +AGTGGAGGGTAGCCCGAAGTTTTTATCCGCCTGAATGGCCGGACATACGTAATTACATATACCGCAAAGG +ATACAGTCCCAGCTCTTCTCGGTGTTTTTGAGTTCGTCGGGCTTCAAGGGTATGTTCGTGGGAAGGGGCT +CAAACCAGACTCTTCCTTTTTTTAATTTTTCATATATAAATTCATGTTCAACTACTAAATCCTTTATGGG +AGGAGCTACATCAACGGGCTCTAAAGTTATGTCGTCGTACACTCTGGTGTTGCACGCGAGTTTGTGTTCT +CCGTTTACCTTTACCACACACGTCCCGCAAATTCCTGCCCTGCACATCGCCCTGAAGGAAAGTGTAGGAT +CTATTTCCTTAATGTTTTGTAAAATTTCCAGAACCGTTTTTCCCTCTCCGTCTACTTCGTACTCCTCCCA +CCGAAAATCACCGTCCGAATAACGCTTTATCTTTACCTTCATACTCAAAATTTTATAGCTTTAGAATTTA +TTATCCAGATTATGGAACTCTTTATAGTGGAGTCTCCAACGAAGGCAAAAACCATTCAGAAGTTCCTCGG +AAAAGGCTTCTTAGTTAAAGCCACACTGGGACACGTAAAGGATCTTCCCGAAAAGGAACTCGGCGTTGAC +CTCAGAACCCTGAAGGCAAAGTACGTATACAAAAGGGGAAAGAAAAAACTCGTGGAACAACTCAAAAAAT +TGTCAAGAAGGTCAAGTATAGTCTATCTGGGAACGGACCCCGACCGTGAAGGGGAAGCCATTGCCTACTT +TTTAAAGAAAGATCTCGAAAAGGTAAATAAAAACATAAAGAGAGCTGTCTTTTACGAAATAACGCCGGAA +GCCATAAGGGAAAGCATAAGAAACGCGGGCGACGTGAACATGAACTTAGTTTACGCCCAGTTTGCAAGGA +GGATACTCGACAGACTCATAGGTTACTTAATATCCCCAATACTCTGGAAGGAGTTCAAGAACTACAAACT +CTCGGCGGGAAGAGTGCAGTCGCCTGCCCTCAGACTTATAGTGGAAAGGGAAAGGGAAATTCAGAACTTT +AAAGTTAAGAAGTATTACTACGTAAAGGCCTTACTCAGAAAGGGGAGTGAAGAGTTTTGGGCTATTTACG +ATTACCGCTACGAAAACCCCTCGGACGCAAAAATCATAGCCAAAAAGCTGGAGAAGGGATATTTCAGCGT +TTACAAAGTGGAAAAGAAAAAGGAAAAAGTGTCACCTCCCAAGCCCTTTATAACCTCCGATCTCCAGTCA +GAAGCAAATGCAAAGTTCGGATTTTCGAGTGAGAGGACACAGAAGTTGGCTCAGGAACTCTACGAAAAGG +GATACATAACCTATCCCAGAACGGACAGCTACAGGATGAACGAAAAAAAGGCAAAGGAATTTATGAACTA +CATAGAAAAGAAGTACGGAAAGGAATACGTGGGAAGGTTGAGGAGGTTCAGGGAAAAGGCAACCGCGCAG +GGTGCCCACGAGTGTATCAGACCAACAAGCCTGAGGGAAGAAATTCCTGAAAGGGAAGAATTGAGACTTC +TTTACGACTTGATTTTCAGGAGAACGATAGCGAGTCTTATGAAAGAAATGCTCCTGGAAAGGGAAAAGGT +TACGGTAGAGGCGATTACACCAGAACTCAAGCACCCTGTTTACCTCGTGGCAAAGGGATTGAAAATCGTC +TTTGACGGATGGAGCAGAGTTTACCCGAGTGAGATAACCGAAGAGAAACTTCCAGAACTTTACGAAGGGG +ATCTATTAGATCTCGTGAAAACGACACTTGAGGAAAGGAAGACCCAGCCACCTCCGAGATACACGGAAGG +AACTCTCATAAAGACCCTTGAGAAACTGGGAATAGGAAGACCTTCCACCTACGCAACTATAGTGAAAACA +CTGAAAGAGAGAGGGTACGTTGAAGTAAAGAAAAAAGCTTTAGTACCAACCGAGATAGCCTTTCAGGTCG +TTGAATTTTTAATGGAAAGATTTCCCACACTTATGGATTACAAGTTTACCGCCCAGATGGAGGAAAAACT +CGATCTCGTTGAAGAAGGAAAGCTCAATTGGAAGTCTGTAGTTTACGAGTTCATGGAAAAGATCTTCGGT +AAGGAGTTGGAAATGGTAAGATAGTGGTGGCCCAGGGCGGAGTCGAACCGCCGACACCCCGGTTTTCAGC +CGGGTGCTCTACCACCTGAGCTACCGGGCCTTACGACAAAAATATATTATATATTCCATTCCCTTTGAGT +TCAAGTGTCATAATTTAATTGTATGCCCAAGGTGATAGTTGCAAACATAAACGCGGAGTTTGAAGGAATA +GAAAATGAAACAATTATGCAAATCCTTTACAGGAACGGGATAGAAATAGACAGCGCCTGCGGCGGGCACG +GGCAGTGTACTTCTTGCAAGGTACTTATAATTTCGGGTTCCGAAAATCTGTACCCTGCGGAGTTCGAAGA +AAAAGACACTCTGGAAGAAAACGGCATGGATCCCGAAACGGAGAGGCTTTCGTGTCAGGCTAAACTGAAC +GGAAAAGGCGACGTGGTTATTTACCTTCCTTAAGGAATTTTTATGATTTTAATAAGAAACTTGAATGAAT +TATCATTCACGAAAGTGTATACTAAAAAAATAACAGGAGGTGGGTATGGAAACTTTCTGGGAAGTTTTTA +AAAGACACGGAGTAAGTAGAAGGGATTTCTTAAAGTTTGCAACTACGATAACGGGCCTTATGGGCCTTGC +CCCTTCCATGGTTCCCGAAGTCGTAAGGGCCATGGAGACTAAACCCAGAGTTCCCGTTTTATGGATACAC +GGACTCGAGTGCACGTGCTGTTCCGAGTCTTTCATACGTTCAGCTACTCCTCTGGCTTCCGATGTAGTTC +TCTCCATGATTTCCCTGGAGTACGACGACACACTCTCTGCAGCTGCGGGAGAGGCGGTTGAAAAGCACAG +GGAAAGAATCATAAAGGAATACTGGGGCAACTACATACTCGCTGTTGAAGGAAACCCGCCCCTCGGCGAA +GACGGCATGTACTGCATAATAGGCGGAAGACCTTTTGTGGAAATACTTAAGGAAAGTGCGGAAGGGGCAA +AGGCTGTAATAGCGTGGGGAAGTTGTGCTTCCTGGGGATGCGTTCAGGCGGCAAAACCAAACCCCACGAC +TGCAGTTCCCATAGATAAAGTAATAAAGGATAAGCCAATAATAAAGGTTCCCGGATGTCCTCCCATAGCC +GAGGTTATGACCGGAGTAATTATGTATATGGTTCTATTCGACAGAATCCCTCCTTTGGACTCTCAGGGAA +GACCTAAGATGTTCTACGGAAACAGGATTCACGATACCTGTTACAGGAGATCCTTCTTCAACGCCGGTCA +ATTCGTTGAGCAGTTTGACGACGAAGGGGCTAAGAAAGGTTGGTGCCTTTACAAGGTAGGATGCAGAGGA +CCCACGACTTACAACTCCTGTGGTAACATGAGGTGGTACAACGGACTCTCCTATCCCATCCAGTCGGGAC +ACGGTTGTATAGGCTGTGCGGAAAACAACTTCTGGGATAACGGACCCTTCTACGAAAGGATCGGTGGAAT +ACCTGTTCCCGGAATAGAAAGCAAGGCGGACAAGGTTGGAGCTATTGCGGCGGCAGCTGCTGCAGGCGGT +GCAATAATTCACGGTATAGCTTCCAAGATAAGAAAGTCAGGTGAAAAGGAAGAATAAGGGAGGTGTTATA +GATGAAGAGAGTTGTAGTTGATCCTGTAACAAGGATAGAAGGTCATTTGAGAATTGAGATAATGGTTGAC +GAGGAAACAGGACAAGTGAAAGACGCCCTCTCCGCCGGAACTATGTGGAGGGGGATTGAACTCATAGTGA +GAAACAGGGACCCGAGAGACGTATGGGCATTTACCCAGAGAATATGCGGAGTTTGCACGTCCATACACGC +CCTCGCATCACTGAGAGCTGTAGAAGACGCACTTGAGATAACTATTCCCAAAAACGCAAACTACATAAGG +AATATAATGTACGGTTCACTTCAGGTTCACGACCACGTGGTTCACTTTTACCACCTCCATGCACTCGACT +GGGTTTCTCCTGTAGAAGCCCTGAAGGCGGACCCCGTCGCCACAGCGGCACTTGCAAACAAAATCCTTGA +AAAGTACGGTGTTCTGAACGAATTTATGCCCGACTTTTTAGGCCACAGGGCTTACCCCAAAAAGTTCCCC +AAAGCCACTCCCGGTTACTTCAGGGAGTTTCAGAAGAAGATAAAGAAGCTCGTTGAGAGCGGACAGCTCG +GAATATTTGCCGCACACTGGTGGGATCACCCAGATTACCAGATGCTCCCGCCGGAAGTTCACCTCATAGG +AATAGCCCACTACCTAAACATGCTTGACGTCCAGAGAGAACTCTTTATACCTCAGGTGGTGTTCGGCGGA +AAGAACCCCCACCCCCACTACATAGTTGGAGGAGTTAACTGTTCAATCTCCATGGACGATATGAACGCAC +CCGTAAACGCGGAAAGACTCGCGGTCGTAGAAGACGCTATATACACTCAGGTAGAGTCCACAGACTTTTT +CTACATTCCCGACATTCTCGCAATCGCCGATATATACCTCAATCAACATAACTGGTTCTACGGCGGTGGA +CTTTCCAAGAAGAGGGTAATAGGATACGGAGACTATCCCGATGAGCCCTACACGGGCATAAAGAACGGGG +ATTACCACAAGAAGATACTGTGGCACTCAAACGGAGTCGTTGAAGACTTTTACAAGGGTGTGGAAAAGGC +CAAGTTCTACAACCTAGAAGGAAAGGACTTTACGGATCCAGAGCAAATTCAGGAGTTCGTCACCCACTCC +TGGTATAAGTATCCCGACGAAACGAAGGGACTTCACCCCTGGGATGGAATAACCGAGCCGAATTACACCG +GACCGAAGGAAGGAACGAAAACCCACTGGAAGTACCTTGACGAAAACGGAAAGTACTCTTGGATAAAAGC +TCCGAGATGGAGAGGAAAGGCCTGTGAAGTAGGACCTCTGGCAAGGTACATAATCGTCTACACAAAAGTA +AAGCAGGGACACATAAAACCCACCTGGGTAGACGAACTCATAGTCAATCAAATAGACACCGTGTCCAAGA +TATTGAACCTCCCTCCCGAAAAGTGGCTGCCCACTACGGTCGGAAGGACAATCGCGAGGGCACTGGAAGC +CCAGATGTCAGCACATACAAACCTCTACTGGATGAAGAAACTCTATGACAACATAAAGGCGGGAGACACG +AGCGTGGCAAACATGGAAAAGTGGGACCCCTCCACATGGCCAAAAGAGGCAAAGGGAGTGGGATTGACGG +AAGCCCCGAGAGGTGCTCTCGGACACTGGGTGATAATAAAAGACGGAAAAGTGGCGAATTATCAGTGCGT +TGTTCCAACCACATGGAACGGTTCTCCCAAGGACCCGAAGGGACAGCACGGAGCATTTGAAGAGTCAATG +ATTGACACGAAGGTAAAGGTTCCCGAAAAGCCCCTTGAAGTTCTCAGAGGTATTCACTCATTTGACCCGT +GCCTTGCATGTTCAACGCACCTCTACAACGAAAAGGGAGAAGAGATAGCCAGCGTAAGGGTTCAGGGGGT +GGTTCATGTTTAAGAGGATTTTTATATTCAGCGCTTCCTTGAGGATATGGCACTGGATAAACTTCCTCAC +CATAATGGTCTTATTTTTTACGGGACTCTACATAGGGACGCCTTACTTCACGACCTCTTCGGGATACGAG +GCAACCTACGCCTACGATAAGAACATAACGATGGGATTTATAAGGTTTCTTCACTTTTCCGCCGGCTACG +TCTTACTCTTTTCCTTCCTCTTCAGGATTTTCATAGCCTTCTTCAGAAAGGGAGACAGACTCTTCATCCC +TAAGTTCTGGACGATAGAGTACTGGGAAGGGATAAAGGAAACCTTAAAAGAATACCTCCTTATAGGCTCC +CGCAAACCGATGATAAGGAATCCCTTAGCGAGAACCGCATACTTTTTCGTTTACTTGATGATTTTCTTCA +TGATAGCAACGGGCTTCGGGATGTACGGACTTTCTGACCCCGACGGATTCTGGGCTTCCGTCTTTGGCTG +GGTTGTCTGGAGTCTGGGAGGAGAGTTTGAAGCCCACTACTGGCACCATATAGTTGCATGGCTGATAATA +CTCTTCTTTATAGTTCACGTTTACTTCGTATCTAGGGAAGACTTCGTCCACAAAAACGGAGAAGTTTCTT +CTATGTTCAACGGCTCTAAGTTCTTCAAAAAAGACCCTGTTGACCTTAAAGATATAAAGTAAGGAGGTAA +AAAAATGAGGAAGTTTTTACCTTTTGTGGGGCTCGCTTCTTTTGCCTTTGCACACCCGGGACACTTTCAC +GGCGTAAACCCTTTTAACTCCGGACTCATTCACCCGCTCACCGGGCTGGATCACTTGTCCGTTATGGTGG +CCGTAGGACTCCTCGGCAGTTACTACGCAGGAAAGAAGGCGTTTCTACCCGCTCTTACGTTTGTTAGCTT +CATGACGCTCGGTTCAATACTTGGACTCCTCGGAGTTAGCGTTCCCTTCGTGGAAAGCGGGATAATTCTT +TCCGTTGCTTTAATGGGAATACTTCTCTTTGCAAAGGACTTAAAACTCTCTTACGTACTCCCGCTTATAG +GAATTTTTGGAATTCTTCATGGTGTAGCTCACGGATACGAAGCTCCCCAGACATTACACCCGGTTTACTA +CGTTCTCGGATTTGTACTCTCTACCGCAGCACTTCACTTCACCGGATTGCTTTTCGGGAAGGCTCTTAAA +GAGAAACTCGTTAGGGTATCGGGACTACTCCTCCTTGCCCTTGCCTTCCTCCTTTGATACCCTTTTCCCA +TGATTACGGTACTCGGTATAGGGAACATACTCTTATCGGATGAAGGACTGGGAGTGAGAACGGTTGAGGA +GCTCCAGAGGAGGTACGAGTTTCCCGAAAACGTGAAAGTGTTGGACGGCGGAACTCTCGGGATAGACTTA +CTTTACCATATAGAGGGAACGGAAAAACTCCTCATAATTGATGCGGTTCTAGGGGGAAAGAAACCTGGAA +CCTTTTACAAAATAAAAAACGAAAATGTAAAGAAGTACTTTAAAAGTAAAGTTTCCATGCACGAACTCGG +AATTCAGGAAGTTCTTGCACTCTTAGAGGTTCTGGAAAAACCCATAAAAGAAATAGTAGTTCTGGGACTG +GAGCCCAAAAGCCTTGAAGTTTCAACAGAGCTCACTCCGGAAATACAGGAAAAAATTCCCCTCCTCGTGG +AAGAAGCCCTATCTCAACTAAAGGAGTGGGGCGTTGAGGTGAAGGAGAAGAGCCATGAGCAGTGTTAAGT +TTTTACAAAATTTAAAAAGGATAAACGAGGAAGATTTGAGGAACTTAATGGAAAAAGGTGAGACCTTTGT +CCTTTACGTGAGAAGCGAAAGGCTCTACGACAAGGTAAAGGAGATATTTGACGTTGACGTTGTTTTTCCC +GAACTTGCCAAAAGCTTCGAAGGTATTCCCTTTTACTGGGGAGATGCTGACGAGCTGAAAGAATTAAATG +TAATTCCTCCTTCCGTTCTTATATTCAAGGAAGGAAAGCCCGTTGAGTTTCTTCAAGGAATAAAAACCTG +GGCTGAATACACGAGGAAACTAAAGGAGAGCCTGCTATGCTGATGAACGCAATTCCGATCTTGAAGGAGA +TACTCCAGGCTTTGAAGGATTTGTATGAAAAGGGAGAAGAGCACGTAATTTACATAAATAAACTCCCTAT +AACTCCAGAAGACAGGGAACTCCTTCTGGACGTTCTCGGAGAAGGACAGGTGAAGATAACTTACTCCTCA +AAGACCCAACCCGCTGAATGGAAAGAGACGGGAATATTCGGAGTCTGGATAGGGATTATTAAAAACAGGG +ACGACAAACCGGTTCTTGAGACGATAGAAATCACTTACTTTCCAAAACTCGCATCAGCCCAAAAGGAAGA +CGTACAGGAGAGTATTAAGTACCTTGAAGAAAAGATTTCGGAGATTGAAACTAAATTAAAAGAGGAGGAG +AAAAATGTGTAAAGACTGCGGATGTTCCATCCCTGAGCACAACCACGAGCATGAACACCATCATCACCAT +CACCATACAAATCCCGCACTCGGTGATAAGAAGACCGTTGAGGTCCTGAAAAAGATACTCTCCGCAAACG +ACGAGCAGGCGGAGAGCAACAGGAGGCACTTTGAAAGGCACGGAATACTGGCTGTTAACTTGATGAGTTC +CCCGGGATCGGGAAAGACGACACTCCTTGAAAGAACCATAGAACTCCTGAAAGACGAACTCAAGATAGGT +GTAATTGAAGGAGATTTGGAAACAAACAGGGACGCGGAGAGGATTAAAAAGAAGGGGGCGCCGGCATATC +AGATAACAACGGGACAGGCTTGCCACCTTGATGCCTTTATGGTTCACGAAGGCATACACCACCTTCCCTT +AGAAGAACTTGATATTGTCTTCATAGAAAACGTCGGAAACTTAGTTTGTCCGGCTTCTTACGACGTGGGA +GCACACCTCAACGTCGTTCTCCTCTCCACAACAGAAGGAGAAGACAAGCCAGAGAAGTATCCGGTGATGT +TTAAAAACTCTCAATTGATGTTAATAACTAAGGCAGATCTCTTACCTTACATGGACTTTGACGTTGAAAA +GGCTGTAGAGTCCGCAAGAAAGGTAAATCCTTCCCTTGACGTCATTACGCTTTCCGCAAAAACTGGAGAG +GGAATGGAATTGTGGCTTGATTATCTGAAGTTTAAGTTGAAGGTCCTCAGGAATGCCCTTCAAAAGGCTA +AAGCTTCACCTTAAAGGGGCCGTTCAGGGTGTCGGGTTTCGCCCCTTCGTTTACAGAATAGCCAAAGAGC +TGGGACTAAAAGGTTTCGTTATAAACGACTCAAAAGGTGTTTACATAGAAGTAGAAGGAGAAGAGGAAAG +GTTAAAGAAATTTCTTTTTAAACTAAACAGGGAAAAACCGCCCCTTGCGAGAATTTACTCTCAGGAAATC +CAGTTTTTAGAGCCTGTAAATTACGAGGACTTCGTAATAAGAAAAAGCGAGGAGAAAGGTGAGAAGGAAG +TCTTAGTTCTCCCGGACATAGCAACGTGTGAGGACTGCCTAAGAGAACTCTTTACCCCTGAAGACAGGAG +GTATATGTACCCCTTCATAAACTGCACCAACTGCGGTCCGAGGTTCACTATAATCGAAAGACTGCCCTAT +GACAGAAAAAACACCACCATGAAAGTCTTTGAAATGTGTCCCGAGTGCAAAAGGGAGTATGAGAACCCCC +TCGACAGACGCTTTCATGCTCAGCCAAACGCCTGCCCGAAGTGCGGTCCATGGGTCAGCCTCTACAAAGA +CGGTAAACTAATTGCCGAAAAAAATGAGGCTTTAGAACTCTTAATTGAAGAAATAAAAATAGGAAAAATA +GTAGCAGTTAAGGGAGTAGGAGGTTTTCACCTTATATGCAACGCAACGAACGAAGAGAGCGTAAGAACCC +TCAGGAAGAGAAAGAGGAGAAGTGAAAAGCCCTTCGCGGTAATGTTTAAAAGTCTTGAACAAGTTGAAGC +ATATGCAAACCCTACCGAACTTGAAAAGGCACTCTTGATTTCCCCGGAAAGACCTATAGTATTAATACAA +AAGAAGAAGGAACTCGCTCCATCCGTATCGCCCGGATTAAAAAGAGTTGGTGCGTTTCTCCCCTATTCTC +CCCTTCACCACCTTATACTGAACTCCTTAGATTTTCCCGTTGTGGCGACTTCTGCAAATATCTCAGAAGA +GCCCATAATCAAAGACAACAAGGAAGCACTGGAAAAACTGGGAGAGCTCGCCGATCTTATCCTCGTTCAC +AACAGGGATATAAAAAGGAGGTGTGACGACTCGGTAGTTAAAGTCGTGAGTGGTGTTCCTACACCGATAA +GACGATCAAGGGGCTACGCACCACTTCCCGTAGAAGTTCCTTTTGAACTTCCCAAAAGAGTTCTTGCGGT +TGGAGGAATGCTAAAAAACACCTTTGCCCTCGGCTTTAAAAACCAAGTAATCCTGAGTCAGCACATCGGG +GATATTGAGAACTTAAATACTTTAAAGGTTTTTGAAGAAAGTGTTTTTGACCTTATGGAACTCTACGAGT +TTGAGCCCGATGTAGTAGTTTGCGATATGCACCCGAGGTACGAAACTACGAGGTGGGCTGAGGAGTTTTC +CAGAAAAAGGGGAATACCCTTAATTAAGGTTCAGCACCACTACGCCCACATGCTCTCCTGCATGGCGGAA +AACGGGATAAAAGAAAAGGTTCTCGGAATAGCTTGGGACGGAACGGGATACGGAGAGGACGGAACCCTCT +GGGGAGGTGAGTTTTTAGTGGCAGATTACACTTCTTATGAAAGAGCATTTAACTTCAAACCCGTAAAACT +CATAGGCGGAGAGAAGGCGGTAAAGGAACCGAGGAGGGTAGCCCTCTCTTTACTCTTTGATATATTCGGG +GAGGAAGCCCTCAACTTGGACCTTCTCCCGGTAAAAAGCTTTAGCGAAAGGGAGCTAAAAAACCTGTACC +TTGCCTGGAAAAAAGGCATAAACTCACCGCTTAGTTCTTCTGTCGGAAGACTTTTTGATGCTTTGGCTTC +CCTTCTTAATCTCAAACAAATCCTCTCTTACGAAGGGCAGGGAGCCATGATGGTGGAAGATTTATACGAC +CCTCTTGTAAAGGATAACTATCCCTATGAGATACGCGGAAAGGAAGTAGATTTAAGGAAGGCCTTCCTAG +AAGTTTTAAAGGAAAAAGACAAGAGTCTCGCGGCAAGCAGGTTTATAAACACGCTCGCGAAGGTTTGCGA +AGACATAGCCCTCATGGTTGGTATTGAACGTGTGTGCCTTTCTGGGGGTGTTATGCAAAACGATCCACTG +GTTACAAAGATAAAGGAGCTTCTGGAAAAGGAAAAATTTAAGGTTTACACGCACCAAAAGGTTCCTCCGA +ACGACGGAGGTATAGCTCTGGGACAGGCTGTTTTTGGACTTTCTCTGGTATAATTTAGGGATTATGATAC +AGGTTGAAATAGTTTCTCCGCAGGGAATGGTTTACTCGGGAGAAGTAGAGAGCGTAAACGTCCCCACGGT +TGAAGGAGAGGTGGGAATCCTTGAAAACCACATGTACCTGATGACCCTCTTGAAACCTGGACTTGTTTAC +TTCAACGGTGACGACAAAAACGGAATAGCTGTAACCTACGGCGTTCTGGACGTCACCCCCCAAAAGGTTC +TCATTCTTGCGGAAGAAGCTTACGAAGTCGGAAAACTTCCTCCAGCAAGCAAGCTAAAAGAAGAGTTTGA +AGAAGCCGTGAAGAAAATGGCAACCGCCCAAACTATGGAAGAGTTAAAAGAGTGGGAGAAGGAAGCAGAA +AAGGCAAGAACTCTCTTAGAACTCGTTGAAAAGTACAGATAACTCAAAACCCGTCCCCTTCTTTCGGGGA +AAATTAAAATTTTTTCAACCGAAAGAGCACAAAATCTCCGTTGACCTCGTACTTTTCCTCTCAAAAATCA +AACCTCCTAAGAGGAATTACAGAATAATAGACCTCGGCGCTGGTTTTGGCTTCCTTTCTATAACCCTTGC +AAAAAAGTACGGAGTTAAAGTAGTAGCCTTTGAATACGACGAAAGAATGGTAAAACTATTGAGGAAAAAC +GTAAAGTTAAACGGCGTTGAACACCTTGTTGAAGTGGTGGAGGGGGACATAAAAGAGATAGAAAAGCATC +TCTCTAGAGGTTCTTTTAACTTGGTAGTTTCAAACCCTCCTTTTTACCCGATAAATTATTCACCAAATCC +AGAACCCTACCACTTTGAGGTTTACGCAACCCTGAAAGATTTTGTAAGGGCTTCCTCTTACCTTTTGAAG +GACGGCGGAGAGCTTTACCTTCTCTCTCCTTGCTTTCGCCTCTACGAGCTCACAGAATACCTTTCAAACT +TCAATTTACCTTTAAGGAAACTCTCTTTAATTTACCCTACTCCCCTAAAGAGGGCGAGACTTGCGATTAC +CGTATCCGTTAAAAACGTAAAAGGACAGCTCGAGTGCGATAAACCCCTGATAATAAATAAAGAAAACGGA +GAGTATACAGAAGAGGTAAAACAGCTCCTTGAAAACTTCCTTTAAAACCTGTGCTCTCTTCCCGTAAGGA +GTCTGTTTATGTTTTCCCTGTGCCTGTAAATTATCAACGCACCTATAACGATAGCCATAAAAAGAACGTT +GACGGGGTATCCCGCAACGAAGAGGAATAGAAAAGCGGATATTGTTGCGGTAATGGATGCGAGGGAGACG +TACCTCTTCCATAGGAAAATTCCTAGCCAGACGAGGAAGGAAAAGAGAGCGACAGAGGGAGAAACCGCAA +ACACTACTCCGAGCGCGGTTGCAACGCCTTTTCCCCCTTTAAAACCGAAGAAAACGGGATACATGTGTCC +GAGAACGCTCGCAAGTCCTGTGAAGGTTAAAACCCAAGAGTCAATGCCAAAGGATTTCACCGCTATTAAA +GCAGGGATAAAACCTTTCAGGAAATCCAGGAAGAACACGAGGACGCCGTACTTCTTACCCAGAGCCCTTG +TTACGTTCGTAGCACCTACGTTTCCGCTTCCAACGTTTCTCAGGTCCACTCCTTTTAACTTGGCTATAAC +TTCACCGAAAGTAATAGAACCGAGAAGGTATGCAAAGATTACCAGGAAGAGTGCCTTCATATAAAAGAGT +TTAATCGCAATTTTCCACACACACCTTCTTTATACGAACCTTTCCTCTGCAGGATTCAAAGCATGCGTCG +TATAGCTTTTCACAACCGCACTCGCAGGAACAGGCTTCCCTTTCCCTTTTTAAAAGAATTTCATAACTTG +GCATCGTGGGTTTTTGAGGAGGTAGTGGTTTTCTCCTTTCGTAAAAGCGTATCCTTTTCTTTAACCATTC +TTTCTTATCGCACGCTTCTTTGTCCTTATAAGCACTGCATATCCTCTCGTAAAACTTTAGATCTTCCTTG +ATACGGTATAGGGTTTCCCTGTAAGTTCTCAGTTCCTTCAAGTAGTTTTCGTAAGCCTTTTCGTACTCCC +TTGATTTTCTTTCATAGTCTTTTAAAAGTGATAGATAAACTTTTCTGGCACGCTCAACGCTTTCTTTTAA +ACATGCGTTGTAACTTTCAAAACACGCTTTCTTACATTCTAAAAACTTTTCTTTACAATCCTGAACGCAA +AGAGTATTCTGAGGTAGGACGTACTCTTTAACGATTTTGTACTTTGGACTGCAGGAAAGGAGTAGTAAGG +CTAAGAGTACTATTAACATAAGTTAGATTATAGGTATTTTCTGTGCTACAATAAACCTTTAAAGAAGGTT +AGGAGGTAGAGTATGGCTACACTGACTTATGAGGAAGCCCTTGAGATACTAAGACAACAGATAAAGGATT +TCGAACCTGAAGCCAAAATGGAAGAAGTAGGTGTAGTTTACTACGTCGGTGATGGTGTAGCAAGGGCTTA +CGGTCTTGAAAACGTAATGGCGATGGAAATAGTAGAGTTTCAGGGAGGGCAACAGGGAATAGCCTTCAAC +CTCGAAGAGGACAACGTTGGTATCATAATCCTCGGTTCTGAAACGGGAATAGAAGAAGGGCACATAGTAA +AGAGAACGGGCAGGATATTGGACGCTCCCGTTGGAGAAGGACTCGTTGGAAGGGTTATCGACCCCCTCGG +AAACCCCCTCGATGGTAAAGGACCCATTCAGTTTGAATACCGTTCCCCAGTTGAAAAGATCGCACCCGGT +GTTGTAAAGAGAAAACCCGTTCACGAACCCCTTCAAACAGGTATTAAAGCTATAGACGCTATGATTCCAA +TAGGAAGGGGACAGAGAGAGCTTATCATCGGTGACAGGGCTACGGGTAAGACCACTGTTGCGATAGACAC +CATACTCGCTCAAAAGAACAGTGATGTTTACTGTATTTACGTAGCCGTAGGACAGAAAAGAGCGGCGATA +GCGAGACTCATTGAGCTCCTTGAAAGAGAAGGAGCTATGGAATACACCACAGTTGTTGTAGCTTCAGCAT +CAGATCCCGCATCACTCCAGTACCTCGCACCCTTTGTTGGATGTACGATAGGGGAGTACTTCAGAGACAA +CGGAAAGCACGCACTCATCATATACGACGACCTGTCCAAGCACGCGGAAGCTTACAGACAGCTCTCACTC +CTCATGAGAAGACCTCCCGGTAGAGAAGCTTACCCCGGTGACGTGTTCTACCTCCACTCAAGACTCCTTG +AAAGAGCTGCAAAACTTAACGACGACCTCGGGGCAGGTTCTCTCACGGCATTGCCCATAATTGAAACGAA +AGCGGGTGACGTCGCGGCTTACATTCCCACGAACGTTATCTCCATTACAGACGGACAGATATACCTCGAA +GCGGACCTCTTCAACAAAGGTATAAGACCTGCTATTAACGTAGGTCTTTCGGTTTCCAGAGTCGGTGGTG +CGGCACAGATAAAGGCTATGAAACAGGTTGCGGGAACCCTCAGACTCGAACTTGCTCAGTTCAGAGAACT +TGAAGCTTTCGTTCAGTTCGCTTCGGAACTTGATAAGGCAACCCAGCAACAAATCAACAGAGGTCTGAGA +CTCGTAGAACTCCTGAAGCAAGAACCCTACAACCCGATACCCGTTGAAAAACAAATCGTTCTCATATACG +CCGGAACGCACGGATACCTCGACGACATTCCCGTAGAGTCTGTAAGAAAGTTTGAAAAGGAACTCTACGC +TTACCTAGACAACGAAAGACCGGACATACTCAAGGAGATAAGTGAAAAGAAGAAACTCGACGAAGAACTA +GAGAAGAAGATAAAAGAGGCGCTCGACGCCTTCAAGCAAAAGTTCGTTCCCTAACTCTCCCTCCTTCTTT +TAACTCATAAATATAAGTATTTCGTCCTTTTCCACCTTTGCCCTTTCGGGCTCTAAATTCCTTAACTTCC +TAGGAAGCATAACGTGAGCTTTGAAGTTTCCCACTCTTACGACTATTTCGTCCTCTCCTTTTACGAGTGA +GATACTCTCCTTCTTTACTCCGGGGGCTTTTATTCTTATTACGTACTTTCCATCCAGTTGTTCTATCTTG +TAGGGAATTTCCTTGTGGAATATCTTGTCGGGTGGTTCGTCTCCGTAAATGAGCTGTGCCAGTTTTTCAA +GCCTCTCAAGACCTACGACCTCTTCTTCAAGGAGCGGAACTTTAAACACGGGAACTGGTGAGAAGTAGCT +CTCTATCTCCTTTACATACTTTTTCTGAATGTTTAGCCACTTTTCAAGGAAAGAGCAGTTTTCCTGCTGG +ATTACCTCTTCGGGTATCACTTTGTTCACTATTACCGCATCCACGTTTACGCCGAAGAGAAGGAAGTAGA +GAAACGCCCTCTGGCTTTCCTTTAAAACCATCTTTTCGGGATTTGAAACTATCCTTATTGAAGTTATATC +CGGATTTATTAATATTTCGTCCACACCTTTGAGTCTCTCGTAGAAGGTTTCGAGAGCCTTAAAGTACTCC +TCGTCTGGGAGCGGGACGTCTGTCATCCTTCCAACCGTAGGTCTTGCGACCTTCATTATGAGTCTTTCCG +TTTTGAATATCTTCTTCATGTACCATTTCATAACCGTGGGCATGGAGACGAACCTTATGCTCTCGCCTGT +AGGAGGTAGGTCTAAGATAAGGACGTCGTGATTGCCCTCCCTGTAGTACTTGTTTACGTAAAGAAGACTC +GTTATTTCCTCCATTCCGGGGAGTATAGCGAGTTCGTCCGCGAGTATCTCATGAAGTCCCGTAGTGTGAA +AGAGGAGTTCTATGAACCTGTAAACTTCTCCCCAGTATCTTTCTATCTCCTCCTGAATGTCTATTTCTTG +AATTTCCAGATTTTCATTTATCTTTATGGGAAGCCCTTTCGCTTTTCTCCTCTCTTCCTCCGGAACATCA +AAGGAGTCCGCCAGAGAGTGAGCCGGATCAAGAGAAACTACTATAACCTTCTTCCCGAGCTGAGAAAGTT +TATACCCGGTCGCTGCGGAAATTGTGGTCTTCCCTACTCCTCCTTTTCCAGAAAAGAGTATTATCCTCAT +GTATGAAATTTTAACTTTTAATTAATACATTACACTTAGACTAAGGAGGCTGGAATGAAAATAGCCCACA +TCTCCGACCTTCACGTTAAGTGCGAGTGGTACGAAGACAGACTGGGAAACAATCTCGTAAAGTACTTAAA +CGCCCAGAAGCCGGATCTTCTGATAATAACGGGAGACCTTACGGATTACGGCTACTACGCGGAGTACAAG +AGGGCTTACTCCTTTTTAGAACTCATAGAAGTGGAAAAGAGAGTTGTAGTTCCCGGAAACCACGACGCGA +GGAACGAAGGGTACGAACTTTTTGAGGAGTTTTTCGGAACGAGGATGCCTTATTACGAAGACGAATACAT +GGTAATAATTGGTATGGACTCGAGCCTACCCGATAGGGAGGAGGGACACATAGGGAGGAAGGGTTACAAA +TTCCTGAGGGAAACTCTGAAAGATAAAGGGGATAAACTAAAGATAGTTGCCCTTCACCATCACGTTGTTC +CTATACCGGCAACGGGTAGCGATCTGGCTATACTTACGGACGCGGGAAATCTTATGAAGGTTGTGGATGA +ACTGGGTGTTGAACTTGTCCTTACGGGGCACAAGCACAAGGCGTGGGTGTGGAAATTAAACGAAACTTAC +TACGTTACCGCAGGCACCGCAACAACAAGGAGACTCAAGGCGAAAGACTACCCATCCTTCTACATGTTGT +ACTTGGAGGATGAAAAGAATATAAGGATGGAAAAGGTAAATACGGAAACCTTGAAAGTTGAAGAGGTTTA +TACGCTGAATTTTGAGGAAGGTAAAGAGAGATGAAGATAGCTTTTATATGCACGGGAAATTCCGCAAGGA +GTCAAATGGCGGAAGGGTTTGCAAAGTACTACGCGAAGAAATACGGTCTTGATCTTGAGGTTTACTCAGC +AGGTTCTAATCCCGCAAAGAGGATTGCACCAGAAGCTATTAAGGTTATGAAGGAAAAAGGTATAGACATA +TCTGCCCAGTATCCCAAAAAACTCGAGGACATTCCCTTGAACGAAATGGACCTAATAATCACACTTTGCG +GAGGAGCAAAAGAGAGCTGTCCCACGGTTCCTGGAGCACGTCAGGAACACTGGGATTTACCGGACCCCGC +GGCATACGAAGGGAGTGAAGAGGAAAGACTTGAATTCTTCAGGAAGGTAAGGGATGAGATAGAGAAAAGG +GTTATAAAACTTATGGAGGAGTTAAAGGAAAAGGTGAAGGCTTAAATTTATTCCTTATGGACAGAATCGT +AATCAGAGGAGCTCGGCAACACAACCTAAAGAACATAGACGTTGAAATACCGAAAAACAAGTTAGTGGTC +ATAACGGGACCTTCTGGTTCGGGTAAGTCTTCTCTTGCTTTTGATACACTCTACGCGGAAGGACAGAGGA +GGTACGTGGAAAGTCTTTCCGCATACGCGAGGCAGTTCCTCGGAGTTATGGAAAAACCCGAGGTTGACTC +TATAGAAGGATTATCCCCTGCCATAGCGATAGACCAAAAAACAACTTCCAAAAACCCCCGTTCAACGGTG +GGAACCGTAACCGAGATTTACGACTACCTGAGGGTTCTGTGGGCAAATGTAGGAAAGCCCCACTGTCCCC +ACTGCGGAAATCTGCTTTCGGGACTGTCCGCCCATGAGATACTTGACAGGATAGTGGAAAAGTACAAGGG +AAAAAGGGTAATGATTCTCTCCCCTATAGTCAGGGGAAAGAAGGGAGAGTTCAGGGAACTGCTGAGGCAG +ATTGAAAAGTGGGGTTACTCCCGCGTAAAGGTGGATGGAGAGCTCAGGAGGGTAATAGAGGTCCCGCCCC +TTGAGAAGAACAAAAAACACACAATAGAACTTGTTATAGACAGACTGACGGTTAGCGAAGAAGAAAGAGC +GAGACTCCTTGAGGACGTAGAAAAAGCCCTGGAGTTTTCGAGCGGACTTGTGAAGATTGAAGAGGTGGAG +AGCGGAAAGGAAGAACTCTTTAGTGAAAAGCTCGTTTGTCCGGAGCACGGCTTTTCAATACCTGAACTCT +CCGCAAGACTCTTTTCCTTCAACTCACCCTACGGAGCTTGTCCTTCCTGTAAAGGGCTCGGTGTGAAGTG +GGAAATAGACCCCGCGGTTTTAATAGACCCTGAAAAACCTGCAGTAAAAGCTGTAAAGATAGTAGAGAGC +GGTTACTTTAATTACCTGAGGTTCCCGATCGCAAATGTAATAAGGAAGCTTGGCTACGACCCCAGAACTC +CGTGGAAGAAGCTTCCCGAAAGCGTAAGGGCTACAGTTCTCTACGGGAGTGAAAGCCTGAACTTTGAAGG +GATAATTCCTCACCTTGAAAGGAGATTTTTAGAGGAAGAAAGCGAAAGGATAAGGGAGGAGATAGAGGAC +TACATAGTGGAAAAACCCTGTCCCGAATGCAAGGGAGCGAGGCTCAGGAAGGAAGCTCTCGCGGTGCTCA +TAGACGGAAAGAGCATATGGGACGTTGTAAACATGCCTGTGGGAAAGGCGAAAGAGTTTTTTGAAGAGCT +ATACGAAAAGCTTGAAGGTAAGGAGAAGATAATCGCTGACAGACTCCTGAAGGAGATTATTGAGAGACTG +GGATTTCTCGTGAACGTGGGACTTGATTACCTTTCCCTTTCTAGAAGTGCCACCACTCTTTCGGGCGGTG +AGATGCAGAGAATTAGGCTTGCCACACAGCTTGGTTCAAAACTCACGGGGGTACTATACGTTTTAGACGA +GCCTTCAATAGGACTCCATCCGAGGGACACGAGTAAGCTTATAAACACATTAAAAGGTTTAAGGGACCTC +GGAAACACGGTTGTGGTCGTGGAGCACGACCCCGAGACGATAGAGTCTGCGGACCACGTAATAGAGTTGG +GTCCCGGAGCTGGAAAACACGGGGGTTATCTCGTCGCTCAGGGCACCGTTGAAGAAATAAAGTCCCACCC +CTCTTCCTTGACGGGGGCCTATCTTAGCGGAAGGAAAGAGATCCCTGTTCCGAAGGAGAGGAGAAAACCG +AGCGGAAAGTTCATAAGGATCGTCAGAGCCAAAGAGCACAATCTCAAAAACATAAACGTTGATATACCCT +TAGGTTTATTTGTGTGCATTACAGGTGTTTCGGGAAGCGGAAAGTCCACGCTTATATACGACATTCTCTA +CAAGTACGCGAAGAATTACTTTTACGGAACTCACGAGCAGGTGGGAGAGGTAGAAAAGATAGAGGGACTG +GAAAACATAGACAAGGTTATAAACATAGACCAGTCTCCCATAGGAAGGACACCCAGGAGCAACCCCGCCA +CTTACACGAAAGTCTTTGACCTTATAAGAAACCTCTTTGCCCAGACGCCGGAAGCAAAGGCAAGGGGCTA +TAAACCCGGCAGGTTTTCCTTCAACGTCAAGGGTGGAAGGTGTGAAGCCTGTCAGGGAGAAGGAGTCATA +AAGGTTGAGATGCACTTCTTACCTCCCGTTTACGTGACCTGTGAAGTTTGTAAAGGAAAACGCTACAACA +GGGAAACTCTTGAGATAACCTACAAAGGCAAGAATATAGCGGACGTCCTTGAAATGACCGTGGACGAAGC +GTACGATTTCTTTGAAAATCACCCCGCAATCAGGAGAAAACTCCAAATTTTAAAGGACGTGGGGCTGGGA +TACATAAAGCTCGGGCAACCCGCTCCCACGCTCTCGGGCGGTGAAGCACAGAGGATAAAACTCGCGAGGG +AACTCTCCAAAAAGGAAACCGGAAGAACCCTTTACCTCCTCGACGAACCCACAACGGGACTACATATGGA +CGACGTTAAGAAACTCATAGACGTCCTTCAAAGGCTCGTTGATAAAGGAAACACGGTAGTCGTAATAGAA +CACAACCTTGACGTTATAAAGTGTGCTGACTGGATTATAGACCTCGGTCCCGAAGGCGGTGAGAGAGGCG +GTCAGGTTGTAGCCGTTGGAACTCCCGAGGAGGTAGCTCAAAATCCAAACTCATACACGGGCAAGTACCT +GAGAAAGTACCTGAAAAAGGAAACCCTAAAGGTTTAGTAAGCAATGTGGTCGGGGTTTTTCTTCGCCTCG +TAGAGTTTTTTATCTACTTCCTTTAATATCTCTTCCGGGGAATTGAAGTTTTCGTTGACTTCCAGAATTC +CAAAACTCGCAGAAACTTTTAATTCCTTATCTTCACAGTAAAAGGTATGGTTTTGTATGACCGTTTTTAA +GCGTCTTGCGATGTTTACAGCATCTTCCAGTTTTACACCGGGAAGTATTATTAGAAACTCATCTCCTCCG +TACCTTCCGATGGCATCTTTTGCCCTCAAATACTTCCTGAGGATTTCGCCTATTCCCTTGAGTATGCAGT +CTCCCACGAGGTGCCCGTACTCGTCGTTAATTTCCTTAAAGTTATTTAAATCCATCATTATTACGGAGAA +GGGGTATCCGTAGTTTTTATAATCCTTGAAGTAATCCTCCAGAGCTTTCTGAATAGAACGCCTGTTTTTT +AATCCGGTGAGGTAATCTATAAAAGCCTGTTTCTTTAAAGCGTCAAGTTCTTTTTTGAGTCTTTCTGTTT +CCTTTTGTTTTTCTTGAAGCTTTGCTATTAACTCTTGATTGACTTTCCTCAGTTCGGAAACCTCTTTCAA +AATATCCTTTAAAATGCTAATTTCTTCCTGCCTTGAGTAATCTTCCAAGGTTTTTTCGTGCTTTTCTATC +TTTTTATCGTACTTTTCAACCGTCTCCAGATACTCGTAAACCGTGTGTCTAACTTCAGTAAGAATTCTTT +CTATCTCGTTAGAAAGCCTCAGGTCTATTTTAGCTTCTTTGAAAATCTTGTAGTATATGTCTATTATTTG +CTCCGTAGTTGCCTCTATGTTATTTTCAACGATGTAGCAAAATACGAAAAACCACTTCGCGTAGTTCCGG +GGAACGGGGACTATGTTATGCTCAACAAAGAAGTTAAACATACGCTTTATTACTTCCTTCAGGTTTCTTT +TATCTACTTCGTTTAATTCTTCCCCTTCCCTTATTTTCTCATGGATCCTGCACTTGAATTCCATTAGGAG +TAAATTTTAGCAAACTTTAACTAACCCTTCCGGCACAAGGTTATTTTCCTTTATCCACTTTTCCATAGTC +TCGAGTGCCCTTTTAGCCATTAATTCCTTTCTCTTCTTCTTATCCCTTACCTTCTTTTCCAGAGGGGGAA +GGAGTCCGAATACGGGGTTCATGGGCTGGAGTTCTCCTTCTTTTGTTACTATGTAATTGACGAGAGCACC +GAGCATAGTTTCTGTTGGAGCTTTTAAGGGTTTTTCTCCTCTCGCGAGTCTTCCCGCATTTATGCCTGCC +AGTATTCCCGTGGCGGAAGAGGCGACGTAACCTTCCACTCCCGTTATCTGTCCCGCGAAGAAGATATTTT +CCTTCTTCTTCAGGTTCAGGTAATGGGTGAGGACCTTGTTTGACTGGATAAAAGTGTTCCTGTGCATGGA +ACCTAGTCTCACGAACACCGCGTTCCTGAGGCAGGGAATGAGTCTAAAGACTCTCTTTTGTTCCTTGTAA +GTCAGTTTTGTTTGAAATCCCACGAGGGAGAGTAGTGTCCCTTCCTTGTTTTCCTTCCTCAGCTGAACCA +CCGCAAAGGGTTCTTTACCGGTTCTCGGGTCTACGAGCCCCACGGGTTTCATAGGTCCGAAGAGAAGGGT +TTTGTATCCCCTTTCCGCCATTTCTTCTATCGGAAGGCAACCCTCAAAGTGAACGGCCTTTTCAAAATCC +TTCGGCTTAACCTTTTCGGCTTTTAGGAGTTCCTCGTAAAATTTCTTATACTCCTCTTCCGTAAGGACGC +AGTTGAAGTAATCGTCTCCACCTTTTCCGTACCTCGAGCCCCAGAAACCCTTGCTAAAGTCCACGCTTTC +CGCTTCAACTATCGGAGCTATTGCGTCGTAAAAGTAGAGGGTATCGTACCCAACTAGTTCCTTTATTTTT +TCAGAAAGTGCGTCCGAGGTAAGGGGTCCCGTCGCTATAACGACAACCTCATCCTCCGGAATTTCCTTTA +CCTCTTCCCTGATAAGGGTTATGTTGGGGTGGCTTTCTATCTTTTCGGTTATGTATTCGGAAAATATCTT +TCTGTCAACTCCAAGTGCTCCGCCCGCGGGCACCCTTGCTACCTTTGCCGCCTCAATCACTAAAGAGCCG +AGCTTCTGCATTTCCGCCTTCAAAAGCCCGGCTCCAGTTGTTAATTCCAGTCCTCCGAGCGTATTACTGC +AAACGAGTTCCGCCAGATTTCCCGTTTTGTGAGCGGGAGTCATCTTCTTGGGTCTCATTTCGTAGAGTAT +TACCCTGTGTCCTTCGTTTGCGAGTCTCCACGCTGCTTCTGAGCCAGCAAGCCCTCCTCCGATTACTATA +ACCTTTTCCTTCATTGCTTTTATGAATTTAAACTAAAGTTTTGTATATGAGAAGAGCTGTAATCATACCT +GCAAGACTAGGCTCAACAAGGCTAAAGGAAAAACCTTTAAAAAATTTACTCGGAAAGCCCCTCATAAGGT +GGGTAGTTGAAGGACTCGTAAAAACGGGAGAGAGGGTAATCCTCGCTACGGACAGCGAAAGGGTAAAGGA +AGTGGTTGAGGACCTATGTGAAGTTTTCCTTACCCCCTCGGACCTGCCCTCGGGCAGTGACAGAGTTCTG +TACGTCGTTAGAGATTTGGATGTTGACTTAATTATCAATTATCAGGGAGATGAGCCCTTTGTTTACGAGG +AAGATATAAAATTGATATTTAGAGAACTTGAAAAGGGAGAAAGAGTTGTAACCCTTGCAAGGAAGGACAA +GGAGGCTTACGAGAGACCTGAAGACGTGAAGGTGGTTCTGGACAGGGAAGGATACGCCCTTTACTTTTCC +CGCTCACCTATCCCATACTTTAGGAAAAATGATACATTTTATCCTTTAAAACACGTAGGGATTTACGGCT +TCAGAAAGGAAACTTTAATGGAGTTCGGCGCTATGCCTCCCTCAAAACTTGAACAAATAGAAGGACTTGA +ACAGTTAAGGCTTTTAGAGAACGGAATAAAGATAAAGGTTTTAATTACGGAGAATTACTACCACGGAGTT +GATACGGAGGAGGACTTAAAGATAGTGGAAGAAAAGTTAAAAAATTTATAAAAAAAGGAAAGCTCCTCGC +AGGGGCAAAAAGGAACTGTCAGAAGTAAAACTGCATCTGTATCTGGTGAACCGTTTGGTCCTTTTCGTCT +TTTTCTTTGTTATCTATAAACAGGACGTTGTAGCCCCACTTAATCTTATGACCTTTTATGTAGTGGTTGA +AACCGAGGGTGATTATGTCTTTCTTGTGTTTAGTAACGTCGTTCTTTTTATCTTCCTGCTTGAAGTGTTC +GTACCTCGCTGCGGGTTCAAACTTTCCGTAAGGAGTGGGTATCAGGTATCCTGCCTGAATGTAGTAACCT +TTTTCTTCAAGGTCTAACTTATCGTACTTCATCTTCACGTATTCCGCCTGAGCGACGAGTGCACCTGGTC +CCAAGTGGAACCTTCCGAATATATCTCCGCCCCAGACAGTTGCTTCTTCATTCTTTATGTTTTTATCCGT +TATATCAAAATCGCTGTTCTTAGCGTAATTGAGTCCTACGCTGATCACGTCTCCTTTGTTCTTTTCACCT +ATACCAGTGTCGTCCTTTTTCTTTTCTACGAATCCCGGAGGAGAGAACTCAAGTCTTATGGCGTAAGCGT +CACCGAGGGAAGTATCCGCTTTTACTGTTCCTCCTGTCTTGTTTTTACTTTCTATGGTTGAACCGTCCCA +TATTGAGAGCATGTACCTGAATATTCCGCCTGCAACCTTTCCGTGGAACATTATTTGGTTGGAGTCGTAA +TCTCCGAGCCACTTCTTGGCGTCTTCCGTAACGTAGGGTCTCTCTATCAGGAGCTGTCTTGAGGAAGAAG +TTAGGGAAACTCTTGAGTAGGGTATCTTATTCTTACCTATCCTTACCGCAAACTCGTCAACAAAGGTCCA +GTCTGCATAAGCGTACTTAACTTTTGGATCAAAGGAATGGTGTTCCTTTTCTCCTTTCTTGTAATCGTAG +TCCCTTTCTCCTTTGTCCGAGTGTAAGGTAAAGTTTATCTTTAGTTTCTTACCGAAGGGTATATTCTTCC +ATTCTTTGGAAATTTCAAGTCTTACCCTTCTGAAGTAAAAGTCACTCCTGCTCTTGTAGTCGTTGTTTTC +CTTGTAAATATCACCGAAATCAATTCTGGGCTGGAGCCTGATTTTTACCTTCAAGTGAGGGTGTTTCTTA +GCAACTTTTTTCACTTCCTTTGCTTCTTCTTTGGTAATTACCCCCTTTTCTTCTAGTTTTTTCAGAAGGA +CGTCCAAGGGATCACTTTCTGCAAAGCTAACAACCGGCAGAATGGCAGAAGCAAGCATAAGTCTTTTCAA +CATTTTCCACCTCCTTATCGATCAATCATTTGTTGAGGGAGTTTAAATGAATTTTGTTAAGATTTTTTTT +AGAAAAAATTAAAAAATTGTTAAGAGGAGAAAAAAGGAAGGAATTAATCCGCCATCAGGTCTCTTTTTAT +CATCTCAGGAGTGGGACAGGCTTCTGGAGGCATCCTCTTTATTTTGGAAGCATAGTACATGACGGGAATG +AGAACGAGGGTGAGGGTCGTAGAACCTATGGTTCCGAAGATAAGGGATATAGCAAGTCCGTTGAATATCG +GGTCAAAGATTATAACGAAAGCACCGATTATAACAGCAGCTGCTGTAAGGAGTATGGGTCTGGTTCTTAT +GACTCCCGCTTCCACTACGGCAACGTGAACGGGGAGTCCTTCTTTTAACCTCTGCTCCGCAAAGTCAACG +AGGAGAATAGAGTTTCTCACTATGATACCGCCGAGGGCGATAAAACCTATCATAGAAGTTGCGGTGAAGA +AGACGTTACCCATTATCTTGTCCATGAGCCAGTGTCCGGGGATTATTCCCACCAGCGTCAGGGGTATGGG +GGCAAGGATAATTCCGGGTATCCTGAAGTCTTTGAACCATCCCAGGACGAGGACGTACATAACGAATACC +GCAACCGCGAAGGCGAGTCCGAGGTCTCTGAACACTTCAAGGGTTATGTGCATTTCCCCGTCCCACTTCA +CGTAAACCCTGTCCTCAAGGACGGGCAGGGACATCCAGAGTTCTCCCACTTCTCCGTAAGGGTTTTCTAT +ATTGAGGATTTTATCCCTGACGTCCAGTATTCCGTAAATGGGTGCCTCTTCCCTTCCAGCAACGTCACCG +ATAACGTATATAACCCTTCTGAGGTTCTTGTGGTAAATAGTTTCGGGAATGGGACCTTCTTTAATTTCCA +CGAGTTCTGAAAGCGGGATAAGCTTTCCTTCCCTGTTGGGTATCTTTACATTTTTAAGTAGCTCAGGAAC +CCTGTACTTTTCGTCGAGTCTTATTATTATGGGAACGTGTTCCGTGTCGGTAGTTTGCATTATGCCCGCC +TGCCATCCGCCTATGAGAGCTTTGAGCGTGTAAACGACTTCCTGCTTTGTGAGTCCTGCAAGTTTTACCT +TGTCCTCTTTAACCTCGAACCTTATCATGGGAGCGGGGTATTCAAGGTAAATTCCCTCATCGGTTATGGC +GGGTGAGTCTTTGAATATCTTGAGAACCCTCCATGCGAATTCTCTCTGAACTTTCATGTCAGGGGCGTAA +ACTTCCGCGACTATCGGGGAGAGAACAGGAGGTCCGGGCGGGACTTCTACCACAGCTACGTACTTAGCAC +CGTACTTGCTGGCTATTTCATGAACTTTCGGTCTTATAAGTTTTGCAAATTCGTGGGACTGTAAATCCCT +GTCATGCTTTCCTACGAGGTTTACCTGAATTTCTGCAAGGTTTGAAGCCTGCCTGAGGTAGTAGTGTCTC +ACTAGTCCGTTAAAGGTAAAGGGTGCAGCGGTTCCCGCGTATATCTGGTAATCCGTGACTATAGAATACC +TTCCCACGTAATCCGCGATTTCCTTTGCGACTTTTAAGGTGTCTTCGAGTGTCGTTCCTTCGGGCATGTC +AAGGACTATCTCTAGTTCGGATTTGTTGTCGTAAGGGAGCATCTTAACGAGAACAGTTTTTGTAAAGAGC +AGTCCCACGGAACCGCCCATGAGGGCGAGGACGAATAGGTAGAAGGCATACCTCTTTAACTTGCTCGCAA +GAAGCGGATACATTATGTGACAGTAAAGCTTCCAGAAAAGCGTTTTCCTTATGTTTATCTCTTCGTGTTC +CCTTTCTTTCTTGAGGATGTGGTAAGCCGCCCAGGGTGTTACGATAAACGCAACTAAAAGCGAGAAGAAC +ATTGCGACCGAAGCGTTGATGGGTATGGGTCTCATGTAGGGACCCATCATTCCAGTGACAAAAGCCATGG +GCATCAGAGCGGCTATAACGGTGAAGGTTGCGAGGATTGTGGGGTTTCCTACCTCGTCCGTTGCGTGGAC +TATGGCGTCTCTGGGGGGCAGTTTTTGCATTTCAAACCATCTGTGTATGTTCTCAACGACGACTATCGCG +TCGTCAACGAGTATACCGATGGAGAATATAAGTGCGAAAAGCGTAACCCTGTTGAGGGTAAATCCGTACA +TTTCGTTTAAAAAGAGTGCTATGGAGAGTGTAACGGGAACCGCCAGACCGACTACTATCGCTTCCCTCAC +TCCTAACGAGACCGCAATCAGGAGAACAACGGAGAAGGTAGCTATAAAGAGGTGTTCGAGAAGTTCCAAC +GCCTTTTCCTGTGCGGTCTCACCGTAGTTCCTCGTCACGGTTATGTTCACGTCCGAGGGGATTACCTTTC +CTTTTAAGCTTTCAACGAACTCAATAACCTGCTCCGCAACAACTACCGCGTTAGTTCCCTTTCTCTTCGC +CACCGCTATCGTGACGGCGGGATAAAGCTCTCCCGGTTTTCCTTCTATGCCCTTGTACTCGTGAGCTTCA +CCGATTCCGAAAAAGACGTAATCCTTTATCTCGGAGGGACCGTCCACAATCTTCGCTACGTCCTTTAAGA +ATATGACCCTTCCGTTCCTAACACCTACAACTACGTTTTCAACGTCTCTGACTGATTTGAAAAATGGACC +CGTCTTTACAAGGTATTCCATATTCCCCTTGTTTATCTTTCCGCTTATAGCCTGAGCGTTTGCGCTCCTT +AAAAGTTGGTCTATGTAAAGGGGAGATATTCCGTAGGCTGCCATTTTGGCAGGGTCGAGAATTATCCTTA +TCTGCCTCGGTCTTCCGCCGATAAGGTAAACATTTGCAACGTTTTCAATCTTCTTTATCTCGTTCTGGAG +CGTAGCCGCGAGTCTTCTTAACTCGTACCAGTCGTAATTCTCACCCCAGAGTGTTAGCGTAAGGATTGGA +ACGTCGTCTATTGACATGAGCCTGACTACAGGGGGAAGGATTACTCCGGGAGGTGCCTTGTCCAGCGCGG +ACATCATCTTGGAGTTGAGGTCAACGAGTGCCTTTACGGGGTCCGTTCCCACGTAGAACCTTGCAGTCAC +TATTCCCATATCGTTTGTGGAAGCTGAATATATGTACTCTATGTCTTTTAGTTCCCAGAGAATCTTTTCC +AAGGGAAAGACTACCCTCGCTTCAACTTCCTCGGGAGTTGCCCCAGGGTAAGGGATAAATATATCTATCA +TCGGAACTACTATCTGGGGCTCTTCTTCCCTCGGTGTAGTTAAAACCGCAAACAGTCCTAAAGCGAGAGA +AACGAGTATGAGTATGGGAGTGAGTTTAGAGTCTATAAAGAAGTTTGCGAGTCTTCCTGCCAATCCGTAC +ATCGGATTAACCTCCTACCCTGCAACCTTCACAGGCCCTTTCTATACCCTCAACCACAATCCTTTCTCCG +GGAGAAAGACCTGCAAGGACCTCGTAGTAATTGCCTAACTTCCTTCCGAGTCTGATAAGCCTGAGCTGAA +GTGTGCCGTCGGGTTTTACGACCCATACTCCCGTAAAGTCCCACCTCTTGTAAATCGCCTTTTCAGGTAT +GAGAACCGTGGGTTCTTCTATTTTCTCAAGTTTGAAAACCTTTACAAAGAGTCCGCTCTTTACGTTGTTG +TCGTCTATTAAAGCCTTTACCTTAAAGGTTCTGCTCACGGGATCCACCGCGGGCTCCACTTCGACTACTT +TTGCAGGGAACACCCTTCCGAGCTTTTCAACGTAGACTTCCAGCGTGTCTCCTATATTTATCTCTCCGAA +GTATTTCTCGGGGAAACTGACTTCTACCTTGTAGGGTCTCGTTTCAAGTACTGCAAGGGGCATACCGGGG +TTTGCTATGTCTCCCCTGTCTACCATTTTCTGTATTACGTAACCGTCAAAGGGAGCTTTTACTTCCGCAT +AAGAAAGCTGAGCCTTTGCGGAGTTATAAGCTTCCCTAGCTACCCTGATTTCGGCTTTTGCCGCCTGGAG +TTTTGCCTTTGCAGCGAGGTACTGTGCTTCTACTTGATCAAATTCATGTTGAGTTATCGCACCTTCTTTT +AGGAGTTTCTTAAACCTCTCGTATGTCTTCTTTACGGCCTCGTAGTGTGCCTTTGCGGCTTCGTAATTCT +TTTGAGCTTGAGCAATTCTTTGCTTCATTATGTTTATCTGAGCCTTTACGTCTCTTGGGTCTATAACAAA +TAGAGTTTGACCTTTTTTGACGAAATCTCCCTCTTTTACCTTTACGTCAACCACGTATCCCATAACTCTC +GTTGATATCTCCGCCCTGTCTCCCGCTACTATCGTTCCTGGGTATTCCACGGGCACTTCCTTTACTACTT +TGACGGGCTCCACTACCAGACCGCTTACGGTCTTGGTTTCTCTCTTTACCTCCTCCGCGTGTATCTTGGG +GTGGAACACTCCTGCGAGCCACATTATTATGAGCACTATCGGTATAACTAGAAAGACCATGTACTTAATT +AAGGTCTTCATTTGAGCACCTCCTCCTTAAGCAGTCCTGCGGAAAAGAGAGCCTTTGCATAGGCAACGTT +ACAATCCCTTAAAGCCTTTGCGTACTCGAATCTCGCCATATCCAGCTGGGTTTGAGCGTCGAGAAGGTCA +ACCATGCGTGCCATACCGACCTCGTACCTCTTCTCAATTACCCTGAGGACTTCTTTAGCTTCTTCCTTTC +TGGACTTTGCGGACTCAAGAGTTTTAAGGGCGTTTTCGTACTCTGCGAAAGCCTTGTCTATCTCAAACAT +TATCGCCTTGGCGAGAAGTTCTCTCTTTCTCTTAAGGGCGAGTTCCTTTTCCTTAAAGCTCTTTTTCTTA +TAAATGGGGCTGAGTCCTGTATTGAAGTTCCACTTGAGTCCAACACCCAACATGTAGCCCTCACCCTGAC +TTCCGAAGGGCGTGTTCTCGTCGTACATGGAGTAATTGGCAAAGGCGAAGACCTGAGGGAGTATGTCCCC +GAGGGCACTTTTCTGACCTTCCTTTAAGGATTTTATGTAGTACTTGAGGGCGAGGTAGTCTTCCCTGTGG +TTTAGTGCCTTTGATTTTAATTCTTCCACTTTAACTGAAGGGCACTTGGAAAAGTCCTTTACGTCAAACT +CTCCGTAATTTTTGTTAGTCAAGAGTTCTAAAGCTTTTTTTGCTACCTCATAGTTGTTTTGAGCCTGAAC +GAGTTTTTCCTTTGCTTTTGAGAGGTAAACCTTTGCCCTCAGAACGTCCGCAAAGAGTGCAACACCCGTC +TTGTAAGCCTTCTCGGCGAGTCTCACGTGTTCCTCGGCATCTTTTACCGCTTGCTTTGCCACCTCAACGG +CGTTTTTAGCGAGAACCGCATTTGCGTAAGCTTCGTAAACTTTGAGGATTACTTCCTCTTCCTTTCTTCC +GTATATAGTCTTGTCCCCCTTCCATTTGTTCTTCGCCATGTTTTTAAAAGCTCTTAATTTTCCTCCCATC +CATATGGGAATTTCCAGAGTTAGTTTAGTTTCAAAGTTCTGGATGGAACCCGGGTCGTTTAACTTGCTCG +GAGTAAAGTCCTGCAAGGTAATCCTTTCCTGGTTTAACTTTGTAAAGAGGTAGTAGGAAGATATATCCGT +CTTTGTGTAGGTTTCCTCAAGCTTTACAGTAGGAAATAGCAACCCTCTCACGGATTTATACTCGTATTCG +GAGGCTTTAACTTCCCTTCTTTGAGAGGAGAGTTCTAAGTTATTCTGAAGGGCGTCTTTTATGAAAACTT +TTAGGGGTAATTCCGCTGCAAAAGAGAGTCCTACCAGTAGAAGAAAGCCTATTAATACCATACCTCTTCC +TCCAGAAATTTAGTATATCACAATATAAGAATATTCTAATGTTCTTATTTCCACTCTAGAATAAGTTTCA +CTTCTCTTCCCAGGAAGTCTTTGACAAAAGAACTTCCGCCTCTGAGGCTTTCAGCTCCTAGGATTATTAA +ACCCACCTCCTCTTTCATTATCTTTTCTCCATTGTTTTCAATTAACTCTATAACCTCCTCCTTAGAAACT +CCCCTTCCGTCCTGAAGAGTATCTGCGGGAACGCCCCAGAGTTCTTTTGCACTTGGAGAACCTATAAAGA +GGACAGAACTCTTTTCCGGCATAAACTCCGTCTGGAGTTCAGCTTTTACCTTTCCCTTTAGTATTTTTTC +TCTGTAAGCGTAGGGAACTATAAACGTAGGATTACTCAGGGGTGTATTTTCAAGGAGAGGTACGTCTCCG +AAGGGCTCTTTCAGTATTATCCTTACAAACTGCTTGTTTAAGAAAAGTTTGTCTCCGTGAACGTGTTCTA +CCTTCCCCTTTACTATTCCTCTAATGGACTGGGAGTAGGGATAAACGTATGAAGGTATTACCTCTCCGTC +CACTTCTATTTTTCCTTTGAGAACCTTCCAGTTCAGGAAGGGGAACTCGTACTCCTTTACGGGGAAGCTG +TTTTCTTCGGCAAATATCCTTATCTCTTTTATGAAGTTCCTCTCTTCCTTTGAGCCGGGTCTCCTTCCCA +AAAAGCCCACTAAATCCCAGAAGATTTTCCCGTTCTTTTGTTTGAAGAGTCCGTATATACAACCGCAGTA +ATCCTGTTGGTATATCTCCCTCTCCTTTGAGAGTTTAAACATCTCCTGCGTTCCGCCGCCCTTTCTGTAG +TCCGGAGCAAGGAACTCAATACCTGTTCTCTTCGTGGCTTCTTCCCCCGCCTTTTTCAACTGGGGAATGC +TCTTTTTAGGACTCATCAAGAGGGTAGTGGTTAAGGCATCGCACCCGAGTTCCTTTGCCACTTCTGCGGA +TTTCTCCAGCCTGTAATCAAAGCATATTTGACAGCGTTTACCCCTTTCGGGCTCGTCCTCGTAGCCTTTT +ACTCTTTCGAGCCAGTTCTCAAGGTCGTACTCTCCCTCGATCAGGTTTATTCCCAGTTCTTTGCATATCC +TTTCGGTTTCAAGATACCTGAGTCTGTACTCCTCGTAAGGGTGTATATTCGGGTCGTAAAAGTAGCCTAT +TATCTCGCTCTCAGGGTAATCTTCCCGGAGTTTTTTTAAGAAGTAAATAGCATCGGGGGCACAGCAGATA +TGGACGAGGATTTTACTCTTCTTCATCGCTCTTTTTTTGTCTCGATACTATCACTTCTTCAAACTTCATC +ACCTTGGTTTTGGGAACTTTAACGATGGCCCTCTGGTAGGCTTCTCCCTGGAGTTTTGAGAGTTCGTTTT +GGATGAACTCCATGAGCTGGTCTATCTGCTTTTGCATTTGTTCCATCTGCTCTTTCAGGTTAAGGATTAT +GTCAACTCCCGCGAGGTTTACACCGAGTTCTCTTGTGAGGAACAGGATAAACTCGAGTCTTTCTAGGTCC +TCGTCCGTGTAGAGTCTTGTGTTTCCTTCGCTTCTGGAGGGTTTTAAGAGTCCCTCCCTCTCGTAAAGTC +TCAAAGTTTGGGGGTGTATATTGTACATCTTAGCGACTACACCTATTGTGTAGTAAGCCTTTCTCTTCTT +CATGGCACTCACCTCTCTACAATTCTTTCAGGCTTTGGAAGAACTTCCTGAAGTTGTTTTAAGAGCTCTT +CCACCTTTTTACCGTCCCCAAGAAGCTTACTAAGAACACCAATCTTGGGAACGTCTATGTGAACCCTGAC +GTAAAGGTCTCCCCTGCCCGAACCTTTCAGTCTGGGCATACCTTTTCCAGGAACCTTTATGAGTTCTCCC +TCTTTAGTTCCGGGTGGTATCTTTACCTTTACCTTTTCACCGTCTAAAGTGGGAACTTCCACTTCTGTTC +CGAGAACAGCCTCGGGGTAGGTTATGTTTACGTCAACGTACAGGTCGTCTCCCTTTCTTTCAAAAATCTT +GTGGGGTTTTACCTTTACTATGATGTAGAGGTCCCCGGGAGGTCCTCCGTATCTTCCCGCGTGTCCCTTT +CCTTCCACTACGAGTTTTGAACCATCCCTCACTCCCGGCGGTATCTTTACCTTTATCGTTTCCTTAACGA +GTCCGTATCCCCTGCCCGTGCAGGCGTGGCAGTTTTCGTAAATCACTCCTTCTCCACCGCATGTGGGACA +GGTTTGTCTTACCTGGAAGAACCAGTTTCCTTGAACGGTTTCTCCTCTACCACCGCATGTGGGGCACGTT +CTTGACTTTGACTCGTCGTATCCCGTCCCGCCGCAAGCGGAACAGGGGACTTCCCTTTCAACCTCTATGG +GAACTGTAGTTCCCTTAAAGGCTTCTTCTAACGTAATCTCAACGGGGACAACTATGTCTTCCCCTTTTAC +GCTCCTCCTTCTCCTTGCCCTCCTTCTTCCCGTAGCCCTTTCAAATATACTTCCTATATCAAAGTCAAAG +AATTCCCTGAGTATTTCCTCTATTGGCGGTATTTCAGTGGTTTCTACCCTCTGCTGTGCTCCTGCACCTT +CAAAGGCTGCGTGTCCGTACATGTCGTAGAGTTTTCTCTTTTCGGGATCGGAGAGTACTTGGTAAGCCTC +GTTTATCTCCTTGAACTTTTCCTCACACTCGGGTTTCTTGCATATATCCGGGTGATACTTCCTGACAAGC +CTCCTGTAAGCCTTCTTTATTTCTTCCTGCGAAGCGTTTCTCGGTACTCCAAGAATTTCGTAGTAATCCT +TTTTAGTAGATGAAGCCATAACTTTCCTCCGTTTACCAGAGTAAATAACTTAAAAGTTGAGTTTATTTTT +GTCAAGTTTCAAAATCACACTAAACTAATAAACGTTTAGGGGAAAGAACACCTCCCTTTAACTCTCCGAT +ACCTATAAATTTAGAGTCTTCATATATCTTAACAAGGCCCTCGTAATCGTAATTCTTTATTAAAATCCTC +TTTCCCTGGAGTATTTTTCCGGCTTCAAAGGTGTTTAGCCTAACTTCGGGGATTACCCTGAAGAGTGTAT +CCACGGGCAGGACGTACTCCTCCGGATTTTCCGAAGAGAGAAACTCTTCCAGACTTACCGCTTCCTCAAC +GCTTATTTCGTCTATCTTCAACCTTCTGAGTTCCTTCATGTAGCCCCCTATCCCGAGCTTCTTTCCTATA +TCGTAGGCGAGACTCCTCACGTAACCCCCGGAAGATATTTCGGCCAAGAATTCCGCCTCCTTTTCTCGGG +GATTGCAGGAAAGGAGTTCCAAGGAGTAGACGGTTATCTTCACGGGCTTTAGTTCTACCTTTTTGCCCTT +TCTCGCGAGTTCATAAGCCCTCCTACCTTTTATCTTTTTTGCGGAGAAGGGCGGAGGTGTCTGGAGTATT +TCGCCCCTGAACTCGTTCAGAACTTCTTTTAACTTATCGCAATTGAGTTCTCCTTCGTAAGTTTCTACGA +CTTTCCCCTGAGCGTCGTAGGTGTCCGTCTCTGCACCGAACTTAACCGTAAACCTGTAAGTTTTAGGCAT +CCCTATAAAGAACTGCGAAAACCTCGTAGCCTTGTTTATGAGGATTATGAGGAGTCCCGTGGCAATAGGA +TCGAGGGTTCCCGTGTGCCCCGCCTTTCTTGCCTTCAGTTTTTCCTTTACCCTTTCCACTACTTCCGTGG +AGGTTATTCCCTTTGGCTTGTCTATCAGAAGTGCTCCGTCCATACACAAAATTATCAATTTAAAATAAGG +CTTATGTACAACTATCCAGACGAGAGAGGTTATTTCGGGCCCTTCGGGGGAAAATTCGTCCCCGAAACCT +TGATGTACGCCCTGGAAGAACTTGAAGAAAAATACAGGGAATTGAAGAGCGACCCTGAATTCCAGAAAGA +ACTCGATTACTACCTGAGGGAGTACGCCGGAAGACCCACTCCCCTTTACTTTGCGGAGAAACTAACGAAG +TACGTGGGCGGTGCGAAGATATATCTGAAGAGGGAGGATCTTCTCCATACCGGTGCCCATAAGATAAACA +ACACCATAGGTCAATGTCTTTTGACCAAGAGAATGGGAAAGAAAAGGGTTATAGCGGAAACGGGGGCGGG +ACAGCACGGGGTCGCAACCGCAACCGCCTCAGCACTTTTCGGCTTGGAGTGCGTCGTTTACATGGGTGAA +GAAGACGCGGAAAGGCAGGCTCTTAACGTTTTCAGGATGAAACTCCTCGGAGCAAAAGTGGAAATAGTAA +AGAGCGGAAGCAGGACCCTAAAGGATGCCATAAACGAAGCACTGAGAGACTGGGTGACAAACGTTGAAAG +TACCCACTACGTGATAGGTTCTGTGGTTGGTCCTCATCCTTTTCCCATGATAGTGAGGGATTTTCAGAGT +GTAATTGGAAGGGAGACTAAGGAGCAGATACTGCAGAAGGAAGGAAGGCTTCCCGACGCTATAGTCGCGT +GCGTGGGAGGCGGTTCAAACGCTATGGGGATATTCTACCCCTTCGTTGAAGACAAAGGAGTTCAGCTAAT +AGGCGTGGAAGCGGGAGGATACGGACTGGAAACTGGACAGCACGCTGCTTCCATATGCGGGGGAAGTGTA +GGAATCCTTCACGGTATGAAGAGTTACTTCCTTCAGGACGAGGAAGGACAAATTCAGCCAACTCACTCCA +TTTCAGCTGGACTAGACTACCCAGGAGTTGGACCCGAACACGCTCTCTTTCACGAGATAAAACGGGCAAA +GTACACCACAGCAACCGATGAGGAGGCGCTTGAAGGTTTCAAACTCCTCGCACGTACGGAAGGTATAATC +CCTGCCCTCGAAAGTGCCCACGCGGTAATAAAGGCGGTTGAAGTGGCAAGAGAATTGGGAAAGGACGGGA +TAGTTGTTATTAACCTCTCAGGAAGGGGAGACAAGGATATGGCACACGTTATGAAACACCTTTCACTCGA +AGGCTAATATCATTAAAGTATTATGGAAATCCTTGTAATAGGCGGTGGGGTAATAGGACTATCCATCGGG +GTAGAACTGCTCCTTGCGGGACACGATGTAAGACTCCTCGTCAGAGATAAAAGGGAAGGTGCTTCCTGGG +TGGCGGGCGGTATGCTCGCCCCCTTTTCGGAAGGTCTGAGGGGAGATTTTTTAAGGTTTTCCGTGGAAAG +TCTAAGGCTCTGGCACGACTACCTTGAAAGACTGAAGGAAATTTCGGGGAGAAAAGTTTTCTTCTCTCAG +GGAATACTCAGAGTAGCCTTTGACGAGAAAGAAGAAAAGAAATTGAGAGAGGACGTTAAGTTTTACTCTC +AGGAAGTGTGTCAGAACCTTATCTCTTACGACGCTGAAGAACTCCTAAAAGAGTTTCCCTACCTTTCGAG +TGAAGTCAGGTACGGAGTTATATACGGAGATGAGGGAAATGTAGACACGGAAGAGCTTATGGAAGCCCTT +TACGTTGCCTTTGAAAAACTCGGTGGAGAAATAATAAACGAGGACGCGGTAAAGATTCTGAGGAACGGAG +AGAGAATAGAAAAAGTCTTCGGCTTTTTTGAGGAGTTTACTGCGGATTACTACGTGTTTGCAACGGGTGC +TTGGCTAAAAGAACACTTCGGCTTTCCCGTATTCCCGGTAAAGGGGCAGATACTCAGGGTTGAAGCACCC +CTCAAAGACTACGTTGTTTACTCCTCAAGGGCATACATAATCCCGAGGGAAAAGGACCTTTTAATAGGCG +CGACAACCGAAAACGCTGGCTTTGACACGAAAACAACTTTAGAAGGTGTTAAAAAACTTTCCGAAGGGGC +GATATCGAGCGTCCCTCAGCTCAAGGAAGCTCAACTTCTTGAGGTAAGAGTCGGCTTTAGACCCGGAACG +CCCGATGAACTTCCCGTTTTTTACTTTGGAGAAAACTTTTCAGTTTACGGAGGGCATTACAGGAACGGCA +TACTCCTCGCTCCCGCAACCGCTGAGGTAGCCCTGAAGTTAATAGACCAGGGGGAGGTTTCGGAATACTT +CAAGACTTTCTCCCCTTACAGGTTCAAGGAGTAAATAATGAGAGTTTACGTGGGCGTTGATACAGGCGGG +ACCTTTACAGACTTCGTTTACTGGGACGGAAAGGAGTGGCGTGTCCTCAAAATCCCATCTACTCCCTCCA +ATCCCGCGGAAGCTGTCCTGAAAGGTCTCGAAAAGTTGAGAAGGGGGAAAGCCCTTGACGTGGTTCACGG +CTCCACCGTAGCTACAAACGCACTCCTTGAGAGAAAGGGGGCAAAAACTGCTTTAATTACGAATAAGGGT +TTTGAAGACGTAATAGAGATAGGGAGACAAAATAGGGAAAGACTTTATGACCTTTACTACAGAAAGCCCA +AGCCACTTGTGCCGAGAGAACTCAGGTTCGGGCTAAATTGCAGGATAAACGCAAAAGGAGAGGTTTTAAA +ACCAATAAACAGAGAAGAACTGAAGGAAATACTAAAAGCCTTGAAAGAAAAAGGAGTTGAGTCGGTAGCT +GTATGTATGCTCCACTCTTACGCAAATCCCGAACATGAGAAAGAAGTGGAAGAAGAACTTAAGAAGAATT +TGAGTGTTTTTGTTTCCCTCTCCTCCGAAATCCTTCCAGAGTTTAGAGAATACGAGAGGTGTTCCACTAC +CGTTATAAACGCCTACGTCTCACCAAAGATGTCAAAATACCTTTATTACTTAAAAGATAGATTAAGGGAG +GGAGACCTTTTCAGGGTGATGCAGTCAAACGGGGGACTGATTTCTCCGGAAACCGCTTCAAAGGAGGCAG +TTAGAACTATACTCTCTGGACCCGCGGGAGGAGTGATAGGTGCTCTTCACCTTGGAAAGCTCGCGGGCTT +TGAAAAGTTAATTACCTTTGACATGGGCGGGACCTCCACGGATGTGTCCCTGATATACGGAACTCCGAAT +ATAACTACGGAGTCAAAGATAGATGGTCTGCCCGTAAAGGTTCCCATGATAGACATAAATACGGTGGGAG +CGGGAGGAGGTTCCATAGCCTACGTGGATGAAGGAGGAGCTCTCAGAGTAGGCCCTCAGAGTGCGGGAGC +GCAGCCCGGACCCATATGCTACGGAAGGGGAGGAAAAGAGATAACTGTAACGGATGCAAACCTCTTTCTA +GGAAGACTCGTTCCGGAGCACTTCTTGGGCGGTGAGATGAAACTATATCCCGAACTGCTTGAAGAACCCT +TCAAGGAAATGGCAAAGAAAATAGGACTCGCACCCACGGAGCTCGCGGAAGGGATAATAAAGGTAGCTAA +CTCCAGCATGGAAAGGGCTATAAGGAAGGTTTCGGTAGAGAGAGGCTACAACCCTGAAGAGTTTGCCCTC +TTTTCTTTTGGAGGAGCTGGTGGCCTGCACGCTGTGCTTCTTGCAAAGAGTTTAAATATTCCGAAAGTCA +TAATTCCCAGAAATCCCGGGCTTCTTTCCGCGGTAGGTATGCTCTTTGCGGATATAGTAAAGGACAAAGT +AACCACCGTTATGCTGAAAGAAGAGGAGGCAAAGCCCGAAACCCTAGAAAAGTTGTTCTTACTTATGGAG +GAGAAAGTACTCTCCGAAATGGAGGGAGAAGGCTTTCCGCCCGAGAAGGTATTCGTAGAGAGGTTTTTAG +ACGTAAGATACAAGGGGCAATCTTACGAGATAACTATACCTTTTGGTGAAAACTTCAAAGAGACTTTTGA +AAAAGAGCACGAAAGGCTTTACGGATATGCCCACAGGGGAAGGAAGATAGAAATTGTAAATCTCAGGATA +AAGGCAACGGGGATAAAGGAAAAACCTCCCTTGAAAGAGTTTAAGGAAAGGGGAGATAAGTATCCCAAGG +ATGCAATCCTCGGAGAGCGGGAAGTGGTATTTGAAGGAAGGCTTGAGACTTTTAAAGTTCTCGACAGAGA +AAAACTCGTTTACGGGAACGTTATAGACTTTCCCGCCATAGTGGTTGAGTACTCTTCAACCACGCTCATA +CCGCCCTACGCAACCGCGGAAGTGGACAGGTATGGGAACTTGATTATTACTCTCCTTTGAAGTACTTCCA +GAAACCCCTTCTATCCTTGTAGGCCTCCTCCTGAGCTTCTCCCAATTCTTTTAAGTACTTCACCTGAGGA +GGGATTATGAAAACGAATGCGAGTCCTTCCTTTACGAGGAGAAGGTTTAACATTTTGTTACGATACTCAT +CGAGCCATACGTAGGCGAGATACCTGCCGTTGTTGTCCATCTTCCTGACGGGCAGTTCCAAGTAAACTAC +TTTCTTATCAATCAATCTCTTTGAGAATTCCTTTGCCTTCTTTCCAAATTCCTTAACGGTTCTTATCCCT +CCGTAAAACCACTTTGCCTGTCCCATTCCCTTCTTCATGTTGTTCGTTTCAAGGGTGTCTATTCCCATGA +GTCTTACTTTTATGAACCTGCTTTTCCCTTCGGGAACGCACCTGAAGGTATCACCGTCAACTACCCTTAC +GACTTTGCAAGGGATAAGTTCGGAGCTGAAAGTAAAACCCAAAAAAGTCAAAAACGGAATTAAAAATTTC +TTCATCTTTCCTTCTCCTTAAGTAGGAAAATCTTTACCTGAGACAAGTTGCCAAAGTAGGTATTCGGGTA +TTCCTCTTTTATAGCGGACCAAAGGCTTAAAGCCTTATTAATTTTTCCCAGTTTTTCGTAAGAAAAAGCT +TCCAAACTCTTTGCTGAAGGGTAATTAAAATCTTCCTTTTTAATTTCTTTTAAGTTTTCAAGGGCTTTTC +CGTATTTCTTATTTAAGTAAAAGTCTGCGGAAAGCCTCTCTTTATAAAACTTTTTCATATTTTCCTCTTC +TATATCTTCGTAGATTTCTTGAAAGTTTCCGAATTTTGCAAGGACGTAAGGATAAAAGGGAGTTCCCTTT +GTGATTTTCAGTATCTCTTCCTTTTTTAATTTCCCTTTTTCAAAAAGGTAAACCTTGTAAGAAATTTCCT +TAAAAGAATTTATCTTGTGTTCCTTGTAAGCGTTGTAAGCCCAAACGCCGAGGACGAGGAGGAAAACCGC +TCCCAGGAATAGATAAAAATCCCTCATACGCTCATTATCTCCTTCTCTTTAGCTTCCATAAGCTTGTTTA +TCTCATCTATGTACTTGTCAGTCAATTTCTGAAGTCTCTCGAGTGCCCTCTTCTTCTCGTCTTCCGAGAT +ACCTTCAAGTTCTTCTATCATCTCCTTTGCTTCCCTTCTCACGTTTCTCACCCTTACCCTCGCCTCTTCT +GTTATCTTGTGCAGGAGTCTAACGAGTTCCCTTCTTCTTTCTTCCGTAAGTGGTGGGAGTGTAACCCTTA +TCACGTTTCCCTGAACCGTTGGGTTCAGGTTCAGTTCTTCCCTTATGGCTTTTTCTATTGCGGGAACCGC +GTTCTGATCCCAAACTTGAATTACTATCTGGTTGTGTTCTGGAACGGAAATAGTACCGAGCTGTTTAATG +GGAACTTTTGAGCCGTAGTACTCAACTTTAATCTCTTCAACCAGAGCAGTGGAAGCCCTGCTGGTTCTGA +GCCCTGCGATTTCGTTCTTGTAGTACTCAACAGCCTTTTTCATATCTTTTTCCGCTTCCTTGAATATGTC +TTCCAGTTCCTTTATCATCTTTCCTACCCCCTTACTACTGAACCTACTTCTTCTCCGAGAACCGCCCTTC +TTAAATTACCTTTTTCCTTAACGTTCAATACGATAATTGGGATTTCGTTCTCTTTACATAGGGTGAGGGC +GGTGTGATCCATGACTTTTAGTCCCATGTTAATGACTTCCAAGTAAGAGATTTCCTTTATAAGAACCGCA +TCGGGATACTTTTCGGGATCTTTGTCGTATATACCTCCCACTTTAGTAGCCTTTATGAGGACTTCCGCAC +CTATTTCCGCCGCCCTCAGGGCTGCCGCCGTATCGGTTGAAAAGAAGGGATTGCCCGTTCCTCCCGCGAA +TATAACGATCCTCCCCTTTTCCAGGTGTCTTATTGCCCTTCTCCTTATGTAGGGTTCTGCTACCTGTCTC +ATCTCTATGGCACTCAGGACTCTCGTGGGTATATTCACGTGGTTCTCAAGGGCGGACTGGAGTGCGAGGG +CGTTTATGACCGTTGCGAGCATTCCCATGTAATCCGCGGTAGCCCTGTCAACGCCTATCTCTTTTCCCTG +AAAGCCCCTGAATATGTTTCCTCCCCCTATGACTATGGCCACCTGAACGCCGAGGTCATACACGTTTTTT +ATTTCGTGGGAGATGTATTCGAGGAAAGCAGGGTCAATACCGTAGCCCTGCTCTCCCGCAAAGGCCTCTC +CCGAAAGTTTTAAGAGAATTCTTTTATATTTAGGTTTTTCCTCCATTAGAGTCCACCGAGTTCAAACCTG +CAGAACCTCTTTATCTCAACGTTGAGTCCGCTTTCCTTTATCACGTCTTTTACCTGTTTCTTTTCTTCCT +TTATGAAGGGCTGCTCGAGTAAAACCTTTTCCTGATAGAACTTCTTGAGTTTCCCTTCAACTATCTTGTC +AACGATGTGTTCGGGTTTTCCTTCTTGAAGTGCCTGCTCCCTTAAAATTCTCCTTTCCCTTTCTAAGACT +TCTTGGGGTATGTCTTCAATCCTCACGTATTCGGGTCTCATCGCAGCGATTTGCATAGCAACGTCCTGAA +CGAGTCTCAGGACCTGATCGTTGAGTTCTGGAGCTTTGAAGTCCAGAAGTACACCTATCCTTCCTCCGCC +GTGAACGTAGGAGTGTAGATAATCTTCCGTGTCGTACCTGCAGTACCTTGAAAGCCTGATATTCTCCCCT +ATCTTCGCTATAGCTTCCTTTATGAGGGTTTCTACTGTCTTTCCGGGTTCGTCGTACAGCTCCTGGGATA +GGATTTCGCTACCTTCACCGCTTTTATTCTTATTCTCATCCTTCTCAAGTATGTGTCTCGTTATCCTTTC +CGCGAGCTTTCTGAACTCTTCGTTCCTTGCGACGAAGTCCGTTTCACAGTTGAGCTCTATCATAGCTCCC +TTCTTTCTGTCCTCGGATACGATTACGTAGATAAGTCCTTCCTTTGTTTCCCTTCCGGCCTTCTTTTCAG +CCTTAGCGAGTCCTTTAACCCTTAAAATTTCCTTAGCTTTTTCTATGTCACCGCCCGCCTCTTCAAGGGC +TTTTTTGCAGTCGAGCATTCCCGCGCCGGTCATTTCCCTGAGTTTTTTTACATCTTCCATGCTTACAGCC +ATTCTCATACCTCCGCTTATCTTTTCTAATTATAACAGGCTCAAAAGGGAACTTTTGCGGGAGGAAAGTG +TGAACTATCCCGCATCATAGATGCGGGGCTTCGGGTGGGTTTACACCCTCTTTGGAGTGCCTTACCACCA +CGGGCAGGTTCACACCGCCCCTACTCCTGCCTATCCCGCCATACAGCGGAATAGCGGAGCTACTTTCCCT +CAACTTGAAAAATACTCTTAACCTTATCGGCCTCAATATCCCACTTATCAGGTCAAATTTCCCGAGTTTC +TTTAGCAAATTCCTGCAAGCGTTTACATCAGCATTCAAAAAACCCAAAAGTCTTGTCCTGAAAAGCCCTC +TCTTTACCCTCGCTTCGGGAGTGTAGGTCTCTTTATTAACAGCTCCCTCTACGGAGCTGTCCACTCCCGA +AGTGTAAGCTTCAGAAATATATTCAACTTCTATTCCATATTCTTTTGCCTTGTATTCCAAATACTCTTTT +ACCTTTCCGTGCGGTAACAAACTCCATATTTGATCTGCTACACTACTCAGTTTACTTTCTTTATTCTTGT +TCCTTGCCGCATCGCCTATGTATATTTTCCTAACTCCGTATTTAAGGGCAAGTTCCAATATCAGGTTGCT +TATTGTATGGGCATAGTGTTTTAAAAGCCTCTTTACTTTGAGCCATAATCTTGAAATTCTCTCCTCCAGA +AAGTGAGTTAAAAATCCTTTCTTTTTAGCTCCTTCAAGTCTGCTTTGAAGACTCGCTATTTTCTTTAAGT +ATTTCCTTAGCAAACTCTTTAATCCATTCCCGTCAATTATGTAGGGTTGGGGTATGCCTTCTATTACTAT +TGCGAAAAAGTTTGATGAGTTCGGATCTAATACCATCACCTTGTCTTGCTTTAATAGTTTTTCTCCATTC +TGAGGTTTTTCGTAGATTATGTGGAGTTCAAACTCCTTAGCGTTGGCTTTCGGAACAATTTGAATATTCT +TTATCAACCTTTCGTCCAGCTCCAATCCCGTATCCAGCCAAAGGTATTTAAGCTCTATTCCATGTTTTTC +TTTTAGCCATTGCCTTAAAGCCTTTGAAAGAGAAAGTCTTATTTTTGTTCCCACAACTTTAAAGCCTGTT +TGGTCGTAGGTTATGGTTCTGTGTGGTTTGTTTTTAGGTCTAAATTTTGGCGGTTTAACTTCCTGTCCTT +TAAACTTTTCTGGATTATGCAAAAACTCAAACCAGTTTTTAAAAGCTCTAACAAGTTCGTCCAAGACAAT +TTGAGCACAGCGACTTTGAAGGTTTTTAAGATGCAAAGAATTGTCCTTAAGCTTGTTATAGAGGTCGTAG +GTGTTTACTTTTGCCTGTTTGGTTTTAATGGAGTAAAGAGCTTGATTAAAGAGCCTTCCTGAATGGTAGG +TAAGGTAGCCTAAAACGATTTTGTATTCGTTAGGAAGGTCTGTAAAAGCTATAGTGATGCATCTTAGAGG +TTTTGGCATTTGAGTGACCTCACAAGATTCATTTTAAAAAACTGCTTACACAGGCGGCTTCTGTCCCCGT +ATCATAGATACGCGGTTTTAGCCCGCGGATTTACTATAAAATACAAGTAATGGAAGAAGAAAAAGTAAAA +GAGGGATTGTGGGAGTTAGCTTACAACCTGTGGTGGACGTGGAATCCGCCGGCTAAGGAATTATTCAGAA +GCATTGACCCGCTTTTGTGGAAGGAAACTAAGGAAAACCCCATTGAGTTATTGAGGAAAACCAAACTCCT +TGAAAACAAGCTCAAAGACGAAGATTTTATATCTCACTTCAAGTACGTTTATTCCCTTTACAAAACCTAC +ATGAACAGGCATTCGAAATACGAGGATACGTATAAGAAGCCTATAGTTTTCCTGTCTCCCGAGTACGGAC +TTCACCACACACTACTTATATACGCGGGGGGACTGGGCTTTTTAGCAGGAGATATACTCAAGGAGAGCAG +TGACTTGGGATTTCCGCTTATAGGTGTCGGGTTTATGTACCCTCAGGGCTACGTAAAGCAGAGGATAAGG +GTTGACGGATGGCAGGAAGACCTTGACGCACAAAATCAAAAGGAATTAATGCCCGTTAAAAAAGTTCTGG +ACAAAGAAGGAAAATGGCTCAAGTGCTACGTTTACGTAAGGGATGAAAAGGTTTACTTTGGAGTCTGGGA +AGTTAACGTGGGAAAGACAAAGCTCTACCTTCTTGACACGAACGTAGAGGAAAATACTCCCTGGAACAGG +GAAATATCCTCAAGACTCTACGTTCCGGACAAAGACCTGAGGTTAAGACAACAGATAGTTCTTGGTTTTG +GCACCGTAATACTCCTTGAAAAGCTGGGCATTGATGCAGGAGGTTTTCACATAAACGAAGATTATCCCTC +GTTCGTGTTCCTTGCAGAAATATTTAAACTTCTAAAAAAAGGTCTGACCTGGGATAAGGCGATAGAAGAA +GTAAGAAAGATTTCTCTCTTTACCACGCACACACCACTACGGGTTGCCGTAAATACTTATCCCTTCCACA +TGATAGAGGAACAGTTTCTATTCGTTAAGGATGTTTACGGAATAGACGTAAAGAAAGTTCTGGAACTCGG +AACGAATCCTGAAGACCCTTCGGAGGGTTTTAACAGTACGATTATGTCCCTCAGACTCGCAAAGTACGTA +AACGCAGTGAGTAAAAGACATCAAGAAGTTTCAAGCAAGATGTGGAGTTTTTTATTTAAAGAAAAGGAGA +ATCCAATAGATTACGTAACGAACGGTGTTCACTTTCCCACATGGATTTGTTCAGATTTGAGAAGACTGTA +CGAGGAGTATTTGGGAGAGAACTTTGTGGAACTTCACGACCACAAGTCTCTGTGGGAATTAATAAGAGAC +ATACCCGACGAAGAACTGTGGGAATATCACATAAGAAATAAAGAAAGACTTATTGAGCACATAAAAGACA +GGGCAAGGGAAAGGTGGGTCAAGGAAAAAGCGGATCCTTCAATCCTTATGGCCGAAGGTCTGTTCCTTGA +TTCTGACGTTCTTACGGTCGGTTTTGCGAGGAGGATGACCGGTTACAAAAGACCGGATCTTATATTCACG +GATGTAGAACGCTTAAAAAAGATAGTGAATGATTCGGAAAGACCTGTTCAGATAATATTCGCGGGAAAGG +CTCATCCGGCTGATATCGAAGGGAAAAAGATAATCCAGAGAATATTTAACTTTGCGAAAGATCCGGAATT +TGGGGGAAGAATAGCTTTCGTTGAAGATTACGACGAACTCCTTGCCCATTACATGGTGAGGGGTGTGGAC +GTATGGTTGAACAACCCTCTTCCTCCCCTTGAAGCCTGCGGGACAAGCGGTATGAAAGCTTCTATGAACG +GAGTGCTTCACCTTTCAATACTTGACGGTTGGTGGATTGAGGGTTATAACGGAAAGAACGGTTGGGCTTT +CGGAGATTACGAAGTTGAAGGAGACAGGAACAGAGCGGATGCGGAGGCCATTTACAACATCCTTGAGAAT +GAAGTAATCCCCCTTTATTACGAAAGGGACGAGAGGGGAGTGCCAGTTAAGTGGATAAGTATGATGAAGG +AAGCTATAAAAAGCATTACCCCTAACTTTTGCTCCAGAAGGATGTTAAAAGATTACATAAATAAGTTCTA +TTCAAAAATTTTAAAGGAGGAGGGATGAAAGGTGTAATCCTTGCGGGAGGATTTGGAACTAGGATTCAAC +CCCTTACAAACAGCATTCCCAAACCCATGCTTCCCGTCGCAAACAGACCCATAATGGAACATGTAGTACA +CAGGCTAAAGGAGGCGGGAATAGAAGAAATAGTCGTTCTCCTTTACTATCAGGCTGAAGTTATAAAGAAC +TACTTTAAGGACGGAAGTGATTTTGGAGTAAAGATAACCTACGTCCAACCCGAAGCAGACTACGGAACGG +CGGGGGCGGTAAAGCAGGCACAAAATTACCTTAACGAGACATTCATAATAGTAAGCGGTGACGTAATAAC +GGACTTCAACCTTTCCGAGTTAATAGCCTTTCATAAAAGCAAGTCTTCAAAGTTTACCTTGGCACTTTAC +AGTGTTGAGAATCCCCTTCAGTTTGGAGTTGTGATAACTAACAAAGAAGGGAAAGTTTTGAAATTCCTTG +AAAAACCCGGCTGGGGTGAGGTGTTTAGCGATACCGTAAACACGGGCATATACGTAGTGGAACCCGAAAT +CCTGAACTACATACCCGAAGACAAACCCTTTGACTTTGCCATGGACCTCTTCCCCAAGCTAATGAAGAGC +GGGATTGATTTGTGGGCTTTAAAGATGAGGGGATACTGGAGGGACATAGGGAATATAGATTCATACAGGG +ATGTCCACAAGGATATATTTGCGGGACTCGTAAAGATAAGAATTCCTGGAAGGATAATTACGACGAAAGA +AGCGAGGATTTACGTAGAAGAAGGAACGGAAATTCCCGAAAATGTTAGCTTAAAGGGAACGGTAATTTTA +GGCAAAAACGTAAAAGTAGGGGAGGGTTCAGAACTCAAGAACTGCGTTATAGGAAACAATACGGTTATAG +GGAGAAATGTGAAACTCTTTGATTCCGTTCTGTGGTGGAACGTAAGTATAGACGAAGAGAGTGAAATAAG +AAACGGAGTTATATGTAACGACGTGAAGATAGGAAAAAGGGTAAAAGCAAAGGAGGGAGTAGTAATAGCC +GAAGACTGCGAGGTTGAGGACGAAGTTCTATTCCTCAAAGACGTGGTTGTATGGCCAGAGAAGGTAATAG +AAAAGGGTTCGGTTGTAACAAAGAACATCGTATGTGAATCTAAGTGGGAAAAGGGAATATTTAAGGGAAA +CAAGGTTATCGGAAGGATAAACGTGGAATTGACCCCGGACAACGCCACAAAACTCGGCATGGCTCTCGGG +AGTGTGCTTCCTCCCAAAAGTACGGTAATACTTGCGAGGGATTATCACAGGGCTTCAAGGACGATTAAAC +GCTCCTTTCTCGGAGGCATACTTTCCACAGGTATAAACGTGATAGACCTTCACCTTTCTCCCCTGCCAGT +TATGAGGTTTACCTTAACGGAAGATAAAAAGGCGGTTTGCGGGGTTTACTTTTCCATATCTCAGGAATTC +CCCGGTAGCGTAGAAATATGCGTATTTGACGAAAACGGACTGCCGATAGACACGAATTTCCAGAAGAAGA +TTGAAAGGGTGTTCTTCAGGGAAGCTTACAGGTTTGAAACTTTTACCGATTTAGGATTGATAAAGGAAAA +GCCTTACTTCTCAGAAAACTACGTCACTAAACTCCTGAGCAGTATTGACGGAGACAGTATAAAGCTTTCC +AGCAATAAAGTCGTTTATGACGCACTCCACTCTCCCATTTCTCCCTTTATTTCCGAGGTTTTGGGAAAAC +TTGAAATAGAAAACGTAATACTGAACGCCCTCTACGATGAGAGAAAACTTTCAAGGATATCAACCTACGC +GAGCAGTTCCGAAGGAAACGTTTCTAAAGTTCTGAAGGCTTTATCCTACGACGTAGGATTTGTAATGGAG +CCCAGCGCCACTAAGTTAAAGCTCGTGGACGACAGGGGGAGGACTATAAGCGGTGATAGGCTCCTTCTGG +TAGTCTTAATGCTTCTTGACAAAAGTGCGGAAAAGCAATTGAGGGTTTACCTTCCCGTATGGGCTCCCGA +GGTTCTGGATGCGATTTTAAACAACGTAATCGTTGAAAGGGGAAAGTTTACGAACCTGAGAAAATCCTTT +ATTGAAGACTTTTACATGCTGGCGGACACGGACGGGAGTTTTACCTTTACGGAGTTCTCATACTCTCCCG +ACGCACTTTACGCCTCCCTCAAGATAATGGAAATGCTAACCAAACTTAAAGTGAAAGTGAGCGAAATTTA +CGATTCCCTCCCCGAGTATTACTTCCTGCATGAAGTTGTAAGCTGCAGTTCCGAAAAGAAGGGCACTGTT +CTGAGAAAAATATCCGAAATGGCTGAAGGAAAGGAAGCTTCCTTCATAGAAGGGGTAAAGATATACGAGG +ATTACGGAAATTGGGTTTTAGTCCTTCCCGATTCTTACAAGGATTTAATACACGTGTACGTTCAATCAAC +GGAGAGGGAAAGAGCGGAAGAACTAATTAAGAATTACATGGAAATAGTGAGGGGGATTTGCAAAAAATGA +AAAAGCTCTTCTTAGTTTTCTGGTGGCATATGCACCAGCCCCTATACAGGGAACCTTACACCGGAGAATA +CCTCCTCCCGTGGACTTTCTTCCACGCAGTTAAAGACTACTACGACATGCCGGCGTACCTTAAGGATTTT +GAGATAAAGCTGAACTTCAACTTAACGCCCGTCCTCATAGACCAGATTCAGGAATACGCCCAAGGTAAAG +CGAAGGACGTATTCCTTGAGGCAATAAGAAAAGACCCCGATGACCTTGAAAAGGAGGAAGTAGAAAAACT +TATAGAGTTCACCAAACTCAATTACGAAAAACCCATATACAGATTTGAAAGGATAAGGGAATTAATGAAC +AAGGAAAAACTGAACAGGGAGGAATTACTTGACCTTCAAACCTTAAACCTCTTAGCATGGTGCGGAAGGA +CGCTCAGGAAAGACCTGAAAGATCTGCTCAATAAAGGAAGAAATTACACGCAGGAGGAAAAGGAGTACGT +ACTAAATAAGTACTTTGAAATTATTAAAAAGACTTTGAGTATTTACAGGGAAATAAAAGAAGAGGGAAAA +GGAAGTGTATCTACGTCACCTTACTACCACCCCTTAATTCCCATCCTCTTGAATCCCAATTGTGTTTATG +AAACGACTCCGAACGTAAAAATACCTGACTTCGCGGTTTCCTTTAGAGAGGACGCTAGCAAACACGTGGA +ACTCGCAAAAGAAAAGTACTTTGAAATTTTCGGTGAGCATCCCGTTTACATGTGGCCTCCCGAAGCATCC +GTGAGCAACGAAGCTTTAGAACTTTACTACGAAAAAGGGATAAACATGCTGGCAACCGATGAAGTAATCC +TTAAGAATTCCGTAGAAAGGGCAAGTCCTTACTTAAGATACTACTTCAGGGAATTAATAAGTGTATTCTT +CAGGGACAAGACGCTGAGCGACCTTATAGGATTTTCCTATCACGCTTGGAACGCAGAAGATGCTGTAAGG +GACTTCATAGGAAGGTTGAAAAAAATACACGAGAGCGTTGATTTTCAACCTGTAGTTTTTGTGGTGCTTG +ACGGGGAAAACTGCTGGGAGTACTACGAGGAAAACGGAATTCCCTTCTTGGAAAAACTCTACTCAACCTT +GGAAAAGGAAGAATGGATAGAAACCCTTACGCTGGAAGAAGCAATGAGAAAGGAAGACGTAAAAACGGAG +GTTATAGAAAGTGTAAAAGCCGGAACATGGTTTGACGGAAATTTCTTAAAGTGGATAGGAAATAAGGAAA +AGAACGAGTACTGGAAAATCTTAATAGAGGCTAAGAAGAAAGCGAAAAACGATTACATACTCGTTGCCGA +GGGAAGCGACTGGTTCTGGTGGCAGGGGGAGGAAAAGGCACCTTTCGTAGAGGTTTTCGATAAACTCTTC +AGGTCTTTTGTAAGGAGGGCTCAGGAGTGAGGGTTTTATTCTGCTCAAGTGAGATTTACCCTTACGCAAA +AACGGGGGGACTGGCTGATTTTTCCTTTTGCTTGATAAAGTATCTGAAAAAGTACGGCGTTAAAGTCAAG +GGAGTTATGCCCTACTACAAAACTTTAAAGGCGGAAAACCTGAGAAAAACGGATAAAGGAGTTACTCTAA +ATCTCAACGGAAAAGATTACACCTTTGAGGTTTACGAGAGTGAGGACTGTTACTTCCTGAGAAATGACGA +GCTCTTTGGGAGGGATTACATTTACGGTCCTCCGGGATGGGGGTATGAGGACAACGATATCAGGTTCGGG +GGATTTAGCAGGGCTGTTTCGGAGCTGATAAGTACTGGACAGCTGGAGGCGGATGTAGTTCACGCAAACG +ACTGGCAAACCGCGCTTATTCCCCTTTTTCTGAAGGAGGTTTTTAAAACTCCCGTAAAGACTGTGTTTAC +CATACACAACTTAGCTTATCAGGGACTATTTCCAAAGGAAACAGTAGAAAGGGTTGGCATCCCCCCTTAC +CTGTTTCACATGGAAGCGGTAGAGTTTTGGGGACTCGTCAACTTCATGAAAGGGGGTATAGTGTTTTCAG +ACCTGATAACTACCGTCAGCCCGACTTACGCCAAGGAAATACAAACTCAAGAATACGGTTACGGACTTGA +GGGAGTTCTTAAAAAATACTCTTACAAATTAAGGGGAATTTTAAACGGAATTGATTACGAAGTCTGGAAT +CCTGAGAAAGATAAATACATTTACCAGAATTACTCCCTGAGGAATTACTCCAAAAAGTTCAAGAATAAGG +AATTTCTGTCAAAGGAACTCGGAATTGAGGCTGAAAAACCATTAATTTCCTTCATAAACAGGTTTACCCA +TCAGAAGGGTGTTGAACTTATACTTAACTGCGCGGAAGAGATGTCTAAACTCAACGCGAACTTTGTATTC +TTGGGAACGGGTGAGTACGAAAACGCCTTTCTTGATGTGAGTAAAATCTACAAAAACTTTAAAGTGTTTG +CCGAATTTAACGAAGGTTTTGCGAGGAAACTTTACGCCTCTTCGGACTTCATACTCATGCCCTCGTACTT +TGAGCCCTGCGGACTCACTCAGATGATAGGCATGAGGTACGGATGCGTTCCCATAGTGAGAAAAACGGGA +GGCCTTAGGGACACGGTAAAGGACATTTCAGAAGGCGGGTACGGGATCACCTTTGAAGAACCATCAAAAG +AGACTTTCCTTTGTTCACTTAAAAGGGCCATTGAACTTTACGAAAATGCGAAGAAGTTCAGAAATTCCGT +TAAGATAGTGATGAGCCTTGACTTTTCCTGCGATAGGATGACAAAAGAATACATAGAGTGCTATGAAGAA +GTTCAGTCTCATCAGTGATTACGACGTTTACCTCTTTAAGGAGGGAACGCACACGAGACTTTACGATAAA +CTTGGCTCCCACGTTATAGAACTAAACGGGAAAAGGTATACCTTCTTTGCGGTTTGGGCACCCCACGCGG +ATTACGTATCACTTATAGGCGATTTTAACGAATGGGATAAAGGTTCTACTCCCATGGTAAAGAGGGAGGA +CGGCTCCGGAATATGGGAGGTTTTACTTGAAGGAGACCTGACTGGTTCAAAGTACAAGTACTTTATAAAG +AACGGGAATTACGAAGTTGATAAGTCCGATCCCTTCGCATTTTTCTGTGAGCAACCCCCCGGAAACGCTT +CCGTAGTGTGGAAGCTCAATTACAGGTGGAACGACTCCGAATACATGAAAAAGAGGAAAAGAGTAAACTC +ACACGACTCGCCTATATCCATATACGAAGTTCACGTGGGTTCTTGGAGGAGAGTTCCAGAAGAGGGAAAC +AGATTTTTGAGCTATAGGGAACTTGCCGAATACCTCCCATACTACGTAAAAGAGATGGGATTTACTCACG +TTGAGTTCTTACCCGTTATGGAACATCCCTTTTACGGCTCTTGGGGCTACCAGATAACGGGCTACTTCGC +TCCGACTTCCAGATACGGAACTCCTCAGGACTTTATGTACTTAATAGACAAACTTCATCAAGAAGGGATA +GGTGTGATACTAGACTGGGTTCCCTCTCACTTTCCCACCGATGCCCACGGGCTCGCATACTTTGACGGGA +CTCACCTTTACGAGTACGAGGACTGGAGAAAGAGGTGGCATCCCGACTGGAACAGCTTTGTTTTTGATTA +CGGAAAACCGGAAGTTCGCTCCTTTCTCCTGAGTTCTGCCCACTTCTGGCTCGACAAGTACCACGCAGAC +GGTCTCAGAGTGGATGCAGTTGCTTCAATGCTTTACCTAGATTACTCTAGGAAAGAATGGGTTCCAAACA +TATACGGAGGGAAAGAAAACCTCGAGGCTATAGAATTCCTCAGGAAGTTTAACGAAAGCGTTTACAGAAA +TTTTCCAGACGTCCAGACAATAGCGGAGGAATCAACAGCCTGGCCTATGGTGTCCAGACCTACATACGTG +GGGGGACTGGGATTTGGAATGAAGTGGAATATGGGTTGGATGAACGACACACTCTTTTACTTTTCAAAGG +ATCCCATCTACAGGAAGTACCACCATGAAGTCCTCACTTTCAGTATATGGTACGCTTTTTCCGAGAACTT +CGTCCTTCCACTATCCCACGATGAAGTTGTTCACGGAAAGGGTTCTCTGATAGGGAAGATGCCAGGAGAT +TACTGGCAGAAGTTTGCAAACCTTAGAGCCCTTTTCGGATACATGTGGGCACACCCAGGGAAAAAACTCC +TCTTTATGGGGGGAGAGTTCGGACAGTTTAAGGAATGGGATCACGAAACGAGTCTCGACTGGCACCTCTT +GGAATACCCTTCTCACAGAGGTATTCAGAGATTAGTTAAGGACTTAAACGAAGTTTACAGGAGGGAAAAG +GCTTTGCACGAAACGGATTTTTCACCTGAGGGCTTTGAGTGGGTAGACTTCCACGACTGGGAAAAGAGCG +TTATATCCTTCTTGAGAAAGGACAAAAGCGGTAAGGAAATTATACTCGTAGTTTGCAACTTCACACCCGT +TCCGAGATACGATTACAGGGTAGGTGTACCGAAAGGCGGATACTGGAGGGAGATAATGAATACCGATGCA +AAGGAGTACTGGGGCTCCGGAATGGGAAATCTGGGTGGAAAAGAGGCTGATAAAATCCCGTGGCACGGAA +GAAAATTCTCACTTTCACTTACCCTGCCTCCCCTTTCCGTGATCTATTTAAAGCACGAAGGATGAGATTG +GCAGGTATTTTACTTCACGTAACTTCACTTCCCTCTCCTTACGGGATAGGGGATCTCGGAAAAGAAGCCT +ACAGGTTTCTGGACTTCTTAAAGGAGTGCGGTTTTAGCCTTTGGCAGGTTCTACCTCTGAACCCCACTTC +ACTTGAGGCGGGAAACTCACCCTACAGTTCAAACTCCCTCTTCGCGGGCAATTACGTACTAATAGACCCT +GAAGAATTATTGGAGGAGGACTTAATAAAAGAAAGGGACTTAAAAAGATTTCCCTTGGGTGAAGCCCTTT +ACGAAGTCGTGTACGAGTATAAAAAAGAGTTGCTCGAAAAAGCCTTTAAAAATTTCAGGAGATTTGAACT +GCTTGAAGATTTTCTGAAGGAACACTCTTACTGGCTCAGAGATTACGCACTTTACATGGCTATAAAAGAA +GAAGAGGGAAAGGAGTGGTATGAATGGGATGAAGAATTGAAGAGGAGAGAAAAAGAGGCTTTAAAAAGGG +TGTTAAATAAGTTAAAGGGGAGGTTTTACTTCCACGTATTCGTCCAGTTTGTTTTCTTCAAGCAGTGGGA +AAAACTGAGAAGATACGCAAGGGAAAGGGGGATAAGCATAGTTGGAGATCTTCCAATGTACCCCTCGTAC +TCAAGTGCGGACGTGTGGACAAATCCTGAACTTTTTAAACTGGACGGAGATTTAAAACCCCTTTTTGTAG +CGGGTGTTCCTCCTGATTTTTTCAGTAAAACGGGACAGCTGTGGGGAAATCCCGTTTACAACTGGGAAGA +ACACGAAAAGGAAGGCTTCAGATGGTGGATAAGGAGAGTTCATCACAACTTAAAACTCTTTGACTTTTTA +AGACTTGACCACTTCAGGGGATTTGAGGCGTACTGGGAGGTTCCTTACGGTGAAGAAACTGCGGTAAACG +GAAGGTGGGTAAAGGCTCCCGGAAAGACACTATTTAAAAAACTCTTATCATACTTCCCGAAGAACCCATT +CATAGCGGAGGACTTAGGTTTTATAACGGACGAAGTGAGGTACTTGAGGGAAACTTTTAAAATCCCGGGA +AGCAGAGTTATTGAGTTTGCCTTCTACGATAAGGAAAGTGAGCACCTTCCCCACAACGTTGAAGAGAACA +ACGTTTACTACACTTCAACTCATGACCTTCCTCCGATAAGAGGATGGTTTGAGAATTTAGGAGAAGAATC +AAGAAAACGATTATTTGAATACTTGGGAAGGGAGATTAAAGAGGAAAAAGTTAACGAGGAGCTTATAAGA +CTCGTTTTAATCTCAAGGGCGAAGTTCGCAATAATCCAGATGCAGGACTTACTCAATCTCGGCAATGAAG +CGAGGATGAATTACCCCGGAAGACCTTTCGGAAATTGGAGGTGGAGAATAAAGGAAGATTACACACAAAA +GAAGGAATTTATTAAAAAACTCCTCGGAATTTACGGAAGAGAAGTTTAAAATAACTCTAAATGCTGAAAG +CACATTCTCTTTCCCCTGAAGAGATATTAAGGATTTTAAAGACGGACAGGAGGGGGCTCTCTGAAGAGGA +GGCTAAAAAGAGGCTAAAAATATACGGAAAGAACGAGATAGAGGAAGAAGAGGAAAGTTTAATTAAGGTC +TTCTTTAGGCAATTTAACAATCCCTTTGTTTACATCCTGTTTGTTGCAAGCGGTATTTCCGCTTACATAG +GAAAAAAAGAAGATTCCCTGATAATTCTTGCTATTATATTCGTGAACTCCCTTCTCGGTTTCTTTCAGGA +GTTCAGGGCCATAACATCTTTAAAGGCTTTAAAGAAATTAACGGAAGTAAAAACAAAAGTTTACAGAGAC +GGCAAATTAAAAGTAATACCCGCTTCCGAACTCGTTCCCGGTGACGTTGTCTACATTCAGGAGGGAGACG +TAGTTCCTGCGGATATAAGACTTATTGAAAGTGTAGGCCTTATGGTTGATGAATCGGTTTTAACTGGTGA +ATCCGTGCCGGTTGAGAAAAACGCGGACGTTGTTTTGCCTGAAGATACTCCCGTTTACAATAGGTCGAAC +GTAGTATTTAAAGGCACGCACGTTGTAAAGGGATGGGCAGTCGGAGTAGTTTACGCAACGGGAAGACAAA +CGGAGTTTGGAAAGATAAGTGAAAAGGCAAAGGAAAAGTCCCCGGAAACACCATTAATGAGGGCTTTGAA +AAAGTTTTCCCTTGCATGGATGGTAATCATCTTTTTCTTACTCTCAATCCTTTTCCTTATAGGTATTTAT +CAGGGAAGAGACATTTACGAGGTTTTACTCCTCATAGTTTCCGAGTTGGTATCTGCAGTTCCAGAGGGCT +TGCCTCTCGTAATAACGTTCACTTTAGTAATTGGTGCGATTGCCCTTTCACGGAGAAAGGTTCTCATAAG +GTACCTTCCCGCTACGGAGACGCTTGGGAGTACAACTTTTATATGTTCTGACAAGACGGGAACCATAACA +GAAGGGAAACTAAAAGTCCAGGAATTCTTCGCCCTGAACGAGAAGTTTTTAAACCTCATTTCTGCACTCT +GCAACTCGTCGGACGGCGAGAGTGGGGATCCGGTTGATCTTGCTCTTCTCAGATGGCTTGAAGAAAACGA +CATAGACTGGAAGAAACTGAGGGAAGAATACAGAACGGTTAAAGTTTTCCCCTTTGATACAAAAAAGAGG +TATATGGCTGTAATTGTTGAAAAGGAGGGCAAGTATTACCTGCTCGTGAAGGGTGCCTTTGAAACTTTAT +CAAATTTTTCCGAAGGTATTTCCGAAGAATTAATAAAAGTTCACGACGTTCTTGCGGAAAACGGCCTGAG +AGTCCTCTTCTTCGCTTACGCCGAAATTCCAGAGCCTGTTGAAGATATAGAAAGCTTAAAACTGAAACCC +GCTGGTTTTGTCGGATTTCTTGATCCTCCAAAAGAGGGTGTAAAGGAAGCAGTTGTGAACGCAAGAAGGG +CGGGAATAAGGGTTATCATGATAACGGGCGATAACTTAAAAACCGCAGTAGCAGTAGCGAAGCAAACCGA +AATATACAGGGAAGGTGACTTAGCCGTTGAGGGAAAAGATCTTTCTAAATATTCAGATGCGGAACTTTAC +AATTTGTTGAAGAGGGTTTCTGTCATTGCAAGGGCACTTCCCGAAGATAAGTACAGGGTTGTAAAAGTCC +TTCAGGAAAAAGGGGAAATAGTCGCGGTTACGGGAGACGGTGTGAACGACGTTCCAGCCCTTAAGGTTGC +CGACATAGGCGTAGCTATGGGTTCTGGAACTGAAGCGGCAAAGAGTGTAGCTAAGATGGTAATAACTGAT +AACAACCTAAAAGTTATAGTGGAGGCCGTTAGGTGGGGGAGGATAATAGTCAGGAATATAAAGAGGGCGA +TTACTTACCTCCTCACCACAAGCTTTGGTGAAATAACCTTACTTTCTTCCGCAATACTGATGAAATTACC +TCTGCCGCTTTATCCCACTCAGATACTCTGGATAAACATAGTTACCGACGGAGTTCAGGATAAAACTTTC +CCCTTCAACAAAGAGGAAATAGACGTTATGAAGGAAAAACCTCAGAAGCCTGAGAAGGTATTCCTGGACA +AAAGGCTTTTTTTAAGATTTTTAACCGGAGGTTTATTCATAGGATTTATAAACTTAATTCTCTTCAAACA +CCTCCTAAGCGTTTATTCATATGAGGTTGCAGTAACTATAACCTTTACCTCAATGGTTGTCAATCAATGG +GCTGTAGGAATTCAGACTGTAAGGGATTACCCCTTCTTTTACAAGCCTTGGAGGAATTTCCAGATGAACC +CATACATATTTATAGGCATATTTATAGGATTGATCCTTCAGCTTTTGGCAATATACGTTTTCCCTAACTA +CTTTCACGCAGTTCCCCTCTCATTAGAACACTGGTTTTACGTAATCTTAACAACATTATCAGTTTTCATC +TTCATAGAAATAAGGAAATTAGTTTTTACAATTTTCAGTGAGAGGTAATCATTATGAACGTATTATTTAC +AAGTGTTCCACAGGAAGATGTACCCTTCTACCAAGAGGCTTTAAAGGACCTATCACTAAAAATTTACACA +ACAGACGTTTCAAAAGTACCCGAAAATGAATTAAAAAAAGCGGAACTAATTTCAGTCTTTGTTTACGATA +AGCTTACGGAAGAATTACTTTCCAAGATGCCTAGGTTAAAGCTTATCCACACACGTTCCGTAGGTTTCGA +CCATATAGACTTAGATTACTGCAAGAAGAAAGGCATTCTGGTTACTCACATACCTGCTTATTCTCCCGAA +TCTGTAGCTGAACACACCTTTGCCATGATCCTTACTCTGGTAAAGAGGCTAAAGAGGATAGAGGATAGAG +TAAAAAAACTGAACTTTTCGCAGGATAGCGAAATTCTGGCACGGGAGTTAAATAGGCTCACGCTTGGAGT +TATCGGAACCGGAAGGATAGGAAGTAGAGTTGCTATGTACGGTTTAGCGTTTGGAATGAAGGTTCTGTGT +TACGATGTCGTTAAGAGGGAGGACTTAAAAGAAAAAGGATGTGTTTACACCTCCCTGGATGAATTACTGA +AGGAAAGCGATGTTATTTCCCTTCACGTTCCGTATACGAAAGAAACCCATCACATGATAAACGAAGAAAG +GATTAGTTTAATGAAGGACGGTGTTTATTTGATAAACACCGCGAGGGGAAAAGTTGTAGATACTGATGCA +CTTTACAGAGCCTACCAGAGGGGTAAGTTTTCAGGCTTGGGACTGGACGTATTTGAGGACGAGGAAATCT +TAATCCTGAAGAAGTACACGGAAGGTAAGGCTACTGATAAAAACCTGAAAATACTCGAACTTGCCTGTAA +AGATAACGTGATAATTACTCCCCATATAGCCTATTACACGGACAAATCCTTAGAGAGGATCAGGGAAGAA +ACAGTAAAAGTTGTTAAAGCGTTCGTGAAAGGAGATCTGGAACAAATAAAGGGGAACTTTGTTGTAGGTC +CTTCCTGAAGCAAATATCTATAAAAGTATTTATATTTATCGGAATGACTAAGGTTGTAAATTACGGGGAA +GTTCAGTACGGTTTTGCTAAGAGGTACTTTGAAGAATTCTTATCCGAGAGGAAAGGAAGGATAGAAAAGC +TCTTGAAACCAGAAAAAACTCCGGTTCTCCTTATGGACATCCAGGGTGTGAAGAAAAAGTACCTCGAAGT +TAAGTATCACTTTCCCGAGTTTAACGTTTACTACGCGGTTAAGGCAAATGACGACGAAAGCGTTATAAGG +GCTCTCGTTGAAGTGGGAGCAGGATTTGAGGTTGCCTCTTCTCAGGAACTTGAAAAGGTTCTGAGGCTTG +GAGGAAAAATTGAAAAAGTAATTTCAAGTAATCCAGTAAAACCTCCAGAATTTATAGAGTTTGCGTATCA +GAAGGGTGTTAGAACCTTCGCGGTGGATAGCATAACGGAAGTTAAAAAAATTAAAGATATTGCCCCGCGT +TCAAAAGTTTACGTGAGGATTGCCGTTCCGAATGAAGGAAGCGACTGGCCCCTTTCCCGGAAGTTTGGAG +TGAGTGTGGAAGAAGCCGTTGAAATTCTAGAGTACGCAAATGACCTTGGACTCGTCCCTTACGGGATTAC +CTTTCACGTGGGTTCTCAGTGTAATAACTTAAGAAACTGGTTCATAGCGGTAAAGCTTTCTGCACAACTC +TGGGAAAAGGCAAGGGCAAAGGGACTAAAGCTTCAGATGCTCAACATGGGCGGGGGAATTCCCGTTCGTT +ACAACTACGAAGCTCTGAGCGTTGAGGACATAGCCTATTACGTCAAAGGACTCATGAGGAAGTACTTTCC +TGTTCAACCTTATGAACTGCAGATAGAACCCGGAAGGGGAATAGTCGGAGATCAGGGAATTATGGTAACA +AAGGTAATAGGGAAAGCTAAGAGAGGAAGTGAAAACTGGCTTTACATAGACACTGGAGTTTTTAACGGAC +TTGCGGAAGCACTCGGGGGCATAAGGTATCCCTTCTTCCTTGAAAGGGAAGGGGAACTGAAGGAGTGGAC +AATAGGCGGTGTTTCCTGCGACAGTATGGACGTAGTGGCTAAGAACGTTTACCTTCCAGAACCTGAAGTA +GGTGATTACCTTTACATACTTTCCGCTGGAGCTTACACCACCGTTTACGCTTCAAACTTCAACGGCTTTC +CTAAACCTGAGGTTGTTCCTTTTTAGAAATAAATTCAATCTTATGAATAAGTACCCCTCTTATTTGAACC +TCTATGAGAGCGGAGAGCTGGAAAAGAGGGTGGAAAAAGCCCTTAATATGCTTGAAAAGTGTAAGGTTTG +TCCCCATACCTGCGGTGTAAACAGGCTGGAAGATGACAAAAAGGGATACTGTAAAGTAGGAAGGTACGCT +GTGGTCGCCGACTACTTTCCCCACTTCGGCGAGGAATTTCCCATAAGGGGATACAGGGGAAGCGGGACGA +TATTCTTCTCTTACTGCAACATGAGGTGTGTTTACTGCCAGAACTACGATGTCAGCCACTTGGGCGCGGG +AAGGATTATGAAACCCGAGGACCTCGCAGAAGTTATGCTGGAACTTCAGGACTACGGTTGCCATAACATA +AACCTCGTTTCTCCTTCCCACGTAGTTCCCCAGATACTCGAAGCCCTCCTAATAGCGGTAGAAAGAGGAC +TTAGAATTCCAATAGTTTACAATACATCTTCCTTTGACTCTCTGGAAACCTTAAAACTTCTTGATGGAAT +AGTTGACATATACCTCGCGGATTTAAAGTACCTAAACAAAGAGTACGGGAGGAAGTACTCAAAGGTGAAA +GATTACCCATCTGTCGCAAAGGAAGCGATAAGGGAAATGTACAGGCAGGTGGGAAACCTGGAAGTGGACG +AAAGGGGTATAGCTGTAAGGGGGCTGCTCGTTAGACACCTCGTTCTTCCAAACGACATATCCACCACAAA +GGAGGTTATGGAATTCTTAAGAAGTATTGATCCAAAGCTTGCGGTAAACGTTATGAAGCAGTATCACCCA +TACTACAAAGCGTGGGATTATCCCGAACTTTCCAGAAGAATAACGGAAGAAGAATACAAAAAAGCCCTTG +AAGAAGCTCAAGGCTTTACCCTGATTGTGGATTAAAATAATCAATTATGGATGTAACCGTAATAAGTGCC +TTTCTGGGCGGACTCCTTTCCTTTCTATCTCCCTGTATCCTTCCGATAATCCCTGCGTACCTCTCCTACA +TTTCTGGTGTCGGAGTAAGTGACGTAGAAACTCAAAAGGGAAAAGTGAACTGGAAAGTGTTCTTTTCAGC +CCTATACTTTGTCCTCGGATTTACGCTTGTCTTTACGGGACTTGGCGCAAGTGCGACTTTTGTGGGGCAG +CTTCTTCACGATTATCAGGAATGGATAATAAGGGTGGGAAGCGGACTCGTGATATTCTTCGGTCTCCACT +TTGCGGGAGTGTTTTTATGGAAGCACTTCCTGAAGGTTTACATACCGATAGGTATCTTAATTCCCGTTCT +TTACTTCTTAAAACTCCTCTCATGGAACGAGTTCTTTAACTTGATGTTTGCCTACGCGGTAGTTTTAATC +CTTTACCTCGTAAAAGCTCACGAGTTTTTATACAGGCAGTTAAAGATAGAGGCAAAGGCGGAAATTTCTT +ACTTGGGAGCCTTCTTAATGGGGGTAGTTTTTGCCTTCGGGTGGAGTCCCTGTATAGGGCCCGTTCTCGG +TTCCATTCTCTTCCTCGCCTCTCAGCAGGAGACCGTAGCAAAAGGAGCTCTTCTACTTTTCGTTTACTCA +ATAGGTCTCGGAATACCCTTTCTCCTTGCAGGACTCCTCTTTTCCCTATTCCTTAACTTTGTGAGGTCCT +TTTCAAGGTACTTCAAGTACGTGGAAATTGCGGGCGGTGTTCTGCTTGTTTCCTTGGGACTTCTTCTCGC +ACTGGATAAGCTCTCACTTATTGCTAACATTACTTTCTGATGAGGACTGTTGTAATAGACTATGGAATGG +GCAACTTAAGGAGTGTCAGTAAAGCTCTTGAGGCGGTAGGATTTCCCGAAGTAGTAGTCTCAAACGATTA +CAGAGTGGCTTCCGAGGCGGATGTCCTTGTTCTTCCGGGTGTCGGTGCCTTCGGAGACGCTATGAAAAAT +CTGGAGGAACTAAACTTAGTCAGCGTAATAAGGAGACATATAGAAAAAGGAAAGCCCTTTCTTGGAATAT +GCCTCGGTCTTCAACTCCTCTTTGAAAAAAGCTATGAACACGGTGAGCATAGGGGTCTCGGGATTTTAAA +GGGTGAGGTTATACTGCTCCCTTTGGGGGTGAAAATACCCCACATAGGATGGAACCAGCTGTGGTTTAAG +AAGGAAAGTGAGATACTGGAAGGTCTGAAAGAGGGAGATTTCGTTTACTTCGTCCACTCTTACAGAGTAG +TTCCGGAAGACGAGAGCGTAGTTCTCACAAAAACCGATTACGGAGAATACTTCGTCTCTTCAATAGAACT +GGATAACGTAGTGGCTTTCCAGTTCCACCCCGAAAAGAGTCAAAAGAAGGGCTTAAAACTCCTTGAAAAT +TTTAAAAGGAAGGCGGAAAAGCTTACCACCTGAAGTGGGAGAAAACCATGTTCGCATGTGCCATCCTGTG +TGTCTCTTCCTTCTTCTTGTACGCTCCTCCCCTCTCGTTCAGCGCATCCAATAGCTCCGCCTTTAACCTC +TCTATCATAGTGTACTGTCCCCTTCCCCTCGGTCTTTCCCTCGCAGCCTGAACCAGCCACTTTATCGCAA +GGCTTATCTGCCTCCTCTCTGGCACTTCTATCGGCACCTGATACGTAGCTCCTCCCACTCTTCTGGGTCT +CACTTCCCACTCGGGCTTTAACTTCTCTATTACCTTATGAAGCAGTTCAACAGGGTGCATGTTTACCTCT +TTCGCAGCCTCTTCCAGTGCAGTGTAGACTATCCACTCAGCCACGCTTTTCTTTCCGTCCTTCATCACTT +TGTTTATTAACTTCTGAACGAGTACGTCCCCGTACTTGGGGTCGGGCGGTATTTCTCTCGGAGGTACTGG +TCCTTTCCTTGGCATCTATTAACCTCCTTTTTCTTCCTTTGGTCTCTTGGTTCCGTACTTGGAACGGGAT +TGTCTCCTTCCTTCAACTCCAGCTGCATCAAGCGCTCCTCTGATAATCTTGTATCTCACACCGGGAAGGT +CTTTCACTCTTCCTCCTCTCACGAGAACTATAGAGTGCTCCTGAAGGTTGTGACCTTCACCGGGGATGTA +GGCGGTGACTTCAATACCGTTGGAGAGTCTGACTCTTGCAACTTTTCTGAGTGCAGAGTTTGGCTTTTTT +GGAGTGACTGTGTAGACTCTGACACACACACCTCTCTTTTGAGGGCAGCCTTGAAGTGCCGGAGCTTTTG +ACTTTTTCTTCCTCTTTTCCCTTCCGTACTTAACTAACTGGTTGAACGTCGGCATTCGCTTCCTCCTTTT +AAGGCAAATTATTAGTATATCAAAATGCTAAAATTAAAGGCAATTAAAACCCCTTTTCAGGAGGAGCTTC +ATGGAGTTTGACTTAATAATCGTGGGTGCGGGTAGTGGAGGTTACGAGGCGGGGCTTTACGCCTTCAGAA +GGGGAATGAAGGTAGCCTTCGTGGAACTCTCTCCGGAGACCGTGGGAGGAAATTGCCTCAACAGAGGTTG +CATCCCTTCAAAGTACATGAGGCACGGGGCTTACCTCCTTGACAAGTTTCAGAAAATGGAGCAATACGGA +ATAATTTCAAAGGGTTACGACATAGAGTACAAAAAACTCAAAGAGGGAAGGGATAACGTCGTAGTGACCA +TAAGGGAAAACTTTAAGAAGTTCGCCCAGCAACTCAGAATTCCCATATACTACGGCAAAGGAGTTTTAAA +GGATCCAAACACTGTGTTCGTGGAAGGACCAGAGGAAACTCTGAAGGCTAAGTACATCCTCGTGGCTACT +GGATCCTCTCCTACCTCTGTCGGGAACCTCGTTCCGGACGGAAAGTACGTTATAGACACAGATCAGATAT +GGGAAATAGATTACGTACCAAAGAAGGTTCTAATAGTCGGGGGCGGAGCAGTAGGGGTTGAGTTCGCATA +CATATTCAGGAAGTACGGAAGTGAGGTTGTTCTGGTAGAGATAAAAGACAGACTCCTTCCCACTCCCGAT +ATCCCCGAGGACAGCGGGAGGTACCTCGCCAGAAAGTTAAGGGAACTGGGAGTTGATATAAGGACGAGAA +CTTCTGTGGAGAGCTGGGAAAAGACTCAGAACGGAGTAAAGGCAAAGCTCACGGACGGGAGCGAGGTTGT +AGCGGACTTCATCCTCCTCGGTGTAGGAAGAAAACCAAACACCAAAGGAATAGGCCTTGAGGAACTCGGT +ATAGAGATGGACGAGAGGGGATTCGTAAAGACGAACGAGTACGCCCAAACGAACATTCCAAACATATACG +CCTGTGGGGATATAACCTCTCCCTTAATGCTGGCTCACAAGTCTATGTACGAGGGTAAAATCGCCGTTTC +CCACATACTTGGCGAGAGGGACTGGAAGAAGAACGAGAGGATAATTCCCAAGATTATTTACTCCGCACTG +GAAGTGGCATCGGTCGGCCTCACTGAAGAGCAGGCGGAAGACGAAGACATAGAAGTAAGGGTGGGAGTAG +CTTCTTTCGTTTCAAACCCCAAAGCCATGGACGACGGAGAGAATGAGGGATTTGTAAGGATAGTGGCGGA +CGACGAGACTGGTGAAATACTCGGATGTCACATAGTCGGTCCACATGCGGGAGAACTCATACATCAGGTA +GTTCACATGATAAAGGACGGAAAAACCGTGGAGTTTGCTTCAAAGACTATGTACTCCCACCCATCACTTT +CGGAAAACATAGGAATAGCTTCCTCGGAGGTTTATTACGGACCTATATCGTGGGTAAAAAGGCGGTAAAA +CTTGACACCACTCATTGTTTATTCAAAGGGAATACTCATATTTCCTAAAGGAGGTAAGTAAATGGCCGTT +CAGGACGTAATAGAGGCTCTCAAGAAGGAAACCCTTGAAGACGTAGGTATAAATCAAAACCTAGCACAGC +TCGTAAAAGACATAAAAATGGTGGGAAATGTTCTCACGATAGTCTTTGAACCCCCAAAGCAGGGACTTGA +AGACATTATAAGAGCAAAGGTTATAGACGCCTTAGGTAACCTTCCCGAGGTTCAAAAAATTGACGTGAAG +TTTGTAAAACCTCAGGCTCAGATTCCCGTAAAGCAGCAAGCACCCCAGCAACAGCAAACCCCACCGCCCC +AAACGCAACAACCCATGTTCACGAGGAAAAAGGTTCCCGGAGTAAAACACATAATAGCGGTTGGAAGCGG +TAAAGGAGGAGTTGGAAAGTCTACGGTTGCTGCAAACCTCGCGGTAGCCCTCTCACAACTCGGCTACAAA +GTGGGACTCCTTGACGCGGACGTTTACGGTCCCAGCGTCCCCACACTCTTCGGGCTCAAGGGTGAGAGGG +TAACAGTAGACCAGTTCCAGAGAATTATCCCCGTTGAGAAGTATGGTCTCAAAATTCTATCAATAGGCTT +TATGCTCCCCTCTGAAGACACTCCCATAATTTGGCGTGGTCCCATGCTCATGAAAGCTCTAACGGAGTTT +CTCTTCAGCACCAAGTGGGGAAATCTAGACTTCCTCGTTATGGACCTGCCTCCGGGAACGGGTGACGTTC +AGATAACCCTCGCTCAGAACGTGGAACTTACAGGAGCAGTGGTTGTGACCACTCCTCAGGACGTTGCCCT +TGCGGACGTGAAAAAAGCTGTTTCAATGTTCAGAGAGGTAAACATTCCCGTCCTCGGAGTTATAGAAAAC +ATGGCTTACTTCATATGTCCGAGTGACAAACAGAAATACTACATATTCGGAAAGGGCAAAGTGGCGGAGT +TTGCAAACGCCTATGGGCTTAAAATACTCGGCTCAATACCGATAGACCCCGAAGTCGCGGAAAAGTCCGA +TAAAGGTGAACCAATAGTTATATCTCACCCCGACTCGGAAGTTGCAAAGGCATTCCTTAGCATAGCCAAA +GTTTTGAGCCAGGTTGTAGAAAGTAAAGTAAATTAATCTAAAAAGGAGGTTGTAAAATGTTCAGAACGAA +AGCCGGCAAAAAAGTAGTTTACGTTGACCATATAGCTACAACACCGGTAGCGGAAGAAGTTCTTGAAGCT +ATGCTCCCTTACTTCAGGGAGAAGTTCGGTAATCCCACATCTCTCCACAGCTTCGGACAGGAGGCAAAGA +AAGCGGTAGAAAAAGCCAGAGAACAAGTTGCACAGCTCATAAACGCAAACATCCCCGAAGAGATCATATT +CACATCCGGAGGAATAGAGGCTAATAACCTTGCGATAAAAGGTATAGCAAAGGCTTACCAGAGGAGAGGA +AAGCACATAGTTACCACGGAAATAGAGCACCACTCCATCCTTCACCCTTGTAAAACCCTAGAAAGAGAAG +GCTGGGAAGTTACGTACTTAAAACCCGATAAGTACGGCTTAATAGACCCAGAGCAAGTTAGAGAAGCGGT +AAGGGAAGACACCGTCCTCGTTTCCATAGGGCATTCCAACAGGGAAATAGGAACTATTCAAAACATAAAG +GAACTCGTAAAGGCGGCAAAGGAAAAGAACCCCAAAGTTATATTCCACACGGACGCCGCACCTTCTCTCG +GACACTACCCCGTTGACGTTCAGGACTGGGGAGTAGACGCTGCTTCTTTTACCGCACACCTCATGTACGG +TCCCAAGGGAGTGGGAGCACTATGGACCAGAAAGGGCGTTAAGGTTAAGCCCCTGATAGAAGGTGGAACC +CAGGAAAGAGGAGTGAGGGCGGGAACGGAAAACGTCCCCGGAATAGTTGGTTTCGGAGCCGCAGCAGAAC +TTGCCATGAAGGAACTCGACGACAGGATGAAGAGGCTCTCCCACTACAGGGATAAACTCAGAAAGGGACT +GGAAGAAAAGGTGGATTACATAGAGTTTACAGGACATCCAACTCAAAGACTTCCCCACCACCTCTCAATA +ATCGTACACTTCGTGGAAGGTGAGGCTATGCTCCTGAGACTTGACCTCATGGGCATAGAAACTGCTTCAG +GTTCTGCGTGCGTATCCTTGGCACTCAAGCAGTCACACGTTCTCACAGCTATAGGTATCCCTAAAGAAGT +TTCAAACGGTTCGGTAGTGTTCTCCTTCGGTAGGGAAAATACGGAAGAAGATGTGGACTACATACTCGAA +GAGTTCCCCAAAGTTATCAACTGGCTCAGGGAAGTTTCTCCCTTCAATCCAGAGAACTGGGAAAAGTACG +TGAAATCCAGAGGATAAAATAAAACTTTATGAACAAACTCTCCCTTTTCGTTTATCTATTTTTCTTCCTT +TCCTTTCTATTTCTGTTTTTATACCTCCTCCAGCCCTTTTTTAACCCTATAGTATGGGCAATAGTTTTCG +GTATTGTCCTTTACCCTTTATACGGATTTATAAAGAGAAAATTAAAGAGTGAAAATTTGGCAGCTTTCCT +TGTTATTTTTATAGTTTTAGTAGCGATAGTAATACCTTTCACGATTTTTGCAGTAATAACAGCCCAGCAA +ATTATAGTTTTTTCTATAAAAGTCGTTAACTTTGTCCAGACACACAGTGTAAACGACTTGATAAATTCCT +TAAAAGAAATTCCTTTTTTGAAGGAAAAAAGGGAGTCTTTAGAACCTTTACTTAACTACCTCCAGAGTGA +AGAGTTCCGGAGAGCTTTAATAAACGCCCTCAATTCCATACTTACCTTCGTGGGGGACAGATTGAGGAGT +TACGTCTACACCGCAGGCACGAGTTTATTCCACGTGTTCGTCTTTTTACTCACTTTATTTTTCATATTGA +GAGACGGTGAAAAGGTACTGAAAGAGATTATCAACTCAATACCTATGAAGAGAGAGGACCTTGAGGAAAT +ACTCAAAACCATATACAGAACCGTCCTTGCGGTAATTTACGGAACGGTGGGAACTGCGGTTGCCCAATCC +ATTATGGGTTTTATAGGATACTCCCTTGCAGGTGTGGAGTTTGCCCTTATATGGGCTTTGATAACCTTCT +TTGCGGCCTTCGTTCCTCCCTTCGGTGCCGCTTTTGTCTGGGTTCCGATGGATATTTACCTCTTTACTAC +CAAAGGAATAAAGGAAGGGCTTATCCTCCTTTTCTTCGGAACGTTCTTAATTTCTACGATGGACAACATC +GTGAGACCGCTCGTAATGAAGCAGGGTATAAAGCTTCCTTACGTAGCCCTCTTCTTCTCAACTATAGGAG +GACTCATAAAGTTCGGCTTTATAGGCGTTTTCTTGGGTCCTATTATCCTTTCCACTATGCTCGCTTCCGT +GAAAATTTACAGGAGAAGAGTTATTCACTCAGGTATTTAAAGGCTTTGTCTCCTATGTCCTTCCTGTAGT +GCATTCCTTCAAAGCAAACATACCTTATAGCTTCGTAAGCCCTTTCTTTTGCTTCTTTCAGGGTTTTCCC +GTACGCACATACGTTCAGGACTCTCCCGCCGGAAGTTACAGTAAAGTTGCCTTCCTTTTTCGTCCCTGCG +TGGAAAACTACAACGTCTTCCATACTCTTTAGGTAATCGAGACCGTGGATTATCTTTCCAGTTTCCGGCT +TTTCGGGGTATCCTCTGGAAGCCAAGACTACGTCCAGAGCGTACCTCTCATCCTCTTTTATATGCACATC +TTTTCCTTCGTAAAAATTAAGGAGCGTTTCGAGGAAATCGTTCTTTACCCTCATAAGTATGGGCTGAGCT +TCGGGATCTCCCAGCCTTACGTTGAACTCAAGAACTTTCGGACCTTCTTTTGTTATCATAAGTCCGGCGT +AAAGGAAACCTCTGTAGTATATTCCCTCTTCTTTTAAACCTTTTATTACCCTCTCTACTATTTCTTCCCT +TATTCTTTTCTCTACTTCCTCGTTTATAACGGGTGTGGGAGAATACGCACCCATCCCGCCCGTATTTGGT +CCTTTGTCTTCGTCAAGGAGTCTCTTGTGGTCCTGAGATGTGGGAAGGGGTACGTACCTATCCCCGTTTA +TCATAACAATGTAGGAGGCCTCTTCTCCCTCAAGGAATTCCTCTATTACAACTCTCTCCGAAGATTTTCC +GAAAATCTTTTTATTCAGGAACCTGTCAAGGGTTTCTATTGCTTTTTCGACCGTTTCACAAACAACCGCA +CCCTTTCCCGCGGCAAGACCGTCCGCCTTTACTACGATAGGAGCACCTACCTTTTCTACGTATTCCTTTG +CCTTTTCAAAATCGGTGAATACCTCGTACCTTGCCGTAGGAATACCGTACTTTTTCATAAAAGTTTTTGC +AAAGGCTTTACTGCCTTCCAGCTTTGCAGCTTCTTTGTTAGGACCGAAAATCTTTAGACCTCTTTTCTCA +AACTCGTCAACTATACCCTCGACTAAGGGGGCTTCTGGACCCACTATGGTGAAGTCTACACCTTCGTTTT +TTGCAAACTCCGCAAGCTTTTCTACATCTGTAGGGGATATATCAACCCTTTTCGCAATTTCCCAGATGCC +TGCGTTTCCCTTTGCTACGTATAGTTCCTTTACTAGCGGGCTCTGTGCCACCTTCCACGCTATTGCGTGT +TCTCTTCCTCCGTTTCCTACTACAAGTACCTTCACGTTAAACTTATTATATAAGTGGTAAGGAGTTTACG +ATGTTTGAAAAACAAGAAGTAGAACAGAAAAAAGAATTAAAGATCCTTGAAATAATAAAGGAAGCAATAG +AACTTGGGGCAAGCGATATACACCTCACCGCAGGCGCACCACCCGCGGTCAGGATTGACGGTTACATAAA +GTTTTTGAAAGACTTTCCGAGACTGACTCCGGAGGATACACAAAAGCTGGCTTATTCAGTTATGTCAGAA +AAACACAGACAGAAGCTGGAAGAGAACGGACAGGTGGACTTTTCCTTCGGAGTGAGAGGAGTTGGAAGGT +TCAGGGCTAACGTTTTTTACCAGAGGGGTTCGGTAGCAGCAGCGTTGAGATCCCTTCCCGCTGAAATTCC +TGAATTTAAAAAACTGGGACTTCCCGATAAAGTTCTTGAACTCTGTCATAGAAAGATGGGGTTAATTCTC +GTTACAGGTCCTACGGGGTCGGGTAAGTCTACAACTATAGCTTCTATGATTGATTACATAAACCAAACTA +AGTCCTATCACATAATAACGATAGAAGATCCCATTGAGTACGTTTTTAAGCACAAAAAGTCTATAGTGAA +CCAAAGGGAAGTGGGTGAAGATACCAAAAGCTTTGCCGACGCTCTCAGGGCAGCTCTCAGAGAAGACCCG +GACGTCATATTCGTCGGTGAGATGAGAGATCTGGAAACCGTTGAAACCGCACTCAGGGCTGCGGAAACGG +GACACCTTGTTTTCGGAACACTTCACACCAACACGGCTATAGACACCATACACAGGATAGTGGACATATT +CCCCCTGAATCAACAGGAACAAGTAAGAATAGTGCTTTCTTTTATCTTGCAAGGAATTATTTCTCAAAGG +CTTCTACCTAAAATTGGAGGCGGCAGAGTTCTTGCATACGAATTACTTATTCCCAACACAGCTATAAGGA +ATCTAATAAGGGAAAACAAACTCCAGCAGGTTTACTCCCTTATGCAAAGCGGTCAAGCCGAAACGGGAAT +GCAGACCATGAACCAGACCCTTTACAAGCTTTATAAACAAGGTTTAATAACCTTGGAAGATGCTATGGAA +GCCTCTCCCGATCCAAAAGAGCTTGAAAGAATGATTAGGGGAGGCAGGTAGTGCCTCTTTTCAAGTACAA +GGCCGTAACTCCTGAAGGAAGAGTAGTTGAGGGGCAGGGGGAGTTCCCTTCAGTTTTAGAACTTTACGAA +AGGCTCAGTGCCCAAGGATTGACACTTATTTCTTACAAAACGATAAAGGAAGAAGTCAAGAAAGGGTTTG +AGATAAACATTCCTTTACCCTTTGGTAGTGTATCGGAAAGGGATTGGTCCCTTTTGTGCAGACAGCTTTC +CGTTCTCGTGGGAGCCGGCGTAAGCATAGTAGAGGCTATAGAACTCGTCGCCGAGCAAATGCAAAACAAG +AAGTTAAGAAAAGCACTTATGGAAACGGCAAAGGATATAGAGGAAGGAAGTTCCATACACGATGCCCTTG +CAAAGAGAAAGAACATATTCCCCGAATTTCTTATAAACCTTGTGGAAGTAGGGGAAGAGACGGGTGAACT +TGATCTCGTTTTAAGAAGGGCAGCGGAGTATTACGAAAAGATAGCGTTTATAAAAGGGAAGATAAAGAGT +GCGTCCTTTTATCCGACTTTTGTTATGATCTTTGCAACGGCTATAGTGTGGTTCATTCTGACCTTCGTAG +TACCCAAATTTGCCGAAATTTATAAGTCTTTAGGTGGAACACTTCCCGCTCCTACACAGCTCTTAATAGA +TATCTCATTAACGCTCCAGAGGAATATTCCCTACATCTTAGGTACTCTACTGATTTCGGTAGCGGTATTC +CTTTACTTTTACAGGACAAACCTGAAGTTCAGGGCTTTAATTCACAGAATTTTACTTAGATTGCCTGTTT +TTGGAGGGATATTTAAAAAGGGTGCCTTTGCAAGGTTTGCAAGAACTATGGCAACGCTTTTTGCTTCAGG +TGTTCCCCTTGAAAGAGTTCTGGAAATCTCCGGAAGGGTTGTAGGTTTTATTCCTATAGAAAAGGCCCTT +AACGAAGCAAGAAAAGAAGTTTTAGAGGGTAAAAACCTGTGGATGGCACTCCAGAATACTGAAATGTTTC +CCAAAATGATAATAGCTATGGTAAGGGTAGGTGAGGAAACAGGACAGATGGATCAGATGCTGAACTCCAT +AGCGAACTTTTACGAAGAAGAGGTGGACAGGAGCATAGAGGGACTTGTTGCTCTCATAGAACCGGCGTTG +ATAGTAATTCTCGGAGTGATTATAGGTGCTATACTCATAGCCCTATACCTGCCTATATTCAACATCGGAA +GTTTCATAATCAGGTAATCCTCTTGTATATAAGGTCTAGAAGGTATCTGAGTTCTTGGCTTTCCTTGAAA +ATTTCTTTTTCTTTTAGTTCTTCGTATAGTTTTTTTATTTCTTCTTTTAAACATTCTCCGAGTTTCTCGT +AAAATCCATCTTTGTCAAGGTAGTCGTCAACCATTTGAAAGAGTAAGCCTACTTTTCTGCCAATACTTTC +CATCTCCTTGAGTTTTTCCCTTCTCTTCGCTACCACAGCTCCGCACATAAAGCAAGCTTCAAAGAGTGCC +CCTGTTTTTTTTACACTGACCTCGTAGAGGTCCTCATACCCCTTTATGTCAAGAACCTGTCCCCCTACCA +TTCCGTTAGAACCTGCCTTTTGAGCGATAATTTTGTTTATCTCAAGTATCTCTTCACAGGAAAGGGTTTT +GTAATTTTCCCTTTGTGATAGGACCTCAAAGGTGTAAGTCAGGAGTGCATCTCCCGCAAGGAGTGCCATC +GCTTCTCCGAACTTTATGTGGCACGTAGGGAGGCCTCTTCTCCAGACATCGTTGTCCATACAGGGAAGAT +CGTCGTGTATAAGGGAGTAGTTGTGAATGAGTTCTATACCAGAGCCAACGGTTATAGCATCATCTTCATT +CCCTCCGAGAGCACTTGCGACCGCAACCGTAAAGAGGGGTCTTATCCTCTTTCCCTTTTGTAAGGGATAG +TACTTCATAGCTTCTATTAATTCTTCTGGACCTTCGGGTTTCAGGATTTCATTAAGTCTTTTTTCTATTT +TTTCTTTCCAGGTTTCTATCCTTTCCATAAGGCTTTTAAGTTTAAAGTAAAACTTTTTCTAAGTGAAGGC +CCTGAGGCGGAGCGGTGTAAGGAGAGTTTCCCTTTCCTTGGAGTAGTTCCTCCAGTACTTCTTCCGAATA +GAGTCCCAAGGAAATCTTGACGGCCGTTCCCACGATTCTTCTCACCATATACCTCAAAAAATGAGAAGCC +TTTAGCCTTATTTCTATTAGAGGGTATTCCACATTCAAACTTACCTCTTCAAGGTTTATTACTGTGTTCC +TTTCCTCTTCCAATTTTGTAAGAGCTCTGAAGTCGTGAGTTCCTTCAAACTTCTTAAGGATATTTCTAAG +GACTTCCGTATTTATTTCCCTTTTTACCTGCCATGAAAAAGGATAAAGGAAGGGATTTCTCACTTCTGAG +TTCCATATCTTATACAGGTAAACCTTCCCTTTTACGGAATAGCGTGCGTTGAATTCTTCGGAAACTTTCT +TAACCGCGTAAACTCCTACGTCTTTGGGAAGAATTCCGTTTAGGGCTTTTAGCAATTTTTCCTCTGGAAA +GTCCTTCTGGGTTTTGAAGTTTGCAATGTAATCTAGAGCGTGGACACCGGAATCGGTTCTGCAGCAGCCT +GTCACTTTAACGTCTTCACACAGAATTTGGGAAAGAGCCTTCTGAATTTCTCCCTGAACGGTTCTTAAGT +TCGGTTGAACTTGCCATCCGTAAAAGTTTGTACCAACGAAAGCGAGGCGAAGGAGGTAATTAGGCATGCT +TTTTCAGTTCTTCCTTTATCCTCTCTATAGTTTTCACGGGAACGGGATCGTAACCATAGAGTTCTGCAAG +GAATACACTTACCCAGTCCGCAAGGTGCACCAGGTAAAGACTTCTCGCAAGGTAAGAGTTTCCTTCTCCT +TTGAGCATTATCGGAACTACTCCGAAATCCTCCAGAATTTTTTTCGTTATATCCACCCTCAGCTTTACCC +TGTGGTGGTCCTTTTCGTCGAACATCAAAAGGTAAACGAACTTATTTCTGAGTTCAGGATTGCTCCAGCC +CATGACTTCGTTGTGGTGCATCTCGGGAAGAATGGTAAAGTAAGCAGGGGATTTTGAGTTTTCGTTTATC +TGTCCTTTCCACCTTTCCGCTATGTGGGCAGTTAAAGGCGTGGAGTAAACCACTGGAATGTATCCGTAAA +TCCTGTTCGCTATTTCCTTGCCTTTCTGTTTTAAGCTTTCAAGGTTTTCCTTGAGGTTCTCCTTTGCATC +TTCAAGCTCGTCTTTATCAACTCCGAGGAGGTTCAGAACTTTGGAGAGCATAAACCCGAGGGAGTATCTT +GGTTGAAAACCCTTTGGAACCTCGTAAATCTCGCAGCCCTCTTCCTTTGCCCTTTCCATTAACTTGCCGT +TTGAAGTAATACATAAGGGCTTTATTCCCCTCCCTATAGCTTCCTCAAAGTTGGAGAGGGTTTCTTCAGT +ATTACCGCTGTAGCTGATACAAAAAACGAGATAGTCCCTATCTACAAAGGGAGGAAGTGTGTAGTCTTTC +ACTACAAAAGTGGGTTTATTAAAACTTCTGTGTTCCAGCCACTTGCTCGCAAAACTTCCTATTATTCCGC +TCCCTCCCATTCCGCAAAAGACTATACCTTTGTAGGGGGTGAGGTCCTTAGCTATGTCTTCCCACTCAAA +CTGGTTGTAAAATCCCTCCACCACTTTGTAAACTTCTTCCATGGGAAAAATTATAAGGGGAAAGAAGAGA +AAAGATTAAACTTCTTCTACGGGAGTCTTTTGTATTTCTTCTACCGCCTTTAGGAGTGCGAGTCCGGACT +TGTGGAGAGAGTTCTGTCCCAGTATGCCTATGAGTCTCAGGAGAGAAAGTTCGTTTAAGAATGTTTCGTG +GTCAAGTCCCGTCATCTTTTCTACTTCCTCAAACTGTTTTGGGAGAATCCTCACCTTTTCTTCCTTTACG +TAAAGGTTTCCTACCTTGGATATGGCTTCCACAATTCTGTACATGAAGGGGTTTACAGGGTTGCCGAGTC +CTTCGGGAACGGAGGATACAGCTTCCTTTATGAGTTCTCCTGCCTTTGTGAGAACGAGTCCTTCATTAGG +AAGGACGTCCAGAAATCCTCTTGCCTGAAGTTTTTCAACCGCGAGGTGAACTTCCTCTTTCATAACTTCG +TCGAATTCCTTGAAGAGTTCACTCAGGAACATTCCCGCTTTTGGTATCTTATGGAGAACCATGAGTTCAA +ACCTTGTGAGGTGTGGCTTTCTCTTTATGGTGTATGCGAGCTCAGAGTACAGCCTTCCGCTGTCAGTGGG +TGCTCCCGTTCTCACGAGTACCTCATCTACAGCCTGCTTGTACCACTCGTAATTGGGGGCCATAAACTCC +CTCTTTGTTATTGTGATAGCCTTAACACCGGTGGCGGTGATATCCCTTATTCCGTGCTTTTCAAGGTCCT +CCAGAACTTTTTTGCCGTGCTCCGTGGGAACGTAATAAAGTTCTCCCTTTTCTGTGAGCTCAGTCGTTAT +TAAGTCAAAAGACTCAAGTGAATAAAGGGCTTCCGTAACCAGATCCATCATCTTCTTGTACCACTCTCCG +CCCTTTTCGTAGAAGTGTTTGAAAAGCTCTTCAACGGTTTTTAGTTCCTGGAATTTTTTCTTTATTTCTT +CTTTCTTCTTGTAATTAAAGTCCTGATTTATCTTCCTTCCGTAGTATTCAACGAGGTGTTTGTACTCCTT +TAGGGGTCTCAGTAGCATTTCCCTGACTATTTCCTCTTTAGTGGGTAAGGGTCCAGCCTGTTCCTGGTGT +TTCTTGAGGAGTTTGTCTATCGTTTTCAGTATTTCTTCCTCAAAGACTTCAAGGTTGAAGGTTCTGTAGA +AGGGGTAGCTCTTCTTTTTCCAGAGTTTGTAAACTTCGAGGAGTTTTTCGCCTGCGGGAAGAAGGTTTCC +TTGGTCGTCAAAGAGTCCGAGCGCGTACATAACTTCTTGTCCCGCTTCGGGAAGTTTTTGTATTCCCTCG +TCAAGGGCGGTTACGAAGTCCTCCAGAATGTCTTCCGATATAAGTGTGTCTAAACTGAAGGGCATAACCC +TCAGGGTTTGCTCCACCGCCTGACCGAGTCCCGTCAGGGCGTATACGTCGGAGTTGGGAACTGAAAAGGC +TATGAGTCTCATGGACTCAAGGAGCAGGGGAAAGTGTTTTCCTTCAGGGAGCATACTCTTTTCTGCGGGA +CCAGGAGGCATCTTCCTTATATATTCCGCAAGCTCCCGTGAGATTTCCAGTTTAGGCGTTATCTCGTTGT +AAATTTCGTAAACGGCTTTTGCGTATTCATTTACGGTCTTTATCTTTCCTTTCTTTTCCACTTCCACTTC +TTCTAAAAAGCCCCTTTCCATTAGGGCGTGCTCTATCTTCTCTCCCGGTCTGCCGTCGTTGAGGATTGTG +GAGTGTATCATGCTGATTATTTCCGAGCCTATCCACCTGAAGTGCTCGTCCCAGTTCTCTGGGTGCGGAA +TGTAACCCTTGTCTATCATCTCGTGGAGGAGGTTCACGAGAGCCTCACCCCAGTAGGTAAGGGTGTACTC +GAGGGGTTTTTCAAGCCTCACTAAGTTCTGAAACTCAAGTTCTAAGAAAACTTCTTCTTCTCTCGTTTTT +TCCGCAACCTTGTAAGTAGGTTCTCCTCTTTCTTTTGCTTCCTTTACAGCTAGGAGTGCCAGAGCGTGTT +CCCTCATTATAATCATTTGCCTTCACCTCCGAACATTTTTAATTCATCCTCTATGAGTTTTTGGGCTTCT +TCCTTGCTCACTTCCACGTAAAGTTTCCCCACGAGGTAGTAAAACTTCCTGTTTGAGTCAAACTTCTCAA +GGGCTTCCTTTGCGAGCTTCAGCTCTTTCTCCATTATATCCCTCTCAAGGGCTTCCAAAAGCTCAATTGC +TTCCTTTACCTTTTCCTCCCTTATGTAGCCCTCTTCCGCTCTGCTCCTTTGCTCAAGGGCTCCTTTTAAA +AGGTTTGTTATGGCTTTTAATCTCTCAAGCATCTTTCTTCACCTCCGTCCAGCCTGCTGTTTTTTTCTCG +GAAGGAACGTAAATAACACTTCTCGGTCTGATATCAAGTCGGTAAAGTCTCCTTATTCTGTTTCTTATCT +CCTTGTCCCCCCAGAACCAGAAGAGTCGGCCTCCGAAGGGGGCTGTGGTCCAAAAGCCTACTCTTAAAGG +GATTTCCCAGTTTTTCATTTCAGAGAGGAGGTTTTTATGGAATATCTCACCTATCGGGTGGTCACGAACG +AGCGTAAGTTCCGCGTGGGCGAGGGCTTCCGCGTAGGAGTGGCATGCGGACCTTAGTTTCTCGTAGTTAT +TTGCTTTAACTTCAAACTCCGCTACACCCTCAAACACTTCACTCTTGAAGTAGTCCTTAAAATCCTTCCT +CTTCAAGTCGTAAACTTCTACCACCTTTTCCTTAATCCCTTCGGAAGACAGGTAAACCTTTTCGGGAACT +TCTATACTTTCTATAAACTCTTTTTCCGCTTCAAATACCATTTTTTCTATTTCCCTCACGAATTTTCTGA +GGGAGGTTCTTTTGTGCCTTTTTACGTAGTTCTTTACCTTCGTGTTTAGAGCTTTGTCCTTTTTCAGGAA +GTAGTAAACGAGAGCGTCTTTTATAGCCTCTTTTATTTCACTTCCGGGAATGAATTTCTTACCGTTTTCT +TCGGGAAATTTCTTAGAAGAGAGGAGAACGGGACTCCATGCAAGCAACTTCATTTGAATTCCTCCAGTGC +GGTGTTTGCCTTTTCTGAAATATCTATGTCAAAAAGGGCTATCGTGGGAAGGAGCCAGGACACCCTGAAG +CGGTTGTCCTTTTCTCTAGTCTTTCCGAAGTAAGCGAGGGCTACCCTTCCGAAGCCCGCCATCTTTTCTA +CCTTCTTAGCTCTTTCAAGGAAATCCCTGGCAACCAAGGGAAGTTTTTTGTAGGGGAGCGGAAGGCTTTC +TCTTCCCCTTTGTTTGTAGAATTCCGTAATGACACCCACGCTCTTTAGGTTGTTGGCGAGCTCATGGAGT +CTGTGTTTTTTGAAGAACGCCATCAAGAGTGTTGGGGCGGGGGTTCTCAGAATTTCAAGATTTTCTTTTC +CTTCTCTCAGCTCCGCTACTATATAGGCCACACCCTCACTCGTCTCTATGTGGGCGAATAACTTTTTATT +CTCTGGAAGTTCAAGGAGTATTTCTTCTATTTCATACGTAGCCCCTCCCTCCTCCCACTTATCCCCAACC +TCCCTGCCTGCTTGTGAAGCAAAAAAGGTTCGAACGCCGTTTTTCTTTCCGAGTATCAAGTCAAAGCCCC +ACCTTCTCAAATCCTGTATTGTAAACTCCCTTTCCTTCTCAGGTTGTCCCAATGTTTCAAAGACGAGTGT +GTTTAGGGCTATCTTTTCTACGAGTTCCTTTTTATCCATTTAGGCTCACCTCTTCGTTTATGCGTGCCAT +CAGGTAATTCGCGGTTATTTCAAGGGCAAACACAAAGAGCGTTATCACCGCAGCTCCCCAGAAAGCACCC +TCAAAGTAGTTCCCTATGGTAAGAGCTCCGAGGAGGTCAAACTTAGAAAGGAGCATTATGATGAGCATGA +GTGTGAAAATTCCGTAGTAAGCGTACCTGTAGTAATCAAGTCCCGCAAGCCACAGGGCTAAAAGTGCAGG +AATGGATAGGTTTTCGGTTCTCTCTACTGGTTCGTTTGTTTTTTTTGCAAGTTCTCTTCTGTCTATTTCT +TTGTTGGTGAGAAAAGCTTCCGCGGTAATTACAAAACTCCCGTAACCGAAGAGGAGTTTATTTGCAAACA +CAAGAGCCCCCAGAAATCCGAGTAAAAACGCAAAACCTTCGGGTGTTAGTACTACGAGGAGAGTTGATAC +GAATATCCCGGTAAAGGCGAAAAAGAGAAGTGTCGCAAAGAGTATTACAAGTATCCATTGGGATACACTT +TCAGCCTTCATTTACTCTCCTCCTTTTTCTCTTCCTTCTTTTCCGTCTGTTGTTTTTCCTTAACTCCGTA +AGTGAAGGGGTGAACAACCGTGTATATGTCCTGTGAAAGTGGGTGCGTGTATGTGAATGTGGCGACTACG +AGGTCCCCAACTTTCAACTTTTCCGTTCCCTCTTTTAGCTTTAGCTCAACTATGGCAACGCTGAGAGGTG +GAATTGTAACGTTTGCGGGAATGTTTGAAAGAACGTATCCCTTTTCTTTACTTTCCTTTCCAGGGGTAAA +AACAAAGGCCTTTTCGGTAATTTTTATTGGGAGTGTTCCGGGATTGGATATGGTGTAGGCTATAAGGTGT +TTCTCCTTATTATAGGTAGCACTCAGAACTATGGGGGAGCCGGGAATGTTTTGAAATTGTTTGAGGAGTT +TTGAAGAGGTAAAGTAAGAGCCGACCCCACCTCCCACGAGGAGGCCAGCCAAGGCTATCATCGTTCCTAT +CACAAAGTACCTCATTATTTTTTAGCCTCCTCCTGTCCAACTTTTCTTACTTCTTCGAGAAGTTCTTCAA +TTTTGTTGTAGAGATCGGCTATCGCTTCCTCAAGTGCCCTCCTTAGAGCTTCCAGAGCTGCTATTTCCTT +TCTTATCCTGTCTACCGCCTCGTCGTAGCTCATTACCGCGGATATTCCCGTTCCTATGCTCATTATCACC +TCGTCAACGCCTTCACTCTTTGCCTTTATCTGTGCGGTAGCTCCTACGGGTATGAGCACTTCTTTACCCT +TTCCGAGTTCCTTTAAGCTTCTTAGAGTAGCTTCTGCGGTTCTGAGGTCCGTTATGGATTGATTGATAAC +GGAAATTTCAGCCCTGAGGGCTTCAATGTTAGCCATGTAACCCCTGAGCTGTCTGTTTAGCTCATCCATT +TTTTGCTCAGGAGTTTTTTGAACTTCCTTCTTCTCTTCTGCCATCTTACCCACCTCCTATTAAGGTTTAC +ATATAATTTTATTATATTCCTTTTAAAAATTTTTGCAATAATTCTTATCATAAAACTTTATAAAATTGTA +TTAAGACTTTGTCCCATACACTATTTTGCTAAAGAGGCTAAATTCTATTAATTGCGATGGCTTGGGTAGT +TGACGAGTTTGACGTGGTAGTTATAGGAGGCGGACACGCTGGGATAGAGGCAGCCCTTGCGGCAGCGAGA +ATGGGCGCAAAGACAGCGATGTTCGTTCTGAACGCGGATACCATAGGACAGATGTCCTGCAACCCCGCAA +TAGGAGGAATAGCAAAGGGAATAGTGGTAAGGGAGATAGACGCCCTCGGGGGAGAGATGGGAAAGGCTAT +AGACCAGACGGGTATTCAGTTCAAGATGCTGAATACGAGAAAGGGAAAAGCAGTCCAGTCTCCGAGAGCT +CAGGCGGACAAAAAACGCTACAGGGAGTACATGAAAAAGGTATGTGAAAATCAGGAAAACCTTTACATAA +AACAGGAAGAAGTTGTGGACATAATAGTGAAGAACAATCAAGTTGTGGGTGTAAGGACGAACCTCGGAGT +TGAGTACAAAACGAAAGCGGTTGTCGTGACTACGGGAACCTTTCTGAACGGCGTTATATACATAGGCGAC +AAGATGATACCCGGGGGAAGGCTCGGAGAACCGAGAAGCGAAGGGCTTTCCGACTTTTACAGGAGATTTG +ATTTTCCCCTAATACGCTTTAAGACTGGAACGCCCGCGAGACTTGACAAGAGAACCATAGACTTTTCCGC +TCTAGAAGTAGCTCCCGGAGACGACCCGCCCCCTAAGTTTTCCTTCTGGACCGAGCCCGTGGGCTCTTAC +TGGTTCCCTAAAGGAAAAGAACAGGTAAACTGCTGGATTACGTATACGACTCCCAAAACCCACGAAATTA +TCAGGAAGAACCTCCACAGAACGGCCCTTTACGGCGGTCTCATTAAGGGAATAGGACCAAGGTACTGCCC +CTCAATTGAGGACAAGATAGTGAAGTTCCCCGACAAGGAGAGACACCAGATATTCCTAGAGCCCGAAGGT +CTGGACACAATAGAAATATACCCGAACGGACTCTCCACTTCTTTACCCGAAGAGGTCCAGTGGGAGATGT +ACCGCTCAATCCCCGGACTTGAAAACGTAGTCCTAATCAGACCCGCTTACGCCATAGAGTACGACGTTGT +TCCGCCCACAGAACTTTACCCAACTCTTGAGACGAAAAAGATAAGGGGTCTCTTCCACGCGGGTAATTTC +AACGGAACTACGGGATACGAGGAAGCAGCAGGTCAAGGAATAGTGGCGGGAATAAACGCAGCCCTCAGAG +CTTTCGGAAAAGAGCCCATATACCTGAGAAGGGACGAGAGCTACATAGGCGTTATGATAGATGACCTCAC +GACTAAAGGAGTTACGGAACCCTACAGACTCTTTACCTCCCGTTCTGAATACAGGCTGTATATAAGGCAG +GATAACGCAATACTTAGACTAGCAAAGCTCGGAAGGGAACTCGGACTCCTCAGTGAGGAGCAGTATAAAC +TCGTAAAAGAACTCGAAAGGGAAATAGAGAAGTGGAAGGAGTTTTACAAGAGCGAAAGGGTAAGCGTTGC +GGTGGGAGGAGACACGAGGAGTTACAGCGTTGCCACACTAATGACCATGAACTACACCCTTGACGATGTA +AAAGAGAAGTTCGGATACGAAGTGCCCCAGCACCCTTACGTAAAAGAAGAAGTGGAAATCCAGCTAAAGT +ACGAGCCCTACATAGAGAGGGAGAGGAAATTAAACGAAAAGTTAAAGAAACTTGAAGACACGAAAATACC +ACCCGACATTGATTACGACAAAATCCCGGGTCTTACGAAAGAGGCGAGGGAAAAACTTAAGAAATTCAAA +CCCATAACCGTAGGTCAGGCCTCCAGAATTGACGGAATTACGCCCGCAGCGATAACGGCACTACTCGTTT +ACCTCGGAAAGTTAGACTGATGGATTTGTTAGATGCTTGGGATTACTTCATAAACGAGGTTAGAAAATTT +TTCAAAGAGAAGGGCTACACCGAGGTCTCCACCCCCCTCCTTCTCGACTTTCCCAACTTAGACTCAAACG +TAGAGCCCGTAAAGGTGGAAGTTCTGGAAAGGGGAGAGAATAAAGTAAAGTGGCTTCACACGTCCCCCGA +ATACTCTATGAAAAAGCTCCTTTCCCGCTACAAAAGGGATATATTCCAGATAACAAAAGTCTTCAGGAAC +AACGAGTGGGGTAGGCTTCACAGGATAGAGTTTCACATGCTCGAGTGGTACGCTGTAGGTTGCGACTACC +TTTACTTAATAGAGGAGCTCAAACAGCTCCTCAATAAACTCTTTGGCTTCAAAGAATTTGAAGTTATTAC +GGTGGAGGAAGCCTTTAAAAGGCACTTCGGGGAGGGAATTCCGCAGGAAGAAAGCAGTATGAAAGAACTC +CTTGAGAGAAAGGGTATTGATTTTTCAGAGGACGAAGACTGGGAAACGCTTTTCTACAGGGCTTTTATAG +AAGTTGAGAGGCATTTAGGTTTTAATAGACCCACTTTTTTGATAAACTTCCCGGAAAGGCTGTGCGCCCT +CGCAAAAGTAAGAAACGGATATGCGGAGAGGTTTGAACTCTTTATAAAGGGAATAGAACTCGCAAACGGC +TGGACCGAGGAGACCAACCCTGAGGAAGTGAGAAAAAGGCTTGAGAGGGAAGCAAAAAAGAGAAATCTTC +CCTTGGACGAGGACTTTATAAAGGCTCACGAAGATATGCCCGAGTGTGCGGGATGCTCCCTCGGTATAGA +CAGGCTCTTTTCCCTCTTTTTAGGAAAGGAAGAACTTGTCAGCGAATTCTTCCGAGCTTAACGGATATCT +TTTGAGCGCTTTCTTTCAGTATTTCCTTAACCCAGCCCGTTAGGTCTTCTTTGGTCATCCTGTAGGAAGG +GGCAACGATGGTGACAGTGTAGTTTACTTTTCCCGCATAGTCGTAAACCGGGGCGGCAGCACTTACAACT +TCCTCCTCGTACTCTTCCAGGTTAAGGGCGTAACCCTCTTTCCTGATTTTCGGGAGTTCTTTCAGGAGTT +CTTCGGGTGTTTTGGTGTGGGGGGTGTGTCTTACCCACTTTACGGTTTTAAAGTAGTTTTCGAGTTCCTT +TTCGTCAAAGTGAGAGAGGTAAATCTTTCCGGAGGCGGAAGCGTAAAGCGGGAGAACCCTCCCGTATCTC +GAGAGTATCATCACTTCCCTTTCTACTTCGCTCTTTTCTATGTAGAGAACCTCGTAAGAGACTCTGGTCG +TCAGGTAAACGTTTTCCTTTACCTTCTTTGCCACCTCCTCGAGGATGGGTTTTGAAGCTTTCTTTATGTC +TAAGTGCTTCAGGTAAGATACGCCGAGTTCAAAGTTCTTTATGCCGAGTCTGTAGAGTTTATTTTCCTCG +TCAAAGGATATCCACTCGGACTCCAATAAGAATGTGAGTATCTTCTGGAGCTTCTGTCTGCTGATTCTGA +GTTCTTCCTGGAGCTTTTCAAAGGTATATGGTTTTTTCTCAAGGAGGAATAGAACCTCAAGGGCAAGGTG +TACGTTCTGGATTATGTATATATCCTTATACTGATGTTCCATAAGTCTAAATTTTAAAGTTAAACTTTTT +TCCTGATGTTTGGACTTGCCTTACTGATAAACACTTTCTTTTTAGTTTTCAGAGTCCTTTACGTGCTTTT +TTACCCCGTAGACCTCTCTCCGGAAGAGGCCCAGTACTGGGACTGGTCGAGACACCTTGACCTCAGTTAC +TACTCTAAACCTCCAATGGTAGCCTACATGAACTTTTTGTCAACGCACGTCTTTGGAAATACAGAACTCG +GAGTCAGGATAAACGCCATACTTCTTTCTTTTCTGCTTTCCCTGATTACCTACTTCTTTGCCAAGAAGCT +ATTTTCCGAAAAGGTAGCATTTGTAGCCTCAGTTGTTCCCAATTTATTCACAGGATTTTCAATAAACTCA +GTCCTCTTTACAACAGATTCCCCTCTCATTTTCTTCTGGGCACTTTCTGTAATTTCCTTCTACTTTGCGA +TAGAAAAAAATACCTTGAGCCTATGGATTTTGACGGGTGTTTTTTCGGGTCTTGCGTTCCTGAGCAAATA +CCCCGCTGTATTCCTCCTTCCCTTAGGGATTCTCTACCTTTATCTCACGAAAAAGGAACTTTTAAAAGAT +TTAAAGATATTCTCCTCTGTTCTGGTAGCCTTTTTAATTGCCCTTCCCGTTCTCATATGGAACGCAAAGC +ATGATTTTATCTCCTTCAAGCATGTCAGCAACCTGGCACAAAAGCACGCCCACTTCCCGAACTTTTCTAC +CTTTTTTGAGTACTTGGGAGGACAGGTTTTACTGCTCTCGGTCATTCCCTTCTTCTTCGTTTTATACGGT +TGGGTAAGAACTTTTAAGGAAAGAAACAAAAGACTTATATTTTTAACCACTTTCTCCCTGCCGGTTTTCC +TGTTTTTTGCTTTTCTTTCTCTGAAAAAGAGGGTTTACGCTAACTGGGCTGGGTTCGGATACTACACGGC +TTCAATACTCTTTGCCTACTACTTTTTAAAATCACCTAAATCTTTGAAATTTCTAACCTTAATCCTCTCT +GCATTTTTAACCCTTCTCTTACACTTCACACCTTTGTTTGATTACCTCGGCTTGAGAAATCTCCTTCCTC +CCAAAAGGGATCCCGCAAAGTTATTAGTAGGCTGGGAAGATCTCGGAAAGGAAGTTGGAAGGTTTTACAC +GGGGAAAGAACTTATATTCTCAACCGCTTACCAGATTTCCGCGGAGCTCGCCTTTTACGTTCCGGGAAAT +CCGAGAACTTACGTTTTTCACGTAAACAGGTACACCCAGTACTACCTCTGGAGGGAAGGACTGAAAAACT +TCAAGGGTAAAGATGCCGTATTCGTGAGCTACGGAGGCGTCCCGAAGGAAGTTATGAGAAGTTTTGAAGG +AAAAGAGTTTTTAAAGGAAGTGAGGGTGGTGTGGAGAAACCAGGTTGTAAGAAAGTTTTATATTTATAAA +CTGAAAAACTTTAAGGGCGAGTTTTATGAAAATCCCAAGGGGTATTAAGATCATCTTGAGATGGGTTGTC +ACTCTTTACATTTATGGCTTTATCCTTTACCAGATAACGCCCTTTTCTTACTTTGAAACCTACATTCCCG +AAGAGAGACTCGCTCCCAAGCCTTACGTTGAAAGGATTTTTTACCTTTTCGGCGTAAAGTCAAATGAGTA +CCCGTCAAAAGAGGTTCTTGAATTCTTAAAAAGCATGGACGTGGATCTCGTTTACGGATTTTTTCCTTTT +GAAGATTACGGGATATTTAAGAATTCTTTAAAGGCTCCGGAATGTCACTTAATCTACACCTCGGAAATTT +CTACTTTTCACAGGATTTTGAACTTTCTTTTTGATTACGTTCCCAAAAAGATAACGGGGAATGAAACGAG +AACCTTTCATTACTTCATTAAGCCTAAGTTAGGCAAGTGCAACGTAATAGTTCAGGACGTTTACCTTTCA +CCAAACTTTTTAGACTTCAAACTTGATCACTCTAGAAACATGGTTTACAAAAGGCTCTGGGAGGATTTAC +AGCTGGAACAGAACGTAATTACAAACGGGAGGAAAAGCGTTGACGTTTACGCTTACTCAACGAAAAGTAT +GTATTATCCTAGCGAAAGCACAATATACCCCTTTAAACTCTACGCAAAGAGTAACGAAGAAAAAACCTTA +ATAATCGTTTACAGGGACGGAAAAGTTTACAGGATTTACGACGAAAGGAGCACAGTTTTGAAAATTAATA +AACCCGGAAAGTACTCCGTAAAGATACTCACTTACGCCTTTTCGTGGGAGGGGTATTACTTCGGCCTCAG +GACGATTGCTTACTCCGCACCGATAACCCTTTTATATTAAGTTAGAATGAAAGTTGTGAGGGCTTTTGTT +GGTTTTTTCACGAGCAAATCCATAAACGAGGTAGCGGAAAGGATAAAAAAGGAAGTGGATTTAAAAATTA +TGGGAAAGTGGGTGGAACCCCAAAACGTCCACATGACGCTCCAGTTCCTCGGGGACATCACAGAAGCCCA +AGCTATAGAGGTGATTAAAAATTTACAGGAAATCTCAAAGAAGAACATACCCTTCAGGATTAAGTACAAA +GGTCTCGGCGTATTTCCCGACGTCAAAAGACCGAGGGTCCTCTGGATTGGTGTATCGGAAGGGGCAAACA +AGTTGACAAATCTCGCAAAGGAAGTGGCAAGACTAAACGCAAAGAAGGGTATTATCCCGAAAAATTCTAA +GAACTTCGTTCCCCACGTTACGATATGCAGGATAAAGTCCTACGACAGGAAAACCTTAAACGAACTCCTC +AGGAAGTACAGAACAGTTGAGTTTGGTGAAGACGAGGTAAACAAGATAGCCCTCATTTCCAGTACACTCA +CGTCCGTGGGACCCATATACACGGTGGTTGAGGAGTTTTACCTCGGAGGGTGAATATGGTCACCTACAGG +TCTGCGGGAGTTGACATAGACAAGGCGAACGAGTTCGTGAAGTTCATAAAAGAAAAGGTAAAAAAAGAGT +TTAATCTGGAAGAATTCGGAGGATTTGCGAGCGGTTTCCCGATAAAGGGTTATAAAAAACCCATTCTCTT +TTCCACAACAGACGGCGTAGGAACGAAACTCAAAGTAGCACAGGCTGTGGGTGTTCACAATACCGTGGGA +ATAGATCTCGTTGCGATGAACGTAAACGACCTGATAACCACGGGGGCGGACCCCTTCATATTTCTGGACT +ACATAGCCACGGGAAAGCTGGATCTTGAAGTTATGAAACAGGTAATGGAGGGGATTATAAAGGGCTGCAG +GGAGGGAGAGGTAATTCTCGCAGGCGGTGAGACTGCGGAGATGCCCGGATTTTACCCGGAAGGGGTTTAC +GACCTTGCAGGCTTTTGCGTTGGACTTTGTGAGGAAGATGAAGTAATTACGGGTAAAGAAATAAAGCCCG +GGGACCTTCTTTTAGGACTTCCTTCTTCTGGATTTCACAGTAACGGATACTCTCTCATAAGGAAAGTTCT +TGAGATGAACAACGTTTCCTATGAGGATTACGTGGAAGAGCTCGGCAAAAAAGTGTGGGAAGTTTTACTC +GTCCCCACGAGGATATACGTAAAGGAAATTAAAAAACTTAAAAAGAATGTAAAAATTAAGGGGATAGCCC +ACATAACGGGCGGAGGAATTCCCGAAAACCTGATAAGGATACTTCCCGAGGGAACAAAGGCTGTAGTTTA +CAAAAAGAACATTCCACAAAACCCCGTGTTTTCCTGGATTCAAAGACTCGGAAATGTAGAGGAAAGGGAA +ATGTTCAGGACCTTTAACATGGGCGTGGGAATGATAGTTATTCTGGACAAAGAAGAGTTTGATAAGGCAA +GGGAGTTAATACCGGAGTCCTTTTACTTGGGTGAAATCCTTGCGGGAAGAAAGGAAGTGGAAATCCTGTA +GCCCGTCTTTCTTTCGCTCTTTTGCTTTTGTTTAAAGTGGTAATAAGCGTAAGCCATAACTATAAAGAAA +AAAATTAAGGTTGCTATCCTTACCCACCTCTTGAAGCGGGCGTACTTAAACTGGTCCGACATGGTTTTTA +TTTTAGAATAAAGACCCATGTTTAGTATGACCGGTTTCGGAAAAGGAGAAGCAGAAAGCGAAAACTGGAA +AGTCACCGTTATGATGCGTTCCCTTAATGGGAAGGGACTGGACGTATCCCTGAGAATGCCACCCTTCTTA +ATGCCTATGGAGCTTGAACTAAAGAACGAAATAAAGAAACACCTTCGCAGGGGAACGGTAACGGTTTACA +TAGACCTTGAACAAAAAGTGGTAAAACCACCCATTGACGTTGAAAAATTAAAGGCGAACGTTGAGATGTT +AAGGGAACTCTCAAACTCCGTTGGACTTTCTCCCACCGACGACAAAATCCTTGACTACGCTTGGAGGTAT +TCGGAAAAAGCGGAAATAGAACTGGACGAAGAACTTAAAAATGTCGTAATGGAAGCCCTGAGGAAGGCTA +TACAGGAACTCCTTGAGAGCAGAAAGAAGGAAGGGGAGCACTTAAAAAAGATTTAACGGAGAGGATAAGG +AAAATAGAAGAAATCGTGAACGTTCTGGACAGGAAGAAGGAGGAGTTCAAGGAAAGGATAAAAGAGAGAG +TTCTGGAGAGGGCAAAGGCACTGAACCTTCCCGAAGAACACCCGACGGTTTTAAACGAACTCATGTTTTT +GCTTGAGAAGTACGACGTTAATGAGGAAGTTCAGAGACTGAAAGCTCACGTAGAACGCTTTAAAAAACTC +CTTGAGAGTGAAGGAGAAGTTGGAAAGAAGCTTGAATTTCTTGCACAGGAGATGCACAGGGAAATAACTA +CTCTTGGGAACAAAATTCCCGACTTTTCCGAGTACACGGTTGAAGTCAAAGCTGAGATTGACAAGATAAA +GCAACAGGCTGCAAACGTGGAATAACTTTTATCCTTATGAGGCTTGACAAGTATTTGACCGACAAGGGTA +TAGTCCCCTCACGGGAAAAGGCACAGGCGGTAATAATGGCGGGACAGGTGCTCGTAAACGGAAAAGTAGT +TGACAAACCCGGATACAGATTAAAGGGGAACGAAAAGGTAGAGGTAAAGGAACTCCCCAAATACGTTTCC +AGAGGCGGGGAAAAACTTGAATGGGCGATAAAGAGGTTTTCCTTAGATTTAAAGGATAAAGTCGTTCTGG +ACGTTGGTTCTTCCACAGGAGGCTTTACGGACTGCGCCCTTCAACACGGGGCGAAAAAGGTTTACGCGGT +AGACGTCGGAAGGGGACAAATGGACTACAAACTAAGGCAGGACCCGAGAGTAGTACTCTATGAGGAAACG +GACGCAAGAGAACTCTCAGAAGAACACGTTCCCGAAAAGGTTGACCTCATAACCTGTGACGTTTCCTTTA +TATCCTCCACGAAAGTTCTTCCAAACGTATTTAAGTTCTTAAAAGAAGACGGACTCCTTTTAGTTCTTGT +AAAGCCCCAGTTTGAACTCTGTCCGAGGAAAGTAAAAAAGGGAGTAGTCAGGGAAAAAGAACACAAGAGG +GAAGCCCTGCAAAAGGTAGTAAACTTCCTAAAAGAGAACGGCTTTAGAATACTCGGAGTTATAAAGTCAA +AGCCGAAGGGCACTAAGGGAAATGAGGAATTTTTCGTTTTGGCTGGGAGAAAAGGGGAGGAAGTAAACTT +ATCCGAGGCGATAGAGAAAGCCCTTGAGGAGGTAGTGGATTGAGGCGTTTTTTAATCCTCCTGTACGTGT +TCCTTGTAAGTTCAGTTCTCGGCTTTATAGCCTTTGAGATATTCACACCCCTTTACGTTCCAAAGAAAAC +CGTTGAAATAAAGTACGGGACTCCCGTTCCGGAAATAGCCCAGATTTTAGAAGAAAATAAAGTTATAAAG +AACAAGTACTACTTTCTCATACTCCACGCCTTTAAGAGGGGAAAGCTGGAAGCGGGCGAGTACGAGTTTG +AAGGGTGGTTGAGCACGTACGACGTTTACAAAATCCTTGAAGAGGGAAAGGCAAAACTCTACAAGGTTAC +TGTAAAGGAAGGTTACGACGTATTTGACATAGCAAAAGTTCTGGAAGAAAACGGAATTTGTAAAGAAGAA +GACTTTTTGAAGTACGCCCTTTCGGAAGAGGTTGCGAGGAAGTATAACTTGAGCGTGCCCTCCATGGAGG +GTTTTCTCTTTCCGGATACATATTACCTTTCCAGGAATATGCACCCCTTAAAGGTTATAGACATTATGTA +CAAAAACTTCCTCGAAAAAACGGAAGAAATGAGAATGGAACTGAGGAAAAAGCACATATCTCTGGAAACC +TGGGTAACGGTTGCCTCAATGGTCGAAAAGGAAACCCACCTGGATGAAGAAAAACCCCTTATAGCAGCGG +TGATATACAACAGGCTGAAAAAAGGAATGAAGCTCCAGATAGACCCTACCGTTATATACGTTGCGAAAAG +AAGAGGTATATGGAAGGGGGAACTCTACAAGAGTCTTTATAAAATAGACGACCCTTACAACACTTACATG +TACTACGGACTTCCGCCGGGACCAATATCTAACCCCGGACTTTCTTCACTAAGGGCAGCGCTCTACCCTG +CGAAGGTAAATTACCTGTACTTTGTAGCAAAACCCGGATACAAGGGACACCTTTTTGCTGAAACTTACCT +TGAACACCTCAGGAATATGAGAAGGGTAGGAAGACGCTAAAGCTCAAAAAGGTCCCTCGTTATTATTGTG +TCCCTTCTGTAAACTTCCCTTTCTGTAGGGTAGTCCTTCCTGTAGTGTACTCCCCTGCTTTCCTTTCTCA +TGAGTGCTCCTTCAACGGTGCAAAGAGCCACGAGGAGTATGTCGTAAAGTTGCCTGTTTTGCGGTGTAGG +TTCCCAGTGTTTTGCCTGTGAAAGCACACTAAGAATTCGTTTTTTTACGTAAGTTAACCCCTCTTCGTCC +CTTTCAAGACCTACGTAATTCCACATGAGTTTTTTTAGCTCTTCTATACCCAAGTTCGGCTTATCACTTC +CTGCTCTCTCAGAGCGAAAGTTCACTTTTGAGGGTTTTAAAATTTTTAAATCTAAGTAAACCTGATAGGC +TGTCCTGTGACCGAAAACCACACCTTCCAGGAGAGAGTTGGAAGCGAGTCTGTTTGCCCCATGAATTCCC +GTACAACTGCACTCACCCACCGCGTACAAACCTTGTATTGAGGTTCTTCCTCTGTCGTCTACCTCTATAC +CGCCTATATAGTAGTGGGCTGCTGGGATAATAGGCACGGGCTCTCTGTAGGGGTCGTACCCTCTTTCCCT +TAAAAAGCTGTATATAGTCGGGAAACGCTCCTCTATCTTAATACCCTTTTGTGCAACGGGTCTCAGGTCT +AAGTAAACCTCCCTTCCCCGTTTTATCTGGTTATATATAGCTCTTGCAACTTCATCTCTCGGGAGGAGCT +CGTTTACAAACCTCTCTCCCCTGTCGTTCACGAGAATTGCACCCTCTCCCCTAACCGCCTCGGATATCAG +TAAGTTCGTTCCCTTCAGGACCGTGGGGTGGAACTGGACAAATTCGGGGTTCTTAACGGTAGCCCCCATT +CTGAAAGCGATTCCTATCGCATCTCCCCTGACTTTCTTAGGGTTAGAAGTGTAGTAGTACATAGACGCGG +CACCGCCCGTTGCCAGAATTAGGAGGGGTGTGCGTATGAACTTTAGACTACCTTCTTCGGAGTAAATTAC +CCCCTGAACCCCATTCTCCTCAATTATTATTTCCTGAAGTTCTCCGTGAAGGATTTTTATTCCTAGTTCT +TCCGTCTTTTTCAAGAGTTTCGTATATATCTCCCTTCCCGTGTAGTCTTTTACTTTCAACACTCTGGGTT +TTGAGTGCCCTCCCTCCAGAGTAGTCTCGTAAAATCCGTTTTTCTTATCAAAATCTACACCCCATCTTTC +TAAATCAAGTATCCTGAAGATGCCTTCGTAGGTTAGGAGTTTTGTATGGAGTTCGTGGTTTAAGTACCTT +CCGGCCCTCAGGGTATCACAGTAGTGAAGGTAAGGGCTGTCATCGGGGAGCACTGCAGCGGCTATCCCAC +CCTGGGAATAGTAAGTGTTCCCGATACCTCGCGTTAAGATTAGAGGTTCAATCCCGAGTTCTTTTAGAGA +AATTGCGGTAGCAAGACCTCCGATACCGCTCCCGCATATTAGAACTTTCGCTTCTTCTTCAGGTAAAAGA +GAAGTATCAAACCTTAGAAAGTAGTTCATTCTCAAGAATTTTTAGTATAACCTCCGTGAGTTTTTGAGGG +TCGTGTCTCACAAAATCTCCGCTTTCTCCTATCAGGTTCTCCGCATAAACGGTTATGCCTTCTCTTCCTA +TTCTTCCGACATCCGGAGTCACGGGTTCCTGATTCTGCTCCAGGTATTTCTTTAAAAGACCGTTTGAGGG +CATCTGTGTATTTACAACTGCAACGTCAACGAGGTCTATACCCGAGAACTTCAAGAAAGTGTCTATATGA +TCCCACGCGGTAAAGTTGTCCGTTTCACCAGGTTGGGTCATAACGTTTACGACGAAAACCTTCAAAGCTC +TGCTTTCCTTCACCGCTTCCCTTATCTGGGGAACTAAGAAGTTGGGGAGGATGCTCGTAAAGAGACTGCC +TGGACCTATTATTATGAGATCCGCTTCCTTTATCCTTTCTATCGCCTCCTCGGGAGCTTTCGGGTTTTTT +GGTTCGAGCCATATATTTACTACTTTGTGGCCCTTCTTTCCGTACTCCGTTATTTCCTCTTCTCCCTTAA +TGACTTTTCCGTCGTCAAATTCCGCGACGAGGTTTACGTTTTCGTAGGTGGAGGGAATTATATCCCCTTT +GGTCTTTAGAATTTTAGAAGTTTCTTTTATGGCTTTCAGAAAGCTTCCCGTGATGTCCGTAAGGGCAGTA +AGAAATAAATTCCCAAAGGCATGACCTTCCAGTCCGTCTCCCTTAAACCTGTACTGGAATAGCTTTTGCA +TAAGTTCTTCCGCGTCCGAAAGGGCTACTATGCAGTTCCTGATATCCCCGGGAGCGGGTATGTTGTATAT +CTTCCTGAGCCTTCCCGTGCTTCCCCCACTGTCTGCAACGGTAACGATGGCGGATAGTCTACCTATGCTC +CTTCCAACTTCTATTTTCAAACCTCTAAGAAGGGAAGAAAGCCCGGTGCCTCCTCCTATAGCAACTACGT +TTACCTTTTTCATATTATCCCCTCAATAAGGATTTTAATCTCCTGACCTCCGAGTTTAACACTTATTTCT +CTATAGTAACCTTCTTTACTCTTTTCTCCGTAAATAATTTCCAGATTTTTGTACTTCACCGCCTTCAGTC +TTTTACCTTCCAGTATTATTTCTTTTCCGTCTCGGGAAACCAGGGTAACAGTTTGGTTGCATTCTTTTAT +CCGATAATCGCCGGGAAAGTAACCGTAAATGAAGTTACTGGGTAATTCGGGAAGTTCAAAACACACACCT +TGAAAGCAAAGTAAAGAAGTGTCAAAAATTACAACATCTCCCGGTGTTTTTATTTTTTCATCGTATCCGT +TTTTCTCAAATACAAAGGGAATTCTCAGAATGGGAGTTTTTACGTAGCCGTACAGTTTTGCTTTCTCGGG +CGGCTTTTGGAAAACTCTGTTTAGTATTTCTTTGGGTTTCGGGCATATCTTGGGAGCACAGGAAATTATT +AAGAGCAAAATAAAGGGAATTAATCTAATCATTTTTCCTCACTTTCACCGCAAGGGCATGGGCAGTGAGT +CCTTCCGCTTTCGCTATTGCCTCCGCCTGATTTGCCACCCTTTTGAAGCCTTCTCTGGAGACGTAGAGAA +CGGAGGACCTCTTTATAAAGTCGTAAACTCCGAGAGGGGAGAAAAACCTTGTACTACCACCTGTTGGAAG +TGTGTGGTTTGGACCGAGGACGTAATCACCCAAGGGTTCAGTGGTGTAGTCTCCGAGAAAAATTGCTCCC +GCGTGTTTTAGCTCCGGAAGGAGCGCCATGGGTTCCCTTACCATGACTTCAAGGTGTTCTGGAGCTATGT +AATTGGCAACCTCGCAGGCGTGGTAAAGGTCCTTCACCAGAAAGATTGTTCCGAATTTCTCTAGGGATTT +TTGAGCTATTTCCTTTCTTTCTAATTGAGAAAGAAGTCTTTCCACTTCTTCCTTTACCTTATTTGCAAGC +TCTTCGGAGGGAGTGAGAAGTATGGACGCCGCGAGTTCGTCGTGCTCCGCCTGAGAGAGCATGTCCGCGG +CTACCCAAGTGGGGTTTGCCCTTTCGTCGGCTATAACGAGGACTTCGGAAGGTCCTGCAATCATGTCTAT +GTCAACGGTCCCAAAGACGAGTTTTTTCGCAAGCGCCACGTATATATTTCCCGGACCCACTATCTTGTCA +ACCTTAGGTATTTTCTCCGTTCCGTAAGCTAGTGCACCTATCGCCTGAGCTCCGCCGACCTGAAAAACCC +TGCTCACTCCCGCTATGTATGCTGCTGCTAAGGTGTACTTGTTCGGTTTTGGTGACACCATTATTATTTC +TTCCACTCCCGCCACGGATGCGGGCACCACGTTCATTAAAACTGTTGAGGGGTAAGCTGCTTTCCCGCCG +GGAACGTAAACGCCCACTTTTTCTAAAGGAACTACCTTCTGACCGAGTATTATCCCCTCCTCTTCTTTGA +AGAAGGAGTTTTCCAATTGTTTTTCGTGGAATACCCTGATCCTGTTTTCTGCAAACTCAAGGGCTTCCCT +CACTTCAGGTTCTATTTCTTCGTAAGCTTTTTCAAGTTCCTCAAAGGGAACTTCCATGTTCTCGGGTGTC +AATTCTACTCCGTCAAACTTTTTCGTGAACTCTATAACAGCCCTGTCCCCCTCTTCCCTTACCCTTTTCA +GAATTTCCTTTACGCTCTTTTCGTACTCCTCTTCCAGTATCTCTCCCCTCTTTGCGAGGTACTCAAGCCT +CTCGTTGAGTTTCCAGTCTTCCTTTCTCAGGTCCTCAATCCTCATAATATGGATTTTAAGGTTTAATTAC +TGCAAGGTAAACGAGGAAAAGAGAAACGATTACAACAACGGGAAAAGCGACGTAATTAAACCTGTCGTAA +ACGGAGTAAGCCTTTTCACCTCTCTTTGGAACGTAAAAGTTGACCAAGTAGAAGTTTATAACCTCTAAGG +GAAGTATTACGAGGAAAACCAAATACATCTTAAGCCTTAACCATTCGGGAATATTGCCTAAAAGCTTTAC +CATGTAAAGTCCAGAAATCAGTGCTGTAAAAAAGCCAAGTATTTCCAAGTTTGTGAGTATTCTGTAAAAC +TTTCTCAGCTCTTTCTTATTACAACCCGTTTCCTTATAGTTTGCGTATTCCATGAATATCCCGAATGAAG +CGGAAGAAGAAGCCCAAATAAACAGCCCGATTAAGTGTAAGAACTTTGCCTCTAGGTAATCAATCATTTC +CTTTTCCACTCCATTAGCTCGTAAAGAACGGGGAGTAAGAATAAACTCAGAGGAAGTCCCGAGGCTATAC +CGCCTATTACCGCTATCGCAAGGGGTTTTCTCTGTTCGGAGCCCGCGGTAAGCCCGAGAGCGACGGGAAG +GAGTGCGGAAACCACGGTTATCGTTGTCATGAGTATAGGACGGAGTCTCTCACGCCTAGCTTCAAGAATA +GCCTCCCTTACCGCGTAGCCCTCTTTTCTTAGCTGTATTATCCTCTCTATAAAGAGAACCGCGTCCCTCA +CTATAATTCCCACGAGGAGTATTATCCCGAAGTAAGAAGAGACGTTCAGGGAGGTGTCCGTCAAGTACAT +AAACCCAAAAACTCCGAGGGCGCTTAAAGGAACCATTAAAAGAACGGTAAAGGGGTGCTTTAGACTCTCA +AAGAGGGAGGCCAGTATCATATAAACGCCTATTAAGGACATAGCCAAAGAGAGCACAAAGCCCGAAAAGG +CTTTCTTGAACTCCTTTACCCTTCCAGCGGTGTCGTAAGTGTAGCCAAAGGGCAGGTTTTTCTTTAGCCA +GTCTTCCACAAGAGACCTCGCGGTCGCAAGGTCAATCCCCTCCAGATTTGCGTAAAACACGAAGGAGTAC +TGCCTGTTGTACCTGGTTAGACTGAAAGGTCCTGCTTCAATTGAGAAGTCTATTAGTTCCGTTATGGGAA +TAAGTTCTCCGTTTCTTGCCCTGATGTAAACTCTGTTTAAGTTATGTATTTCCTTTACGAAGTCTTCTTC +GGCTTTTATATAGAAGTCATAACTCTCTGAGCCGAGCTCATACGTTCCCACCCTGTACTTTCCAAAGAGA +AGGGAGAGAGTAAGTCCAAGGTCTTCCACCGAAACACCCAGGTGTGAGAGCTTTTCCCTCTTTACACTTA +TCTTTACATAGGGGGCGCTGAGCTCAAGGCTAGTGTCCACGTCCCTGAAACCTTCAACGTTTGAAAAGTG +CTCTTCCATGCTTTTCGCTATCTTTTTCAGAACTTCGATCCTCTCACCCCTTACAATATATTGAAGGTCC +GTAGTTCTTCCCGCACTCGCACCTATACCATGGGGAGGTTCAACGCTGACTTTTACGTTCTTTAGTTCGG +AAAGCTCCCTTCTCACTTCACTCATAACGACCATCTGGTGAGGTCTTTGAGAACGTTCTTTGAGGTAAAC +GAAGAAGAGTCCGCTGTGAACACCCGCACCTCCCACTCCTTCTCCGACCACCATTCCCACCTTTGCGATA +TGCGGGTTTTTAAGGAGAATCCTCTCCACTTCCTTCGCTTTTTCTTTTACGCGTTCAAAGGAAGTCCCCA +CGGGCATCCTCATCCTCACCATAAATCTTCCCTCGTCAACGTGGGGAACGAACTCCTTCTTTACCTTAGG +AAATAGGTAAACGCTCAGCCCAACAAAGAAGAAGGAAAGGAGAAGGACTATAAACTTGTGGTCAAGGGAA +AACCTGAGAGCTTTGTCAAAGGATCCCTCAAACCTTTTGTAGAGTTTCATAAAGAAGTTCTCCCTCGGTC +TTTGGGTAATGAGCCTCACCGTGGCGGAGGGTGTGAAGGTAATCGCAACCAGGTAAGAGAGACCGATAGC +TATTATAAGCGTCAGGGCGAAATTCTTTAAAAAGGTTCCGAGAACACCTTTCAAGAAGACAACAGGCAGG +AATACCACGATAAGGACGGAAGTTGAGGCAAGGAGTGCAAACATAACCACTCTCGTTCCCTTAACGCCCG +CCTCAAAGGGAGGAAGACCCTCTTCCCGCCTTCTGTGTATGCTTTCCATAACGACTATGGCATCGTCTAT +GACTATACCCACCGCTACCGCAAGGGCAAGGAGAGTTATCGTGTTCAGAGAGTAGCCGAGCTGATAGAGA +AAGAAAATGGTTCCAAGAATCGTTACGGGAATTGCGAAGACGGGAACGAGTGTAAGGCGAAGGTTTCCAA +GGAAAAGGTAAACGGTAAACGCGGTGAGGAAAACCCCGATAATTATCTCCTCAAAGGCTGCCCTTATGCT +CTCCTTTACGTAAACGCTCGCATCAAAGGTGTAATCAAGTTTTATATCAGGAGGAAGGAGTTCCCTGAAA +AACTCCATTCTGGACTTTATCTCATCAATTACCCTTACCGTGTTTACCTTAGCCTGTTTGAACACCAGAA +GCGCCACCGCCCTATTTCCGTTAAACCTCGCAAGACTCCTCTCCTCGTCCTCACCGAAGTATACCCTCGC +CACGTCCCCCAATCTCAGGTTTTCCTTGATGTAGAGGTTGGAGAGTTCTTCGGGCGTTTTAAACTTTCCG +TAGAGTCTCAGTATATACTCCCTCCTCTTTCCGTAAACGTTTCCCGCGGGAATATCCTGATGGTTTTTGT +CAATTTCCCTAAGGACATCCAGAGGAGTGAGCTCGTAGCCGTAAAGCTCCGATACCTTCAACCGAACCCA +GAGGACGTTATCCCTGAAACCTCCGAGACTTACCGAACCCACTCCGTAGAGTTTTTCAAGTTCTCTCTTT +ATTACCTTGTCCGCGTAGTAGGTGAGTCTTTGGTAATCCGCCGTGTCCGAGTAAAGGAGTAAAACCATTA +TGGGAGCAACAGAAGTGTCCACCTTTACAACGGTAGGTGGCTCAACGCCTTTGGGAAACCTCCTCATAGC +CCTTTGGATAGCGTTGCTCACTTCCTGAGTTGCCACGTCTATGTCCTTGTCAAGGGTAAAGGTAACCACG +ACACTGGCAAATCCTGGATAACTCCTTGAGATTATGCTCTCTATTCCACTTACCGTTGATACCGCCTCTT +CTATTATCCTCGTTACGTTCGTGTCTACCACGTAAGGGTCCGCACCCGGATAATCCGCACTAATCCTGAC +TACGGGAAACTCAACATCGGGAAGCCTGTCTATAGGCACGAGCTTGAGGGAATAAAGCCCCAAAAAGACG +AAGGAAAGCATAAGCATAAAAGCGGTAACAGGTCTTTCAATGAAGAATTTCTGCATTTACTTAATTATCC +TTTAATTTATTTTTATTATGTAGTGGGTTAGAATATACTAACCGGAGGTGGAAAGATGGCAAAAGTTCTC +GTTCTCGGTGGCGGAATAGGAGGAACTGAAGCTGCGATAGCCCTTAGGAAAGAAGGCTTTGAGGTTAGCT +TGGTTTCTGATAAACCCTACCTTTACATATATCCCATATCTATATGGATACCTACTGGCGAGGCAAAGTT +CGAGGACGTTATAATCCCCCTCGATAAGTTCGCCAGAAGGTGGGGAGTAAATCTTATAATTGATAGAGTA +GAAAAAATAGACGCTCAGAATAAAAAGGTACACCTAAAGAGCGGTAAGGTTCTGGAAGACTTTGATTACT +TAGTCGTTGCCCTTGGACAGACTAAAAGAAAGGAAAAGGGACTGGAAAACACTCTATCCATATGCGGAAG +CCCTGAAGAGGCTCTGAAGATAAGGGACAGACTCGTTGAATTAATAGCGAAAGGAGAAGGGAAAATTGCC +TTCGGCTTTGGAGGAAACCCTAAGGACAAAACCGCGGTGAGAGGAAGACCCGTGTTTGAAGTGCTATTTA +ACGTGGATTACCACCTTTCCAGACTCGGCATCAGGGACAGGTTTGAGCTTACCTTCTTCGCTCCAATGCC +TAAACCCGGGGAAAGACTCGGAGAAAAAGCCCTCAAGATGCTCGACCAGATGTTCCAAAAGTACGGCATC +AAGAAAATTACGGGTAAGAAGATAAAGGAATTTAAAGAAAACGGAGTGCTCTTTGAAGACGACACGTTCC +TGGAATCGGACCTCATAATTTACACTCCCGCGGGATGGGGAAATCCCGTATTCGCGGACTCAGGCTTTCC +TTTAAATGAGGCTGGATTTATAAAGATAGAGGAAACGTGTCAGGTGGTAGGGTACGAGTGGGCTTACGCG +ATAGGAGACTCGGCTGCGATAGAAGGTCCTCCTTGGACCGCAAAGCAGGGACACCTTGCCGAGGTTATGG +GACACATAACCGCACATAACATAGCGGTAAAAGAAGGAAAAAAGAGCGGAGAACTGAAGTCCTACAAAGA +GCACATAAACATCTTGTGTCTCATGGACATGGGCTGGAGAGGTGGAGGATTCGCTTACAGAAGCGACAAG +AGGGCTATGCTAATCCCAATACCTGTCCTCGGTCATATCATGAAAAAGGCTTGGGGAGTTTACTATAAAC +TGTACAAGCTGGGCAAAATTCCTAAAATTATTTAGAGGCCCGGAGGAGTTTTATGAAAACACTTTCCGTG +GAGAGGATAAAGGAAAAGGTTATAAATGGGGAGAGAATTTACCCTGAAGAAGCCCTCTACCTTTGGGAAA +ACGCCGACTTTGTAACCTTAGGAAACCTCGCAAACTTTGTGAGGAAGAAGTTCCATCCCGATGACATAGT +CACCTTCGTTGTGGACAGAAATGTAAATTACACAAATGTCTGCATAGCCGGGTGCAAGTTCTGCGCCTTT +TACAGGAGAAAGTCCGACGAAGATGCCTACGTTCTGGATATGGATACGATACTTCAGAAGGTAAAGGAAC +TCGTGGAGTGGGGCGGGACGACGCTCCTCATGCAGGGAGGAATTAATCCGGACCTCCCCCTTGAGTTCTA +CGAGGACATGATTTCTCAGATAAAGAAACACTTTCCGCAGGTTCAGATACACTGCTTTTCCGCCCCAGAA +ATAGTTTACCTTTCCAAGAAGGAAAAACTCCCAATAGAAGAAGTTATAAGGAGGCTCAAAAAAGCAGGAC +TCATGTCCATACCCGGCGGAGGAGCGGAAATACTTTCTCAGGAGGTAAGAGACAAGATAAGCCCCGGAAA +GTGTACCGTAGAAGAGTGGGAAGAAGTTCACAGAACGGCTCACAGGCTCGGCATGACCACAACCGCTACG +ATGATGTTCGGACACGTAGAAAGCATTGAACACATAATTGAACACCTTGAGAGAGTAAGGAAGATACAGG +ATGAGACGGGAGGATTTACCGCCTTTATCCCGTGGACCTTCAAGAAGGGAAACACTGAACTTGACTTCGT +GGAAGAAGCTACACCCACATACTACCTAAAAGTTCTGGCACTCTCAAGAATATACCTTGACAACTTTAAA +AACATTCAAAGTTCCCACGTTACACAGACTATGCAAATCGGACTCATAGGACTTCACTTCGGGGCTAACG +ACCTTGGAAGCGTGATGATAGAGGAAAACGTTATATCTTCCACAAACTTCAAGGTAAGGATACCGAAGGT +AGAGGAAATGGTGAGGGCTATAAAATCCGCGGGCTTTATCCCCGCACAGAGGGACACCTACTACAACATT +ATTAAAGTCTTTCAATGAAGAAAACTAAGTTCTCCTCCTACGAGGAATACAGGAATTACTTCAAAAGGTT +AATAGACCTGGAGAGAAGGGCTCAAACGGAACTCCACCTGAAGGAGATTAAAACCTTAAGCGGTAAGGAA +AGGGAAAAGAGGGGAAGGGCTATTTTGAACTTGAGGGCAAAGTTCCTCGGAAGGGGGCTCGGAGGAGTTT +ACCTTGTGAGATACTCAAGACCTCAGGGACTCCCGAAAACGGAGATATCAACGGGAGATATAGTTCTCGT +GAGTAAAGGAAAGCCCACTGTCAAGGAAGTTCAGGGAACGGTAGCAGAAAAAACGAATTACTATTTGGTA +GTTGCCTTCAGGGACAAACCCCCTCCCTATGCTCTCGGTAAAGACGTGAGAATAGACCTCTTTTCAAACG +AGATAACCTTTAAGAGAATGGAGGAAGCCCTGAAAAATTTCAAGGAACATCCCTTGAGGGACTTTATTCT +TGGAAAAAAAGTTTAAAATACTTAAAAGGAGGTGGAGAAAATGAAGTTAAGATATGTATTTTTAAGTGCA +CTCGCACTAGGGATTTTCGCCTGCGAGCAACCACAAAAGAAAGAGGAAACAAAGAAGGAAGAGCCCAAGA +AGGAAGCTGTAGCTCAAAAGCAGGAAGCTAAGAAAGAGGAGCAAAAGCCTCAAGAACAGCCAAAACAAGA +GCAAAAGCAGGAAGTTAAGCAAGAAGAGCAAAAGCAAGTGGCTCAAGCCGGAGGAGCAGGCAACCCTGAA +AAAGGAAAGGCAATCTTCCAGCAAAAGGGATGTGGTTTTTGCCACCAGCCGGCAGTGGACACCGTAGGTC +CCTCTCTCAAGAAGATAGCTCAGGCTTACGCCGGTAAAGAGGACCAGCTCGTTAAGTTCTTAAAAGGTGA +GGCTCCCGCAATAGTAGACCCTGCTAAGGAAGCAATAATGAAGCCTCAGCTCATGCAACTCAAAGGTCTT +TCTGAACAAGAACTCAGAGACCTTGCAGCCTTTATAATGTCCCACAAGTAATTCCTTTTCTCCTCTTTCC +TTTGTATAATTTTCCTTTATTCCATTTGAGGAGGTTGTTATGGCAAAGGTTAAGATGAAGACTAACCGCT +CAGCTGCGAAGAGGTTTAAGGTGACCGCTAAGGGTAAGATAAAGAGGTGGAAGTCCGGCGGTGCCCACTA +CAACACAAAGAAGTCCTCAAAAAGGAAGAGACACCTAAGAAAGCACACCTACGTTAAGGACAACATGCTC +AAGCACGTCAAGGCACTCCTGAAGGAGTTTTAAGCGGTTCAAGAAAAGAAGTGTGAATTACCTTTTCTTC +TCCGTTTTCAAATCTAACCTTTGCCCTCTCTTCTTCAATCCTTAAAACCACACCCTTTCCGAAAACCCTG +TGGATTACTTTATCTCCCTTCTTTATCAATCTATTGGGCCTTAAATTTTCTTCGTAAGCGACCTTTTTCT +TCTTTTTGAAGGCGGAAAGGTCTAAGAGGTGCTTCGGAATGTCGGACAAAAACCTGCTCGGTTTTCTGTT +TTCTTTCTTGGTGTAACTCATAAAGAGGAGGTCCTTTGCCCGCGTAATCGCAACGTAAAAAAGTCTCCTT +TCCTCTTCCAGTTCCCTTTCACTCTCCTGAGACCTGTGGTGTGGGAGTATACCCTCTTCAAGCCTCGGAA +GAAATACCACGGGAAATTCCAGACCTTTAGCGGAGTGTATAGTCAAAATTTTTACGGCGTTTTCCTCTTC +CTCTTCTTCCGAGGTCAAGGTTATTTCCGCGAGAAGGTCCTCAAGGGTGTAAGCCTTTGCGTAAAAGTCT +TTCAGGGAGCTTAAAAACTCCTTAACGTTTTCAATCCTCTCCTCGTAATCCTTCTTGAACTTTTCCTTTA +ATAGTTCGTAGTAATCTATCTTCTCAACGAAAGCTTCAAGTCCTTCGTGGTACTTTTCGGGGTTTTTGTA +AAGGGGAACCACAGCCTTCAGGAACTCATACGCGGAAATTGCGGCGTTTTTGGGAAGCTTTTTAAGAGAC +TCCTTGAGGGCTTTAAACCAGTTCCCTTTAAAGTTTTTCTTCACTACTTCAAAACTCTTATCCCCAAAAC +CCTTAACAAAGAACTCCGTTAGCCTTTTAAAAGCCACCTCGTCCGAAGGGTTGTAAATAAGCCTCAGGAG +TGCAATTAAGTTTTTTATCTCAATTCTTTCGTAAAACTTTATAGTTCCCACGACTTTGTAGGGAATTCCC +GCCTTGAAGAAGGTTCTCTCAAAAACGTCCGTTATGTATCCGACTCTCACGAGAACCGCGATGTCTTTCA +GCTCATACTCTCCTGCCAGTTCCTTTATCTTCCGGGAAATCCAGAGAGCTTCTTCTTCCTCGTCCTGAAA +GCGTCTAACGTAGGGCTTTTGTCCTTCTCCCCTTACTCCCCTCAGTTTCGGGATTAAATCCTTCCACTCT +AGGGTAGAAGCCTCCAGAACCGCGTTTGCTACTCTGAGAATAGGCTCTCTTGAGCGGTAATTGAGTTCAA +GTTTTATTATTTTCGGGTTGAAGTCTTCTATGAACCTGAGAATGTTGTCCGGTCTTGCGTCCCTCCACTC +GTATATACACTGGTTAGGGTCCCCTATAGCGCATATGTTTTTATTCGCAAGGAGTTTTAATATCTCATAC +TGAATGTTGTTCGTATCCTGATACTCGTCCACCATTATGTACTTGAAAGTGTTCCTGTACTTTTCCCTTA +CCTCGTCCACGAGAAGCAGGTTGTACAGTTCCCTCATCAAATCGGAAAAATCAAGGAGTTTATTCTCTCT +AAGTACCCTCTGGTACTCCTCTAAAAGCACACCGAGCCATGCTTCTGGCTCTTCAAAGTTTTCCTTAACC +TTTGAGATTTTTTCCTTCACTTCTTCCGGTTCCTTTTTCAGACCGTACTTTTTAAGGATTTCCTTTACTA +TCAGAGTCGTGTCCTTCTCGTCCGCTATTGAAAAGTCCTTGGGAATTCCTATCTTTTCTCCGTCCTTTTT +CAGGATTTTCAGGGCTACCGAGTGAAATGTTCCGCTCCACTCAAGCTCAAGCCCGAAGGTGTTTTTTATC +CTTTCTTTTATCTCCTTTGCCGCTTTGTTCGTGAAAGTTATACAAAGGATTTCGTAGGGCTTCAAACCTT +TTTCCTTTATCAAATACTCAACTTTGTGGGTAAGGGTTTTAGTCTTTCCCGATCCCGCTCCCGCCACGAC +GAGCAGGGGAGAGCCGAAATGCCTAACAGCCTCTTCCTGTTGAGTGTTGAGTTTCATTTTTATGGATTTT +ATACTACCCGTGTATACAATAATTTCTTATGAGAAAAATAATCTCGATGCTTTTCATACCCTTGTTCATC +TTCGCTATGGCGGAACCCGCAGGTGCCCCACCGGAGGTAAAGAACATAAAAATACTCGTACTCGACAGGG +CCGGGAAAAAGCACGAGCTCAAAAGCCCTCTCTGCGAAGGACTGTCCTACCTTAAAGTAAAGCATGGAGG +TATTGAGTACTCCGTTTCCTTGACAAGTTTAGAAGAGATAGAAGTTCTAAGCGTAAGCGGTGATGTGGCC +AAAATAAAGTTAAAGTACAAAAACGGAAAGGAGGAGATTTTCGATATATCTGCAAATACACTGTGTACGG +GAACTTCTGACTTCGGAAATGCCTCTTTTTACCTGAAAGACGTACAAAAAATCCTATTCAGGAGAGGTGA +AAAATGAAAAGGATAAGCTTCATTCCTTTGTTAATCCTCGTGTTCTTTGCAGGTTTTATCCTGGGCCAGA +GTTCGGAGAATAAGAAGGAAGAGGACAAGTACTTTTACCTTAAACTCTTTACGGAAGCCCTTAAGATAGT +AGAGAGAGAATACGTAGAACCCGTGCCGATAAAGAAGCTCATATACGGGGCGATAGACGGTATGGTTTCC +TCCTTAGACCCATTTTCCGACTTCTTCACCCCCGAGGAGTACAAGGAATTTCTCTCGGAAACTGAGGGAG +AGTTCGGTGGCGTGGGTATAGAAATCACCATGGAAAACGGAAGACCTGTGGTGGTATCGCCCATAGAGGG +AACGCCTGCCTGGAAAGCCGGAATAAGACCGGGTGACATAATAATAGCGGTAGACGGCGAGGATACCTTC +AACATGTCCTTGATGGAAGTAGTCAAAAAGATAAGAGGAAAACCTGGAACAAAGGTAAAGCTCACGATAC +TGAGAAAGGGTGAAGGGAAACCTATAGAGGTAACACTGGTAAGGGCGAGGATAAAGGTTCCCAGCGTTAA +GTACACCAATTACAAAGGAATAGGATACATAAAAATTTCTCAATTTACTTCGGGAACCTCTAAGAGTTTG +GAGAAAGCCATACTGGAACTTGAGAACCAGAACGTGAAAGGCTTCATAATAGACCTCAGGAATAACCCCG +GAGGACTTCTGTCGGAAGCTGTGGATGTAGGAGATCTCTTTATCCCCAAAGGAAAGTTGATAGTTTACAC +GAAAGGAAGAAAGGGAGAGCTCCACAGGTACTTTGCCGAGAGGGAACCCATAACACAGGGGCTTCCCGTA +GTGCTCCTCGTTAACAAAGGGTCGGCAAGTGCGTCAGAGATAGTGGCGGGAGCCCTTCAGGATTACCACA +TAGCTACACTAGTGGGAGAAAAGACCTTCGGTAAGGCCTCCGTTCAAAACCTGATACCCCTCTCCGACGG +CTCTGCTATGAAATTGACCATAGCCTACTACTACACGCCTAAGGGAAGGCTCATACACAAGAAGGGTATA +AAACCCGACGTAGAGGTTAAAATGGACGAAGAAACTTGGAAAAAGCTCTTTGAAACTATAAGGAAAATGC +GCTTTGAAGGACACATGGAAAAAGTGATACTCCTTCCCGACATAGACGTTCAGCTGAGAAAGGCTATTGA +AATACTGGAGAAAAAGGCTAAACTCAAAAAGGCAGCATGAGGACATTAGCAGTTGAGACCTCGTGTGATG +AAACCGCTCTTGCTATTTATGACGACCAAAAAGGCGTACTGGGAAACGTAATACTTTCACAGGCCGTAGT +TCACTCCCCCTTCGGTGGGGTCGTTCCCGAACTCTCTGCAAGGGAGCACACGAGAAACATACTTCCTATA +TTCGACAGACTCTTAAAGGAAAGCCGAATAAATCTTGAGGAGATAGACTTTATTTCCTTTACCCTAACTC +CCGGATTGATACTTTCGCTCGTGGTGGGTGTAGCCTTTGCAAAGGCCCTTGCCTACGAGTACAGAAAACC +TTTAGTTCCCGTTCACCACCTGGAAGGTCACATATACTCTGTTTTCCTAGAAAAAAAGGTTGAATATCCC +TTTCTCGCTCTGATAATTTCAGGTGGGCACACGGATCTTTACCTTGTAAGGGACTTTGGGAGGTACGATT +TTCTCGGAGGTACTCTGGACGACGCTGTCGGGGAAGCCTACGACAAAGTTGCAAAAATGCTCGGTCTGGG +ATACCCCGGAGGTCCCATAATAGACCGACTGGCTAAAGAGGGAAAGAAATTATACCCTTTACCCAAACCA +CTTATGGAGGAAGGAAACTTAAACTTCTCCTTCAGTGGGCTTAAAACGGCGATACTGAACCTCTTAAAAA +AGGAAAAAAACGTAAGGAAAGAGGATATCGCTTACTCATTCCAGGAAACGGTGGTAGAAATACTACTCGA +AAAAAGCCTCTGGGCTATGAAAAAAACGGGGATAAAAAGGCTTGTTGTGGTAGGAGGAGTGTCCGCAAAC +TCGAGGCTGAGGGAAGTGTTCAAAAAAGCTTCTCAAGAGTACGGTTTTGAACTCTACATACCGCATCCGA +GTCTCTCTACGGACAACGCCCTTATGATAGCTTACGCCGGTATGGAGAGGTTCAAGAGGGGTGTTGTAGC +ACCTCTGGATGTAAATCCCCAACCCAATATTCCCCTGGAGGAGTTCGGAAGGATATGGACTTGAAGCAAA +TTCCAAAAGTTTTATAATTTATTAATTGGCACGGGGTGTAGCGCAGGTGGTAGCGCGCTGGCATGGGGGG +CCAGAGGTCGCCGGTTCGAGTCCGGTCACCCCGACCACTTTCCTATGAAACTACTCTGGCTTCAACGACT +TTCATGTTGTGGTAACACTCACTCCCTCCTATCCTCGGAAGAGGCAAATCTCCTGTTTGAAGAGTTTGAA +GTTCTTTTCCACCCCTCTTTTTCCACGGAAAGTGAGGAAGATGTCATAGAAAGAGTCTTAAAAGGAGGAA +AGCTAGATCTTCTGGTAGTTGAAGGAGCTGTAAAAAGGGACGATGAGGTTATTAAAAATCTCTGCGGTAT +TTCCGATTACGTTGTAGCCGTGGGAAATTGTGCGGTCTACGGAAATATTCCCGCACTTTCGGAGGACAGC +GTCTTCGGACTTCAATACAGGTTCAAAGAAAAGGGTGGTATTCTGGGAAAAGATTTTGAGAGTAAAAAAG +GGTATCCGGTCATAAACCTGTCCGGCTGTCCTGCAAATCCCGAGTGGATAGTCGGCACACTCTTGAGGAT +AAAGTGGAAAGGTAAACTGGACTTGGACGAGCTGGGGCGCCCAAAAGAGTACTACTCTTCCCTTACCCAC +TGGGGTTGTTCCAGAAACGAGTACTTCGAGTGGAAGGTGGAGACGGAAAAACTCGGCTCTCCTAAAGGTT +GTCTCTTTTACCACTACGGTTGCAGGGGACCAATGACCCACTCCACTTGTAACGTTCACCTGTGGAACGG +TGTGAACTCAAAAACGAGGGCGGGCACCCCCTGCTTTGGATGTACGGAGTACGACTTTCCAAGAGTTAAC +CTGTGGGAAACAAAGCTTTACGCTGGCATACCGGCGGAACTACCCTTGGGAGTTTCCAAGAGGGGATACA +TAATGATATCCGGGGTGGCAAAGATGTTTGCTCCCGAAAGGTTGAAAGATGAAGATTGAAAAACTGGTTC +TCACCCGCGTTGAAGGGGAGGCCTCTTTAAACCTCGTCTGGGAAAGGGGTGTTATAAAAGACGCAAAAAT +TAGTTTTTACTCTACAAGAGGCATAGAAAAGGTTCTAAGGGAAAGACCCTTTATGGATGCTTTAGTTATA +AACCCGAGGATTTGTGGCATATGCGGGCACGCACATCTCATAGCCACGGTGAGGGCAATAGAGAACGCTA +TAGGTATTAAAGAAATACCTGAAAAGGCTAAGATTACTAGACTCGTAACCCAGATAACGGAAATGGTTCA +AAACCACGTAAAGTGGTTTTACCTCTTCGTAATGCCGGACTTCCTGAAATTTAAGGAGAGTTTATCCCAG +TTCGAACCTTTTAAAGGAGAAAGGTGGAAAAGAGCCGTTCAATTTTCCTCTCAGATAGTGAAGATTATCG +CCCTCTTCGGAGGACAGTGGCCCCATTCCTCCTACGCCGTTCCCGGAGGAATTACATCAAACTTCTCGGA +AAGGGAAGTCCTGAAAGCTTTAAACCTTGTAAAAGAGGGAAAGACATTTTTTGAAAAGAACGTTTCCGAA +GATTTAGAGCTTTTCCTGAACCTGTGCGAAGAATTTAACCTTTTGAGTATAGGGAAGGCTTACAATAGGT +TCTTGAGCGGAGGCGGTTTAGCTTACTGTTTTAACCCGTCCTACAAAAAGGGAAAGGGAAAAGTGTGTAA +GTTCAACGTTAGATATGTGCAGGAACTCGAAGCAGCCGATTACTCAAAAGCTAATCCCGTAAGGTACAAA +GGCTTACCTTACGAGACAGGGCCCCTCGCCCGAGAACTGATCTCTAAAAATCCCCTTGTCCTGAAACTTT +ACAAAAATTACGGAGACAGTTACGCGGTGAGAGTTGCGGCAAGACTTGCAGAGATTAAAGATCTACTCGA +AATCCTTGAAAAGCTTTTGAAAGAATTAATGAATCACTTGGAAGAACCTTCGTGTTTATGGGAGGATCGC +AGTGATGAAAGCGGTGAAGGGTTCGGAGTTGTAGAGGCGGCGCGGGGAACACTCATACACAGGGTCGTAA +TAGAGAAAGGGAAAATAAAGGATTACAAAGTGATAACTCCCTCCCAGTGGAACCTAGGACCGCGGTGTAA +AAAGTACTTGGGAGTGGCTGAAAAAGCTATCGTAGGACTGGACAGCGAACTAAAGGCTCAAATGGTTCTA +AGAAGTTTTGACCTCTGTTCCGTATGTACCACGAAGTGATTACTTAATCACCGTCAGGAATATACTGAAC +TCACCATTTTTAACCTTGTACTTCGTAATCGATAACTTACTCCTGAACTGTTTGGGAACCTTCTGGTAAA +CTTCCGAAGCCTTAAAGGGCTCGAGTGCACTCATCTTCAAGTAATCACCTTCCCTTGAAAAGTGTTCGTT +CTTTGTTAAAACGTCTAAACCTTCCGAGGAAAGGATTTTCAAGTAAACTCCGAAGTCCGTAACCTCGTCA +CCTTTTTTCTCGTTGTAAACCTTGTTTGGTTCCTCTTTTCCCCTGAACTCAAAGGACCTGTTGAATAAAA +AAACCCTTTTCTTTCCCCTTATCTTGACAACTCCGTCCTCAAAGGTGAACTCAAAGTCTGGATAAGCCCT +CTTGAAGTCTTCGGGTTTTAGTGGAACTTCTACCTCGTTGTCTATCAGGTTTCCGAAGTGGAGTAGATCT +TCTATGAATATTCCCATACTTTAATCTTTATACACCATCTTCCCGTCTTTTATGGTGTAAATCACTTTAC +CCTTGAGAACTTTGCCCCAGAGGGGTGTGTTCCTGCTCTTCGAAAGGTTCGTCTCTTCGTTCAAAATCCA +TTCCTTATTGGGATCAAAAATAGTTATGTCCGCGGGACTTCCCAGTTTCAAGGTTCCGAGGTCTACACCG +ATTATCCTTGCAGGGTTGATTGTAAACATCTCTATCAACTTCTTGAGTGAAATTATTCCCTTTCTGTAGA +GTTCAAGAGCCGAGGGTAAAGCTGTCTGGAGCCCAATAATACCGGGCATCGCAAACTCAACGAGCTCCTT +TTCAAAAGTCTGGTGCGGGGCGTGATCTGTGGCAAAGCAGTCTATAATTCCTCTTTTCACACCTTCTATC +AGGGCCAACCTGTCCTCTTTCTTTCTGAGTGGAGGGTTTACCCTTGCGTTTGCCCCCGAGTTCAAAACTT +CCCTTTCCGTAAAGAGGAGGTGGTTCGGGTTTACCTCGCAGGTTATCTTCACTCCCTTTTCTTTGAAAAA +CTCTATTATTTCTAAGGAAAGCTTTGTGGATACGTGCTGTATGTGGACGTGTCCCCCTGTTCTCTGTGCC +AGTATCCCATCTCTCGCTATCTGGATCTCCTCAGCCTCCGGAGCCCTTGAGGAAAGTCCCAGAAGGGCGG +AAACCTCGCCCTCGTTTATCACACCGTAGGCGAGTTTGTCGTCCTCGCAGTGATCCATTATAGGAACACC +GAGCTGTGAGGCGAGTTCTAAGGCTTTTCTCATCACGGAACTGTCCATTACGGGACTGCCGTCGTCCGTA +AAAGCCACACATCCCGCCTCTTTTAAAGAGTAAAAATCCGCAATTTCCTTTCCCTTTCTTCCCTTGGTTA +TAGTCCCAGTAGGAAGAACCCTGCAAAGTCCGACACTTTTAGACTTCTGGAGAATGTAATTAACCACCGT +TGTGTTATCAATGGGAGGGTTTGTGTTCGGCATGCATACGATAGTCGTAAAACCTCCCGCAACGGCACAC +CTGCTTCCGCTCTCTATATCCTCCTTGTAAGTCTGCCCCGGATCTCTCAGGTGAACGTGTATGTCTATAA +ATCCCGGGCACACTATTAAACCCTTTGCATCTATGATTTCCGCCTCGGGGACTAGGATGTTTTTATCTAT +CTTCTTTATCTTTCCATTTTCTACGAGGATATCAAACTCCCCCTCGAGATTTTGCGAGGGGTCTATTACG +TAACCGTTTTTCACGATTAACTTTAGCATTTAAGACATTATTTTAAAAAGGCTTCTTCAGTTCCTCTGAC +AATATTAGTTCCCTTTTCTTCTCCCAGGCAAGTCTCCTGTAGATGCTTACTCTAACTTTTTCGAGTTTTT +CATAGCGCGGGATTTTCACGGTGTAAGGTATGAGGTAGGCAAGGGCTGTTTTTGCCTGCGGAGAGAGTAC +CCTTCTTAGAACCTTTTTCTTTCCGTCTTTGTAATAAAACTCGATTATTAAGTAAAGCTTTGGATTTCCC +TGATCCGCCGTGGGCAGGTTGTGAGGTATACCTACGTTGATTATGTTAAGGGCTCCCTCAGTGAGGATAA +GTTTTATGTCCTTGGGTGTTGCTTTACCTGCGGGGAACGTGTGGTCGTGAAGGGCTTTTCTGGAGTGAAA +GAGGAAGAAGGGAAATTTGTCCATAATCCATGCGTAATCTACAACCTTCATATGGCACTGCTGACAGGTA +GTTTTAACCCTTGCGATTTTCCACTCTCTGTACGTCTTTTGATGGCATCCTGCACAGATTTCTGACTTCG +TGTAATTCTTATCCTCCCTTGAGGGGTGAGGGGGAGAGAAGACTTTGTAGGGACCGTGCATGGCTTTGGT +TTCTTCCTTAAAGTGACAGGCTATACAGTTTACACCCTCGTGTCTCCTCTCCACCCTTAAAACGGGTTTC +TTTAAGGGATCTACTTGATGGGGAGCGTGACAGGAGAGACACTTGAGCTTTGAGTAATTTTCACTTTCCT +CCTTGAAGTGTTCGCTCACCCACGCTTTTGCGTGCCTGCTCTTTTCCCAATCCTCGTAGATTTTTGCATG +ACAGTCAGAACACCTTTTGGAAGGAGGTCTCTGAAGTAGATCCTCCTCTAAAAATATCTCGTTTAACTTT +TCACAACTAAAAAGGAATAAAGAAAGTACGAGAACGAGCCAGATCATTTAGCTAGTGCTTCTTTTATCTT +TGCGGGTATCAGGTGAACGTTGTGACAGGTGTAGCACGTAACCGTTACCTTTTTCATATTCTGAGCAACT +TTTTGGGTGTCCAGCTTTTCAGCGTTAAAGAGGTTTTCCAGAGCCTTTAGGGCCTGATCGTACTCTTTCC +CCGTTATGGCTTCCACTTCCGCTTCTTTTGTGTGACACTTTGTGCAGGTTTCCTTAACCGCCCTTGCCCT +TTCAACGAAGTTTATCCCGTGTTCTTTAGCCTTTTCGTATTCCCCTTGAGAAATGTAAATGTTCGTAGCT +TTGAGGGAATTTGCGAGCTTTTTCATAAAGTCTCCGAGGTCCATTTCCATAAACTCTATAGGATCCTCAA +CCTTTACGCTGTGAAAGTCGGGAAAGTGGTAATAAATCTTTACCGCTACTTCGTTATCCCGGTGGCACTT +TGCACAGGTCTGACCCAGTTCCCTTGCAGTCTTTATAACAGCGTCTACGTTTTTGGAACTTACGGCGTTG +AGGTAGGCGTCAGCCTTAGAGAAATCAAAGTAATCCTTCCACTCGGGAACCATTTCTGCAGTTTCTCTGT +AAGTTTTCACGAGTTTTTGAGCCCATTCTTTAGCCTTTTCCCAGTTTTCGTCGTTGATGTTTAACTGAAC +CGCGTAAAAGGCCGTGCTCATGGTGTGCATATTGTTTAAAAACTCAAACTTCTCCGAAGCGGGAGGGTAG +TACTTCTTCAAGCTTTCTGGAGGCTTCTTTAAAGTAATTTCGCCCCCGAAGGAAAAACTTAAAACTGCCA +AGCCCAGCAAAAATTTCCTCATCTCAGCCCCTCCATAACGGGTTTAACTCCGACCCCGTAATCATAAACC +AACCTTCCTCCCAGATTTCCCTGAAGAATTACCAAAACAAAGGTTATTAAACCAAGAACCAGAATAAAAA +CTCTTAAAAGATTTGAAGGCTTTAAGTAATTGAAAATCTTCAGTATTCCTAAAAGGGTTATCGCAATAGC +CACGATAAGTCCAAGGGTTTCGTGATACTCAAGTATGTTGTAAGCAGGTGTATTTTCTATAAGCTTTTCC +GCTTTTTCTTCGTCCAGATGTCCCGTAAAGAAGGCAAGCCACGCAAAAATAACCGCGAAACCTAAATTGA +GCAACGCTCCTGCGTTGAATATATCTCTTTTAAACGTGAACCATAAAACTTCGAAAATTATCCCCGTAAT +CGTCAACGCTATTGTGAAGTGAACTATCGGCGGATGGAGAACCTCCATTTTAGCCCCTCCTGTTTAAAAT +GTAGTTCTCTATTTAAAATATTCACTAACTTATAATTATTACCGATGGAAGAGATACTTATATGGATAAA +GAAATTAGAAAAGTACCTCTATGCGCTTAATGCGAAAGTGGCCGGAATACCTCTTTACAAAATAATTATT +GCATCTGCAATTATGCTTTTTACCCTAATTTTAAGGAGACTTATAGCTTTTTTAATAGTTAAAATCTTAA +CGAAATTAACTATAAGGACAAAAACTGATGTTGACGAATTAATAGTAAAGGCATTCGTAAAGCCTTTTAG +CTACTTTATCGTTGTTTTTGGTTTTTATTTATCCCTTTTAGTGCTTGAAGTTCCGAAGGTTTACGCAGAT +AAATTTCTTAAAACTTTTTCACTGCTTATACTCGGATGGGCAATTATAAGATTCTTGAATCTATTTCACA +ATAAAATTGTGGAATTTTTCGTAAAAGTTGGGGGAAAAGACTTTGCTGAAGAGGTAGGAGATTTTATTTT +AAAGATTTTAAAGGCCTTTGTCGTTGTTATCGTAGGTGCTTCCCTTCTTCAGGAATGGGGAGTAAATATA +GGAGCTATCCTCGCTTCCGTAGGACTTTTGGGTCTTGCCGTTTCACTAGCGGCTAAAGATACCTTTGAAA +ATATACTGAGCGGATTAATAATACTCTTAGATAAACCTGTGAAAGTGGGTGAAACGGTAAAAGTTAAGGA +TTTCATGGGAAGTGTTGAGGACATAGGTCTGCGTTCAACGAAGATAAGAACCTTTGACAAGTCTTTAGTT +ACTATTCCCAACAGAGATATAGTTAACAACCACGTTGAGAACTTCACGAGGAGAAACAAAAGGAGGGTAA +GGTTTTACATAGGAGTGGTTTATTCTACAAAGAGGGAGCAACTTGAAAACATATTAAAGGAGATAAGGGA +ACTTTTGAAGGAGCACCCCGGAGTAGCGAAGGACGAAAAGTTTTACGTTTACTTTGAAAATTACGGAGAT +AGTTCCCTAAATATACTAATTCAATACTACGCAAATACGAACGATTACGAAGAGTACTTGAAAATAATAG +AAGACATAAACCTTAAAATAATGGAAATAGTTGAGAAAAACGGAAGTTCTTTTGCTTTCCCAAGCAGATC +TGTATACATAGAAAAGATGCCGAAATCTTAACTTTTCTTTTTTATATACGCCACCGCTACAGAATAATCC +CTCTCGTGAGACAAGGAAACTATCACTTCGTAATTTTTCAGGATTTCTTCTACTCCTTCTCTGTTTATTA +CAACCGTTGGCGGTCTTCCTCTATTCCCGAGTATTTCTATCTCCTTAAACCTCAAAAAAATTTTAAATTC +GGTGTAAAAGGCTTTTAAAACAGCTTCCTTCCCCGCCCACCTCGCGGCGAGGCAGGGAAGGAAATCGCAG +TGTGCGTAGCAGTATTCAAGTTCCCTCTTCGTGTATATCCTGTCTAGGAATTTATCCCCGAAGCGTTCAA +GGGCATCCTTAATCCGTTCATTCTTCACTATATCCACGCCTATCATTTAGCGTTTTGCTGTTGCTGGGGA +GACTTGTAGGGGACGGGTATGTACTGAACGGACGGCGGTTGGGAACCCATCGGCTGTTCGTAGAGTTCCA +TGAGTTCGTAAACCTCTTGGGGAACGTTTGTGTTTACAGGCAGTCCGAGACTCTTCAAGTATTCTACGGT +TAAGGGATAGTCGTGTGTGAACTTTCCGGTTGCGAGCTCTTCCGCTATTTTCTTAGCCTTTTCCTTATCC +ATTCCGTTTTTTGTAAGGAGATCTACGAGGCAATCCACCATTTGTTTTATAGCCTTTTCGGAGACGTCCG +CCATAATAAGGGTCTGGTCGTCGATGTCCTTGGGGTCCTTTTTCTCTAAAACCTTTAGAATAGAGGCTGC +TGGCATGTTTCCTATTTGAGGGTCAACGGGTCCGAGAACCGCGTTTTCGTCCATTATTATCTCATCTGCC +GCAAGTGCTATCAGAGTTCCACCGGACATGGCATAGTGGGGAACTATGACTCTTACGGGAGCTTTGTGCT +TAACTAAAGCGTTTGCTATTTGGGTTGCTGCGAGCGCAAGACCTCCGGGTGTGTGTATTATAAGGTCTAT +GGGCATATCGTCGGGAGTCATCCTGATAGCCCTTAAAACCCTCTCACTGTCCTCAATAGTCATGAACCTG +AATATGGGAATTCCCAGAAAACCAATTTGTTCCTGTCTGTGAATCATAGTTATAACCCTGCTCTTCCTCT +TTTCCTCCAGTTTCCTTATTACGTCCTCCCTCGCCTTGATAAGAGCCATACGCTTGTACCAAGGGGAGAG +GAGGATAAAGACAAAAAGTAAAAACCAAAGTAAGCTGAAAAGGTACGAAAACGGGTCGTAGTAGGGCATT +ATTCTCCTCCTCTTAAAACATTTCCAATAATAAATTCTACGATAAATCTGGCATTTTCCAACTTAGAACC +TTTCGGAAGTTCAACTATCTGGTCCTTTGTTATCAAATACCCTTCGTGTTCCTTCTTTCCCATAACTTTT +ACAGGATTTGCAACGATTAAATCAAGATTCTTCCTCTCAAGTTTTTCCCTTGCGTACTCAAGAAGGTTGT +CACTCTCCAGTGCAAATCCCACCAGAATTTTATATCCCTTCTTCCTTCCGAGTTCTTCCAGAATGTCTGG +ATTCTTCACGAGTTCTAAAAGGATTTTATCCCTTTTCTTTATCTTTTCTTTACTAACCTTTGAAGGCTTG +AAGTCTGCAACAGCTGCGTTCATGACCACTATATCCGCCCAGTCGTAGTGCTCTAGAACCTTTTCTCTCA +TCTCCTCTGTGGTTTGAACTCTTATTATCTCCACTTCAGGAGGTTCTTTTGCCGTAGTAGTTCCCGCAAT +TACTTTCACTTCTGCTCCCTTCCACCTGAAGATACGGGCAAGTGAAAAGCCCATCTCACCGCTTGAGTAA +TTTGATATAAATCTTACGGGGTCTATAAACTCCTTTGTCGCACCGCAGGTAATTAAAACCTTCTTTCCCT +TTAAGGGTTTTTCTTCGGATACGTAATAAATCCAGTCTATCAATCTGTCAATGCTCGCCAGTTTCCCCTC +CCCAACCTCTTTGCAGGCGAGAACTCCGAACTCCGGTTCTATTATTACGTGTCCCCACTCTTTTAATTTT +TTCAGATTTTCCTGAGTGGAAGGAGATTTATACATAACGGTGTTCATAGCGGGGGCTACAAGCAGAGGCT +TTCCGTAGGCGAGAATCGTGGTAGTGAGGAGGTTGTCTGATATACCGTTTGCTATTTTTGCTATCGTGTT +TGCCGTGGCCGGTGCTATTAAAAAAACGTCTGCCCACCTCGCTAAGTTTATATGGGCAAGGGGTTCTTCT +TCCCAGTCCTTATCCGTATACGCTTTATTCCCGCTCAAGGTTTGAAAAGTTAGTGGAGACATGAACTTTT +CTGCAAAGGGGGTAAGTATAGTTTTTACGCTGTGCCCTTTCCTTTTTAATTCCCTTACGAGTTCACAAAC +TTTGTAGGAGGCTATTCCTCCGCAAACTCCTATGAGGATATTCATTAAGTTAAATTTAAAATAACAAGTA +TGAAGAACGAAAAGTTATACAGAGAAGCCCTTCAGGTAATGCCCGGAGGCGTAAACAGTCCCGTCAGAGC +CTTTAAAGCGGTAGGGGGAAAGCCCATTTTCCTTGTTAAGGGAAGAGGACCAAGAGTCTGGGACGCCGAA +GGGAACGAGTACATAGATTTCCTCGCTTCCTGGGGGGCTATAATCCTCGGACACGCTCCCAAGAAAGTGG +TGAAAGCGGTTCAGGAGGAAGCTGAAAAGGGACTTTCTTTCGGTTTGACAAACCCTCACGAAGTAACACT +GGCAAAGCTCGTGGTTGAGATGGTTCCTAGTGTTGAAAAAGTAAGGTTCGTAAACTCTGGAACTGAAGCC +ACGATGTCTGCGGTGAGACTCGCAAGGGGAGTCACAGGAAGAAAGTACATAGTGAAGTTTGAAGGTTGCT +ACCACGGTCACTATGATAGCCTCCTCGTGAGTGCGGGTTCGGGCGTGGCTACTTTCGGGATCCCTGGAAC +TCCCGGCATTCCTGAAGAAATAGCGAAGCTCACCATAGTCTTGCCTTACAACGATGTTCAAGCTCTGGAG +GAAGCCTTTAAAGAGTACGGCAGTGAAATAGCGGGAGTTATAGTGGAGCCCATAGCGGGAAATATGGGCG +TAGTTCCCCCAAAGAAGGAATTCCTTATAAGACTCAGGGAACTCACGAAAGAGTACGGAAGCCTCCTTAT +GTTTGACGAAGTAATTACGGGTTTTAGACTTTCAAAGGGCGGAGCTCAGGAACTCTTTGGTATAGAGCCC +GACATAACATGCCTCGGGAAAATACTCGGAGGAGGACTGCCCGTAGGTGCTTACGGAGGAAGAAGGGAAA +TTATGGAAAGGGTAGCTCCCGAGGGTGAAGTGTATCAGGCCGGAACGCTTGCGGGAAATCCCCTTGCTAT +GGTTTCGGGTTCTGAAACCTTAAAAGATTTAAGGGACAAAGAACCTTACAAGGAACTGGAAGAGAAGATG +GAGAAACTTGCCAGAGGCGTTAAGGATATCCTCACCGAAAAGGGAATACAGCACACGATAAACAAGGTAG +GTTCTATGATGACGGTGTTCTTCACGGATAAGAAAGTTGTGGACTTCCAAACCGCTAAGACTTCGGACAC +AGAGCTGTTCGCAAAGTTCTTCAGAGCACTTTTAAACAAAGGTGTGTTAATTCCGCCCTCTCAATTCGAG +GCGTGGTTCTTAACCACCGCACACGAGGAAGAAGTAATAGACGAAGCCCTTGAAAGAATCCGGGACGCGG +TAAAGGAACTGTGACGAATGCTTAAAAACCTTATCAGGAGTGTAATAAAGGGTTCTGTGCTCCTCGTTTT +TTTTCTCCTCCTCTCTTTCCTCTTCTTGGCCTACAGGAGCTTTTCCCCGGAAGCCCTTTATCTCGTTGGA +AACCTCAATAAGTTTTACCTACTTCTGGCTTTCTTTTGTTTATTCCTCGTCCACACCTTTGACAACGCCA +GACTCTTTATAATTTCCAGAGCCCTCGGTATAAAGTACTCCTTCCTTTACGGTTACATTACTTCCTTTGT +GAATACCTTCGGTGCTACCGTAACTCCGGCTCACATCGGCGGAGAGGGGATGGCGGTTTACATGCTCCTC +AGAAAAGGAATAAGTGCCCACAAGGTGGCTACTGCGGTTACCTTTAAAACGGTCACGGGTATGGTTTTCT +TCATATTGTGCTTTCCCTTCCTCATTCTTCAAACCCTAAAAAGCCCCAAAAATTTTATAAATCTGTTCCT +CATACTTTTAGTTCTTCTCCTGTTTACTCCCTTATTCTTTACGGGAATAAAGAAATTCCTTAAGAAAAAG +GATAGTGAAGGTCTCGGATCTAAATTGAGAAAGTTCTTGGTCAAGTACCTCGGTGCGGTTAAGTTCTTCT +ACAAAAGGAAGAAAGCGGAGTTCCTGCTCGCGAGCTTGTCCTCAATAGGGCTTTACCTCTCGTTTCTCTT +TATAGCCTTCTTCCTGCTCCTTTCCTTCGGAAAGGAAGTTTCGCCTTTGGAAATCCTTTCACTTCAGCTC +GGACTTCTTTACGCGATATTTGTAAGCCCCACACCGGGAGGTAGCGGAGTAGGAGAGATTGGGGGGTACG +TTATCTTTGCGGGACTGCTCGGTCAGAACGAAGTTGGTGTTTTCGTCCTTCTCTGGCGCTTAATAAGTCA +GTACTTCAGCGCCTTCCTTGGAGGTATCCTATTTTTCATATGCTTACTGATAGACACAAAGAAGTACTTA +AAGGTCTATTAGCGGGTATATTGTTTTACCTTTCCTTCTCAAAGTTAAATCTTTACTTTCTCGTATTTCC +CGCTTTATTTCTGGGAATAAGAAAGAACTTCTTAAGGCTCTTTTCCTTCGGTTTTAGTGCCTTTTTCCTT +TCCCTACTCTGGATAAGGATACCTTTAATAGATTATGGAAATATTAATCCCTTCATAGCCTATCCCGCTT +TAGTTCTGCTCGTTCTTTTCCTGAGCTTATACCAGTTCGGACTTACGTACCTTTTGTGGAGGGTTTTTAA +ATTTAGTTTTTTTGCATTTCCATTTTTGTACACCTTAGTTGAAATCTTGCGCTCCCACCTGCCTTACGGA +GGCTTCCCTTGGCTGCTTCTGGGTGTCAACCTCGTGGACATTCCCGTGCTCAGATACACACTAAACGCTG +GAACCGTTTTCCTAGGGAGTTTTGTAGTACTCCTGATTTCACTCTTTCCCTTATTCAATAAAAAAGAGAA +GATCTTTTCTTTAGCAATTATCACTCCTCTTCTAATTTACGGTTTTATAAAGGAAACATCTTACAGAGTT +ACTCACTACGGATTAAAAATCGCGTTAATACAGCCTTTTGTGCCTCAAGATGTTAAACTCAACAGGGAAT +TATTTGAATTGAAATACGGCGAAATAATTGAACTTGTAAAAAAAGCGGTTGAAAAAAAGCCCGATTTAGT +CGTGCTCCCAGAGTCTGCATTTCCTTTTTACCTCGGCGAACTGGAAGAAAAAGGAAAGGAAATTCTTGAA +CTCTCAAAAAAAGTTCCCATAATTACGGGTTTTATAGAAATAGATGAAGGCTTTAAACCTTACAATACGG +TAGTTCTCTTAAAAGACGGCAGAGTAATAGAAAAGTACAGAAAGATCAAATTAGTTCCCTTCGGAGAGTA +CACACCCTTTCCCTTCAAGTTTTTTTCCAAATACGTGCCGTACCTGAGCTTTGAAGATTACAACAGGGGA +AATAAGGTAAAGTGTTTCCAGTTAAATGGGTTCTCAATAGGAACACCTGTATGTTTTGAGGTTGCTTATC +CTTTCTTCGTTAAGTCTTTCGGGTGTGAATTTATAGCAGTTTTGACAAACGATGCCTGGTTCAGGGATTC +AGAGGGGACTTTTCAGCATATGAAACTCGCAAGAGTAAGAGCAATTGAAAATGAAAAATTCTTCCTGTGG +GTAAACAACACAGGCCCATCGGGTATTATCTCTCCGAGAGGTGAGGTAATAAAGAGTATTGATTACGGAA +GTAGAGGTATTTTACTTTTCTCCTTTTAATATTTCTTTGACACGCTCGTATATGTAAAACCTCACCTTGA +CCTCATCTGGAGTATCTAGGAAGAGTTCGTAACCGCAAAGGATATCACCGTTTTCAAACTCTCTTACATT +TACTAGCCTTGCACTCCCTTTAATCCACTCCTCAAGGTTTGGAAGATAAATCTCCACTTCGGAAATTTCT +TTGTTCTTCAGGATTTCGTCTATCTCTTCCATACCGCATTTTATGGAAAATCCGACCTCAGAAATGTCGT +AAACTTCCTTGGTTATTTCGTTAAACCTTACCTTTACAGGATTTTCAGGATCGCTTAGAACTCTAACATT +CCTTCTATCTCCCAAAGGTTTCTCTGGTGTGAGTGAGGGAAATTCTAAGAGTACTTCGTCTTCCTTCTTT +GCCTTTATTTTCGTTGGAAGCATAAATGTACTGTGTTTTAGATAAACCTTATCACCTATATTTGCAAACT +TCTTGAGAAGTGGTGTCATTTTTAACTTTATACTGTTGTCTTCTATCCCTATGGACTTTGTCTGAATGTA +AACTAGGATTTCTTTTTCTACCAAAAAGACTTCAGTCTTAAGTTGCATTACTCATCCCCCTCAGAAAATC +AACTACTTCTTCTAGTTTCATACCTCTCGACCCTTTAATCAATACCGCACACCCTTCAAATTCTTTTAAA +TTTTCCTCTATAAATTGTAACATTTCTTCTTTAGTTTTAGCGTAAAATTTCTTACTTTTGTTGAAACTAT +CGTAGGCATATTTCATTTCATCCCCGTAAAAGATAGCAAGACGAATACCTTTTACCGTATTTAGAAGCCT +TCCTACCTCTTCGTGGAGTTCTTTACTGTGCTCTCCCAGTTCCAGCATGTCACCGAGTATAAAAACCTTG +TCCCGCTTGAACGCTCCCACACTTTTTATCGCATTCCGGAGTGATACCGGATTAGCGTTGTAGGTATCGT +CAATAAGGATAAAGTTCTTTAAATTGAAAACTTTCATCCTGCCCTCTACAGGACTAAATTCTTTTAAAGC +CTCCTTAAACTCTTTTAAAGTGAATCCCAGTACCTTCAAAACACAAAAGCATGCCAGTATGTTTTCCACA +AGTCCTAAACTCGGAACACTTATAAAAAACTTCTCCCCTTCTACCTCAAAGGATACGCCTTTCTCACTAA +CCTCTACATTTTGGGCTTGCAGCTCTCCCCTTTCTCCGAAGGAAATCTTCTTTGGTAAAAAGAATAAGGT +ATCCAAAAATTTTCCCGGAATAACGGCATAAAAGTTATCCGAAATCCTGCAAAACATTTCAGCGTTTCCC +CAAATTACTCCCTCTAAACTTCCAAAACCTTCAAGGTGTTCCTCTCCCAGAGTAGTTATAAGCCTAACGT +GAGGCTTTGTTATCTCGATTAAATTTTTTATCTCACCCCTTTTACTTGCCCCGTGTTCCAGAACCCAAAA +GTCCGTCTCTAAAGAGGCATTTGCTACGGCAAGGGGAAGACCAACCTGAGAATTTAAGTTTCCCGGAGAT +TTGTAAACTTTTCCCTTTATAGAAAGTAAGTGCGATAACAATTCTTTAGTGGTAGTTTTTCCGGCGGAAC +CTGCAACTCCTATGACTTTTCCCTTAAAGTTTTCTCTTTTAAACTTTGCGATTTCCCTTAGACTTTCAAG +CGTAGACCTGACTTTAATTAAGAATTTTCCCGGAGGAACATCAACTTCTCTTTCGGAAATAACACCTACT +GCCCCTTTTTTGAAAGCGTCGGGTATAAAGTTGTGGGCGTCAAATTTTTGTCCTTTTAATGGAATAAATA +CCTCACCTTGTTTTATTGTTCTAGAATCTATCGAAAAGGTTTTTACGGGAATATTTGGAGAACCTACCAA +GGAACCTTTTAGTATCTTTGCAAGAGTTTGAGATGTGATTTGCACAGGAATTAATTATAACAGGTAAAGC +CCCTGGCAGCGACCTACTTTCCCGTGCCGCTGCCGGCACAGTATCATCGGCGCTGGGGGGCTTAACTGCC +GGGTTCGGAATGGGACCGGGTGTTTCCCCCCCGCTATGGCCACCAGGGGCAATCCGTCAACAGAATAAAG +CCTGTACCTCCTCCCACCGGCGTGCAAGTCGAACGGGCGATTAGTACCGCTCGGCTTCACCCCTCACGGG +GCTTCCACCTGCGGCCTATCAACCCGGTAGTCTCCCGGGGCCCTTCAGGGAGCCCTTATCTTGGGGTGGG +CTTCGCGCTTAGATGCTTTCAGCGCTTATCCCGTAGCAGGATGGCTACCCGGCGCTGCCCCAGTCCAGGG +ACAACCGGTACACCAGTGCCTGCCCCGTCCCGGTCCTCTCGTACTAGGGACGGACCCCCTCAAGGCTCCT +GCGCCCGCGGCGGATAGGGACCGAACTGTCTCGCGACGTTCTGAACCCAGCTCGCGTCCCCCTTTAATGG +GCGAACAGCCCAACCCTTGGGACCTGCTTCAGCCCCAGGATGGGGGGAGCCGACATCGAGGTACCAAACC +GCCCCGTCGATGTGGGCTCTCGGGGGCGATTAGCCTGTTATCCCCGGAGTAGCTTTTATCCGCTGATCAC +CCGCCCTCCCACGTGGAGCGGGTGGGTCACTAGGCCCCGCTTTCGCGGCTGCTCGGCCCGTCGGCCTCAC +AGTCAGGCCCCCTTATGCCCTTGCACTCTACGGCGGATTTCCGACCCGCCTGAGGGGACCTTTGGGCGCC +TCCGTTACTCTTTAGGAGGCAGCCGCCCCAGCTAAACTGCCCACCTAGCACTGTCCCCGCGGGGGATTCA +CCCCGCTGGGTTAGGACCCCAGCCTGTCCAGGGTGGTATCTCACCGGCGCCTCCACCCCCGCCGGAGCGG +GGGCTTCCCAGGCTCCCACCTATCCTGCGCAGGACAGGCCAGAGCCCAATGCCAGGCTGCAGTGAAGCTT +CACGGGGTCTTTCCGTCCTGCCGCGGGTAGCCGGCATCTTGACCGGCATTACAATTTCGGCGGGACTCCC +CTCGAGACAGTGCGGCACTCGTTGGGCCATTCATGCAGGCCGGAACTTACCCGGCAAGGAATTTCGCTAC +CTTAGGACCGTCATAGTTACGGCCGGCGTTTACCCGGGCTTCAGCCCCCAGCTCATCACCGGGGGCCTTC +ACCTTCGGGCACTGGCCAGGCTTCAGACCACATACATCCCCTTTCGGGTTTGCGTAGTCCTGTGTTTTTG +GTAAACAGTCGGCACCGCCCTGTCACTGCGACCCACCAGGGCTTCGGCCGCGTGGGCCTACACCCCAGCG +GGCACCCCTTCTTCCGAAGGTACGGGGCCAACTTGCCGAGTTCCTTGAGGGGAGTTCCCCCGACGCCTTA +GGCTCCTAACCCAGCCCACCTGTGTCGGTTTCCGGTACGGGCAGCTCGGCCTCACAGCCGGCGCCGTTGT +TTCTTGGCAGTGTGGCGTCGGCCGGCTTACGGCATCGGCTCTCGGGGTATGACGGGACGGATTTGCCTAT +CCCGTCCCCCTACTACCTTGCACCCGCATTCCATAGCGGGCCCGGCCTAGCCTCCTGCGTCACGACACCG +GCTCCACCGAGCTGGCGCGGGAATGTTGACCCGCTTCCCATCGGCTACGCCTCATCGGCCTCGCCTTAGG +GTCCCGGCTAACCGGCGGCTGATTTCCATTGCCGCCGAACCCTTGGGCTTCCGGCGGGCAGGTTTCTCAC +CTGCCTTCGCTCCTACTCATGCCGGGATTCTCACTTCCCAGCGCTCCACCCTGCCTCACGGCTTGGGCTT +CAGCGCGCTGGGAACGCTCCCCTACCGCCACAGGAGTCCGGAGACTCCTGTGACCCGCGGCTTCGGCGCC +GGGCTTAAGCCCCGCTAAATTTTCGGCGCCCCCGCCCTCGACCGGTCAGCTGTTACGCACTGTTTAAAGG +ATGGCTGCCTCTAAGCCAACCTCCCGGCTGTCTTAGGACGGGGACTTCCTTTACCACTTAGCCCGGACTT +TGGGGCCTTAGCCGGCGGTCTGGGCTGTTTCCCTCTTGTCCTCGGAGCTTATCCCCCGAGGACTCACTGC +CGCCCTTCCTTTCCCGGCATTCGGAGTTTGCCGGGGTTCGGTACCCCTTTCGGGGCCCTAGCCCCAGCAG +TGCTCTACCTCCGGGAAGGAACGGGCGACGCTGCACTTCGATGCATTTCGGGGAGAACGAGCTATCCCCG +GGCGCGATTGGCTTTTCACCGCTACCCTCACCTCACGGGACGGTTTTGCAGCACCGACCCCTTAGGGCCT +CCAGCCGGTGTTACCCGGCCTTCACCCAGGGCAAGGGTAGATCGCCCGGCTTCGCGTCTGCCCCCAGGGA +CTTTGGCGCCCTATTCGGACTCGCTTTCGCTACGGCTTCGCCTGACGGCTTAGCCTCGCCCCTGAGGACA +ACTCCCCGGCTCATTCTGCAAAAGGCACGCAGTCGGGGCCCATAGGACCCCTTCCACTGGCTTGTGGACC +CGGGGTTTCAGGTTCTATTTCACTCCCCGCCAGGGGTTCTTTTCACCTTTCCCTCACGGTACTATGCGCT +ATCGGTCTCCCGGGAGTACTTAGCCTTGGAGGGTGGTCCCCCCGGATTCCCGCGACCTTTCACGTGGGCC +GCGGTACTTGGGAGCGTGCCTCAGGGAGACCCCTACCCTTTCGCCTACGGGGCTTTCACCCTCTATGGCG +CCCCATTCCAGGGGACTTCGGCTAGGGTGGGGTTTTGTAACTCCCCGAGGGGCCGGCGGACCCCTCCAGG +CACGTCCCGCTACCCCCTGTGGGCTAAGGCCGCCGCCATGGCACCCACAGGGTTTGGGCTGAGCCCCTTT +CGCTCGCCGCTACTCAGGGCGTCTCAATTGATTTCCTTTCCTCGGCCTACTAAAAGGTTTTGCTTCGGCC +GGTTCCCTTCCCGCCCGAAGGCGGGATGGCAGGCTTGTCGCCTGCCGGGTTTCCCCATTCGGGCATCCGG +GCCTCAACGGCTCTTGCGCCTCCACCCGGCTTATCGCAGCTTTGCACGCCCTTCATCGGCTCCGGGAGCC +GAGGCATCCACCCCGGGCCCTTACTAACTTGCACACCGGCGGGAGGAGGTACAGGCTTTATTCTGTTGAC +AAGGAGCCAAGTGGAGGTGGTGGGACTCGAACCCACGACCTCCTGCTTGCAAAGCAGGCGCTCTCCCAGC +TGAGCTACACCCCCGAAGGTGCCCCTAATATGGGCCTCCCAGGACTCGAACCTGGGACCTTGCCCTTATC +AGGGGCACGCTCTAACCAGCTGAGCTAGAGGCCCTGCTTTGCAAGGGGAGCAACTGAGTAGAGGGTGAGC +CTCTCCTCCTTTTATATGCACTAGACAGGGATGAGCTCCCCTTTTGTGGGGAGCTTTTGTCTCCGTTATA +AAGGAGGTGATCCAGCCGCAGGTTCCCCTACGGCTACCTTGTTACGACTTCGCCCCAGTCGCCGGCCCGG +CCATCGGCCCCTGCCTCCGGCTCCCGAAGGAGCCGGTTAGCTCGGGGACTTCCGGCCGGACCGACTTCCG +TGGCGTGACGGGCGGTGTGTGCAAGGCCCGAGAACGTATTCACGGGGACATCGCTGATACCCCGTTACTA +CCGATTCCGGCTTCATGGGGGCGAGTTTCAGCCCCCAATCCGCACCATGACCGGGTTTAGGGATTAGCTC +CCCCTTACGGGGTCGCATCCCATTGTCCCGGCCACTGTAGCGCCTGTGTGGCCCCGGGCATAAAGGGCAT +ACTGACCTGACGTCATCCCCCCCTTCCTCCGGCTTATCGCCGGCGGTCCCCCCAGAGTGCTCCCCAAACG +GGGTAGCAACTGGGGGCAGGGGTTGCGCTCGTTGCGGGACTTAACCCAACATCTCACGACACGAGCTGAC +GACGGCCATGCACCACCTGTGCCGGGGGAAAGTCCTAGGGACTTCCACAACTCCGCTTTCGCGGAGTCTC +CCCGGCATGTCAAGCCCGGGTAAGGTTCTTCGGTTAGCATCGAATTGAACCAGACGCTCCACCGGTTGTG +CGGGCCCCCGCCAATTCCTTTGAGTTTCAGGCTTGCGCCCGTACTCCCCAGGCGGGGCGCTTAACGCGTT +AGCTGCGAGCCTGCCCCAGAGGGACAAGCCCTAGCGCCCATGGTTTACGGCCGGGACTACCCGGGTATCT +AATCCGGTTTGCTCCCCCGGCTTTCGTCCCTGACCGTCAGGACAGCCCCAGCAGGCTGGCTTCCCCTTCG +GTGTTCCTCCCGAGATCTACGCATTTCACCGCTACCCCGGGAATTCCGCCTGCCCGGGCGTGCCTCAAGT +CGGGCAGTTCGGGATGCCGGTCCACGGTTGAGCCGTGGGCTTTGACATCCCGCTTACCCGACCGGCTGCG +GACGCTTTACGCCCAGTGACTTCGCGCAACGCTTGGGACCTACGTATTACCGCGGCTGCTGGCACGTAGT +TAGCCGTCCCTTCCTCTGGGGGTACCGTCACGGACACGGGCTATTAACCCGTGTCCGCATCGTCCCCCCC +GACAGGGGTTTACACCCCGCAGGGCTTCATCCCCCACGCGGCGTCGCGGGGTCAGGCTTTCGCCCATTGC +CCACGATTCCCCACTGCTGCCCCCCGTAGGGGTGCGGGCCGTGTCTCAGTCCCGCTGTGGCCGGCCACCC +TCTCAGGCCGGCTACCCGTCATAGGCTTGGTGGGCCGTTACCCCACCAACTACCTGATGGGCCGCGGGCC +CATCCCCAGGCGGGAGCGTGGCCGAAGGCCAGAGGCCCCCTTTGGCCACCGCGCCTTAGTGGCGGGTGGC +ATTATGGGGTATTAGCCCCGGTTTCCCGGGGTTATCCCCCTCCTGGGGGTAGGTTACCCACGTGTTACTC +ACCCGTTTGCCGCTCAGCGGCCGGCCCCAAAAGGGGCCGACCCTGCGCACGACTTGCATGTGTTAGGCAC +GCCGCCAGCGTTCGCGCTGAGCCAGGATCAAACTCTTCAGGGAAATAGGCGCAAGCGATTTATGGGGAAC +CAGAAATTGGGATCACCTGATGCTGGACCCCACTGATTAAAGGAGGAGAGGCTCACCCTCTATTCAGTTG +CCAAGGAGCCTAGGTGGGGCGTTATTGCCCCGGACACGAAATTTTAATTATAAACATCTTTCACAAAATG +TCAAGACTTTTTAGCTGCCTTTCTTCAGGTTAATCACCTGTGACATCTCCTTATTCTATATCCACTCCTA +CCCCTAGTCAAGAGGTAAATTAATTTCCTATGAAAAAACACGATGGAATAATTGTCCTGCTTTCAGGCGG +AATGGACAGTGCAACGTTACTTTGGCTTGCAAAAAGGGAGTTTAAAAAGGTATACGCTATTTCCTTTGAT +TACGGTCAAAGGCATAAAGTTGAACTTAAATACGCAAAGGAACTTGCTAAACTTGCAGAGGTGGAAGATC +ACTTTATAGTTCAGGTGCCGTTTTATACCTCGCTTAAAGGCTCTGCTTTAATAGACGAGAGTGTTGAAGT +TCCGAAAGGAGAGTACCCTGAAAACGAACCTCCTGTGACCACCGTTCCCATGAGGAATTTGATTTTTCTC +TCAATTGCCTCCGCTTTTGCGGACAACCTAGAGGTAAATTACATAGGGATAGGTGTTCACGCCCTTGATA +CACCTTATCCAGATTGCAGACCTGAGTTTATAACCGCTGCGGAAGCAGCCATTAACGCAGGTTCTACTTT +TGTTGCAAAGAAAAAGGAGAGAATGCACGTTTACGCTCCCTTTTTGGGTATGAGTAAAAGGGATATAGCA +CTCCTTGGGAAGGAACTTGGTGTTCCCTTTGAGAAGACTTACTCCTGCTATATGGGAACTGAACCACCCT +GCGGAGAGTGTCCCACGTGTATACAGCGGGAGGAAGCTCTAAGGGGAATCCTCTAAGTACTTTATGCTTT +TCATTACTTTGTAATTTGTAAGGTCAAGGTGCAGGGGTGTGACGGAAACGTATCCATTCAAAACTGCCCA +GTAGTCTGTCCCTTCTTCCGCGTGCCAGCCGAATTCTTCAGCCGCGATCCAGTAAAAGGGCTTACCGTAT +GGGTCTATGTACTTAAAAACCCTTTCTTTGTAAGCCCTTTTTCCCTGCCTCGTTACTTTTATGCCCTTTA +TCTCTTCGTACCTGAGGTTAGGGATGTTTACGTTGAGGTATGTATCTTCGGGTATACCTTCGTTTAGGAC +TTTCTTAACTATGTCCACGCACACTTTTGCTATTTCTTCGAACATTATATTTTCTCTGCCAAAAGCAGAA +AAGGCTATAGAAGGTATTCCCAGTATCCTTCCTTCCATTGCTCCCGAAACAGTTCCGGAGTAAGTTATAT +CTTCTCCGAGGTTAGGTCCTTCGTTTATTCCCGAAAGTACAAGATCGGGTTTCTTTTCTTCAAGGATAAC +TCTGTAACCAAGGTGAACGCAGTCCGCAGGAGTTCCGTCTATAACGGTGTAAAAATCCGTGTCTATTTTC +CTCATCTTCAGGGGTTCCGTAAAGGTGAGGGAGTGTCCAACGCCGCTTAAGTTCCTGTCGGGAGCGACTA +CAACTACTCTCCCAAGGGATTTCAAAGCTTCCCTGAGGGCGTTTATTCCGGGAGAAAAGTAACCATCGTC +GTTTACCAATAAAAACGTAGGCATAATTCACCTAAGTATTTTAACCGTTCCCTCACCTATTATTTTCCCT +CGTATCACCTTTCTGGAAAAGGGAGAAAGGACTCTGATAACTTCTCCGTAATACCCGTTTTCTAAAGCTT +TCGTTCTGAACCTGATAACTACGTTTCCGTTTTCATACACAGCGTTTACTATCTCACCTCTTTTAACCAG +AAATTCCTTTTTCAGGTAGGATCTTCTTACAATTGTCCCTTTTTTTATCTCCTTTAAAGCTACAAAGTTT +ACGAAGTTTTCCTTAAAATTTTGGGGACATCTTTCCAGATAAATTTCTCTCTCTTCTACGTTTGAAAAGT +TCAGTCTTTCTCCAGGATATATATCCCTTTTCGCTACGAGCACCCTGCACTTCCACTCAAGTTCTAAGGC +TATCGTTCCAACCTTTGTGTTTTTGAGGTGAAGAAATCCTCTTGGAGAATTTTTGTAAACTTTGAGTTCT +ACTTTTGAAAAGTTATCAGGTATTCCCGTGAGAACTTTATAATTTTTCAGCCTAACTTCTTCACCAAACT +CCTTTCTTAATTCATTTTTTATCAGGCTTTCTAAGTCAAGGGAGAAAGTAAATAGAAAGAAAAGGAAATT +AACGGCGTAAATTAGCCGCTTGAGAGAGCATTTCATCCGCCGCCTGTATTCCCTTGGTGTTGAACTCATA +GGCTCTTTGGGCTATTATGAGGTTCACCATTTCTTCAACTATGTTGACGTTTGAACTTTCCAGATATCCC +TGTAGCAGCGTTCCGAGTCCTTGATTTCCGGGATTGTCTATTATGGGCTCTCCCGAGGCTGTAGTTTGAA +TGTAGAGATTATTCCCTATTCTTCTTAAACCCGCGGGGTTTACGAACTTTGCGAGTTCTATCCTTCCCAC +TTCTTCAACTTCCGTTGCTCCTTGTCTTAAAACCGAAACAGTTCCGTCCGCGGCTATGCTTACACTTATT +GCGTCCGCGGGAATGGTTATCTCAGGGTCTAAGGGGTATCCGTCGCTGTTCACTATCCTACCTTCTGAGT +CTAATCTGAACTGTCCGTTCCTCGTGTAGGCTATCGTTCCGTCCGGAAGAACGATTTTAAAGAAACCGTC +TCCCTGAATGGCTATATCGAGCTGATTGTCTGTTTTCGTGAGGTTTCCTTGAGTGAATATACCGTAAGTA +TCAGAGACATAAGTTCCTAAACCTATCTGGAAACCGGAGGGGCTTCTCGTCGTTGGAGAAGTAGGTGCAC +CTGGCTCTTCTACCGTTTGGTAGAGAAGGTCCTGAAAGGTAGCACGCATTTTCTTGTAGCCCACGGTATT +TACGTTTGCCATGTTGTGGGAAATGACGTCAAGGTTTGTCTGCTGAGCCGTCATTCCGGAAGCTGAGGTC +CAGAGAGCTCTAAACATAACCACCTCCCTCTAGGTACTTATTTTAAAATTTAAGCTTAACATGAAAGTTG +TAATAGTAGGAAACGGTCCCGCAGCTGCAAGCGCAGTGGAAGCCTTCAGAAAGGTAGACAGAGACAGTGA +GATTATAATCCTTTCCGACGAAGAGTTCCCAACCTACGCTCCAAACTGCATGGAAAACGTGATAAGGGAC +GACATATCAAAGGAAGCTCTCTTTTACAAAGGCGGAGAAAAGTTCTACGAAAAGTACAGGGTTGATTTCA +GGCCGAAAACCGAGGTTGTAGGCATAGATAACAAAAGGAAAGTAGTTATCACTAAAAAAGGAGAGGAAAT +ATCCTACGATAAATGTTTGCTCGCCGCTGGAGCTTACTCCTTTATCCCTCCCATAGACGGGGTTGACTTG +GAAAGGGTCACGACCGCTAAAAACCTTTACGACGCTTACAAGATAAGGAGCTGGATACTTTCAGGAAAAA +TAACAAAAGCTGTAATAATAGGTGCGGGGCCCATAGGCATAGAGGATGCGGAAACACTCAGACACATGGG +GATAGACGTTACAGTAATAGAGGTCTTTGACAGGATACTCCCGAGGATGCTGGACCGCCAGATGGGAAAG +CTGTACCAAAAGCCTCTAGAAGAGGAAGGTATTGAATTCCTGCTTGAACATCAGGTGGTAGCAATACACG +GAAAGAATGGAGAAGTTGAAGCGGTAGAGGTAAAAAAGAGGGGAACGGATAAGACCTTTTTCATAAAAAC +GGATATGGTAATAATTTCCACCGGAGTAAGACCGAGGACTTACCTCGTTGAAGGAACGGACATTGAAATA +CACATGGACAAAAAGCTCAACAAACCAATAGGCGGTATTCTGGTGAACGAGTATCAGCAAACGAGCGACC +CGGACGTTTACGCCGCGGGAGACATAGCCTCAGGAGTGGACATGTGGGGAAACCACAGGTGGATAGCCCT +TTTCCCTCCTGCACAGCAAGCCGGGTACGTGGCGGGCTTTAATATGGCTGGACTAAAAGTAAGGAATAAC +GGTCTGGTTGATTACAACGCAGTAAAGACCCGTTCCGTAACTGCCGGAAGCGGAGGATTGTTTGAAGACG +CGGACGAGAGCTTCTTTCTCGAGTATAAAGAATACCTCGTAAAAGTTTTCCTAAAAGACGGAAAAGTAAG +GGGATACCAGTTCGTAGGAGTGCCAAAGTATCCAAAACTCAATCCTAGAAATCCTTTAATAAGAGTTTTA +AACAAGATAAATACGTGGGAGGAAAAGGTTTTATTGGATAAAGGGCTCGGTTTGGAGGCTTCAGGAGCTC +TCTTTCACTTCTTTGTAAAGTTAAACAGGGAGTTCAAGGAAGTTCACAGAAGATTGGTGGAAGAAATGTT +CGTGAGGGCGATGGCAAACCCCTCACGAGAAATACCACTTTTCACAGTACAGGAAGGAGAAGTCCTAAAA +ACAGTAGGAAAGTAAGGGGAAACACCTCGGAAAAGTCCAGATCTTCGTACTTTGGTGCTTCTGCCTTCTC +TTCAAAGAATACGGGGGAGAACATCTTAAATCCTACCCAGAGCCACACGAGCCACTCAATTAAGAGTATA +GGGGTGAGAATTAGATTTCCTTTAAATACACCGTAAAGGGTGAAAAAGGCGTAAGCGGGTGCTATTACGA +GTGAGGAAACGAGCGCCACGAAGGCAAGCGTTCCCAGAACAGGAAGATAAGTAGCTATACCTTTAAATTC +CTCAACCTCAGGTTTAGCGCCTTGATTCTTCATGTGGAGGATTAAAAAGTGAATCACCGTCAGGGGAATT +GCGAACGCTGAAATGAAGAAGAGCATCTTTTCGGGATGAAGCCACGAGAGTGACGCCACTGCTATGTAGT +AGGTGAGCAACCATTCTTCGTAATTCTGAACTCTAAAGAGCCTGTAAGTATATGCGATGGATGTGAGAAC +GGCGAGTAGTATCAGGAGTGTTCCTGCTTTTCCAACCCCAAGGGCTCCTACAAGGACACCTAAAAGAACG +AGAACAGGGAAGAAGTAGTTTCTGCAACTTTTACAGTTTTCAAAGACGTAATCAACTACGAAACTGAAGG +GGATAATCGGAACAAAAAACACACCGAGGAGTTTTATCATTCCCTTGCCTCCTTTGAGGTTTATAACGTT +TTTTATTATACTTGACCCAAAAGTTCCAAAAACCTTACCTTAATACATTATGAAATTCAGGAGTGATAAG +GTAAAAAAAGGAATAGAAAGGGCTCCTCACAGGGCGCTTTTGAGGGCCTGCGGACTTTCTGATGAGGACT +TTGACAAGCCACTTATAGGGATAGCAAACTCATACATAGACATAATTCCGGGGCACGTTCACCTGAGGGA +GTTCGTAGAACCTATAAAGGAAGAAGTCAGGAAACTGGGCGGAGTTCCTATAGAGTTCAACGTAATCGGA +GTTGACGACGGAATAGCCATGGGACACGAAGGTATGCATTACTCCCTCCCCTCCAGAGAACTCATAGCTG +ACAGCATAGAAACGGTTGTAAACGCGCACCAGCTGGACGCACTCATATGCATTCCCAATTGTGACAAAAT +AGTTCCGGGAATGCTCATGGGAGCTTTGAGGGTAAACGTCCCCACCGTTTTCATAAGCGGGGGACCCATG +CTCGCGGGAGAGGTAAACGGTCAAAAGGTGGATCTCATCAGCGTCTTTGAAGGTATAGGTAAGGTAAAGA +GGGGAGAGATTTCAGAGCAGGAACTAAAAGTTATAGAAGCATCCGCCTGTCCCACATGCGGTAGCTGTTC +TGGAATGTTTACTGCAAATTCTATGAACTGCTTAACGGAAGTACTCGGTCTTGCACTTCCCGGAAACGGA +ACTATCCTCGCCATAGACCCGAGGCGTGAAATACTGGCGAGAAACGCGGTAAAAGCCCTCTTTGAACTTC +TAGAAAAGGATGTAAAACCGAGGGATATAGTCACGGAAGAAGCCCTGGACGACGCCTTCACCGTGGACAT +AGCGATGGGAGGCTCTTCAAACACCATACTTCACTTACTTGCGATCGCGAGGGAGGCCGGAATAGAGTAC +AACCTTGCCAAGATAAACGAGATATCTAAGAGAACACCCACTATATGTAAGATTTCACCCGCATCACACT +ACCACATTGAGGATCTAGATCGCGTTGGTGGAATACCCACTATTATGAAGGAGCTCTCAAAACTCGGACT +CCTTCACACGGAAAGGAAAACCGTAAGCGGTAAAACGATAGGGGAAATAATAAGCGATGCTCCGGACGCC +GACGGCGAGGTAGTGAGAACCATTGAGAACCCTTATTCCAAGGACGGAGGTATAGCAATACTCTTTGGAA +ACCTCGCCCCCGAGGGAGCTGTTGTAAAGACCGCGGGAGTTGATCCCAAGATGCTCACCTTTAAGGGTAA +AGCCATATGCTTTGATTCGGAAGAGGAGGCTATAGAGGGAATTCTCGGAGGAAAGGTAAAGCCCGGACAC +GTGGTCGTGATAAGGTACGAGGGGCCTAAGGGAGGGCCCGGTATGAGGGAGATGCTCTCACCCACTTCCG +CAATAATGGGAATGGGACTGGGAGACAAAGTGGCACTCATTACGGATGGAAGGTTCTCCGGCGGAACGAG +AGGGGCGTGCGTGGGACACATTTCTCCCGAAGCGGCGGCAGGAGGACCGATAGGAATAGTAAAAGACGGA +GACGAGATATTAATAGATATACCGAACAGAAGGATAGAGCTCCTGATTTCCGAAGAAGAGTTCAATGAAA +GGATGAAGAACTTCAAACCTAAGCAAAAGGAGATAAAGAGTTCCTGGCTAAGGCGGTACGCAAAACTCGT +GACTTCCGCCTCAAAAGGTGCTATCCTCGAGGCTTAACCCTGTTTCTTTTTTTCCAAAAACTCCTTCTGT +TTCTCCTTTAGTTCTTCCATTTTTTTCATTACTTCTTCAAAGGAAAGGTTTGTCCTGAAGCCGTCACCTA +CAAAGTGTGTCCTCACTCCGTTGAAGAACTTTACCGCTATCCTTATAGGGGGCTGAGCCGGAAGTTTTAC +CTTTTCGGCGAGTTTTGAGAGGACGTAGAATCCCACCGTCTGGAGCTGTGACTCCTCCTTTATGAGCTTT +AGAATCCTCTTTGTTTCCTTTTCTATCTCTTCCCTCTTTTGGGCTTCTTCGTAAAGGAAGTTCGTAAACT +CCTCGTCCCACAGTTTTCCTATCCAGAGGGGTCCTCCTATGTGGAACTTTGAACCGCAGTGAGGACATTT +CTCTTTGAACTTGTAAAGGTCTGTAACCACTTCCCTGTTCATACAGTTAAAGCAGTACTGAATGTATCCG +AACTGCTCAATTAATTTATCAACCTTTTCCACTCCCCTCTCTTTGACAAAAAAGAGTTTGAAGTAGTGCA +GGTGAGAGTAGGCGAATATGGGTATCATAGCTATGTCGTACTGTGCCGCAAGCTCTATAACCTTCTTTAT +TAATATCCTTATTCCCACCTCGTGCTTGAATTCGTTCCTGAGCGGTCTTGCCATGTACCTCCTCATACAG +GTTTTTGGGTATGTTCCGGAGAGCGGTGCCGTGTCTGTAGCGGTTAAGCTCAAGATACCTCCCCTCTTCA +TGGAAAGGGCAACGCTTTCTATAAAGGGAACGGGTGTTCCGAAGGGATCGAGATCCACGTAATCGAACCC +AAAACCCCACTCCTTCCTCAGGAAAAAGTTCGCCTCCATCCCGTGTATCTCGTACCTGTCTTCAGGTATG +TTGTTTAGCTTGAAGTTTTCCTTCATTATCTCTATCGCCTTTGAGCTTATGTCGTTTGCGTAGGCTTTTT +CAACGCATGAAGTTTCAAGTAAAAACCTTATAGCCCTTATACCGCTTGCGGATAATGGATCCGCTACTTT +TACCGGTCTTCCTAGTTTTTTGCAGAGGTATTCGAGTCCCAGAACCGCGAGATCCCTGTTTACCCTCATT +CTGGGGTTGTAAAAAACGGGCATGTCTGAGCTTACCGTTTTGGGGATTTCGGGTACGATTATCTTAGCTA +TTCCTTCCTGAACGATTTCCATAAGGAAAAATATTAACAAATGGAGCTCTTGAAAGAAGTAATCCTTGAA +AGTGAAGAGGATACATACAAACTTGCAGAAGAGATCGCACAGCTTTTAAAGGGAAGCGAGGTAATATGTC +TCAGGGGAACTTTGGGAGCGGGAAAGACTACTTTTGTAAAAGCTCTGGCAAAGGCTTTGAAGGTAAAAAA +CCCGAGTGCAGTAAGGAGTCCCACCTTTACACTCGTCAACGAGTACGAAACGGATAAGGGAAAACTGATA +CATATAGACCTCTACAGAGTTCCCGATTTTGACTACTCCGAATTTATAGGAGAGGGTATCTTAGCCGTTG +AGTGGGAGGAGAGGGACAAACCCTGCGATATTATTCTGGAAATAGAGATATTAGATGAAAATAAAAGAAA +GGTAAGGATTTACAGAAAATGATCAGTGGTAAAGCCTTTTACAAATTTTAACGCCTTCCACACTCTTTAT +TTTCTTCATTATCTTTTCCAAGTGTTCCTTATTTTTTACCTCAACGGTGAAGTCCATAACTGCTTTTCCT +TCCCTCGTGTTTGTCATTGAACTCACTATGTTTGAACCGCTTTCCGAAATAACCTTGGTTATATCCGAGA +GAAGACCTATCCTGTCAGAGGCCACAACTCTTATATCGGTCTGGAAGTATCCCGAAGCCTGAAGTTGAAC +CTCTTTAACCTTTTCCGGATTTAATCTCAGTACGTTTTTTAGGTTTGAACAACTCTTCTCATGCAGGACT +AAGCCCTTCGTTCTGGTGATTACTCCGAGGATCTCATCTCCCGGAATGGGTTTGCAACACTTTGCCACTT +CGTGCTTTATATTGCTCAAATCTTCCAGAAATACCGTTGAACTTCCTCTCCTTTCCTCTTTTTCTTCCTT +CTTCTTAGGAAAGATTAATTTTATGAGGTTTGCGGAAGATATCTTTCTCTTTCCTAGGGCAAGGAGGAGT +TCCTCTTCGGTATCAAACCTCACTCTTTCCCTGATTTTGTTAATTAAGTCCTCGTGAGAAAGTCCGAGTT +TTTCCCTTATCCTCTCTAAAATCCTCTTTCCTTCCGACAAGTACCTTTCCCTTTCCTGTTTCTTTAGGAA +TTGTTTTATCTTGTTCCTCGCCCTTGAGGTCTTTACAAAGGAAAGCCACTCGTAACTCGGGGATTTATTG +GGATTCGTTATTATTTCTACAACGTCTCCGCTCTTTAACTCGTAATTTAAGGGAACAATCCTGCCGTTTG +ACTTCGCTCCCGCACAGTGGTTTCCGACCTCCGTGTGTATCTTGTAGGCCAAGTCCACAGGTGTTGACCC +CTTAGGCAAAACAACGAGGTCACCCTTAGGGGTAAAAACGAAAACCTCTTCAAAAAAGAGATTACTCTTC +AGGTTTTCCAGAACTTCACTGGGATTTGTACTTCCCTGTATGCTCTCAACGAGTTCTCTTAGCCAGGAGT +AAACGCCGGCGTCGCTTGGATTTTTCCCTTCCTTGTAAGCCCAGTGGGAGGCTATACCTTTTTCCGCCCT +CTCGTGCATCTCCCAAGTCCTTATCTGAAATTCAACCAGCTTTCCCTTATCCGCGATAACCGTTGTGTGG +AGAGACTGGTAGAGGTTGGGCTTCGGTAGAGATATGTAGTCCTTAAACTTTCCCGGAACCGGTCTGAACA +GGCTGTGGATTATTCCGAGAACCGTATAGCATTCTGGAACGGTATTGACTATTATCCTCACGCCCAATAT +GTCGTGGACGTCCTCAAGTCTTATCCCCTTTCTCCTTGTTTTCTCCCATATACTGTAGTAGTGTTTTGAA +CGATACTTTATCTCAGCCTCTATTCCGTACTTCTCTAGTTCCTTTCTAACCTTTGGTATAACGTACTTCC +TGAGATACTCCTCAAGGTTCTTCCTCGATTCCTTTACAAAGTTCCTTACCTTTTCGTATTCTTCTGGGTA +GAGGTACTTAAAAGCCCAGTCTTCGAGCTCGTTTTTTATACTCCATACACCGAGCCTGTGAGCTAAGGGG +GCGTAAATTTCCATAGTCTCCTTTGCTATTTTCTTTCTCTTTTCCTCTCTGAAAACCCATAAGGTCTTTA +CGTTATCAAGGCGATCTGAGAGCTTCAGAAGTATAACTCTCGGGTCTTCCGCTGTTGCCAAAATTAACTT +TCTGTAGTTCTCAGCCTGTTCGGATTTGTACTTAATCTTTCCTATTTTCGTAACACCTTCCACGAGTTTT +GCAACCCTTTCCCCGAATCTTTCCTTAATCTCTTCGTAAGTTGTGTCCGTGTCTTCTAACGTGTCGTGGA +GAAGTGCGGCGATTATTGTTTCATGATCCATCCCAAGTTCTGCCAGTTTGAGGGCTACGTTCAAAGGGTG +TATTATGTAGGGCTCCCCCGTTTTCCTTTTTTGCTCTCCGTGCTTTTCCTTTGCAAATTCGTAGGCTCTT +TGAATTTCTTCCGCGTGCTGGGGGTAATGGGAAAGGAGTTTTTCAAGATCTTCTTCAAGAGAAACTTCTC +CCAATTTTGACATCCCTAGTTTAATATAAATTCCTTAAAGGGGATTAGAAATGATATTTGGGAGATTACT +GAGAGGTTTTTCGAGCAACATAGGAATTGACCTTGGCACCGCAAACACGGCGGTTTTCGTTGAGGGTAAG +GGGATCGTCCTATACGAGCCTTCAATAGTGGCAATAGACACAAAGAGTAAAAAAATTCTCGCGGTAGGGA +AAGAAGCCAAAGAAATGGTAGGGAAAACCCCCGAAAACATACAGGCTATCCGTCCGCTCAGACACGGTGT +GATATCCGATTTCGAAGTTACCCAAGCTATGCTAACTTACTTCATCAAGAAGGTTCTCGGTAGGAGCATA +CTAAAACCGAAACCAATCACAGTAATAGGTGTTCCTACTGGAATAACGCCCGTTGAAAAGAGGGCAGTTG +TGGACGCTGCAAAGAGTGCGGGAGCGAGGGAAGTGTACCTCGTAGCCGAGCCCATGGCCGCGGCCATCGG +TGCAGGACTCCCCGTAGAAGAACCAATAGGAAACATGATAGTGGATATAGGTGGGGGAACCACGGATATA +GCGGTTATATCCCTGGCCGGTATCGTTGTTTCAAACTCCCTGAGGGTTGCGGGAGATGAGATGAACGAAG +CCATAATCCAGTACATAAAGAGGAAACTGCACCTCCTTATAGGTGAACAGACCGCAGAAAGGATAAAGAT +AGAGCTGGGAAGTGCGATTATGGAAGAAGAAGAAAGACAGATGGAGATAAGGGGAAGGGATATGACGGGA +CTCCCGAGAACGGAGACAATTACAAACCACATGGTAACGGAAGCGCTGGAGGAGACCGTGAACTCAATAG +TGAACGCCGTAAGGACAACACTCGAGAAAACGCCTCCTGAGCTCGCCTCCGACATAGCCGAAAGGGGTAT +AGTTCTCGCCGGAGGAGGATCACTCCTCAGGAATCTGGACAAGAAGATAGAACAGGAAACGGGAATAAAG +GCGAGGTACGCAGATGAACCACTCACTTCAGTTGCAAAAGGTCTCGGTATGGTTCTTGAAAATATAGACC +TCATAAGGAGAATATCTATGGAATGAGTCTAAAAAAGCTCAACGTATACTTCTTTTTACTTTCTTCCTTG +AGTCTTCTCCTGCTTTTGCTCCAAAACGTAAACAATCCCTTTACACAATTCATAAGAAACGGAGCTTTCA +TAGCGCTTTCTCCTATTTTGAAAGTTCAGGCGGAACTGGAAGAAGAGGTAAGAAAGGGAATAGAGTTCCT +TAAGGATTTAAAGGAGGAGAGTAGATTAATAACGAAGTACAACAAGCTCAAGGAGGAGATTTTAATATAC +AAGGAAAAGGTAAATTCCTACGAGAAAATGCTCCAAAAGCTTGAGAAGGATCTGGACTTTAATTTCCCGA +CACGGGCTGATTACGTAATTTCCAAGATAATTTTTTACGATACTTCTGGAAAGGATCTCTTCTTCATAAT +AAGGGACGGCCAGAATAAGGGTATAAAAAAGGGGGATTTAGTTGTGGCGAGGGGAGGGGTAGTCGGCGTG +GTTGACGAAGTTTACTACTCAACGAGTAAAGTGATTTCCCTTTTCAACGAGAACACTTATCTGCTTGCCA +CGGTGAACAATTCTGACAAAGTCTACGTTTACCACGGAGGGTATCCCCACGGAGAACTCCTGTACGTTGA +CGTAAACGATACGGTAAACGAGGGGGATGTAGTTCTGTTTAAAGACCTAACCATGAAAGTTCCAGCTTAT +AAAATAGGGAGTGTGGTATACTCGGGCATAAGTGAAAACCCTTTCTTCAAGAAGGTGAAGGTAGAGCCTT +ACGTTTCTCCCAGAGAAGTGGAGTTCGTGGTAGTTTTTAAAGAATGAGAAAGATAGTTGTTCTCTTCAGC +GGAGGCGTGGAGAGCTCCGCCCTCCTTGCACATTACCTCACGAGAAATTACTTGGTTTACCCCCTTTACG +TGAGGTTCGGATACCCCTGGGAAAAGGAAGAAATAAAAAGGGCTAAAAAAGTATTTAACTTCTTTAAGTC +CAAGTATCCAAACCTAATGCTTTTAGGTATAAGGAAGTTCAGGCGGTACTCAAAAGATTCAATAAAACTC +CGAAGAGTGAAGAGGATTTAGAAATACCCATGAGAAACTTTATCCTTTGCACCGCGGGAGCACTTTACGG +AGTCCCAAAAGGAATAAACACGTGTGCGATCGGGAGTTTGGGAATGTACCCATTTGAGGATAATAAAAAG +GAGTTCTTTGAAAAATTATCCGAAACTATATCCATGAGCTTAGGTAAGGAGTTTTACATAGAAACTCCCT +TTATGGGTATGCACAAACACGAGGTAATAAAAAGATATGGAAAATTCATTCCCCTTGAACTTTCCCTTAC +GTGTATCAATCCCGTTAACGGAGAGCCATGCGGAAAGTGTATAAAGTGCAAAGAGAGGGAAGAGGCCCTC +AGTTTGCTCTAGCCTTCATGTACTCCTGTATCTTTTGTTCTATTAGGTCCTTATAGTAAAGCTTTTCCTT +CTTGAGTTTTTCTATTTCGAGTTCAAGGTCGTGTGTCATGGGATGGTGCTTTTCAAGCTTTCTTATTTTT +TTGTCAAGCTCCTCGTGCTTATCCTTCAACTCTCTGAACTCTTTATCCTTTTCGTAGAGTTCCTTTACAA +TTTCTTCTCTCGTCATAGGTCACCTCCCTTAATTAAAAAGTTATTCCTCAGAGGAGAAAATTAAATCCAG +GGCCTCTGTGTCCCTTCCGGCGAGGTCGTAATCCGCAACCTGCGTTACCTTTACCTTGAGAATATCACCG +CTCTTTAAATCTCTTGAACTCTCTACGTAAACGACACCGTCCACCTCGGGAGCCTGGAAGTAAGCCCTGC +CTTTCGGAACGAAAGAGAACTCTTCCTCGTATCCGTCTATCAGCACCTCAATTTCTTTCCCTAAAAACTC +TTCATTTTTCTTCCTCGTGATTCCTCTCTGGATAGCCATAAGTTCTTCTCTCCTCTCTTCTTTCACCTCT +CTTGGAATGGGATCTCCCAAGGGATAGGCGTGAGTTCCCTCTTCGGGAGAGTATGTAAAGACACCGAGCC +AGTGGAAGTGCCCTTCCTCTACGAATTTCTTAAGTTCCTTGAAGTCTTCTTCGCTTTCTGTGGGAAATCC +CACTATGAACGTCGTCCTGAATACGGCGTTTTCTATTTTCTTCCTTATATTTTCTATCAGGTTTCTCACA +AACTTACCGTCGTAGCCCCTTCTCATGTCTTTCAGTACTCTGTCGCTCACGTGCTGGAGAGGTACGTCAA +AGTACGGGAGAACCTTCTCAGAATTCGCTACGTAATCTATTAAATCCTCGTGCACTTCCGTGGGGTAGAG +GTAGAGGAGTCTTATCCACTTGATGCCTTCCACTTTTTCCAGTCCTTCAAGCAGTTCCACGAGTTTGTAC +TCTTTGTAGAGATCCTTACCGTAGTATGTAGTGTCCTGAGAGACCACGCAGATTTCTTTTACTCCCTGAT +CCGCCAGGAATTTCGCCTCATCCACTATTTCTTCAATCTTTCTTGAGCGGTGTCTTCCGCGGATCTTTGG +AATGGCACAGAAGGAACAGAGCCTGTTGCACCCTTCCGCTATCTTCAGGTAAGCGTAAGAGCGTGGAGTG +GAGAGAATTCTTTTAATTTCCTTTTTTTCCTTTAAACCCAAGTAATTGAGTATCTCGTTCCAGCTTTCCG +TTCCGAAGTAGGCTTTAACTTCCGGGATTTCCTTCTCCAGTTCCTCCTTGTACCGTTCTACTAAACAGCC +CATAACGATTACTTCCTTTCCACTCTCGGCAAACTCCAGTATGGTTTCTATGCTTTCAAGTTTTGCAGGC +TCTATAAAACCGCATGTGTTCACGATAATTACGTCCGCCTCTTCGGGATTCGGTGTTAGCTCTACTCCCG +CCCCCTTGAGCTTTCCCAGGAGTATCTCACTGTCAACTAAGTTTTTCGCACACCCTAAACTAACTACTCC +AATTTTCATAAAGAATATTTTAGGTTTTGGGCTCGTATGTGATAAGTAGAAGCTTAAACTCCTCGTCGGA +GATCCATTTTCCGAGAACCTTTAACGTGCCTCTTTCAAGCTCAATTAAGTAAAGACTTTCCTCTTCCAGA +TTTTTGTACTCTTTATCCTTTGGCTTCTTTCCCGAGGTAAACTCGCATACTTTTATAAGCTTTTCTATAA +AGCTGTCGCTCACGAATTCAAGGTAGGGTACTATTTCTAAAATCCTTTCTCTGCACCTTTTTGATAAAAA +GATGTTCTCTACTTTTTGAAATATTTTCATTTCCTTTTCTTTCCTCTTAGCGTCCTGGTAAAGGATTATC +AATGTTATTATTAAAGGATAAAGAAAAGTTAAAGAAAGCGTAAGTCCGAGAAGTATGTCTTCGAATCTCA +GCTTTTTCAGAGCCATCCCTTCCGCCTCACCCAGAAGAGGAGAACGAGCGTTACGAAAACCATTAAGAAG +AGAGAGTAAGGGTATCCATACTTCCAGTGGAGTTCGGGCATGTGCTTGAAGTTCATACCGAAAATGCTCG +CTATTAGAGTGGCGGGAAGGAAGATCGTGGCAAGAACGGTAAACACCTTCACGGCTTCGTTCTGTCTTAT +AGTTATAAGACCGAGAAGGGAGTTCTGTATACTGTCTATCTTTTCCATGTAAAAGGATGTGTACTCAAGT +AGGGTTGTGAGATCTTCGTATATTATCCTAAGTTCTTTCTTTGTGTGGGCGTTTATTAGAGGACTTTTCA +GGGCTTTTGTTATGATCCTTATCTTCTCATTTATGCTTTCCCTGAGTGTTATGTTGAGTTCGTCGTAAAA +GGCGAGCTCTCTTATCATCTCTTCCGATTGTTCCACAAACATCTGTCTCCAGATGTCCTTAATCTTGTTT +CCCAGAAGCTCCAGCCTGTCGCCTATTCTGTCAACTTCTATTCCGAGAATTTCGGCAAATAGGCTTTCGG +GAAACTGGAAAAACTTCCTCTGAAAGTTAGTCCTGTTTTTAAAGATCATTATTGAAGGTATGTCCCTGTA +GCGAACGGTCACGAAGAACTTTTCCTTTATGTAGAAGACCACGGGTTCTACGAGTATTTCCTCCTTTTGG +GGTATTACAAAGGAAAGTGTAACCTCCAGATAATCCTTATCTTCTATATACTTTGAACTTATCTCTATAT +CTCCGAGTATTTCCTTAGGGGGCATACTGAAGCCCGTTTGTTTTCTTAAGAACTCTATTTCCTCCTCGGT +AGGATTGAAGAGGTCAAACCATATTACGTACTTTCCCTTGTACTCCTTTAACTTTTCTTCGTCTATTTCT +TCAAATCCTTTGAATGTGTTTACGTACAGCTTTATCACACATTCATATTTTATCAAGCAGATCTTCTATG +AGCCTTAGAGCGTGCAAAGAAGAGCTTTCCCTCGCTTTATTTTTCCACGCGATGTCGTAAGCGGTTCCGT +GGTCAGGGGAAGTTCTTATAAAGGGCAGTCCAAGGGTAAAGTTTACACCCTCATCAAAGGCCAGCATTTT +GAATGGAATAAGTCCCTGATCGTGGTACATACAAAGAAAAACGTCTTCCTCTGACGGATTTATAAAAGCA +ACGTCTGGAACTAAAGGGCCTACCACTTTGATGCCTTCCTTCTTTGCTTCCTCTACGGCGGGAATAATTT +CCTCTATTTCCTCCCTCCCTAGTTCGCCCATTTCCCCTGCGTGGGGGTTAAGCCCCAGGACCTTTATAAG +GGGTTCAAACTTAAACTTTTCTAAAAATTCTTTCCTTATCAGTCTTACCTTCTTCAGGATTTCCTCTTTC +TTGACGTAATTGGGGACGTCTTTTAATGGGATGTGCGTTGTCAGTAAAACCACCTTTAACTTCTCCGAAT +ACATCATCATGGCGTAATCTTTGGTTCCGGAGGCTTTTGCTAAAAACTCGGTTTGCCCTTCGTACTGAAA +GCCTGCCTTCTTTGCCCAGAACTTGTTTATGGGCATGGTCAAAATCCCGTGAATGTTTCCTCTGATGGCG +TCTGCGACGGCTCTGGCAAGGTACGCAACTGCCGCCTTTCCCGAGGATACGGAAGGCTCAACCACTGGAA +CTTTCAGAACGTTTAAATCTATCAGGTAAACCCCTCTCTCCTTTGCCTCTTCTACCTTTTCAATTTTTTT +GTAGTTGAGTTTTATCCCTGTTAACTTGCTCGCTTCGAGAAGTGTTTTCTCCTCGCCGTATATTACGTAA +GTGAATTTTTCTTTAAAGTGTTTGGAAATTTTCAGTATAAGTTCAGGACCTATCCCGGCTGGATCACCGA +GGGTTATTCCTATTTTCTTATTCATAGTACTCAGCACCGCAGGTTTCCGTTTCCCATACCACTACTTTTA +CCAGGTTAGGGTACTTCTCCTTTACCTTTTTATACAACCCCTTTGCCACGTTTTCCGCACTCGGAGAAAA +GTCAAAGACATCGTTCAGTAGGGTGTAATCGGGGAGGATATCCTTTAAAAAGTTGTCTATTTCTACAAAA +TCCACTCCCATTCCGCCCTTATCAAGTTCTTCAGCCTTTATGAAAACTTCTACTGTCCACGTGTGTCCGT +GAAGGGGTTCCGGCTTACCGTGGTAGTCGGTGAGAAAGTGGGCTGCATTGAACTTCCTCTTTACTCTGAC +TATCCAGGGCATGGAAAAGATTTTAAAGGTTTTCAAGCTTTTTCAGGAGTCTTTCCTTCTGTCCTCTTTC +TCCCTGTTTTCCCTCTTCAAGGAGTTTAAGTGCTCTCTCGTAGTAATTCCTTGCCTCCTCCTTGTAGCCC +ATCTTTAGCAGGACGTCCCCTACGTGTTCGTTGACTACGGGGTCGTCGTAAGCTTCTCTCAGAGCTTTCA +AGAGGTACTGCATAGCCCTTTCGTAATCTCCCTTTAGGTAGTAAACCCAACCCATGCTGTCTATGTAAGC +TGGGTTTTCCGGATCCTTTTCCAGAGCTTTTTTAATGAGTTCTTCCGCTTCCTCCACCCTTTCCTTTCCG +TACCAGAGAAGGAGTGAGTAGCCGAGGTAGTTGTAGTAATCTGGATTTTCGGGATCGAGTTCTATCGCTT +TTCTCAGGGCTTTTTCCGCATTCTTTATATCACCGAGATTGTCGTAAACAATGGCCTCCATGAAGTAAAC +GCGCGAATCGTTCGGATAATCCTTCTCCAGTTTTTTCAATATTTCCAGTGCTTTGTCATACTGCTTTGTC +TTTGAGTAGTAATCCGCCTCTAGAAATAGTATTTCCTTTTTGTCGGGTGCGAGGACTTTAGCCTTTTCTA +TTAGCCTTTTTGCATCTTCGTAATTTCCTAAATCAAGGTAAATTCCTATTAATCTTTCTATTACCTTTAT +GTTTTCGGGAAATCTGTTCAGGAGGTTTTCGTATATCTCCTTAGCCTTTTTTAGTTCTCCGGTAGCTTCA +AGGGTAAGGGCGTAGGCAAAGGCAACGTTGGGGTTGGAAGGGTTCACGTAGTAAAGTTCTTCTAATATCT +TTTTCGCTTTATCAAACTCTCCCGTACTTAGTAAGAGGAGGGCGTACTCGGTTTTGTAATTTACGTTCCT +TGGCTTTAAGTTTATCAGCTTTTCGTAAATCTTTATAGCTTCTTCTATCCTTCCCGAGGCCGTGTAGAGT +TTTGCGAGCTTTTCCAGAATTTTGGGGCTGTTTGGGTACTTTTCAAGTACGCTTTTGTAGAGCTCTTCCG +CTTCTTTGAACTTCTTTTCCTGAAGGTACAAGTTTCCGAGGGATAGCACAGCGGGTGCGTAATACTTTTT +CTTTTCAAGGGCTTTTAAGAAGTACTCCATACCCTTTTGAATGTCTCCCTTTGCGAGGTATATCCTCCCG +AGGAGGTAGTATGGGAGCGGATTGTCTGGGTCAGTTTCCATGTATTCTAATAGAACCTTCTCTGCTTCTC +TCAATTTCCCTTTGTTTATGTATTCGTTTGCCAGAAAAAGTACTACGTTTTCGTTGAAAGGAAAGGACTT +ATAGGCTTCCTTTATGACTTCAAAAGCTTTTTTGTCTTCCTTTAAGAATTTGTATATGGTGTAGAGATAT +ATGTAAGCTTGTGGCTCGTCTGGGTAGGTTTCCAGAAATTCCTTGGCAAGTTCCTTGGCTTTTTCGTACT +CCTTGTTTCTCAAGAGCACCTTTATCGTGTCTTTGTAAAGTTCGGGAGATGGTATTTTTTCAAGGGCGGA +AAGACAGTAGTTTTGGGCAATTTTGGGTTTATCGGAGAGGTATGCACACATCAACGCGTCAAAGTAAGGG +TTTGAAAAAGAAATACTGAATAGTGAAAAAGCCACTATCCACTTTCTCATTCCTGCACCTTGTATATTAG +TATAGGTTTGTTAACTTTGCCAAGGAGTTTCGTCGCAGTTCTGCCGAGAATGAGCTTTTTCAGTCCGGAA +AGCCCTTTAGAGCCTATTATTAGGAGTTCTACCTCGGGGGTTTCGTTAACGTATGAAGATATTACATCAA +CCGCATCTTCTCCCTCCAAAAACTTAACTTCAGTTTTTATCCCTTCTTCTTCAAACCTTCCTTTTAACTC +ATTTAGGATTTTCTTCTTCTCCTCTGAGAATTCTTTCTCTATTTTGTGCTTTAGTTTTTCTATTAAAGGC +ATTTCTATACTTTCGTGGACGTGGACTATCTCAACGCTTACCTTAAAGTTTTTGAGAAATTTTAGGGCAA +ACTCGGCGGTTTTCTGAGCTGTTTTTGAAAAATCGTAAGCAATTACAACCTTTTTCCTGAACTCAACTTC +AGAACCCTTTATCACGAAGTCGCTCTTCTTCCCGTGTTTTACTACCTTTTCCGTGGTAGAACCTATAAGG +AGTTTTTCAATAAGTCCTTTCTTGTGTCCTCCCAAGAAGACCATATCGGGGTTTAGTTTTTCTTCGTAAT +CGAGGATTACGTCAGCGGGGTCTCCCACGTCCACATGGCTCCGGGCTTTTACGGGTTTTAGAAATTCTTC +AAGAGCCTTTAATTTTTCCTTTGCTTCTGCCTTCTTTTCGTCTTCCAGTTTTTCGAGGAGTTCTATGTCT +ATGACGCTCACACCCATGGTTTCGGGGTAGGGCAGGTACAGAACCGGCGGTATAACGTGGAGGAGGTGTA +CCTCGCAATCTACCTTTTCCCCCACCCTCTTTACGGTTCTCAGGAGCGGGTTTGTTATCTCTGAGAAGTC +AACGGGAACTAAGAACTTCATAGTAAGCATTTTAAAATAACAAGAATGCTAAAAATAGGAGTACTGGTTT +CGGGAAGAGGAAGCAACCTTCAAGCGATAATAGACGCCATAGAAAGCGGAAAGGTAAACGCGAGTATAGA +ACTCGTGATTTCCGACAACCCTAAAGCCTACGCCATAGAAAGGTGTAAAAAACACAACGTAGAGTGTAAA +GTAATTCAGAGAAAGGAATTCCCTTCAAAAAAAGAGTTTGAAGAGAGAATGGCTCTTGAGCTGAAGAAAA +AGGGTGTTGAACTTGTAGTGCTTGCGGGTTTTATGAGAATACTCTCTCACAACTTTTTAAAGTACTTTCC +GAATAAGGTTATAAACATACACCCTTCCCTAATTCCCGCCTTTCAGGGGCTGCACGCTCAAAAACAAGCA +GTTGAGTTCGGTGTGAAGTTTTCCGGTTGCACCGTTCACATAGTGGATGAGAGCGTTGATGCTGGACCCG +TAATAGTTCAGGCTGTAGTTCCGGTGCTCCCCGAAGATGATGAAAACACCTTGGCGGACAGAATTTTAAA +GTGGGAACACAAAATACTCCCTCAAACTGTCCAGTGGTTTGCTCAGGACAGGATAATTATCGACGGAAGG +AAGGTAATAGTAAAAGACGCAACCTACGGAACGCTTCCAGTAAATCCCGCTCTTGAGATTTTTTAAGTTT +TTTGTAGAGTCCTTTCGAGGGCTTCCTTTCCTTTATCCGTTATGTAGTACTTTCCTTCTTTTTCTTCAAT +TAAACCCGCGTTTTTGAGTTCCCTCAGGGAGGAACGCACCTGAAAGAGTGGTCTGTTTGCTATGTTCGCT +ATGTCCTGATCGCTCAATCCGGGTTTTTCCAAAAGGGCTTTTAATACAGCTGCTGCCCTTTCCGAGAGCG +TTCCGTCGGGATTTACGCAAGCCATTTTTCTACCTCAAAAAGTTTTTAAAGGAAAGGAAGAAGGATTAAA +CCTTCTTCTTACAGATGTACCAGTCTGCACACTCGTATCCTTCTTGTAGTCTCTTGACCGCGTCTTCGTA +AGTAGTCGGTGGCGGTACGATGACTTTTGTATTTTCTTCGGTAAATTCCCAGGTTTGGGGTTCGGGTACC +CAGTCCGCGGGAGTTGCCACTCCTTCCCTGTCTGCGGTTTGGAGCGCATCAACGAGTCTTATAACTTCCC +TTATGTTCCTACCGGTTGTGAGCGGGTAGTAAATCATAGCCCTGAGTATTCCCTTGTCGTCTATCACAAA +GAGTGCCCTCACAGTGAAGGTTGTGCTCTGTGCTGGGTGTATCATTCCGTACTTCTTTGCAACTTCCATG +TTGTGGTCCGCTATTATGGGGAAGGGGATTTCAATTCCAAACTTTTCCTTTATGTTCATAACCCACGCTA +TGTGTGAGAAGTTGCTGTCAACTGAGAGTCCTATGAGCTGGACGTTTCTCTTCTTGAACTCTTCGTAATT +TTTAGCGAAAGCTACGAACTCGGTAGTACACACAGGTGTGAAGTCCGCGGGGTGTGAAAATAGAACTACC +CACTGTCCCTTAAAGTCATCGGGGAATTTCACGGGACCGAAGGTCGTTTGTGCTTCAAAAGCCGGTGCCG +GCTCACCGAGTCTCGGCAGAGAAACTACTTCCATTTCTTTCCTTTCTTCCATGGCTCCCACCTCCTTTAA +CATTATTTTCATTAATTAATTTTATAAAGATATTGTTAATTGTCAATAACGGAAATCATAAAAGACGGAT +AAAAAATTTTTTATGGTTAGTGTATAATAAGGGGAACGCTTCCTCGGAAAGGACACTGTGCCTCCTATGG +ACACTGGGATACTCGTCGGCTCAATCCAGCTCGACTCCACACTACCCCACCAGCAGGTTAGGGAAATAGG +TAAGAAAATCGCCAGAATTCTGGAGGAAGAAAAGGAGAGGGGACTAAAGAGATATTACTTGGCCTTCGGT +ACGGAACCCGGCACGATCACCATAGGCGGTGGTGGGAACATTCCTGACACTCGTATACGTTCCCATATTC +TACATGGTCATCTACAGGATAAAGCGCTTTCTCTCCTAGCCGTTTTTAAACTTTTCCAGTCTGCTCACCT +GAACGTCCGAGACGAACACAACTCCAGAGTGCTTGTTAAAGAAGGGAGTGAGACCTTCAAGTATAGCTTC +AACCTTCTCTTCGGGCATTACGGATATTACCATGTCAAGAACGTCCTCTTCGTTAAAGAGGAGATGCCCC +TCGTGAAATCCGTGGCTTCCCTTTCCCGAAAGGTTGTGTATTATCGTGTATCCCTTTACTCCCGCCTTTT +CAAGCAGGTCAAGCACAAAGTCTAAATCTTCACCTCTCACGATTATCTCAACTTTCTTCATCTGGTAGAG +GTTAAGCTTACCCATCTTTTACCTCCGTTTTAAGTTCGTTCCAGCTTCCCTTCTTATACCTGTAAAACTT +CTTGCTTTCAGGGTCAAAGATTACGAAGTTCACCCACTCGTTCTGAATCAAGTTTCTGATAGCGTAAACC +CTGTTTATAACGCTCAGGGCAAATTCATAGGGAGCCTCAAGTAGAATTATCAACCTTGCGGGTATGTGGA +GAGGTTTCCCTTCTTTGTAAACGGTCTGAGTTGGGAGTCCGGTTCTCAGGTCGCTGAAGTTTCCGCTAAT +TACGCCGAACCTTCCCACCACGTTGTGGTAAACCTTACTGCCACTTCCGTACACCTCGTTGTCCGTCGTG +GAGAAGTAGTATTCCATGTTAATCCACTGTCCGACTATCGCGGGACCTGAGAGTATAACTTCCAGAAGAA +ATCCCCTCCTGTCCACACGGTAGTCGTAAGAGTGAAGGAATACCTTACCTTCTAGGTTTAGATGTTTTGT +GAGTTCTCTCCTTCCTATTACGAAGGCGTAGTTCCCGGAAAGTCCCCACTCGGGTCTTACCTGTGACCAG +TCGTAGGCGTTTTCAACTACTTTGTATATTTTTCTGAGTTCGTCCTCCGCTTCCTCATCAAAGAGTTCCT +TGTACCTCTCGGAAGCGGTAAGCATGCTCGCTTTGTCAAAGTCTTCCTTTATCTCTTTTAGTTTTTCCTT +AACTTCTTGGGGAAATTGCTCAAGGTCGTAGAAGTGAACCTCGTCCGTTGTGGTGTTGTGAAGTCCCGGA +ACGAAGTAAGTGTTCTCGGGAATGTTAATACCGAACTTTTCCTTTATCCTTTTCCTGACTTCCGGGTTGT +TAGCCATTCTGCAAAAGACTATGGCGTTGTATAGTCCAGAAGCACCACCGCAAGCACCGCAATCAAGGGC +GGATTCATAAGGATTGTTGTCGGACTTGCTCCCGTGCCCGATTATGAAAACGAAGGGGGCAAACTCCGTA +AGCCCCACCATCTTAAGAGCCCTTCCAATAAGGCTCGCCTGTTCGTCAAGGGTAAAACCGAGTTTGCTGA +GTCTCTCAAACAGAATATTCCAGTAACCTCTGTCAACCTTGTACACCTTTCTCAGTCTTTCAATAAATTC +CCTTTGTTTTTCACCTTTAAAGCCGTAGAGTTCCAGTCTTTCAGAGTAGTCCGTTTCTCCCAGGCACACC +TTCAAGGTTTCTTCCAGAAGGGGCTTTTCCGGGTTCTTTATTCCGTATTCGTGCTCAAAAACCCTCTTTA +AGATGGTCTCATACACCCTGTTCACGAGCTCCTTTACTTCCTCTCTTGACGGCTTGTTTATTATGTAGTC +CACATTTTCTTTAGACTCTAAAAGCTTTTCCTTTAGTTTTGAGTAGGAGTAAGGCATGAATGTCTTTCCT +ATGAAGTCAAACCCGAAGAGGAAACCTATCGCTTCAACGGTAACGTAGGGGGTGAGCACGTTTTGTTTTA +AGTCGTGAAGTATGTGCTCAAGGAGATGAGTAACCTCGTATTCTTCCTTCATTTCTTTCGGTATCTCAAG +AACTACGTTTCTCGGCTTTATGAGGACAGGGCACAGGAACTCTTCATGTCCTTTGTGAATTTCAACGAAG +GCCATAGGGACGCCGAAGAACCCCGCTATTCCGTATGTTTCATAATTCCCTATCTTTTCTAAGTTTCTCC +TGTACCTCTCCGAGCGAACGTCTATACAGAAGAGAGCCTGAGCTTTTGGCTTTTCCTTTTCCTGATTTGC +CCTCAGAACGCCCTCTGTTAGCCTTTCTATTAGACTGTCTTCCAGAGCTTCAAGCCATATAAAGCCTTCC +TTTTCTTGAAACTCCCCGTAGATTTCTAAAACTTTTTTAAGTTCTTCCTTAGAAAGTTCCTTTACCCTTT +CACCGAGCCAGTCTTTCAAAAACAGGGCAAAGTTGGAGGCGTTTATGTGGGCTTTCCTTGAAAGGTAGGT +GTTTATAAAACTTTCAGCGTTTTTCAGGTTTTCCCTTACCTGCGAAGAGAGTTCAGCAGGAACCCTCTTG +GTTGCGTACTCGTAGGTGAGGAATGCCTCTTCAATCTTTTCTTCAAAGAACCTTTTGAAGTTTTCATATG +TAGGCTCAAAGGGGTAAACCTTTTTCCTGTGCTCCAGTATTCCCTTTTCCAGAATTAACCTTACAGCAAG +AAATTCCACGAGGTCCGAGGGATAAACCCTCTGGAAGTAGTAGTGTTTGTTGTGAGAACGCCACTTTATG +TAGCCCGCTATCCCTTTCAACTTTGCAAGCTCAAGGGTAATGTAGCGTTCCCACAGCTCCTCGGGAATTC +CGTAAGACTTCAGGATATTATCTATTGCTTCTTCAGGCTCTTCAAAACTTTCCATAAGTTCACCGAGTTC +TCTGCCTCCCCTGATTATAAACCTCAGGTTGTACTTGGCAAGTTCCCTGAAGGCTCTAAAGAATCCCTCC +TTTCTCCTTGGCATTTCAACCACAGACTGCCCTTCGTCCAGAAAGTCCAGGGAAAGCTTTATGAGCAACT +CATTTACAGTTCTGTTTACACTTTCTCCAAAGAAAAGGTCCACAAAGTCCGCTATCGTGTACTTTTTCCC +GAACTCTGAAAACAGGTTTTCCATTACTTCTTTCGGGTTTTCTGAAAAGAACCCCTTCAGTTTTTCAACA +AGATCTGTGTCAGCTTCCCTGATAAGGTAGGTGTTCTCGTAAACTTTCAGCTTTTCGTCTTTTATAAGTC +TTAAGAGATCCTCATAAGTAAGAGGTGCACCTTCCAGATTTACGTTTTCCTTTAAAGAATTCAGTAATTT +TTCTTCTTTTATTAAGCCTTTGTTTAAAAAGTCTATGTAATCCTTTCTCCTTAAAAAAGCTCTTCCTTTA +AATATTTCTTCTCCTTCTTTTATCGCTTTTGAAAAGTGTTCGCCTTCAAGCTCGTGGAGAGGGTTGTGGT +AGACGAAGTTCCGCATAGGCCAGAAGTAGGAAAGCGGTTCTCCCGCTACGTTTACGAGTGAGCGTATGTA +TAACTTCCTTCCAAGTTCCATAACTCTACCCCCTTCAAGCGATAAAGAATCCGATTACAAGCAGTAAGAC +AAGAATTCCCAGGGCTGGTTTGAACACTCTATCGTCTAAATCCGTGTAAATCAGGTCTTCCCTTTCTCTG +TAAAAGAGGAACTTCCCGAGGGATACGAGAATAGCTGTACTCAGTATCACCCAGCCAATTAGGAAAAGGG +CGTATGTGTATAGGTTGAGTTCTATACCTGCGTAGTAGTATGCGTAAAAAGTTATGAAAAGGGGAGCTCC +GTATAAGAAAAGAGCTGTGATAAAGGTAAGTGCGGAAAACTTAGGCGCTTTTTCCAAAAGTCCCGTTATA +AATCCAAACTCAGAAGAGCCATAATACTTTCTAAGGAATTCACCAAGATATACGAGGATTAAAATTCCGA +AAGCTACAAATATCCCGAGCCAGAACTTACTCGAAATCCAGAGAACTGAGGCAGAAGCTCCGAAAATATC +GGGTATAAACTCACTTAAGTTTCTGGAAGAAAGACTCCTTAAAGAGAAAAAGGCAAAGGTTATTAAAGGC +ACGAGTGGAGAAAGAGAAATTTCTCCGAAGAATACCACTCCGAGAAGGGAACCAATAAGTAAAAGAACAG +AATAGGTGTAGGGATTACCCTTCAGCTTTAGAATCAGGTAAACGCTTGGAAGAAGAGGAATAAAGAGTCC +TAGCAGAAGGGTTTTTACGAAATCTGCGGTGCTCAGCTCAAGGGCTAAGAGGAAAAGTGCAAAGAGAGAT +ATTCCCGCGAATACGCTTTCTTTTTTCAAAACATCGGAGACTTTTAAAAGAAACTCTTTAATAAACTCGT +AAAGGTCCGTAAAGTAGAGTTCTCTGGAGAGATGGGTGTAAACGAAGGTGTTGAAGGTAAGGAACTTTTC +CTTGTTGGCGTAATATATGAAAACCCAACCCGCGAGTATTATCAGTCCTATCAGTATCATTTCCGCTATG +AGAACTACAGTATTTGCAAAGGAGCTTTCGTAAATTCTCTCTATTATTTCCTGATTGGGGTAAAGGAACT +TAGAGAGTGTATGTCCCATAACTACGTATCCGAGGAGGAATATAAGGAGTGAGAGTATAGCTATTAATGC +TGAAAGCAGGGGCTTTTCCCTTTCCGTCCTGAAGGTGCTTATCACGGCCTGTGCTCCCGTAGCCCAAGCG +AAAAAGAAGATTATGAGCTGAGTTTCATATTCCAAAAAGTGCTCCTCAACTATCAGGTGTATTAAAACCA +CGAGGAGCAAGGGAACGAGTATGGAGAGCAGTGCGTAAAGCAACCACGGCACGTTTTTCTCAAATTTTAT +TCCTCTTGTCACTACCTTGTAAACTTCGTCTTCTGGGATGTTTGGGTCCTTTCTCGCGCTGTGTATGACG +TTACCCGAGTAAAGGAATAGGGTCGCCTTGAATATACCGTGTGCCATCATGTGGTAAACTGCAAGGGCAA +AAGCACCTATCCCAAACTCCATAACCATGTATCCCATCTGCCCTACAGTGGAGTATCCCAGAGACTTTTT +AACGTCGTTTTGTATAAGCATCAGGGCGGAACCGAGTATCGCCGTAAGAGAACCTACGAAGAAGGCAAGG +TAAAGTCCCGGGTTTTCGTGCGTAAAGAGAAAAGCAGTTCTGTTTACGAGGAAGGCTCCCGCGTTTACTA +TACCCGCATGCATGAGAGCGGATACGGGAGTGGGACCTTCCATACTGTATACAAGCCAGAGGTGAAATGG +AACCTGCGCGGACTTTATCATGGCTGACATAACGACGAGTAGCGGAACTACCCACAGGGTAAACGAGTAC +CCTTCAAAGGAAAGTACGGCCTTTTCAAGTTCGGGAATGCTCAGGGTTCTGAATTCAAGGTAGAGGAGAA +CAATGGCTATAAGCAGGGGAACGTCCGCAAGCCTCTGGGTTATAAAACTCAGGTTGGCGAACCTTACCGC +TTTCTCCTCACGGTAGTTGTGGTTCAGGAGTAAAAACAGGAGAACTCCTACGAGGTGCCAAGCGAAGAAT +AAAAGGAGCAGGTTTCCGGCAACCACGAGAAGGATAAGCGTAGCGGTCATTAAGTCCAGAAGGGCGTAAA +AGCGTCTGTATCCAGGCTCGTCCCTCATGTAGTTTTCCGCGTACTTGTGTATCACAGAACTGACGAGGAG +TATGTAAGTAGAGAGGAGCAGCCCCAGTCTGTCTGGAAAGAGCTCTAAAACTCCGAAGAGAGAAAAGTGA +CCAAATGATCCAGTAAGCAGGAGAATTAAAGAAATGAGGAAGTTTGTGAGTGTAAAAGAAGTACTCAGCC +GCGCTCCCAGAACTCTATTCTCAAGCCTATAGACAAGAAAAGCGGAAACCAGTTGCAGGAGTATAGGGAG +GATGATCATGTATTGCATGGAAGGGTATTATAAGGGGAAAGGGAGAAAAAGGAAAGATGTTTTTTATCAG +TTTTAGATGAGTTGTTGTTGTTTTTTGAGGGCTTTTAATATCTTCTTTCTCCTGTTCCTCTCCCTTTTCT +TCTTCCTTTCACTCGGTGGCTCGTAGTACTCTCTCCTCTTTAACTCGGTCAAAATTTGTTCCTGCTCAAC +TCTTGCCTTGAACCTCTTTAAAACCTTCTCTATAGGTTCTCCTTCCTGAACAATTACCGTAACCAAGCTT +GCATCACCTCCTTTATCGGATTCGTAATTATACCAAATTAAAATCTATTTTAGAGATGTTCAAGTACATA +ATCTTAATAACATTTTTAATGGTTTTCAACCTGGTCTATTCAATCTACTCCCTGAGGGTGTGGAAGGAGT +ACACTGAAAGTTTCTACTTCTACTCACACCTCGTAAAGGAAAACATGTTGCTTATGAAGGAAGTTCACGA +GAGGATTAATTACAGAAAACTCCTGAAGTACGCAAGAAAGCACGGCTTTAAGGATGTAAGTCCGAAAGAC +GTCAAAGGAATTTTAGAGATATATCTAACCAGCGAGAAGAGTGAACAATCGCGCCAGAAGAAATGAAGTC +CACACCTTCAACCGCGTAATCCAGAACGTTATCAAGGGTTATGTTTCCCGAGACCTCTACCAGCGCCCTT +CCCTTTATAATTTCCACAGCTCTTTTTACTTCTTCCGGTGTGAAGTTGTCGAGCATAATCACGTCAACAC +CTGCACTCAGTGCTTCTTCTACCTCTTCCAAGTTTTCAACTTCCACCTCAATTTTGTAAACAGGGGAAAT +CCTTTCCCTTACCCTCTTTACAGCCTCCTTTATGCTTCCGGCCACCCTCTTGTGGTTGTCTTTGATGAGA +ACCATGTCGTAGAGTCCAAACCTGTGGTTCGTCCCGCCTCCTATCCGCACTGCGTACTTTTCAAAGTAAC +GAAAACCCGGCGTTGTCTTCCGAGTGTCTAAAATTTTCACGTTAGTCCCTTTAAGTTTTTCTACAAACTT +TCTCGCCGTTGTGGCGATTCCGGAAAGTCTCTGAAGGATATTCAGGGAAAGTCTCTCACCGATGAGGAGG +CTCTTTGCATCTCCCTCAAGAATTGCAAGTATTTCTCCTTTTTCGAAAACCTCGCCTTCCCTTTTTTTGA +ACTCAACACTTACTCCGCCGAGAATTTCAAAAACCATCTCAACGAAGGGAGCACCTGCAAGTACGCCTTC +TTCCTTTGTCTTTATTACCGCCTTTGCTTTTTCACCTCTGTAAATTCCTTCTGTAGTTATGTCGCCTGTT +CCTATGTCTTCGAGTAAAAACTCTTTTAGTTTTTCCTTTACGAGGATTTCGTTCATGGTTGGGTGGTGGG +GGTGGAGGGAGTCGAACCCTCACGGGCTTTTCGCCCAGGGGATTTTAAGTCCCCCGCGTCTGCCAATTCC +GCCACACCCCCTAACTAAAGAAATATATTATACTTATAGAAAGAACTTTTCTCAAGAAATCATGAGAGAA +CCCATCGTAGCTATAGCCACTCCTTACGGTGAGAGTGCAATAGGTATAGTTCGCCTATCGGGAAAGGGCG +TACTGGACTTAGTTAAGAAGTTCTTCAAAACGAAGAGGGAAATAAAGCCGAGGTACGCCCACTTCGGCGT +TCTCTACGACGATAAAGGCGAAGAACTCGACGAAGGAGTCCTTATATACTACAAAGCTCCTCACTCCTAT +ACGGGCGAGGATATGGTAGAACTCAACCTCCACGGAAATCCGAGGATTCTCAAAAGAGCTCTGGAACTTT +TTGTAAACGCCGGAGCACGGCTCGCAGAACCCGGAGAGTTTACCAAGAGAGCCTTTTTAAACGGAAAACT +GGATTTAACTCAGGCGGAAGCCGTTGCGGAGTTAATATCCGCAAAAACGGAACTTGCGAGGAAGGTAGCC +CTGAAACAACTTCACGGAGAGCTTTCAAAACACATAAGACCTTTGAGAGAAACGCTTCTGGAACTCCTCG +CCTACGTAGAGGCTGACATAGAGTTCGCGGAGGAAGACATACCGACCCTAACAAAGGAACAGGTAATCCA +GATGGTGGACAAAGTAATAGAGGGAATAAACGAACTCCTGAAAACCGCAAAAACCGGAAAGTTCATAAGG +GAAGGTGTAAAATTAGCTATCGTTGGAAGACCCAACGTAGGAAAGTCCTCCCTCTTTAACGCACTCCTCA +AAGAGGAGAGGGCTATAGTCACGGACATAGCTGGAACCACGAGGGACTTTATAGAGGAAACTCTCCAGAT +AAAGGGAGTGCCCGTAAGACTCGTAGACACCGCGGGAATAAGGGAAACTAAAGACCTGGTTGAGAGAATA +GGAGTAGAAAGGAGCAAACAAAAGGTTAAGGAAGCGGATCTTATTCTCTTCGTAATAGACGCAAGTCAGG +AAATTACCGAGGAGGATTTAAGGATATACGAGGAGATAAAGGAAAAGGATCACATCGTAGTGGCTAACAA +GGTGGACTTAGGGATTAGGGCAAATCTCGAAAAGTTTAAAGGAGAAAAAATTGTAAAGGTGAGTGCTTTA +AAGGGAACTGGACTGGAGGAGCTTTCCGAGGAAATTCTGAAAAAAGTCGGTGCAAATCTCGAAGAAAGTG +TTAATATATACATATCCGTTAGACACGAAACTCTTCTCAAAAAGGCAAAAGAAGTTTTAGAAAGGTTTAA +GGAGGAGTTCAGGGAAAAAGATATAAGTCCTGAAATCGCCATGCTTGACCTGAGGGAAGCTTCGGACTAC +TTGGGAGAAATTTTGGGAGAGATTACCACGGAGGATCTTTTAGGAAAAATCTTTTCCACCTTCTGCATAG +GAAAGTAAGAAGAGGAGGTTATCATGACTCAGCAAACCGCTCAACAAGAACAACAAAAGAGTGAAGTAAA +AATTTACAGCAGGGAAGAGTTAAAACAAAAGACCTTAGCGGAGCTCCAGAAAATCGGGAAGGAGCTCGGA +CTCACCAGAACCACGGGACTTAAAAAAGAGGAGTTAATAGAGAAAATACTAAAAGCTCAGCTCGAAAAGA +GCAGACTCGTTTTCGTAAAAGGTGTCCTCGAAATTCTCCCCGAAGGCTACGGCTTCTTAAGGATGCCGGA +GAACAACTACATGCCAAGCTGGAACGACGTTTACGTTGCCCCCTCCCAGATAAAGAAGTTCGGACTCAGA +ACGGGAGATACGATTGAGGGCTTTGCGAGACTGCCCAGAGAAAACGAAAAGTACAAGGCGTTGATCAGAA +TGGAATCCGTGAACGGACTTCCGCCTGACCCCGAAATACTCAAGAGAAGACCCCAGTTTGAAAAGCTCAC +ACCCCTTCACCCCATGGAAAGGTTCAAACTCGAGTACGACCCGAATGAGCTCTCCACCCGTGTGGTCAGC +CTGATAGCACCTATAGGTAAGGGACAGAGAGGATTAATAGTAGCACCTCCGAAGGCCGGAAAAACGGTTC +TCCTCCAGAAAATAGCCCAAGCTATTATAAGAAACCACCCAGAAGTTTACCTCATAATTCTCCTGATAGA +CGAAAGACCCGAAGAAGTCACTGAAATGAGAAGGATAGTGAAGGACAAGGCTGAAGTAGTAGCATCTACT +TTTGACGAACCACCCGAAAGGCACATGCAGGTTGCGGAAATAGTCGTGGAAAAGGCAAAGAGAATGGTAG +AACTCAAGAAAGACGTAGTAATACTTATGGACTCCTTGACAAGGTTTACGAGAGCTTCTAACGCGGTGAC +TCCTCCTACGGGCAGAGTTCTCACGGGTGGTATAGAAATCACAGCCTTCCAGAGACCTAAAAAGTTCTTT +GGTGCTGCGCGGAACATAGAAGAGGGAGGAAGCCTCACCATAATCGCAACCGCTCTCGTAGAGACAGGTT +CAAAGATGGACGATGTAATCTACGAAGAGTTCAAAGGAACGGGTAATATGGAAATACACCTCGACAGAAG +ACTAATGGAAAGGAGGATATTCCCCGCCATAAACATAGAAAAGTCAGGAACCAGAAAGGAAGAACTCCTT +TTAGAGCCCTGGGAACTCCAGAGGATTTGGGTTCTCAGGAAGTTCCTGTCAACAATGGACCCTGTGGAGG +CTATGGAATTCCTCCTTGAAAAACTGAGAAGGTTCAAAACGAACGAGGAGTTCCTTAAAGCCATGAACGC +TTGAAAGCGAAGAACTTTTATAATAACTTTTTTATCTTGCGAGGAGGTAGGTAAATGAAGAAGGGTATTC +ACCCCGAACTAAAACCCACAACTTTCGTATGCGGTTGCGGAAACACCTTTACGCTTCTCTCCACAAAAGG +AGGAACTGTTTACTTAGAAGTTTGCAACCAGTGTCACCCCTTTTACGCGGGCAAACTGAAGATAAAGCCC +GCTTACTACGAAATGCTTGCGGAATTTGAAGGAGGTAAGAAAGAAGAGTAAAAAATGCTGAAGGAAGCCT +ACATATCCAGACTTGACAAACTCCAGGAAAAGTACAGGAAACTTCAGGAAGAACTCAGTAAACCCGAAGT +AATACAGGACGTAGAAAAGTACAAGAAACTCAGTAAAGAGCTTAAAGAACTCCAGGAGATAAACGAGCTA +TACGAAAGATACAAAAAAGCCCAGAAGGAATTAAAGGAAGCAAAGGAGCTTTTGAAGAGTTCGGACAAGG +ACTTAAGGGAACTCGCGGAAGAAGAGGTAAACAGACTTACTGAAGAGATGAAGAAACTTGAAGAAGAGTT +AAAGGTTCACCTGGTTCCAAAGGATCCAAACGATACTAAAAACGTTATCCTTGAAATAAGGGCGGGAGCG +GGTGGTGAGGAGGCTGCCCTCTTTGCCGCGGACCTCTTCAGGATGTACCAGAAGTACGCAGAAGAAAAGG +GCTGGAAGGTAAGTATACTCTCTTCAAACAAAACGGGACTCGGCGGATACAAGGAAGTAATAGCCCTTAT +AGAAGGTGAAGGTGCTTATTCGAGGCTAAAGTACGAAAGCGGTGTCCACAGGGTTCAAAGAGTACCTGTC +ACCGAAAGTAGCGGAAGGATTCACACCTCAACCGCCACCGTGGCGGTTCTTCCCGAAGTTGACGAAACGG +ACATAAAGATTAAGCCAGAGGAACTGAAAATAGAAACCTTCAGGGCTTCGGGAGCGGGCGGACAGTACGT +GAACACCACCGAAACAGCTGTAAGGATTACACACATACCTACGGGTATAGTGGTTCAGTGCCAGGATGAA +AGGTCTCAATTCCAGAACAAACAAAAAGCTCTTAAAATCCTGTACGCGAAACTAAAGGACTACTACGAAA +GAAAGAAGCAGGAAGAAATAGCGAAGGAAAGAAAGGAACAGGTCGGAACTGGAGAGAGGAGTGAAAAGAT +AAGAACTTACAACTTCCCTCAAAATAGGGTTACCGATCACAGGATAAACCTAACCCTTTACAAGCTTCAG +GATGTTCTGGAAGGAAAACTGGACGAAATAATAGACGCCTTGAGGGCGAAGGAAATAGAAAAGAAACTGG +AACTAGTAGAAAAGGAAGGTTAATCCTTTATAGGGATACTTATCCAGAGTTGTTCCTTGTCTACATCCTC +CCTTTTGAGGTTAACTTCTATGTTGCTGGCGTCAAAGTAGGGGTACTTTCCAAACACGCTAACCAAGTCT +CTTTTTATCTCCTCTACTATACTCGGCGGAAGTCCGCTTCTTTCGTAAGATAAAACTAATTGCAGACGTT +TCTTAGCCACGTCTTTACTTTTTCTCGATTTAAATAATCCGAACAATTTCTTACCCTCCTAGTAACCGGC +TCAAAAGCCCTTTCTTTTCTCCGTAGCGCTTCAGGGGAATGCTTTCACCCATTAACCTGCGGGCTGTGTC +TATTATGGCTTGAGATGCGGGAAACTTTTCATCAAGTACTATAGGCTCACCCCTATTAGTAAAGTCCACG +AGTTTCGGTTCTTCGGGAATTATACCGATAATTTCGGCTTTAAGTATATCTACTATATCCTCAACTGATA +GCATAGCCCCCCTTTTCACCATTTCCCACTTTATCCTGTTTACGATAACTTTGTAATTTCTCTTGTCCAT +GCTCTCCAGAAGCCCTATTACCCTGTCCGCGTCCCTTATAGAGGAAACCTCTGGATTAACAACTATTAGA +GCTTTGTCCGCAGGGGATACCGCTATCTGAAAACCTTTTTCTATACCAGCAGGAGAATCTACGAGGATGT +AATCGTAATTTCCTGAATTTTTAATCTCTTCTACAGTTTTGTTCCACTTTTCAATGTCTATTACGTCCTT +ATTTGCCCTCTGGTTTGCGGGAAGTAGCCATAGGGAAAGTCCCCTTTTGTCCTTCACGAGTGCTTTTTCA +TAAGGCACCCTTCCTTCAAGCACGTCAAGAATGTCGTATACTATCCTGTTTTCAAGACCTAGAATCATAT +CCAGGTTTCTCAACCCGATGTCTGCGTCGATTAAGAGGACTTTTTTACCAAGCTTTGCGAGTGCGGTACC +TATGTTTGCGGTAAGTGTAGTTTTTCCTACGCCTCCCTTTCCGGAGGTTATAACAATAACTTCAGCCATC +TTTCCGCTCCTTCTATTGGTTCTAATACTATATCTTCGCCCTCTATTTTTGCAACTTCCGGGTATCCCGG +TGAGTTTCTATCCGCCTCCGACATTATAGCCTTCTTTTTCCCTATCTGGAGGAGTTGAGGCTCCATCTTG +AGAGCCACTATGACCGCCGAGTGATCTCCTATCAAACCGGCCTTTGCAACACCCCTCAGCTTTCCCATAA +CTATGATGTTCCCACCAGCGAGGACCTCGGCATCTTTGTTCACATCTCCGAGTATTAAAATGTCTCCTCT +GTGTTCTATCCTCTGACCTGCCCTTAACGTTCTCTCTATTATGAGAAGTCTGCTTTCTTCCCTTTTCTCC +TTTCCTTCTTTCTTACCTTCTATAAAACCGCGTGAGAACTCCTTCAGGATTTCTTCTACTTTTTTTCTCT +CTTCCGGCTTTAATACTTCCGGGTTTTCAAGGATTATCAAGCTTCCTTTGAATATATTGTGGGAGAGTTT +TTCTTTCAATTCTTTAAGTAATTTATCTATGTTTCCTTTTTCCTTTATCTTTATCTGGATTACGGGAAGT +GTTTTTCCCTTTATCTCTATCACCTTAACTATTATTATAAGGAAGTATGGATGTGTTCGTTCTCGACACG +AGCGTTTTCACAAACCCGGAGATATACAGAACCTTTGAAGAGGATCAGAGAGGAGCTATGGAAACCTTTA +TACACCTTGCCCTGAATTCCAGAGCTGAGTTTTACATGCCCACTTCCGTTTACACGGAAATGAGAAAAAT +AATGGATGTGGGGGAACTCTGGGCGGAATTTGAGATGGTGGTAAAGATACGCTCTCCCAGGAGGTTTCAA +TTAACTGTTCCCGCGGATTTTCTCTATGAGTTCATAGAAGAACTCAGATATAGGATTAATAAAGGTTTGA +GGATAGCGGAAGAACACACGAGGGAAGCGAGCGGTTGTGAAGACGTCGGGAAATTAATAGCTAGGCTCAG +GGAGAAGTACAGGGAAGCCCTCAGGCAGGGAATACTCGACAGTAAAGAGGACGTGGATGTGCTGCTCCTT +GCCTACGAACTGGACGGGGTTCTCGTTTCGGCGGATGAAGGCCTCAGAACATGGGCGGACAAGATAGGTA +TAAAACTCATAGACCCTAAGAATTTCAAAAACATTTTAGAGAGCTTGGTAAGACACAGGTTTTAAATGAG +ACGCCCGCCCTTCAGGGCGTCCCTCACCGCCTTTTCTATACCTTCAGCGTCTATACCGACGAGGTTTCTG +AGTATGTCCTGCTTTCCGTGTTCTATGAACCTGTCCGGCACACCTAAGTTTATTACCCTCTTCATTATTC +CTTCCCTTGCGAAAAACTCCAGAACTCCGCTTCCAAAGCCTCCAACTACCGTATTGTCTTCAACGGTTAT +GAATGTGTCGTACCTATTTGCGAGGTCTCTGAGCATTTTCTCGTCCATCGGCTTTACGAACCTCGCGTTG +ACTACACCTACCCTTATCCCTTCCTTGTAGAGTTTTTCCGCGGCTCTAAGGGCTTGGTATACGGGGTATC +CCACCGCAAGTATAACGCAGTCCTCACCTTCCAGAAGCTCCTCCCAAGTTCCTATTTCTATCTTTTTAAA +ACCTTCGGTAGGAACTCCGTAAGCCGCACCCCTCGGATACCTCAGGGCGAAAGGCTTTCCGCTGTATATA +CCAGTGTAAAGGAGGTCCCTGAGCTCCTGTTCATCTTTTGGAGCGCAAACTACCATATTGGGAACGCATC +TCAGGTAAGAGAGGTCAAAAACTCCGTGGTGGGTGGGACCGTCGTCTCCGACAAGTCCCGCCCTGTCTAT +TGCGAAGGTAACGGGCAGGTTCTGGAGTGCTACGTCGTGGATTACCTGGTCGTAAGCCCTCTGGAGGAAA +GTGGAGTAGTATGCTGCGACTGGTCTTAGTCCTTCTGCGGCGAGTCCTGCAGCAAAGGTGCAAGCGTGCT +GTTCAGCAATTCCTACGTCAAAGAACCTGTCAGGGAACCTCTTTGCGAACTCAACGAGTCCCGAACCTTC +CCTCATGGCGGGAGTAATTGCCACGATTTTCTCGTCCCTTTCAGCCAGTTCCACGAGTGCCTTTCCAAAG +ACCGAGGTCCAGGTGGGAGGAGAGCTTTTTTTAATGATTTCTCCGGACTCAACCTTGTAGGGCGCAACTC +CGTGCCACTTTACGGGATTTTCCTCCGCAGGCTTGTAGCCCTTTCCCTTCTTCGTGTAAACGTGGAGAAG +GACGGGTCCCTTTATATCTTTCACGTTGTTTAATGTATCCTCAAGGGCCTTTATGTCGTGTCCGTCTATG +GGACCTATGTAATTAAAACCGAGTTCCTCGAAAATAACTCCGGGTGATATTAGACCCTTGAGGAACTCCT +CCGTGAGCTTCATTATCCTGAGAGGAGTCTCCCCGAAGTGCTGTAAGAAATTCTTAATCTTTTGTCTCGT +TTCTTGAACGAAATGCCCGCTTATTATCCTGTTCAGGTATGTGGATATCGCTCCTACATTCGGAGATATA +GACATCTCGTTGTCGTTCAGTATCACGATAAACCTGTCCGGTCTTATGTGTCCCGCGTTGTTTAGAGCCT +CGTAAGCCATACCCGCCGTGAGTGCACCGTCCCCTATTACCGCTATAACGTAATCCTCTTTTTCTCCTTT +CAGGTCCTTTCCTATCCTGAAGCCCAGGGCTGCAGAAATAGAGGTAGAGCTGTGTCCTGCTCCGAAGGCG +TCGTATATGCTCTCCTCTCTTCTCAAAAATCCCGAAATGCCCTTATACTGTCTCAAAGTAGGGAATTGCT +CTTTTCTGTCTGTGAGTATCTTCCATGGGTATCCCTGGTGTCCTATGTCCCAGACTATTACGTCCTCAGG +CGGGTTGAAAACCCTCAGGAGTGCTATCGTTAATTCAACAACACCAAGGCTCGGACCTACATGTCCTCCG +TTCTTTGAAGTTACATTTATGATGTAATCCCTTACCTCTTGAGCGAGCTTCTGGAGCGTTTCATAATCGT +AATTCTTTATATCAAAAGGCCCTTTATAGTCCTTCAAGATCTCGTACTTCTCAAGCATAGTGAATAAGTT +ATTCCATCCTCAGAAGAACATCAATCTGAGAAGCCATCCGAAGATAACTACGCTCAATACAAGCCCGAGT +CCCACAACTCCCACAAGTACTCCTATCTTCCAGTTCAGATCCTTTTGCTTTATCCATATAAGGGGGAAGG +TTGCGAGTGTATAGAGCATCAGGAGTATCCCGAGCCACTTGTGGGGGAACAGGAATATGAAGGTTACCTT +TTGTTGAACGTAAGGGTTTGTGGCCTGAGAGAGTCCGGTTATCACCGCAAGAACTACAAACACAGCGGAA +ATTGCGTGGTTAAAGAGTCCGTGGTGCAGGAAAAATAGAACGTGTCTCCTAAAGCCGTAGTAAACTACGT +AGCTCAAGTAAGTCACAAAAATGAGTCCCACGAGGAAGTAATTTACTAGTGGGTGAAGCTTTCCCATACT +TTTAATCATACATTCGCTTTTTCAAACTCGTTCACCTTTTTGTAAAGCTCGTCCAGAACCTGGAGGTAGT +CTTCCTTCCCTTCTTCTACCTTATCCATTAACTCTTCAAGTTTTCTAGTAAACTCTTCCGAGACGAAAGG +CATTATCTTTTCTCTGCTTTTGAGGAATTCGTAAACCTGCTTTCCGAGCTTCGTAGGAATTAAGAAGCCG +TGTCTTTCTATAACGTAGCCCCTTTCAAGGAGTTTGGAAACTATCGTGGCGTAAGTGGATGGTCTGCCTA +TTCCCCTTCTCTTCATCTCTTCAACTAAGGAACCTTGAGTATATAGGTAAGCCATTGGAACGCTCTTTAG +TTCTTTTTTGTCTTCCACATACACGCTCCCTTTCAGGTCCGGCTGGAGTTCTAATGGGTACACTTTGTTA +AAACCTTCTTCAAGAATTTCGGTTGTGAGTATGAGTTCTTGTTCCCTGCCGAGGGCTTTTACTTTCACTT +TCTTGGTTTTTACCTTAACGGGCTTCATCTGAGATGCCATGAACCTCTTGAAGATTAACTCGTAAAGAAG +TAGATGTTCTCTTGTGAGGTTCTGGAGCTGTCCCGCGAGCATCATACTCCTTAGGTCCTCAACGTCTAAA +GGCTTTGTGGGTCTTATACACTCGTGAGCACCGCCCTCTCCCCAAACCCTCGGATAGAAAAGTTCCTTTC +CGAGTTCCTCGCTTATCCACTCTTTCGCCACTCCTATCCCGACGTCCGAAACGCGCGTGGAGTCTGTCCT +GTGGTAAGTTATAAGACCGTACTCAAAGAGTTCCTGGGCGAGTTGCATCAATTTCGGCACGGATATCCTG +TAGCGGTCCGAGGCTTCTTTAAGCATGGTGTCGGTGGTAAAGGGCGGAGGTGGATTTTTCAGTTCTTCTC +TTTCTTCAAGAACTTCAACGTCAATCTCTTTCAGGTTTTCGTAAAACTCCTTTGCTTCCTTTTTGTCCTG +AAACTCAAAACCGAGCCTAAGCCACCTTCCGTTTTCTTTAAAGGTTATCTGAACTACATGCTTTTTCTTT +CTGTAAAGTTTTTCCCTCTCTATAATCCAGCCGAGAACGGGTATCTGAACTCTACCGCCAGAAAGCCAGT +GTTTATCAAAAGCTTGCTGTACTATCCTTGAAACTTCAAAGCCAACCCACCTGTCCGCTATTCTCCTAAC +GAGCTGAGCCTTTACGAGGTTTTCGTTAAAGTCCCTCGGGTTTTCCACGGCGTGTTTTATAGCCTTTCTC +GTCACCTCGTGAAACTCAATCCTTTCCACGTTGGGGATGTAGGGACTTAGCAGTGCTCCGAGGTCCCAGC +CTATCTTTTCCCCTTCCGTGTCTGGGTCCGTTCCGATGAGCACCGTGTCCACCTCCTGAGCGAGTTCCCT +CAGTCCCTTTACTATGTTCTCCTTTCCTTCTATAACTTCGTAAATGGGAACGTATTCACCGTTTTTCGCT +ATTACGCCGTGGAATTCCTTGTCCTTCACAAGGTCAAAAACGTGTCCGAGTGATGCCGTAATCATTATGT +AAAGGTCCCCAACCATTACCTCAAGAACGTCTATGCCCCCTATCTTTCTGCCCATGGGTTTTCCGAAGAA +GTTTGCTATGGTTCTGGCTTTGTTAGGGCTTTCTACCACTACCAGTACGGGCTTGACGTGCTCCTTTTGC +TCCGCTTTTACCTTTCCTTCCAGGATTTCCCTTACCTTCTTCCTGTCCTCGTCTATTTCCCTTAGGACTT +CTTTCAGGTCCACTTCTTCAATTTTCTTGAAGTTTATGTCCTGATTGAACCACCTTACCTTCTTTTCTAA +GTTCTTGAAAGCCCTTCTGTCGTCAACGAGAACGTGGCTCAGACCTTTCGTAAGTCCACCAGCGTACATT +CTTGAAGTTCTTCCGCTCGCCTGAAGGTATCCCGTCACGTCCGCAACGACGAGTTCAAACCCTTCCTCTC +CGAGTCTGAGAGTTAACTCTTCAGAGTTTTTTATCTTTTCAACGATATCTTCCCTCAGCAAGAACTCCTG +AACTTCTTTTCTCAGGTTCTCAATCCTATCTTTTAAATCAGGCCTCTCCTCAACGAAGTCATCGCTCAGG +AAGGAATACCTCCTTAGCCTCTGTATCCACGTGTCAACCTTCTTTACTTCACTCTTCAGTTTTTCGTCCT +TGAGGATTATAGGTCTCAGAGAGAGGAGTGCCCAGAGGAGGTGGGAGACAGAGGTTTCTACTTTGAGGGG +AACTCTTATTTTCGGAACGCCGTAGAAGATTGCGTACCTGACCACGTGGGGAAGGTCAATCCCGCGAGCC +AAGGGGTTTTTAAAGGAAGAGATACCTATCGCTACCTGTGCTTCTCCCTTCTCAAAGAGTTTTAGATCCT +CTTCGTAGGTGACCGCCTTAACTCCGTGGCTTTCTAAGAACTTTTTAACCTCTTCAACAGCTTCCCTTCC +GTAATCAGATGAGACAAAGACGAGTCCTCCCTTTCCGAATTCTTTAACTCTCTTTAGGAGTGTTTCCTTT +AAGTTTTGGGTTTCCTCGTAGGTTTCCACTATGTTTCTGAGAAGGACGCTCGGCTTTCCGACTTCAAATC +CCAGTAGTTCCCTAAAAAGCTTTATCCTGTTTGAACGGGGATTTCCGGTGGCGGAAGAAACCGCAAGAAC +TCCCTTTTTCTTTTTGGCTATCTCCCTGAGTTCCTCGCTCCTTTTCTTTATCTCCTCCCAGTCCTCTTCA +CTCTTATTTGGTTTTTCTTTCAGTCTAATGAGTTCAAAAGCCTTGTGTATGTCTTCCTCGGAAAAACCGA +GGAGGTAGAGAACCTTGTCTACGTTCTTTGCCGTCTTCAGGAAACTGTCCACGTCGTCTACGAAGATGAA +GGAAAAGTCTTTGGGGAGTATCTCGTAATTTTTGTAAAGGAACATAGAAGTTGTGATGAGGATGTCAAAG +TCTCCCTTCTGAATTCTTTCCTTTAACTCTTTTTTCTTCTTTTCCGAGAGTTTGCCCCAGACTATTAATC +TGTCCTCGTCAACGCCGAAGGTTTTTATCCTCTCTGATACCTGCTCAACGAGGAGTTGTGTGGGAAGTAT +TATGTAGGACTTTTTCCCCTGCTTTGCGAGGTAAGATGCCATGGAAAGCCCGAAAGTGGTTTTTCCCACT +CCCGTGGGGGCGAGCATGGCAAAGCTCCTTCCGAGGAATACCTTCCTAGCCCATGACTTTTGCAAACTCC +ACGGAGAAGTCCCCAATATCTCTTTAAAGAAATCTTCCCAGTCTTTCAGCTCGGATAAGAGTTCGCAGAA +CTCTTTAAAGCTCCCATTCTCCAGTTTCTGACAGACTTCCTCTCTATTTACTTCTTCGGGAAGACACTTT +TCACAGGGAAGACCTTTTAGCAGTCTTTCGGCGGATATCTCGCCACCGCAGTTCGGACACAGAGTATCAA +AAATAGCCTTAATCATAAGAAAGAATGATATTACGAGGCGGGGAAATCTTCTCAGGCAATTACTCTGATA +CTTGTCATCTTCGGGAAAGAGGTATATCTTAATAATCGTAAGCTAAACTTAGTTTAAAAAATCAAACTCA +AAGGAGGTGGGAACCATGGCACTCTTTGACGAATGGTATCAAAAAGGACACCAGATCGTCCACGAAGTTA +TGAAGGAGCTCGGAATTGAAGATGAGCACAAAGCCTTCAGACTTCTGAGAGCTGTTCTCCAAACCTTAAG +GGATAGACTCCCCGCCAGTGAAGGAAAGGACTTTGCAGCTCAACTTCCGATGGTTTTGAAAGCAGTCTGG +TGTGACGGCTGGGATCCAACAAGAGTGCCCGACAAGAGCATAAAACACAAACAGGACTTCCTTGAAAGAG +TTATGAACCATCCCGGACTCAGGAGACCTGCGGACATTGAAAGCCTTGAAGACGCAGAAAGAGTTGTAAC +AGCAGTATTCAGAGTTCTAAAGAGACACATTTCTTACGGAGAGATAAAGGACGTCCTGAGCGAACTCCCC +GAAGACATAAGAGAAATGTTAGAAAACGCTTAATTTTTCCTTTCCCCTTTCTAAATTTTTTTATTGGAGT +TGGAATATGAGGGTAAGAGAGCCGGCAGTTGCAGGAACTTTTTACCCGAAGGATAAGGAAGAGCTAAATA +AGTTAATGGATTTACTCTGCGGTTTCGAGCCAAAGGAAAAGATAAAACCCAAAGCCATTTTAGTTCCCCA +CGCGGGCTACATATACAGCGGAAAAACCGCCTGTGAAGTTTACAAGAGGATTGAGATTCCCGAAAAGGTT +GTGCTTCTTGGACCCAACCACACGGGACTTGGAAAACCGATATCCGTGTACAGCGGAGATGCATGGGAAA +CCCCTTACGGAGTTGTTGAGATTGACGGAGAACTGAGGGAGAAAATCTTAAAATACCCCTACGCAAACCC +TGACGAATACGCACATTTGTACGAGCACTCTCTGGAAGTCCAGCTTCCCTTCCTCCAGAGGTACGCAAGA +AGGGAGTTTAAGATACTCCCCATAGTTGTAACCTTTGTGGAGTATGAAGTTGCAAAAGATTTCGGAAGGT +TCTTGGGAGAAGTTCTGAAGGAAGAAGACGCCCTCATAGTTATAAGCTCGGACATGAGCCACTACGTTCC +CGCCGAGGAAGCGAGAAAGAAGGACGAGATACTCATATCCGCCATGGAAAGACTAAACACCGAGGAGCTC +TACTTTAAGGCTGTTCAATACAACATAACAATGTGCGGAGTTGTGCCTGCGGTTGTAGGAATAGAGTCGG +CAAAAGTGCTCGGAGCAACGAAGGGAATAGTGGTTGATTACTCAAACTCCGGAGACACGACGGGAGACTA +CTCTCAGGTGGTAGCTTACTTAGGAATGATTTTCCTTTAATACTTCACTCACGAGAACGCCTTCTCTGAG +TCCCCAGTCGCTCACGATTAAACAATCCTTTTCAAAAATTTCTAAGGTTTTTAAGAATATGCCTATTCCC +GCGAGGATTACCTTTGCCCTCCTGTCCTCAACCTGCCTGAACCTCTTACTCCTTTCCTCCGAAGGGATTT +CTTTGAAAGTATCAAACCACTTCTTTATCTGTCCGTAAGTCAAAACTTTTCCGTGAACTTTCTGTGGGTC +GTAAGGGTAAACGTTATACTCAAGTGCCGCCAGAGTCGTTATAGTTCCGCCCAGTCCCACAATCGTGTCA +ACAGGTTTCTTTACCTTACTAAGTTCCTTCTCTAAAAATTCAAAAAATCTTTTGACTTCCTCTTCCGTTG +GAGGGTCCTGCTTGAAGAAGGTCTCGGTCAAGTTCACTATACCTATGGGTAGGGAAATTACTTCCCTCAC +TTTATACCCCTTTCCGAAAACGTATTCCGTTGAACCACCCCCCTGGTCCACTACACAAACCTCTCCTTCG +GGCTTTAAAGAGTATGCAACCGCAAGGTAGGCATATCTCCCTTCCTGTTCGGGAGTAATCACTTCAACTA +CGAGTCCGACTTCTCTTTTTACCCTCTCCAGAAATTCCTCTGCGTTTTTTGCCCTCCTTATTGCCTCCGT +TGCTACGGCCTTTACCCGTTCTACCTTGAATTCATCAATTAACTTCTTATACTCCTTCAGCACCTGAATG +GTTTCCTCTATCCTGTCCTCTTGAAGCCTTCCCGTTTCCTTTACCTTTGTCCCGAGGGAGGTAATCCTTC +CCCTCTCAAGGATTATGGAGAGTTTTCCGTCTTTGATTTGGGCTATCGTTAGTCTCACGGAGTAGGAGCC +TATGTCTATGGACGCCACCCTCATAATTGGTTTATTATCTAAAGACATGGGCAAGCTCGCTTACGTTTTT +CCCGGACAAGGTTCCCAATACGTGGGTATGGGATACGAGTTTTACAAGCAGTTCCACGAGACCGCTGACG +TGGTTCACGCGGTTGAACACTCCCTCAGAATGTCTTTAGACGATATCGTTGACGTTATGTTCAAGGGTCC +AGAAGAGAAACTGAACAAAACCGTATACACCCAACCTGCACTCTTTGCGATTTCTCTCGGTATATACAAA +GCCCTTGAGAGTATGGGATTTCCAAAGCCAGACTTTGTAGCGGGGCACTCCCTCGGAGAGTATACAGCCC +TTGCTGTTGCGGGCGGGATAGACGTTCAGCTCGGGGCAAGACTCACCTATTACAGGGGAAAGTACATGCA +GGAGGCTGTTCCCGAAGGAAAGGGAGCTATGGTGGCGATTCTGAAACTCCCTCCTGAAAAGGTAGAAGAA +GCGTGTGAAAGGGCGAAGGACGTCGGGGTGGTTGAACCGGCAAACTACAACTCATCTACCCAAACCGTGA +TATCGGGGGAAAAGCCTGCGGTTGAAAAGGCCGCCCAGATAGCAAAGGAAATGGGTGGAAGGGCAATCCC +GTTGAAGGTTTCAGTTCCCTCCCACTGCTCACTGATGAAACCCGCGGCGGACGCCTTTAGGCTTAAACTC +GCTCAAGCTCCGATTCAAAATATTAAAATCCCTCTGGTTCAGAACTACACCGCAAAGGCTCACACCATGG +CACACGAGATAAGGAACAACCTTTACCATCAGATATTTTCCCCGGTAAAGTGGTATCAGAGTGTTATATG +GATGCACGAACAGGGAGTTGATACCTTCGTAGAAATAGGTCCAAAGAACGTTCTCTCAAAACTCATACAG +CAAACGCTCCCGAACGTGAGGGTGTTTAACGTTGAAAAACCAGAAGATGCGGAAAGCGTTTTAAAGGCGA +TAACATGAGGGCTCATCCCGAGTGCATTCCCTGTCTTATAAATCAGGGCCTGAACGCCGTAAAGAAGTTA +AACCTTCCAAAAGAAAAGGAAATGGAAATAGCAACAAGGAGTTTAAAGTTCCTCTCCCAATTTGACACCT +TTGACCGCTCCCCCGCTTACTACGCCTACTTCATCCAGCAAATAGTGAAGGAAATTTCAGGAGAAGAGGA +CCCATTTAAAGACCTTAAAAAACTTGCAAACGAGAAAGCTCAGGAACTCCTGTCTAAAGTTCTCAAAGGA +ACACCCGACCTGAAGGAGGCTCTCAAGCTCTCCGCAATCGGAAACTTCATAGACTTCGCCATAAAAGGTG +TGTTTGACCTTGAAAGGGAACTCCAAAAACTACTGGACAAAGATTTCCTGATTTTTGATTACGATAAGTT +TCTTGAAAGGCTTGAGAACGCCAAAAGTGTTTTCATAATAGGGGACAACGCGGGAGAGATAGTCTTTGAC +AAGGTCCTCGTAAAAACCTTAAAAGGCATGGGAAAGGAGGTCGTTTACGGAGTAAAGGGAAAACCAATTC +TGAACGACGCCACTCTGGAAGACGCGGAAGAAGTATCCATGACACGGCTTTGCAAGGTAATAGACAACGG +CTCGGACAAGGTGGGAACGTGGCTTGAAGACTGCAAAAGGGAGTTTGTGGAAACCTTTTACAGTTCTGAC +ATAGTTATAAGCAAGGGACAGGCTAACTTTGAGACCTTGAGCAGTGCGGACAGGGACCTTTTCTTCCTCC +TCGTTGCAAAGTGTGACCCCATAGGAAGGGAAACGGGAGGGAAGAGAGGAGAGCTCATATTCAAGTACAA +GCCCTCAAAGGATTAACATCCCGTCCCCGTAGCTGTAAAACCTGTATCTCTTTTCCACGGCTTCCCTGTA +AGCCTTAAGTATAAACTCCCTTCCCGCAAAAGCTGAAACGAGGATTAAGAGGGAAGAGCGGGGAAGGTGG +AAGTTGGTAATCATTGCATCAACGACTTTGAACTTAAAGCCCGGATAAATGTAGAGGTCCGTCCAGCCCT +CAAAAGGCTCAAAAGGTTTCGTCTCTAAGGCTCTTACAACTGTCGTTCCCACAGCTACAACTCTTTTACC +CTTTTCCTTGGTCTCCTTTATCTTTTCTACAGTTTCTTTTGGGATTTTTACGTATTCGGGGTCTACTCTG +TGTTCTTCAACCCTTTCCACCTTCACGGGCTTGAATGTTCCGTAAGAAACGTGAAGGGTTATGAAAGCAA +AGTTTATCCCCTTTTCCTTCAGCTTTTCCAGAAGCTCTTCTGAAAAGTGCAGGGAAGCGGTGGGAGATGC +TACTGCTCCCTTTTCCTTTGCAAAAATAGTCTGGTAGTAAACCCTGTCTATTGGCTCTTCCTCTCTCTTG +AGATAAGGAGGGATAGGTATGTGCCCGTACTTGTCTATGAGTTTTAAAGGTTCTTCTCCCAGAAGTTTTA +CCCTGAACTTTCCCTCCTCTATGTGTTCCAGAACCTCCACCTTAAAGTCGGGCGCTACCTCTATCACGAG +TCCGGGTCTTATCTTCTTTCCTCCGATAAGAGCTTTCCACTCGTCCGGCTTTATAAAATCCGTTAGAACT +ACCTCAACCCTTCCGCCCGTAGGCTTTCTCCCGTATAGCCTTGCTGGTATTACCTTCGTGTTGTTGAAAA +CGAGGAGGTCCCCCTCCTCAAGGTAGTCGGGAAGGTTTATAAATGTGTCGTGTTTTATGCTCTGATCCTT +CCTGTTTAGGACCATAAGCCTTGCACTGTGGCGCGGAACTGCCGGGTATTTAGCTATCAGTTCCTCGGGA +AGTTCGTAATCAAATTCTTCAATCCTCATAAGGAAAAAAATTTAAGCTTTCCTCTCAACCACGAAGTCTA +TTAACTTCAGTATCTCCCTTTTGTACTCGTTCTCGGGATACTTTGATATTATCTCTTTAACCACCTTTAG +CTCTTCCTTAGCCCTTTCTTTCGTCTTTTCCACTCCGCCCAGTTCCACCACTTTCTTCCTGAGTTTTTCT +GAGTCTTCAAGTCCTCTTAAAACTCTCTTTACCTCTTCCCTGTCCAGATTGTCCAGAACGGATATAAGTG +GATACGTGCACTTTCCTTCTCTTAGGTCGTTTCCTACGGGCTTCCCTAAAACCTTCGGATCCCCTTCGTA +ATCAAGGGCGTCGTCTATTAACTGAAACGCCCTTCCGAGCCTCAAACCAGCTTCATACAGCTCCCTCCAG +TCTCCGCACTCCCCGCTCATCGCTCCCACACCAAAGCACGCACCGAAAAGAACTCCCGTCTTTCCGTCAA +TAATCTGGAAGTACTCCTCTTCGGATATGATGTCTCCTACTTTGGATATTTCAAGCACTTGCCCTTCCGC +CATGTCCATGACAACTCCGCTGACGAGCCTGATCATTTCCATATTTCCGTATGTAGAAAAGAGGTGCAGG +GACTTTGCGTACATGTAATCACCCGTCAATACCGCCACGCCGTTCCCGAACACGAGGTTTGCGGACTCTC +TTCCCCTTCTCGTCTTTGCCCTGTCAACCACGTCGTCGTGCAGAAGTGAAGCCACGTGTATGTACTCAAG +GGCAACTCCGAGGGGAAGGGCTTTTGAAGGGTCCCCTCCGCACATACCGCTCACGAGTAAGGTAAAGAGG +GGACGGAGTCTCTTTCCTCCGCTCTCTACGATATACCTGCCCGTTTCAAGGACGAGTCTCACTTTGGGGT +TTAGCTCTTCTACGAGTCTGTCTTCTATAGCCTTCAGGATTTCCATCTCAGCACCTTGATAAGTGTGCCC +GGCGGGACTTGAACCCGCGACCCCGGGGTCCGGAGCCCCGTGCTCTGTCCACCTGAGCTACGGGCACTAT +TATAAATAAATTACTTTGATTTCAGTCATAACGTAAACCTTGCAAATGAATGAATTTATAATTCAGTAAT +AAACTATCAAGGAGGTGCTAAAATGAGCTTCGAATACAATGAGAAGGTTCTTGATCACTTCTTGAACCCG +AGGAACGTTGGTGTTCTTGAAGATGCAAACGGTGTAGGACAGTGTGGTAACCCCGCTTGCGGAGACGCAA +TGCTCTTTACTATAAAAGTTAATCCTGAAAACGACGTTATAGAAGACGTAAGGTTTAAGACCTTCGGTTG +CGGTTCTGCGATAGCGGTAAGCTCTATGCTCACAGAAATGGTAAAGGGGAAACCCATACAGTACGCCCTA +AACCTCACCTATAAAGACATATTCGAAGAACTCGGAGGACTGCCACCCCAAAAGATACACTGCACTAACC +TTGGACTCGAAACGCTCCACGTTGCTATAAAGGACTACCTCATGAAGCAGGGTAGAGTAGAGGAAGCTTC +CAAGATACCCGACTGCTACGAAGAAGAGGAAGAACAAGAAGAAAGCAAGGAGTTCGAATTCCTGTCCGGA +ACGTAAGATGGGAAAAAGAAAAGCTCTGGCCCTCCTTTCCGGGGGGCTTGATAGTTCTCTTGCTGTAAAG +CTCGTTCAGGAACAGGGAATAGAAGTAAAGGCTTTTCACTTCTACACGGGTTTCTGTATAACAGAGTTCA +AGAGGAGACTCGGTCAAACTAAAGAGGACGGCTCCCCCTACGTAAACCCCGCCATTAAAGCGGCAGCACA +ACTGGGTGTTCCCATAGAGATAGTTGACATATCAGAGGAGTACTACGACGTAGTGATTAACCCCAAATAC +GGCTACGGTAAAAACGTAAACCCCTGCGTAGACTGCAGGATAATGATGCTAAAAAAAGCCAAGGAGATAA +TGGAGAAGGAAGGTTACGACTTCATAGTCACGGGAGAGGTACTCTACCAGAGACCCATGAGCCAGACCCC +GGAAAGACTAAAGCTCATAGAAAAGGAAGCGGGACTCGAAGGTCTAATTTTGAGACCTCTTTCCGCAAAG +GTTTTGCCCCCAACTATTCCCGAAAAAGAGGGCTGGGTTGACAGGAACAAACTCCTCGGTATAAAGGGAA +GGAGCAGGAAGGTACAGATTGAGCTTGCGAAGAAGTACGGGCTTGACTACGAACAACCCGCAGGCGGATG +TTGTTATCTGACGGATGAGACTTACGCAGCGAGATTCAAAGAAGCCTACGCGACTGAAGGCATCATCACG +AGAATGACCTTGTTCTGTTTGCGGTGGGAAGACACCTCAGACTTCCTTCTGGAACGAAACTGATAGTTGC +GAGAAATCAGGGAGAGGTTAACTTCCTGAAAGGTTTCAGGAACAGGTATAACTACGCCTACAGGAAAGAC +GGAAAGGGTACCTTTGCCCTCATAAAGGGAAATCCTCCCGAGGAAGAACTCCAGCTCATAGCGGACATAA +TCGCAAGGTACTCCAAAAACGAACCTGCAAAGGTGGGCATTCACTTAAACGGTAAGGAAATAGAGCTCAT +AGGAAATCCGCCCAGCGACGAGTTCCTCGAACAGTTCAAGATATACGCAAAGAAGGAGGTAGGACATGGA +CGTTAAGAACATAAAGGCTGACGTAGTTCACGACGTTACGGGAACCTTTTGCCCCGTTCCGGTTGCGGAA +ACCGCCAAACAGATAAAGGAAATGGAAATAGGCCAGGTTCTGGAACTGATAGCGGATGACCCGGGTGTTG +TTGAGGACATTCCCGCCTGGTGCAAAGCCACCGGTCAGGAATTCCTGGGTATGTATGAGGAAGACGGAGA +GTACCACCTATTCGTCAAAAAATCAAGGAGCTCAAGTGATGGTGGCAGTTATGAAGTTTTCTGAAGACAT +TCCCCTTACCACTTTACTTGAAACAGCGCCCGAGTGCGAAGAAATCCTCATGAAGTACGGACTCCAAAAG +ATAAAGGAAGACGGAGTTTACGAAATCGTTGTTCCGAGACTGACACTGAGAGGTTTTATTACACTTATGA +ACCTGAAGGAAAAGGAAAGGGATGAGCTGGTAAGTAAACTTGAGGAAATTTACAATAAAAAATTAAGCGG +AGGCTGAAGTATGGCTGAAATGAAGAAGGTTGAAGAAATTGAAAAAGTGCTCGAAAAAATAAGGCCTGCT +CTTAAGGAACATCAAGGCGAGCTCAAGCTCGTAGATATTAAGGAAGACACCGTTTACCTTTCCTTTGAAG +GAGGTTGCTCCAGCTGTCCGGTTGTAGACATATCCCTCAAAAACCTCGTTGATACAGTAATTAAGGGAAA +CGTCAAGTGGGTTAAGAAAGTAGAAATAACTCAGCAGAAATTCGACATACAGCAATTCGCTTAATGATTA +ACGCCCAAACGCAGCTATACGGAGTAATAGGCTTTCCCGTAAAGCATTCCCTATCCCCCGTTTTCCAGAA +TGCCCTTATAAGATACGCTGGTCTTAATGCGGTATACCTCGCCTTTGAGATTAACCCCGAAGAACTAAAA +AAAGCCTTTGAAGGATTTAAGGCTCTTAAGGTTAAAGGGATTAACGTAACCGTCCCCTTCAAGGAAGAAA +TCATTCCCCTCCTTGACTACGTTGAGGACACAGCTAAGGAAATAGGTGCCGTAAACACGGTAAAGTTTGA +AAACGGAAAAGCTTACGGCTACAACACCGACTGGATAGGTTTTTTAAAATCCCTAAAGAGCTTAATTCCA +GAGGTAAAAGAAAAAAGTATTCTCGTCCTTGGAGCTGGAGGAGCTTCCAGAGCGGTTATTTACGCTCTTG +TAAAAGAAGGGGCAAAGGTATTTCTGTGGAACAGGACAAAGGAAAAGGCAATAAAGCTAGCTCAAAAGTT +TCCCTTAGAGGTTGTAAACTCTCCCGAAGAAGTAATTGACAAGGTTCAAGTAATTGTAAACACGACGAGC +GTAGGACTAAAAGACAAGGATCCCGAAATTTTCAATTACGACTTAATAAAGAAAGACCACGTAGTCGTGG +ACATAATCTACAAAGAGACAAAGCTTTTAAAGAAGGCAAAAGAAAAGGGAGCTAAACTCTTTGACGGGCT +TCCCATGCTTCTGTGGCAGGGAATAGAAGCTTTCAAGATATGGAACGGATGTGAAGTTCCCTACTCTGTG +GCAGAAAGATCTGTAAGAGATCTCCGTGGGTAAAGAGTATTTCTTGAAAGTAGCCTTAAGGGAAGCAAAA +AGAGCCTTTGAGAAAGGAGAAGTTCCCGTAGGTGCAATAATCGTAAAAGAAGGAGAAATAATATCAAAAG +CCCACAACAGTGTGGAAGAACTCAAGGACCCCACCGCCCACGCGGAAATGCTTGCCATAAAGGAAGCCTG +TAGAAGACTAAACACGAAATATTTAGAAGGTTGCGAACTTTACGTTACATTAGAACCCTGCATAATGTGT +TCTTACGCCCTGGTTCTTTCAAGAATAGAAAAGGTTATTTTTTCTGCATTAGACAAAAAACACGGAGGTG +TCGTGAGCGTTTTTAACATTCTGGATGAGCCTACCTTAAACCACAGGGTAAAGTGGGAGTATTACCCACT +TGAGGAAGCATCAGAACTTTTATCAGAGTTCTTCAAAAAGCTCAGGAATAACATAATTTAAATGACACCT +TTTAAAGAACTTCAGAAGTTCATCCACTGGAAAGAGCGATTTTTAAGGGACTACGAAAAGATAGAGAAAG +GAGAACTGGAAAAGATAAGGGAAGAAGTTAAGGAAATGCTCGGGGAGGAGCCCGATGAGAGACTCCTGAA +AGCCTTACGCTCCATGTACGTGGGAGGAATGGAACACAGGGTAGAAGATGAAGAGATCAGGTACTGGACC +AACTGGGGAGGTGTTAAAACTTACGAAACCTTTAACAGGTTTCCCCTGCTGAGCGATATAGAACTCGCCT +TCGTTTTCTGGGCACTCGGGAAGTTATTTGTTCCTCTATTGATGCACGAAACAGGTGTGAAGTCTGAGCC +ATTCAAAAAACTAAGCAGGGAAGAGCAGGAAGAGGCAGTTCTGGACGAACTCGATACTTTGTGGGAAACA +CAACTTACTTTAATTCTTCAAGCTCTTCAATTTCTGGATTTGAAGTCTATTTCAAGCGAGAAGCCCTCTT +CTGAGGGGTAAACTCTTACTTCCCACCCGTGTTGTTCAATTATCTTCTTTACCAGACTCATTCCCACTCC +AAAACCCTTCGGATTTTTACTGAAAAAGGGCTCAAATATATGCTTAGCTTCCTCTTCTGATAAACCTCTC +CCGTTATCCCTGTAAATCAATATTTATGTGTTAATTTCTATAAGTATCTCCTTTCCGCCGTGTTCTATGG +AGTTATTAATCAAATTGTAAAAGACTTCCTTCAGTAATTCCCTGTCTGCCAGTAATACTTTATCTCCGTG +AACTTTAATACTTATACCTGCGTTCTTGTAGAGTTTGGAGACTTCTTGTATTAAGTCCTTCAAGGAAATC +CTTTCTGGTTTCAGTTCTCTTTCCCTTCCTATACTCCTGAACTGGTTTATTAAATTGTTTATCCTCTCCA +CTTCTTCGTAAATCGCCTTCACTATTTCCCTCAATTTATCCTTATCTATTTCTTCCTTTTCGAGCTGTCT +GAGTATCCTTCCAAGGTTCAGCTTTATAGGAGTTAAGGGGTTCTTTATCTCGTGAGCTATCCTTTTTACG +GATTCTCGCCATACCTTGAACCTTTCCGCAAGGACTATCGGGGTTATGTCTTCAAATATGTAAATCTTTC +CCTCGTTCTGGTCAACTTCCTGAATCCTGAGGTTTTTAATGGATTTAACTTCTTTTAAGAAATTTTCTAG +GTTTTCTACTTTCCCGAACATCTGGTTAAAGGTTTTATTCGTGTAAACGTTTCCGTTGTTTTTTTTGAAA +AGTACACCTACTGGGAGGGCATCAAGCAGTCTCTGGAGTGCTTCCTTTTCCTGTTTTAATTTTTCGTAAA +GTTCCCTTAAGTTTTCCTTCATAACTAAAAAAGCACTGCTCAGTTCTTCTATTTCATCTCCTCTTTTTTC +AACTTTTATATCCACATTCAGGTTTCCCTTGGATATTTCCAGAGCTTTTTCCGTGAGTTCTTCAAGGGGT +TCACTCACATACCTTGCAAAGAGCATCGCAAGCCATACCGTTGCAAGAAGGGTAAGGAGTCCCACTGAAA +CCATTAAAAAGGCGTATATTCCCGTGACTATGTCTCTGACTTTTGTAAGGGAACGAAGGTCCAAAGCAAT +ACCGCCGAAACGTTCAAGACTCTCGGGAAACTTGTCCTTTTCGACGAGAACGTACTTATCTCCGAGGCAA +AGGTAATAAACTTCCTTGGTTTCCTTTATCTCGTAATTACACGCTTCCTTGAAGACTCCCTTTACAAAAT +CAAGCTCCTTAATCTTTTCTTCCGGCAAATTCTTTAAAATTTCCCTTTTTTCGTACAAATCCTTTATCCT +GTAATCCTGCAGTTCCCTGTAGGTTAATTCCGCTTCCCTTATTAAATCCCTAATCTTACCGCTCAAAAAC +TCCCTCGTGGTTTGGAAAATTAAGAAAGCCGAGAAAATGTTCAAAATAAATAAGGGAACGAATATGTAAA +AGATTAGTACGTTTACGAGTTTTCTCCTGAGTCTGTGCTTTGCTTTGCCTAGGTAAACCTTTATTAACTT +CCTGAAAATTACCGCGGAAATTATGAGTAAGAAAAGCAGGTCAACGTTTATCGCTATTAGTATGAAGGGA +TAATTTGCATCGGGAAGTTTTTTTAAGTTTAAGAAGAATCCTATATTTACTCCGATAAGGATAATTAAAG +CGAGGAAAAGTAGGAGTTTATTCACCCTTTTCTTTTATGTGCTGGTGTTTTACTATTTCGCCCTCGGACA +GGTATATAGCAGCTTCCGCGACGTTTTCCGCGTGATCCGCTATCCTCTCGTAATGCCTTGCAACGAAAGA +GAGGTGCATAGCTCTCTTTATGTTTCTCGGGTCCTCTAAAACGTAAGTCATGAGTTCACGTTCGAGCTGG +TGGTAGAGTTCGTCCACAGTATCGTCCTTCTCTATTACTTTTTTTGCGAGAAGTGTGTCTTGCTGTATGA +AGGAAATTACGCTGTCGTTTACCATTTCCTTTACTATTTCGGACATGAAGTTTATGTTCACGTAAGGTTT +TAGAGGGGGTTCTTCTGCCAGAAGGATTGCCCTTTCGGCTATGTTTTCCGCCTCATCTCCCATTCTCTCA +AGGTCGGAAACTATCTTGTATATCCCCATTATCATCCTGAGGTCTCCGGCTTCGGGCTGGTACAGGGCTA +TCATCCTTATACACCTTCTCTCTATGTCAACCTCAAGGAGGTCTATCGTGTCATCACCCTTTATCACTTC +TTCCGCCAGTTCCACGTTTTGTTTGTTCAGGGCTTCCGTGGCTTTGTCTATGGCCTCCTGGACGAGTTTT +GCCATTTTTATTACCTGTTCCTTTGTCTCTTCAAGTTCTTTGAAGAGTTTCATAATAGTATTAATATATG +TTGGAAAAGGTTAAGAAAATATTTAGGGAAAGTGCGGAGGTAAAACTCGCCTTCGTGGAGCTCTACGCCC +AGCAAATTGTAGACGTTGCGGGAATAATAGCGACCGCCCTGAAAGACGGAAATAAAGTTCTCCTCTTCGG +AAACGGAGGCAGTGCCGCGGACGCCCAGCACATAGCGGCGGAACTAGTGGGAAGGTTCAAAAAGGAGAGG +AGACCGCTTCCCGCCATAGCACTCACCACGGACACGTCTATCCTCACAGCTCTCGGGAACGATTACGGCT +TTGAGACGATATTTGAAAGACAGGTGGAAGCCCTGTGTATGCCCGGAGACGTGGCTATAGGGATAACGAC +TTCCGGGAACTCTGAAAACGTTATAAGGGGTTTAAAAAAAGCCCACGACCTCGGAGCAACCACGATAGCC +TTCACGGGAAGGAACGGCGGAAAAGTAGCCCAGATAGCCCACTACACATTCATAGTTCCCTCTTACGAGA +CTCAGAGGATTCAGGAGTGTCACATAACCCTCGGACACGTTCTCTGTGAACTCGTTGAAGAGATGGTATG +CGAAAGGTCCTAGTCTTTTTAAAGAATTCCAAAAAGGCATTTGAGACTTTTAAAAGAGTTGAAAGAGTTT +TAAAAGATTTAAACCTCAGCTACAAAAAGTTTATAAACAGGAAGGAACTTTTTAAAGTTTTAAAACCTAA +GGATTATGAACTCTTTCTCGTTATAGGGGGAGATGGTACATTCTTGAGTGCCGCTCGCATCGCTTCGCGT +TTCGGTGTTCCCCTTGTTGGTGTAAACGAAGGGAGGTTCGGTTTTCTCACAGAAATAAAGAAGGAAGAAA +TAAAAAAAGTTCTGCCGCTGGTACTGGAAGGAAGGGCGAAACTTCAGGAGAGGTTGATGATAGACGTTTA +CCTGAGGAGCAGAAACAGGTTGAGGTATCTCGGGAATTACCTGAACGACGCCGTGATTTCAAAGAGCAGT +ATAGCGAGGATAATAAGGACTAAGGTGTTTATAAATGGGGAGGAAGTTCTGGAGGTCTTCGGAGACGGTG +TTATCCTTTCCACACCTACGGGTTCAACCGCCTACGCACTTTCCGCGGGAGGACCGATTGTTTACCCCGA +ATCTCAGAACTTACTCTTCGTTCCCATATGCCCCCATACGCTTTCAAACAGACCCCTCGTTCTTCCCTCT +AAATTTGAAGTCAAGTTCAAAGTGGTTTCGGAAAATATGGAAGCCTTCTTGACCTTGGACGGTCAGGAGG +GATTTCATCTAAAGAAGGGGGACGAGGTAATCGTTAAGCGTTCAAGGTACGTTTGCAGGATGTACTCCCA +TCCCCGTAAGTCCTTTTTCGGGATACTGAAAGAGAAGTTAAGATGGGGTTGATAGCTTTTTAGACTTCCT +GAGGTCGGAACCCTTTATAACGAGCAACTCGTTCATCTCGTAAATTTTTGAAACTACGTTTTCTCCGAGT +CTGCTTGCAAGATCCGCACTTATCCTCACGCTACTCTCTTCTTCCCTCTGGAGTGAGTAATTCGTGGTTA +TTATCGTGCTCTTAAGGTTGTTATACCTGTAAGTGATTATGTAAGAGATGAGTTCCCTCTGCCAGTCACT +GAGCCTCTCAGAACCGAGGTCGTCGAGAACCAAAACCGGTGAGTTTAAGACAGTTTTTAAAAACTTTGTA +TCCTTTCCCTCGTCCATTAAGTGTTTTAACCTGAATATTAGATCCTTCGTATCGAAGAAGTATCCTCTGA +TTCCCTTCTTCTCATAAATCGCTTTTAATGTTGCAACCGCAAGGTGAGTTTTGCCGACTCCAGGAGATCC +TACAAAGGTAAGCCCTTTCCCTTCCTCGGGATTGAAGTTGTGGACGAAGACCCTTATCGTCAAAAGTGCC +CTGTTCTGGGATACGTTCTTGGGGTGGTAAGTGTCTAAGTTGGCGTTCCAGTACCTCTTTGGGATGTTTA +GTTCCCTGTTTACATCCCTTTTCTTGAACCTGCATTCGCAGAGCCTTACCTTGTTGTCTTCGGTCTTTAC +GAATCCCGTCCCCTGACAAATACTGCAGGTAGCGGTATCTTGCATACTTTTAAATATCTGGTTTCGTAAG +TTATTTTTCAATCGTTACTTTTCCTCCCTTTCATAAACTCAACGAGTTCCAAGGGAAAGGGGAATATAAC +GGTCTTCGCGTTGTGTAGTCCTATAGTGTGTAGAGTTTCCAAGTACCTCAGTTGTATGGCTATCGGTTCC +TGAGCTAGAATTCTCGCAGCTTCAAGGAGTTTTTGTGCAGCCTGGTATTCCGCCTCAGCGCTTATTATCT +TAGCCCTCCTTTCCCTTTCCGCCTCAGCCTGCCTTGCAAGAGCCTTTCTCAGTTCTTCTGGAAGGTCTAT +TTTCTTGAGTTCAACCGCTATAACCTTCACACCCCATGGATCCGTTTGCCTGTCTATAATTTCTTGAAGT +TTCATATTTATCTTTTCCCTTTGAGACAGGAGTTCGTCCAGCTCCGCCTCACCGCAGACACTCCTCAAAG +TCGTCTGGGCGATCTGGGAAGTTGCGTAAAAGTAGTCTTCCACCTCGACAATAGCTTTTACAGGGTCAAC +AACCCTGAAGTAAACGACCGCGTCCACCTGAACGGTTACGTTGTCCTTCGTTATAACGTCCTGAGTGGGA +ACGTCCAGAGTTACCGTCCTCAGGGAAACCCTCACTATTCTATCTATAATCGGTATAACTATTATGAGAC +CGGGACCTTTAGCCCCTATTACCCTTCCGAGACGAAACACAACTGCCCTTTCGTACTCGGGAATTACTTT +GATTGCTGAAGCCAAAAACAGCAGGACTAAGATCGCTATGAATATCGGCGGAAGAGGCAAAAATTCCATA +ATAGTATTTAGATTAATTCAAGAATGTAAAAAGCCAAGGTTAAACACGTTATAAATATAACGAGCCCGTA +AGCTTTGTAGAGCCAGACGTTAGTTCTATAAAAGCCCCTGTCTATTTGGCTTATGGTCCTGTAGAAGTTT +GCGGTACCGAGCACGAGTGTTAAAACTCCTATACCGATAATGAAAGCACCTATGCTGAAGAGCTTTTCGT +GGTGAACTCTTGTACTTATGTGAAGTATTCTGTCGAGCTGAACGAGGAAAAATTCAAACTTCTCTATAAC +GAAACCGAAAACAGTTATAGCTATAGCCGTTCTTATCCACGCGAGGAACGTCCTTTCGGCAGCCATGTAG +ATACGGGGGTCAACAACTTCCTTTGCGTCAACCTGTTCACCGCACTTTAAATAACTCATCGTTTTGTAGA +AACTGAAGAGTCCTACAGCGGCTACTAAAGTAGCTATAACCGCAAGAGCTCCTGCTCCTGTTCTCAAGAA +TTCCGCTATATCACCCTTATTCATCATCTTCGCCACCCACTCAATCTTTGTTAGTCCAAGAGCAAAACTG +ATAACCAGAATTGAAAAACGCAGTTGACTGAGGTAAGTCCTTTCCGTGGACATAAAAAGCCTTGGTTCCT +GAAGGGGAGGTAATTTCTTATAAATGTCCACAAAAACTTAATTATATCTTAAAATTTTTAAGTTATGAAG +AGAATGGCGGGAGTCCTCGGAGTAGTTCTCGGAGTCTTTGCCCTTTTCGGAAGCGGGAAGAGCGTAGATT +ACGGAGACTGGTGTCCCAAAGGAAAAAGCCTCGGGAAAGACATTTACGTTGAAGGTATAGTTGACTACGA +AGGTAAGAACTGGTGTAAAGTTGTAGTAAGAACACCTTACTCAGTCACCGAAGTTTATTACACACCCGAT +GGCTCCGGAGAGAAGGTTGTAAAGTACAAGAACGGAAAAAAGATGGCTGAGATAGAGCTCGTGGAAAATC +AGGTTTACCTGAGACTTTACGACAAAAATGGAAAAGTTGTTGAGGAGATAAAGTCGAGGGAAGAGTTTTA +GAATGTAAATTATGATAAAGGTTCTATCACCCGCGAAGATAAACTTGGGGCTGTGGGTTCTGGGGAGGCT +ACCGAGTGGTTACCACGAGATACTTACCCTCTACCAGGAAATCCCCTTTTACGATGAGATTTACATAAGG +GAGGGAGTGCTCAGGGTAGAGACGAATATAGGCATTCCTCAGGAGGAGAACTTAGTTTACAAAGGATTGA +GGGAATTTGAAAGGATAACAGGGATTGAAATTAATTACTCTATCTTTATTCAGAAGAATATACCACCCGG +TGCGGGACTCGGAGGAGGAAGCTCAAATCTGGCGGTAGTTCTAAAAAAGGTAAACGAACTCTTAGGATCT +CCCTTATCTGAGGAAGAACTGAGGGAACTTGTAGGCAGTATTTCCGCAGACGCTCCCTTTTTCCTTCTCG +GAAAGAGCGCTATCGGAAGGGGAAAAGGGGAAGTTCTTGAACCCGTGGAAACTGAAATTTCGGGTAAAAT +CACACTAGTAATCCCTCAAGTCTCTTCAAGCACGGGAAGGGTTTACTCTTCCTTGAGGGAAGAACACTTC +GTTACACCAGAGTACGCGGAAGAAAAAATTCAAAGAATCATCTCGGGAGAGGTTGAGGAAATAGAAAACG +TCCTCGGAGATATAGCGAGGGAACTTTACCCGGAAATAAACGAGGTTTACAGGTTTGTTGAGTATTTGGG +ATTCAAGCCTTTTGTGAGCGGGAGCGGTTCAACGGTTTACTTCTTCGGAGGGGCATCGGAAGAGTTAAAA +AAAGCTGCAAAGATGAGGGGCTGGAAAGTTGTAGAGCTAGAACTCTAAACCTTTGATAAGATAACTCTAA +AGGAGGAGATTATGGAAGAACAAAGATTTGTAGCAGTTCCTTTTGCGCTGGTGGGCTTTTTCGTAACAGA +CAGGGACGTTGAAGAGAGCATAAGGACGGACATGACTCCCGAGGAACTGGAAAAGCTTCAGGAACTCCTC +GCAAGGTTCTTGTTTAAGGAAGGCGTCAGAGTGGCTATTTACCCTTCGGTGGTACCCCCTGAGCAAGCCT +CAGAAGCCGTTAAGGAACTTGAACAATTAATCTTCGGTGAGGAAGAGGGAGAAAAATGAGCGTCAGGGTG +GTAGTTTGTGGTGCCCTCGGTAGGATGGGAAGGAGGATAATAGAACTTGCACTTCAGGATAAAGATGTGG +AAGTAGTCGGAGGAGTTGAACATCCGGACTGCGTACCTTCAATAGATCTGGGAGAAGCCCTTGGAAAGGA +AGAACTGAAAGGAAAACCTCTAACGAGCAGACTCGAAGAACTCCTTCCCTACACGGATGTGGTTATAGAG +TTTTCGGGAAATCCCACCGCGGCTGTAGGGCACGCGGAGTTAACCACCCTTGAAAAGAAGGCGATAGTTA +TAGGAACTACTGGATTTACGAAACAGGAAATTGAACAGATAAAGGAGTTTTCAAAAAACGCTCCCGTTTT +ACTCTCACCCAATATGAGTTTGGGAGTAAACCTCCTCTTCAAACTCGCAGAAATCGCTGCAAAGGTTTTG +AAAGACAAAAACTTTGACGCGGAAATAATGGAAATACACCACAGGTTTAAGAAGGACGCTCCGAGCGGAA +CGGCTATGAAACTCGCCGAAATACTCTCCGAAACTCTTGAGAAGAAGAACTTGGTTTTCGGTAGAAAGGG +AGAAGCTCCCAGAAAAGAGGACGAGATAGGCGTTATGGCTCTAAGGGGTGGAGACGTGGTAGGAGATCAC +ACCGTTTACTTCTTAGGATTTGGTGAGAGGATAGAGCTCACCCACAGGGCGACGTCCAGAGATACCTTTG +CAAAAGGTGCCGTTGAAGCGGCAAAGTGGATTAAGGGGAAAGAACCCGGATTTTACACGATGTTTGACGT +GCTCGGGCTCTGAGCCCTCTTTATATGCTTCACGTAAACGAGAACACCTTTACTTATGTTGTACAAAAAG +TAAAGAGAACTTATAAGGAAGAAAGTGGGAGGGAGAAAGTAAAGCTTAAAAATCAAAAAGATTAAGGAGA +ATATAGAAATTATGTGAAGGTAAAAGTTATTCCACATCTTTTTCTGAGGGATTACCTCAAACATCGTGGG +GGCTTTGGGTACGCCTTTTGTAGAAAGGTGCATCCACACCAGAAATGGGATAATCCTGTACATCATTGCC +ATAATAACGCTTAAAACAAACATTCCAAAGGAAATTAGGAAAAGGTAGAAGAGATTTTCTCTGAACGGGA +ATAAAACACACGAAATTATCAAAAAGGTCATAGATACGTACCAGAGACTGATGAGCGGGTCCTTTATCTT +TCTCTTTCTCCGGAGGAGTAGTTTAATCGTAAAGAAGGCGTAAATTGTAAAAATCAGAGATATAAAAACG +TCTATTAAGGAAAAGTTAGGTAAAAATACTTTCAAAACCAGTAAAGTAAAAACTGTTTTGGGAAGGTAAG +AGGATATAAACTTGGGATAAGGTGGGGTTACGAAAAACATTTCTATAACTTGAAAGGAAACGCTTGCAAC +TAGAGTTGCAGTCCATCCAAAGAGCATAAAACTCATGTGAAGGTCAAATAAATACTTGTGGTTTAAGTTT +ATAAAACCGAATAAATTCAGCACTAAGAACGTTGCAAGAATAATGCCTGCTGTGAAGGAGCCAAGGGCAA +ACCTGAAGCCTCTCGGAGCATCTCTTAAGTTCTTTATCCTTAAAAGTTTATATAGCATAAGGGAAGATAT +GTAGAGGAGGGAAATGAGTAAAAAGAAAAGTCCGAGAAGAGCAACTTTATTGAAAGAATAAAGACCGTAA +ACCAGAAATAAGGTTCCGAGGGTGAGCCCGATGTGTACAAAGGTTGCCTTTTTCAGGGGATCTTCTATTA +CCGCACCCGCCACCACGGGAAGCATCTGAAAGAGAGCTCCTATCATTGTGCTCGCCATGAATCCTAGGGT +GAACACGTGAACGGAAGGAGTTAAGTAAAACTCCTTGTTAAAAGCCTGATAAAGCAGAAACAGGAATTCT +AAGTTCAGAAAAATCAAAGCAGTTATGAAGAACCTCGCGATTATGCTGAAAGGGGGCAGGTAAAGAAGGT +TTAGTCCTCCCGGGCTCATACTTCTCCAAGCTCTGCCATTTTACTGACCATCTTTTCCGCGTTGAGGTTC +TGATCGGACATGGGGTAGAGTATCTGTTCCTCCTTCATGTTGTGTTGCTGGATAAGTATCATCAAAGACT +CACCGAGGGAGAGGAATTCATCCTTGTTCTTTTCCTCCAGAGCCTTTTCCATCCTCTCGAGCAGTTCCCT +TGCCTGATCGTGCTCCATCCTCATTACCTGAGTTGGGCCCATCACTATACCTGTTCTTTGTTCAAACTCG +GGAAATAAAACTTCCTCTTCCTTTTTAAAGTGAAGTAAGGTTTTTTCCTTGAACTCTTTAAAGAGTTCCT +TTGCCTTTTCCCAGTTTCCTTCGTTTACAGCCTTTTCCACTTCCGCGTAAATCTGGTCGCACTTCCTGTG +TTCTTCCGTGAGGTACTGAGTTATACTCATTTTGCACCTCCGTGAGTAAGTATTCATTTATTAATATACA +TCTAAAAAGAAGATTTAAAAGGTTAGAATATTTATCCATGGAAAAGACGGTAACCTTTCTACTCAATCCT +CTCAAAAACAACAAGGTATGGGCTGTACTGATGCCGGACGGTGAGCTAATGGACGATATAGTTTCGGTAA +AAAGGGCTCAAACGTGTATGGAAGAAAACGAACAGATCTGGGTAAACCCCTTCGGCGGTGCCTACATGTG +GGACACGAAAGTGAGCGAACCCTACGAAGCCGAGTTCGTTTTATTCAAAAAAGAAGCCGTTCAATACATG +TGCATCTTCAACTTGCACGAGGCTGACCTTCAGTACATAGATTACTCACCTATAAGCGGTGAACTTCTGT +TTGATGAGGAAGAGTTAAAGAAGAAGTTGGACGAGAAAACGCTTAATGAGTTCAAGATATTTATGAACGA +ACTCTGGGGCTACATAAAGGAAGTCTCTTAATCCTCACTCTCTATCACTATTTCGTCGCAGTCTTCTTTT +TCTATTACCAACTGACAGGTGAGTCTCTGGTCTTCGTCTACCGCCCCCACTCTCCAGAGGGTTTCCTCTT +CTTCCTCCGAAGGCTCGTTTAAACACTCCATTCCCTTTATAACCCTTGCAACGCAAACACCGCACTGACC +GTCCGTACAACCGAACTCTATGCCTGCCTTTTCAATTTCGTGACTGAGCTCACCGAACCTCACACCTTTG +GGTATGTCAAACTCTTTTCCGTTGATAATTACCTTCATACTCAAGTATTCTAAGCAAAAGCTTTATAACG +TTCACTGATTTTCGTTCATCATTCTAGCAGGGCTTCCACGTAGGCGTCAGCGTCAAAGGGCTGAAGATCG +TCAATCCCCTCACCAACACCGACGAGCTTTATTGGGATTTTGAGCTCCCTGCAAATTGCCACTACAGCAC +CGCCTTTTGCACTCCCGTCTAGCTTGGTGACCACTATTCCCGTTATGTCAACAGCTTCCTTAAAGACTTT +CGCCTGTTGAATTGCGTTCTGTCCCGTAGTTGCGTCTATAACGAGCAGGGTCTCGGAAGGCTCCTCTTTG +TCAAACTTCTGTATTACTTTCTTTATCTTCCTGAGTTCGTTAATTAAAGGCTCTTTTGTGTGGAGTCTTC +CCGCGGTGTCCACGAGAACCACCTCGTAGCCTTCTTCTTTCGCCTTTTTCATACCTTCGTAAACCACAGC +TCCAGGATCGGAACCCTCTTCCTTCTTTACTATGTCCACTCCTGCCCTCTTCGCCCAGACTTCTAGCTGT +TCTATAGCCGCCGCCCTGAAGGTGTCTCCCGCAACGAGGAGGACTTTTTTACCTTTCTGTTTTAATTGAT +GGGCAAGTTTCCCTATTGTCGTGGTTTTACCCGAGCCGTTCACTCCCACGAAGAGTAAAACCGCCCCTAC +CTTTTCGGGTATTTTTAACTCTCCCTGACAGTTTTTCAGGAGTTCCTTTAACTCCTTTTTGAGGAGCTCT +TTTATCTTTTCCCCTTCTTTTATATTCTTCCTTATGGCTTCCTTTCTGAGTTTTTCTGTTAATTCTACCG +CTGTTTTCACGCCTACGTCCGCTTTGACGAGCATTTCTTCAAGCTCTTCAAAGAACTCCTCGTCTACTTT +CCTTCCCCTGAAGAGAACTCCAAACTCTACCGCTTCCTTCGTCTTCTGGAGACCTCTCCTTAACTTGTCA +AGTATTGATTCCTTCTTTTCTTCTATGAGACCGAGTTCCTTTTTAAGCTGTGTTATGAAGTTTTCAAGTT +CCTCCTTTTTCTCGTAGGGAACTAGCTTTTCCGCTCTCTGGGCGTACTCAAGGGCTTTATCTGGTTTTTC +TAGCTGGTGGTAAATCTTTGCCACGTTGTAAAGACTCTCAAAGTCTCCAACCTTTAAAAATTCTTCTATC +GCCTTCTGGTACTCACCTACCGCTTGATAAACCTTTGCCCTTTCCTTTGCCTTTCCAATTTTGTCTCCGT +ACTTTTTGAGAAGGGGGTAAGCCTGTACGAGTTTCCCCTCCTGAACGTAAAGTTCAAAGAGAAGTTCCGC +AAGGTCCTCTCTCTGGGAAGCGTACTTCTTTAAAATCTTCTCCGCTTTTTCTTTCTTTCCCTGTTTTATG +AGTTCGAGGATTGCGTTTTTATCCCCTTTTTCCGCCTTTTTCTCTACGTCTGACTTTCTCCAGAAGAAAA +CCATACTGTATTAATTTAAACAAAGATTTTAAGTCGCTTAACGCCTTTCTCTTTTCAAGTGGTAGTAGGG +CTCTATAGTTTGTATCCTCGGGTCCTCCACAGCCTTTCCGAAGGTAAAGTGGTACAGATCCTGAAAGGTT +TTATCGCTTATTCCAAGAACTTCGTGCATTGCGTCGTCAAAAAAGCACCCTATTCCCGTGCCGTTGAGGT +TGTGAGCAGTAGCCTCGAGATACAAAACCTGACCTATTAAGCCTGCCTCCCAGTGTAAATTCCTGTAAAA +CCAAGGCTCTTCTCTTAAAACTGGCTCAAACAAAGATATCATCCCGAGGGAAAAAGCACTGTCGCTCGCT +ATGTCCTGAGCACACGCGACAAAGCCCGCAACTTCCCTGAAATCTCCCGTCTTTAGCAGGTACAGGGGGA +AGTCCTCAAAAACCTTTTCCCAGAGGAATTCGGAAGAGGTTATCTCTTTTAAATCTTTTAAAAGCTCTTC +ATTTCTCACAAAGCAGTAAAGTCCCTTCGGGAGGTTCTCAACCCTGTTGACGAATATAAAGAGATTCACA +AAAGGAAGTCCTATTTCAACGTCAAAGGGGGAGTAATTGTCCCTTGGCAAGGTTTTATCAAGGGCGTGTA +TAAACAGTTCCCTCAATATGTAAGTCTTTCCGTCGTAAGCCATACCGCTCCTTCTCTTTCTAATGACCTC +TTCTGCGGACATGTATGAGGGAACCAGGTTCAGGATGGGAGGGTTTCCGTAGATTACCCTGAACTCCTCC +GTTCTCGGTTTTTCGGTCTCCTTTATAGCCCTGTAAATTATCTCCCAGATGACCCTTTCCTTACTCAGAA +CGTTAGGCCTTCCGTAGAAGTTCAGCTTCTTAAACTCGTTGATTATGCTTTCGGGGATTGTCCTCGGAAC +GTCCTGTACTTCCTTCGGGAATACAAATAAGGCAAGTTCTGGAAACTCCTCTTCCCCTTCTACCCACTGA +ACCCTATCAAATCCCAGCAGAATTTCCAAATCTTTATCCGAGAGGGCGTTTAAGTATTTAACTTTCCAAC +CTTTTAAGTTGGCAGAAAACCTCACGCTACCTATTGCGTGCCCCGTGTCAAGGAGGCAGTACCTGTATGC +CCTCTCCCCGTACTTCCAGGATTCCCTCCAGGGGATACTCGTGAGGATTAATATAAAACCTTCTGTCCCG +AAAAAGTCCTTAATTTTTTGGGAAAGCTCGTAAGGGATATCCGCCCTCTTCTCAAGGGCGTGAAGGAAAG +GATTGTAGTGAAAAACTCCCTGAAGACCTCCGAGGTGAGGTATTATTACGTAGCACTCCGTGGGGTGAAG +GTTTCCGCTAGAGGGGTTCATCCTCACTGACCAGCGAGAGCCCGGTATAGCCTTCCAGGCGGAAAGCCCG +AGGGCAAGCTCTAAAAACTTACTCAAGCTCTTTACGTTAAACTCTTCCGTGTTTACGAGTCCGTAGTCGT +AGAGAGCCTCATACGGGTGGGAAGGATCCTTAAGGAGCGGGAGATCTAGTCTTTCCGTCCCCTCCCAGAA +CCTGAAGGGATTGGGCTGATTTTCCCAGTCCAGATATCCCAGCGAGCGTGCAAACCTGTAAGGGTAGTGC +TTTGTCTCCGAGTGATAAAAGAGAACCTCCCTGAAGTCTCCCACACCTACAAGTATAAAATAAAGTTCCT +ATGAAAGAACTCGTAAAGGAGAAAGTCCTTAAGGCTTTAAAGGAACTCTACAACACACAGGTGGAAAACT +TCAAGGTTGAAAAGCCAAAGGAAGAAGCCCACGGAGACCTCGCCTCGAATGTAGCGTTCCTGCTTGCAAG +AGAACTAAAAAAACCTCCCGTAAATATAGCCCAGGAGCTAGCGGATTTCTTATCAAAAGACGAGACTTTC +AAAAGCGTTGAGGCGGTAAAAGGTTTTATAAACTTCCGTTTCTCCGAAGATTTCTTAAAAGAAGAGTTTA +AAAAGTTCCTCCTCAGCGGAGAGGCATACTTCAAAGAAGACTTAGGAAAGGGTTTAAAGGTTCAACTTGA +GTACGTGAGTGCGAATCCCACGGGTCCGCTTCATTTAGGACACGGCAGGGGTGCGGTGGTCGGAGATACA +CTCGCAAGGCTTTTTAAGTTCTTCAATTACGACGTTACGAGAGAGTACTACATAAACGACGCGGGAAGGC +AAGTTTACCTCCTCGGTATCTCTATATATTACAGATACTTAGAAAAGTGCCCTGAAAGGGACGAAGAAAC +CTTTAAAGAAATAAAAGAGATATTTGAAAAAGACGGATACAGGGGGGAGTACGTAAAGGAAATCGCGGAA +AGGCTAAGAAAACTAGTAGGGGAAAGTCTCTGCAAACCCGAAGAAGCAAACCTGAAGGAAGTAAGGGAAA +AGATTTTAAAAGAGGAAAGTATTGAACTCTACTACACGAAGAAGTACGAACCGAAGGACGTTGTTGACCT +CCTCTCTAACTACGGACTTGACCTCATGATGAAAGAGATAAGGGAGGATCTATCCTTAATGGACATTTCC +TTTGACGTCTGGTTCAGTGAAAGGAGTCTATACGACAGTGGAGAAGTGGAGAGACTAATAAACCTTTTAA +AGGAAAAGGGATACGTTTACGAGAAAGACGGGGCACTCTGGCTGAAGACTTCCCTTTTCGGGGACGATAA +AGACAGGGTTGTGAAACGTTCGGACGGCACATACACTTACTTTGCCTCGGACATAGCTTACCACTACAAC +AAGTTCAAAAGGGGCTTTGAAAAAGTTATAAACGTCTGGGGAGCGGACCACCACGGATACATCCCTAGGG +TAAAAGCAGCCCTTAAAATGCTGGAAATTCCAGAAGACTGGCTTGAAATCCTGCTTGTCCAGATGGTGAA +ACTCTTCAGGGAAGGAAAGGAAGTTAAGATGTCAAAAAGGGCGGGAACTTTCGTAACCTTGAGAGAGCTA +CTTGATGAGGTAGGAAAAGACGCTGTGAGGTTTATATTCCTTACAAAGAGAAGTGACACGCCCCTTGACT +TTGACGTTGAAAAGGCAAAAGAAAAGAGTTCCGAAAACCCCGTTTACTACGTACAGTACGCGCACGCAAG +AATTTCGGGGATATTCAGGGAGTTTAAGGAAAGGTATAAAAAAGACGTATCCGTGGAGGAGTTAATAAAC +TACGTTCAGCACTTGGAAGAAGAGGCTGAAATAAAACTCATAAAGAAGGTTCTATTTTTCAAAGACGAAC +TCGTTGACATAACCTTAAAGAGGGAGCCTCACCTCCTTACCTACTACCTGATAGACCTTGCCGGGGATTT +TCACCACTACTACAACCACCACAGGATACTGGGAATGGAGGAAAACGTTATGTTTTCAAGACTGGCTCTC +GTGAAGGGCATAAAGGAAGTGGTAAGACTGGGGCTCAACCTCATGGGAGTAAGTGCTCCAGAGAGGATGT +AATTGTGAGATAATTTCTCTCATGCGCAGTGACGGAAGAAAAGAGGATCAACTCAGACCAGTAAGTATTC +AGAGAGACTTTCTTGAATATCCGGAAGGTTCGTGTCTTATAAGTTTTGGAAAAACAAAAGTAATATGCAC +CGCCTCCGTAATAGAGAACGTTCCCAACTGGTTAAAAGGTAAGGGGCAGGGCTGGATAACTGCGGAATAC +TCGATGCTCCCGAGGGCTACCCAGCAAAGGACTATAAGGGAGTCCGTTCAGGGAAGGATAGGGGGAAGGA +CGCACGAGATACAGAGGATGATAGGAAGGGCTATGAGAACCGCCGTTGAACTCACAAAGATAGGCGAAAG +GACTATATGGGTTGACTGCGACGTAATTCAGGCGGACGGTGGTACGAGAACCGCCGCGATAACGGGTGCC +TTTGTAGCTGTAGCAGACGCGATAATTAAGCTCCACAAGGAAGGGATAATTGAGGAGACTCCCATTAAGG +ACTTCGTTGCTGCGGTTAGCGTGGGAATTGTTAACGACCGAATACTCCTCGACCTTAACTTTGAAGAGGA +CTCCGCAGCTCAGGTTGATATGAATGTTGTGGGAACGGGAAGCGGAAGGCTTTCCGAGGTGCACACCATG +GGAGAAGAGTACAGTTTCACAAAAGATGAGCTCATAAAGATGCTTGACCTTGCCCAGAAAGGCATAAACG +AACTCATAGAACTCCAGAAGAAACTTTACGTGATACAGGACGGAAAATGGGAAAGGAGCGAACTGAAGGA +AGTAAGCTCTACTACTTAGGCTGTTCGGGATACTTTTACCCCGGATGGAGGGGGAAGTTTTATCCCAAAG +ATTTAAAACCTAAAGATTGGCTGAAGTATTACTCTAAATTTTTCAACACCGTTGAAATAAACTCAACTTT +TTATCACTTTCCAAATGAAAAGAACTTAAGAAGACTTTACAGGGAAACTCCAAAGGACTTTAAATTTTCG +GTTAAAGTGAACAGAAACATAACCCATTACAGGAAGTTCAAAGACGTAAAAGAATTAATAAAAAACTTTT +ACGAAGTGTGCAGAAATGGATTGAGGGAAAAACTCGGATGTGTATTGTTCCAGCTGCCTCCTTCTTACAC +CTATACGAAGGAAAATCTTGAGAGAATTCTGGAAAACTTGGACTTTGGATTTAAAAATGTCCTTGAGTTC +AGACATATATCCTGGTGGAATGAGGAAGTATTTAAAATCTTAAAAGAAAGAAATGTAACGTTTTGCTCCG +TAAGTGCTCCAAATCTTCCCGAATCATTAATTGAAACCTCGGAAACAGTCTACATAAGATTCCACGGAAA +AACGAGCTGGTACAAGTACAATTACTCGGAAAGGGAACTGAAAAGCTGGGCAAAGAAGATAAAGAAGTCT +GGAGCTAAAGAAATTTTTGCTTACTTTAACAACGATTACAACGCCTACGCACCTCAAAACTGTTTGAAAC +TCAAGGAACTTCTCGGGTTGCTAACAGTTAACTAATTTCTTAATAATACTTGAAGGTAGGAACGGTTAAA +CTAATTTTCCATGGAATTCGTAGTAAAGGAAACGGACGGAGATACTCTATACAAGTTAGTACTCGGACTA +GTTGTTCCAAGACCTATAGGATGGGTTTCCACGATCAGCAAGGACGGAATACTGAATATAGCTCCTTTTA +GTTTCTTCAACGTCGTAAACGACGAACCGCCCGTTTTAATGATATCGGTGAGCAACAGGGACGACAACAC +TTTAAAAGACACAGTAAAGAACGTACTTGACACAAAAGAATTCGTTGTAAACATGGTGAGCGAAGAAGTA +TTTGAGAAAATGCTGATCACGGGAGAGGAATTTCCGCCCGAAGTAAACGAGTTTGAAAAGGCAGGCTTAA +CACCAGAAACTTCAAAATTCGTAAAAGCTCCAAGAATTAAAGAAGCAAAAGTCTCTTTTGAGTGCAAACT +TTATAAGTACGTCCCCGTTTACGATATGCACGTGATATTTGGGGAAGCTCTTTTAATAAAAGTAGAAGAT +ACAATTCTCGACGAAAACTTAAACGTCAATTATGAAAAGTACAGACCAATAGGAAGGCTCGGGGGGAAGT +ACTATGTTAAAGCTTTTGGAGAATGTAAGTTGAAGGTATAATAAGCCGTATTATGGCAGCGGCACCGGTA +GAGGGAAATGGGGCAGGATTAGACGTCCATACTTTATTTTTGCACTTAGCTATACTCCTATTTTCCGCAA +AGCTTTTCGGTTCGATATTCAGGAAACTAGGTATCCCTCCCGTCCTCGGAGAGGTCACAGCGGGTGTAAT +TCTCGGTCAGAGCGTACTTGGGTTAATTCCGCTCTCGGAAGCAATAAAGGTCCTTGCGGAACTCGGTGTA +ATACTCCTACTCTTCGAAGTAGGTCTTGAAGCCGACATAAATATGTTAATGAGAGTGGGCCTTTGGTCCA +CTTTAGTCGCAATAGTTGGAGCAGCACTTCCCTTTGCGGGAGGGTTTATAGTTTCCTACTACTTCTTCGG +TCTTGATCTCGTGGCTTCACTCTTTATGGGAGGGGCACTTACCGCAACGAGCATAGGTATAACGGTAAGG +GTTTTAACCGATTTGAATAAACACAAAGAACGTTTTGCTCAGATAGTCCTCGGTGCGGCAGTTCTGGACG +ATATTATGGGTGTTATAATCCTCGCAGCTTTGTACGAATTTTCAAAAACGAAGGCAGTTCATTTTGACAC +CACGGTTAATCTGATAATACACATCTTGATGTTCTTCCTTATAGCTCCCTTCGTTGCAAACGTCTTAGCA +AAACTCCTTTCCATAGCTGCGAGGAAGACTCAGGACATGGATTTAATCCCTGCTTCTATAATGGCTCTTA +TACTACTCGCAGCTTATTCAGCTCATAAATTCGGTTCTCCGAGTATTCTCGGTTCTTTTACCGCAGGACT +TGCCCTCTCGAGGAGATTCGTAATCCCCTTTGCCGCTATGCTCCGTTTGGACGAAAAATTGCTTCACAAG +GTTGAGGAGTCAATAACTCCCCTTGTATGGGTAATGGCTCCTATATTCTTCGTTTCCGTAGGACTTGCAC +TTAACTTAAAAGCTATAGACTTTTCCTCTCCGGAGTTCTGGACCTTTTCTTCAGCACTTATAGTAGTAGC +GATAATAGGAAAAGTTCTGGCGGGTTTCGTAGCTCCGGGTTCATTGAAGGAAAAGGCAAGCATAGGCTTT +TCCATGCTCCCCCGTGGAGAAGTGGGATTGATATTTGCCGAGTTCGGAAGGAGCTTTAAAGCTATAAACG +AGGTAGAGTACGCAGTTATCGTTTTCGTCGTGGCTGTTACAACGTTAATAGCCCCGATAGTTCTTAAACT +TCTTTTAAAAGAAGAATAGATGGAATGGGGGCATGTTTTAACAATAATTTTTGGCACAGCAGGGTTTATA +GGCTCAGTAAAAGGATAGACAGCGTTGAGAAAAGGATAGACGATTTAAAAGATGGCATAAAAGAAATAAG +ACAGGAATTAAAAGAAATCGCGGGTGAAGTTAAAGAACTAAAAGAACTCCTCTACAAGGTTCTGGAGGCG +GAAGCTAAAAAAGAAGTTTAAAAGTTCTATCTTTAATCTTTATGGAGGCAAAGGAGAAGAAGTACGGAGA +AATTGAGATCGAAAAGGCACAGCTCGAGGCATGGCCGAATCCAAATCCCGAAAGGGATTACATGATAGAG +ATAACATTTCCTGAATTTACGTGCCTGTGTCCGCGTTCAGGTTATCCAGACTTTGCAACGATAAAAATCC +GCTACATTCCCGACAAGTACATAGTTGAGTTAAAGTCCTTAAAGCTCTGGCTCAATAAGTTCAGGAACAG +GTACATATCCCACGAGGCGGCTACAAACGAGATATACCAAGCCCTTTACGACCTTCTTAAACCCAGATTC +TTGGAAGTTGTGGGAGACTTTCATCCGAGGGGTAATGTGCATACCGTTGTAAGGGTAAGGAGTGATGAGA +ATTACGGATAATGGCGGAGGGGGAGGGATTCGAACCCTCGGAGGGGTTTTAGCCCCTCTGCCGCTTAGCA +AGCGGCCGCCTTCGGCCTCTCGGCCACCCCTCCTTTACAAAACTATTTAAATAATTATATTCTCAAAACT +TACCCTTTTCCAGCCTTTTTAAGGAGTAGTAATCCCCTATGCCGTACTTAAACCAGAGTTCCTCAAGGAT +TTTTATAAAGATTTCTGCGGTAAGGGTTGCGTCCTTTAAAGCCCTGTGAACTCCGTTCGTCTCAAAACCG +AAGTTCTCAGCTATTTCCTTTAAAGAGTACTTTTTAAGTCCCGGAAAAACTTTTCTCGCCAACTTCAGCG +TGCAGAGAGACGGGTTTCTGAACTTTTTTCCCCTGTACTGTTTTGTGTACTTGTTTATGAACTTTATGTC +CTGTTCTACGAAGTGTCCAACCACTATGTTATCACCCACGAATTCCAGAAATTCGGGCAGAACTTCTTCT +ATGGTGGGTTGTCCTACGAGCATGGCGTTTGTTATGCCCGTTAACTTCTTTATCCTCTCTGGAATGAAGT +AACCTGGATAAACCAGAGTTGAGAACTTTTCAGTTATTATCCCTCCTTCAACGCGTACAGCGGCAAGGTC +TATAACTTCAGACTTTTCAACGTCAAACCCGGTAGCCTCCAGGTCTATAACGACGAAAGTGCCATCAAGG +AGATTGTCTCGCATTTTAAGACTTTTGGGAGAGCTCTTCAATCTCGTAATCCTCTATTAACGGGTTGATG +AGGTACTTTTCTACAAGCTTTCTGAGATCGGTGTCTTCTGAAACTTCGAGTTCAACAACTTTTCCTACTC +TCACGTTTGATACGTTAAAGCCGTTTTCCTTTAACATCTCCTCAACGGCTCTGCCCTGAGGGTCCAGAAG +CCCCTCTTTCGGCATTATTATTACCCTTACGAGCTTCATAAAAACCTCCTTCCCTTAAATTTTAATCACA +TTCAAGAAGGATAAAACTTATGTTGTCCTTGCCATCCTGATAGGCAAGCTCAAAGAGGCAGTTAGCTCTT +AATTTTATGTCCTCTTTGGAAAGACAGGAAACCTTTTCCCTGAAAGAGAGAGCTTCCCAGAGACCATCCG +AGCATATTAGGAAAGTGTCTCCTTTCTTTACTTCCTCTTCTCTGACGAACACCTCGGGAAGGTCAGGGTA +ACCTCCTAGGATCGCACTCTCGAGTATGTGCCTTTCGGGATGGAGTCTCAGTTCTTCGTAGGAAATCCTC +CCTTCCTTGTAGTACTGAAAGAGGTAAGTGTGGTCCTCCGTCAGGAGTTCTAAATTTCCGTCTCTGAAGC +GGTAAACTCTGCAGTCTCCCACGTTAAAAACAATTGCTCTATCTTTTGAGAGGTAAACACCCGCAAGGGC +AGTTCCAAAGCCGTAGCAAAACTCATTTCCTTCGTTTATATACTCGTCAAGTCTCTTTTTAGCTTTTAAA +ATTATCTCCTTGATATATTCGGGTTTCTCCGGTTTTTCTTCCTTTAATACTTCCAGAACTAAACCGCTCG +CCTTTTCACCGCACGCGTGTCCGCCGAGGCCGTCTGCCACCGCAAAGGGGGTGAATTCATAAACCTCAAA +CTCTTCAACCTGAGGTGTGTTCATAGACGTTTCCCTGAAGAGTTTTCCGTCTACGAGCAGGGCATCTTCG +TTTTTGGGTCTTACCTTTCCCGTGTTCGTAATGTATGCGGTCCTTACCTTCATTTTTCTTTGATGGCTTC +CAAGAGGCACTCCCTCATTAAGTCCTCGGATGGCGTTCCTATGTCCCTTATGGTTTCAAAGTCCTTGTTA +AAGCCCTCCTTTTCAAGCTTCTTCATGAGTATTTTGAACACGTTTTTGAGACCTTCTTTCATTGGGATGC +CTTCTTTGAATATGTAAAGTTCGTCGTCCTCGTTGAAGAACTCTATACCGTATTCTTCAGGGTTTTCTAT +CTCAAAGTCAACGCCGAGGGCGTAAGCCTGACCGTGTTTTATGGCGTTCTCCTCGGGAATGTAGTGTTCA +GAAAAACAAGAGTACTTTACATCTTTGAAAAGGTTTTCATCCATCGGGGTAGCAACTATATATAAAGCCT +CTTCCTGCTTAACTTCTCCTTTTTCGTTCACACCCGCAAGGGTAACTAAATAGCTCCAGGACTTCATAAT +AAGAATATTTAAACCTGCCCTGCGGTATTGCAAACTTTTTGCAGTTTAACTATTTTTTAAAAGTAATCTT +CAGGAGGAGGTCATGAACGCGTTGAAAAACTTCTTTATATGGGCAATCATTATCGGAGCTGCGATAGTAG +CCTTTAACCTATTTGAAGGAAAAAGAGAATTTACCACGAAGGTTTCCTTAAACGAAGTAGTTAAGCTCGT +TGAGGAAGGTAAGGTAAGTTACGCGGAGGTAAGGGGAAACACGGCGATAATTCAAACTAAAGACGGACAA +AAACTGGAGGTGACTCTCCCACCTAACACGAACTTAGTTGACAAAATGGTTGAGAAAGGTGTAAGGGTTG +AAGTTGCAAACCCAGAACCGCCCGGAGGGTGGCTCGTAAACGTATTCCTCTCATGGCTTCCAATACTCTT +CTTTATCGGTATATGGATATTCCTCCTCAGGCAGATGTCGGGGGGTGGAAACGTAAACAGGGCCTTTAAC +TTCGGAAAGAGCAGGGCGAAGGTTTACATAGAGGAAAAACCGAAGGTAACTTTCAAGGACGTTGCAGGAA +TAGAAGAAGTAAAGGAAGAAGTAAAGGAAATTATTGAATACCTGAAAGACCCCGTTAAGTTCCAGAAGCT +CGGCGGAAGACCTCCCAAGGGAGTTCTCCTTTACGGTGAGCCAGGTGTGGGTAAAACGCTCCTTGCGAAA +GCTATCGCGGGCGAGGCTCACGTTCCCTTCATCTCGGTCTCTGGTTCTGACTTCGTTGAGATGTTCGTCG +GTGTAGGAGCCGCACGGGTAAGGGACCTTTTTGAAACCGCAAAGAAGCACGCTCCCTGCATAATCTTTAT +AGACGAGATTGACGCGGTAGGAAGGGCAAGGGGAGCTATTCCCGTAGGCGGTGGACACGATGAGAGAGAA +CAAACCTTAAACCAGCTTCTCGTTGAAATGGACGGCTTTGACACCTCAGACGGTATTATCGTAATCGCCG +CAACCAACAGACCAGACATCTTAGACCCGGCTCTTTTAAGGCCCGGACGTTTTGACAGGCAGATATTTAT +ACCCAAACCTGACGTAAGAGGTAGGTACGAAATACTCAAAGTTCATGCGAGGAACAAGAAACTCGCTAAG +GACGTTGACCTTGAGTTTGTGGCGAGGGCAACCCCGGGCTTTACGGGAGCGGACCTTGAAAACCTCCTAA +ACGAAGCGGCATTACTCGCGGCAAGGAAAGGTAAAGAAGAGATAACTATGGAAGAAATAGAAGAAGCCCT +AGACAGGATTACTATGGGACTAGAAAGAAAGGGAATGACCATATCGCCAAAAGAAAAGGAGAAGATAGCT +ATACACGAAGCCGGACACGCCCTCATGGGACTCGTCTCCGATGACGATGACAAGGTTCACAAGATATCCA +TAATCCCGAGGGGTATGGCTCTGGGAGTAACGCAACAACTTCCCATAGAAGACAAGCATATATACGACAA +AAAGGATCTCTACAACAAGATACTGGTGCTTCTGGGCGGAAGGGCTGCGGAAGAGGTATTCTTCGGAAAA +GATGGAATCACTACGGGAGCAGAAAATGACCTTCAGAGAGCAACGGACCTCGCTTACAGAATGGTTTCCA +TGTGGGGTATGAGCGATAAGGTCGGTCCGATAGCTATAAGGAGGGTGGCAAATCCCTTCCTCGGAGGAAT +GACCACAGCGGTAGACACAAGCCCTGACCTTTTAAGGGAAATAGACGAAGAGGTAAAGAGGATTATTACG +GAACAGTATGAAAAGGCTAAAGCTATAGTGGAGGAATACAAAGAACCCTTGAAAGCCGTGGTCAAGAAGC +TACTTGAGAAGGAAACGATAACCTGCGAGGAGTTCGTAGAAGTGTTCAAGCTCTACGGTATAGAGCTTAA +AGACAAGTGTAAGAAAGAGGAACTCTTTGACAAAGACAGGAAATCTGAGGAAAATAAAGAACTTAAATCT +GAAGAAGTTAAGGAGGAGGTAGTCTGATGGGAATGACTATAACCGAGAAGATTCTGGCGGAACACGCTGG +TAAGAAGGAAGTCCACCCCGGAGAACTCATAACTGCAAAGATAGACCTCGCAATGGCAAACGATGTGACC +GCACCCCTTGCCATAAAGATACTTGAGAAGTACGGAATAGATAAGGTCTTTGACCCTGAGAGGATAGCCC +TTGTTCTCTCACACTTCGTTCCCGCAAAGGACATAAAGTCCGCTGAGCAGGCAAAGATAGTAAGAGAATT +CGTAAAAAAGCACGGTATAAAGTGGTTCTTTGAAGAGGGAGAAGGTATAGAACACGCCATACTCCCCGAG +CAAGGACTCGTCGTTCCCGGGGACCTCGTTGTAGGTGCGGACTCCCACACCTGCACTTACGGAGCTCTCG +GAGCCTTTGCAACGGGGGTCGGTTCCACCGATATAGCCTACGCTATGGCTACCGGAGAAGTTTGGCTCAG +AGTTCCCGAAAGTATGAAGTTCATCTTCTACGGAAAACTAAAACCATGGGTGATGGGAAAGGACCTAATC +CTCTACACGATAGGGCAAATAGGGGTTGACGGAGCACTCTACAGGGCTATGGAATTTGACGGAGAGACCA +TAAGAAACCTTTCTATGGAACAGAGGTTTACTATAGCAAACATGGCGATAGAAGCGGGTGGAAAGAGCGG +AATAATCTCTCCTGATGAAAAAACGATAGAATACGTAAAACAAAGGGCAAAGAGACCATGGAAAGTTTAC +CAGAGCGACCCTGACGCTGAGTACCACTCCGTTTACGAGTGGGACGCTTCTCAGATAGAACCCTTAGTAG +CGTGGCCCTACCTACCTTCAAACGTGCATCCCGTTTCTGAATCCACCCATATAACGATAGACCAGGCATT +TATAGGCTCCTGCACAAACGGAAGAATAGAGGACCTGAGAGTTGCAGCAAAGGTGTTTGAAGCTGCGCTA +AAGCAAGGAAAGAAAGTTCACCCTTACGTGAGGTGCATAGTAATTCCCGCGTCCAAGGCTATATACAAGC +AAGCTTTGAAAGAAGGACTCATAGATATCTTTATGGAAGCCGGTTGCGTGGTTTCTACTTCTACGTGCGG +TCCCTGCCTTGGTGGACACATGGGAGTGCTTGCGGAAGGTGAAAGGTGTATATCCACATCTAACAGAAAC +TTCCCCGGAAGGATGGGTCATCCTAAGAGCGAAAGCTACCTCGCAAACCCTGCCGTGGTCGCTGCGAGTG +CAATAATGGGAAGAATTGCCCACCCCGACGAGGTGGTGAAAGCCGAAACCCTTGCGGGTGTTTAATTCTT +CTTTTCTTTATGCCCGTAAAGTTAAAGGTTTACTTAAAACCTGAGAAACCTATAAAATCAAGCCTTCTCA +CACCTGAGGCGGTTCACGGTCTCTTTTTTAACCTCCTTTCGGAAGAATTCGCAGAAGAACTCCACAGACC +TTCAAAGGTAAAGCCCTTTTTCCCTGTGGTTTCCTCAATTTTACGAAGAGGAAAAGGAACTTGATAAGTT +CTATCTGGAAGTCTTATTTCTGCAAGAAAGTTTAATGCCCAAATTTTTATCTTCCTTTTTACTTGAAAAT +AAAGAAATCCGTTTAAACGGTGTAAAACTGAAAAAAGTTTTAAGCCCGAAAGTGAGCGAGGAGAGTATTA +AATCTTACGAAACCCTTTTTAATTAGGCAGGAGAGGAAAACACCGTGGTTATGGACTTCATATCACCGAC +GACGTTTAAAAAGGGCGATTTTGACCATCCCCTTCCTGAACAGAAGTTCGTTTTTAAAAGCCTGATAAGA +AAGTAGGTGAGGTTTTCCGATTTTCCCCTTGATGCAGATTTAAGGGAATTTATTGAGAAAAATATTTTCG +TGTCTGGCGTATGGACAAAGACGAGGAAAGTTGAAACGGGACAAAATGCAAAACTCGTAGGCTTCACGGG +AAGGGTAGTTTACTACGTGTGGATAAACGCCCTCTCTTCCTTTTCTGAGTTTGCCGGCGTAGGCAGAAAA +ACCACAATGGGTTTCGGAAAAACAAGAAAAGTTCCCCTCAAAAATTTAGAATGATGTATAATAAATTTAC +AGCCTTGCTGAGGGCTTTTTAGCTCCTTGGCAATTGAATAGGGTTTATGGGTCTTGATAAGTGATGCTTT +GATGATGTGATGAAATGAAATCATGATGTGATATGATTGAAGTGATTGAAAATCAAGGGTAAAAATTTTA +TAAAGGCATACTCAATTTTGCAGAACCTCGGGTTAGCGGAAATTAACATTCGTTTCATTAAGGTCAGAAG +TCTAATAAGTTATTTATAAAGCGTTTTTTTAGACACAGGCGTGCAGGGTTACGCCCTAATAATGAGGGAT +TGCGACTATAATAATGTGGCTCTCTGCAATGATAACAAAAAGCGTTGAAATGCCCTAAGTAAATAAGAGG +TTTTTCTTTCTCATTTCATAAACTTAATAAATAAACACTCACTTATAATTAATATTTCCTATGGCTAAGA +TAAAGCACCTTGAGGAAAAGTTCGGGGAAAAGCCTGTAAGTGAGCTCGTTTATGAAGATGAGAACGCAAA +AGTAATCAGGTTTTACCTTAAGAAGGGACAGGAGATAAAGCCTCACACATCCCCTTCCAGCGTTTACATT +ACAGTTTTAAAAGGGAAAGTAACTTTCACAGCGGGAGAGGAAAAAATCAAAGGGGAGCAAGGTTCTACGA +TTTACTACGAGCCTAATGAACTCCACGGATTTGTGGCAGAAGAGGATAGCGTTCTGGAAGCTGTCATAAC +TCCAAAACCCGTGAGGAAAGTAAGCCTCAAATAAGAAATTCTTATATCCTTATAATGATAAGTAAGTGTT +GATTTACTTTGATAAAGGTCATAATATTAATATCAAATGGGGAAGCAGGAGAAGGACTTAGGAACTGCTT +GGGAGTATCAGGGTTGTCTTATTCCGAAAGATCTTTATTACGACATAGAAAATCAGGTCTGGGTAAGAGT +AAACGAAGACGGAACGGTAACGCTCGGGCTCACGGACGTGGGACAGACCCGTGCCGGTAGACTACTCCAT +ATAAGGGTAAAACCCGTAGGGACGAAAGTAAAGAAGGGAAAACCAGTTGCGACACTTGAAAGCGGGAAGT +GGGCCGGACCCGTTCCCGCACTCGTGGAGGGCGAAATCGTTGAAGTAAACCCGAAAGTCGTGGAAGACCC +GAACTACATAAACATTGACCCTTACGGAGATGCGTGGATCGTAAAGATTAAACCCACAAGCGAAGAAACG +CTCAAGAGAGACCTCTCCGAACTTGCTCACGGTGAAAAAGCTCACGAAGAAATGAAAAAGCATATAGACG +AGTGGGATATAGTTTGTATGAGGTGTGTGTGATGGGTGCGAAGGATAAACACGTTATTCTTCTGGTTTCT +CAATGGTGTCCTACATGTCCTCATGCGGATGCCCTCTGGAAAAAACTTCAGGAAGAATACGGCTTTAAGT +ATGAAGTTCTGGACATAGGTACTCCGGAGGGCAGGTACTGGGTCACAAAGCTAATGGTAAGGAGTGTTCC +TTCCACGGTTATAGACGGTAAGCTTGCATTCGTGGGGGTGCCAAACGAAGCGGAAGCACGCAAAGCAATA +GAGGAGGGGGTTTAACTTTATACCTTTTTATAATCTTTAAGTATGTACTTTCAAGACATCATAATGACCC +TTCACAAGTTCTGGGCTGAAAAGGGATGTTTAATCTGGCAACCCTACGACGTTGAAGTCGGTGCAGGGAC +AATGAACCCTGCCACTTTCCTGAAAGTTCTTGGTAAAAAGCCGTGGAACGTCGCATACGTTGAACCCTCA +AGAAGGCCTCAGGACGGAAGGTACGGAGAAAACCCCAACAGACTCCAGCACTACTACCAGTTTCAGGTAA +TTTTAAAGCCCGCACCCCGAAATCCTCAGGAGATTTACCTTGAAAGCCTTGAAAGACTAGGCATAAATCC +CCTGGAACACGACATAAGGTTCGTGGAAGACGACTGGGAATCTCCTACCTTGGGAGCATGGGGACTCGGC +TGGGAGGTCTGGCTTGACGGAATGGAAATAACCCAGTTCACCTACTTCCAGCAGGCGGGAGGACTTGACC +TTGACGAGATATCCGTTGAGATCACTTACGGACTGGAAAGGATAGCGATGTACATACAGGATAAAGACAG +CGTTTTTGACATAGAGTGGAAAGAGGGAATAACCTACGGCGAGATATTCAAGCGTTCGGAGTGGGAGTGG +AGCAAGTACAACTTTGAACTTGCAGACACGGATATGCTCTTTCAGGTTTACGAAATGTTTGAAAAGGAAT +CAAAAAGGATGGTTGAAGAAGGGCTTATATTCCCCGCTTATGACTACCTCCTGAAGTGTTCCCACGTGTT +TAACATACTGGACGCAAGAGGAGCTATTTCCGTTCAGGAGAGGGCGAGGTACATAAGGAGGATGAACAAC +CTTGCAAGGGAAATAGCAAAGCTCTATCTTCAAGTCTTTGAAAATGTTGGAGCAACTTGAAAAAAAACTC +GGCTACACCTTTAAGGATAAATCTCTACTCGAAAAAGCCTTAACCCACGTATCTTACTCAAAAAAAGAAC +ACTACGAAACTCTTGAGTTCCTCGGCGATGCCCTCGTGAATTTTTTTATAGTTGACCTTCTGGTTCAGTA +TTCCCCCAACAAAAGGGAAGGCTTTTTATCTCCCTTGAAAGCTTACCTCATAAGTGAAGAGTTTTTTAAT +TTACTCGCTCAAAAACTGGAACTTCATAAATTCATAAGAATAAAGAGAGGAAAGATAAACGAAACAATTA +TAGGAGACGTATTTGAAGCTCTTTGGGCAGCGGTTTACATAGATTCGGGAAGGGACGCAAACTTCACACG +GGAACTTTTTTACAAACTTTTTAAAGAAGATATACTGAGTGCTATAAAAGAGGGAAGAGTAAAAAAAGAT +TACAAAACGATACTTCAGGAGATCACTCAAAAACGATGGAAGGAAAGACCGGAATACAGACTCATAAGTG +TTGAAGGTCCTCACCATAAAAAGAAGTTCATAGTGGAAGCAAAAATAAAAGAGTACCGAACACTCGGCGA +AGGAAAGAGCAAAAAGGAAGCTGAACAAAGGGCAGCCGAGGAATTAATTAAATTACTGGAGGAATCAGAA +TGAAAAAAGGAGTAATACTTATAAACCTCGGCGGACCTGATTCTCTGGAAGCGGTAGAGCCGTTCCTTTA +TAACCTTTTCTCAGATCCAGATATTTTCTCCTTACCCTTTCAAAAAGTTCTCGCAAAAATAATCGCAAAG +TTAAGGGCTAAAAAAACGAGACATTACTACGAGCTTATGGGAGGAAAGTCTCCCCAATACGAACAAACCC +TTGAACAGGCTAAAGCACTTCAGGAAAGACTAGGAGAAGATTACAAGGTAGTTGTGGGAATGAGATACTG +GAAACCTTACATAAAAGACGCACTTTCTGAACTCCTGAAGGAAGGAATAAACGAAGTAATACTCCTTCCC +CTGTACCCCCAGTACAGCAAAACGACAACTGGTTCCGCTTTTAACGAGTTTGAAAGGAGCAAAAAAGCCC +TCAAAGCGGACCACATTAAAGTTAAGAAAATAGAACACTTTTACGACCACCCCCTCTATATAAAGGCGTG +GGCCGAGCAGATAAAACAGAGCGTTGAAAAGCCCGAAGAATACCATTTTCTCTTTTCCGCCCACAGCCTT +CCCAAGAAATTGATAGAAGAAGGAGACCCTTATCAGGAACAAACCGAAAAAACGGTAAAACTCATTATGG +AAAATTTCCCTGAAGTAGAATACACGCTTGCTTACCAGAGTAAAGTGGGTTTCGGAAAGTGGCTCGAACC +CTCAACAGACGAAGTAATCAGAAACCTGATTAAGAAAGAAGTTAAAAAGTTATTAGTTATTCCCATATCC +TTTGTTTCCGAACACAGCGAAACCCTTTACGAACTCGACAAACAATACAGAGAACTTGCCCAAGAACTGG +GATACGAAGAATTCGTAAGAGTCCCTACTCTAAGAACAAACCCCTACTTCATATCTGCACTTGAAGATTT +AGTAAAAAATGAAGTATAGTAAAATTAAGTAAAGGGCTTTTTTAGCCCTCTCGTGGCTCCTTGGCAACTG +AATAGGGTTTATGGGTCTTGATAAGTGATGCTTTGATGATGTGATGAAATGAAATCATGATGTGATATGA +TTGAAGTGATTGAAAATCAAGGGTAAAAATTTTATAAAGGCATACTCAATTTTGCAGAACCTCGGGTTAG +CGGAAATTAACATTCGTTTCATTAAGGTCAGAAGTCTAATAAGTTATTTATAAAGCGTTTTTTTAGACAC +AGGCGTGCAGGGTTCCTAATGTACCATAGAGGAGTTGAAACGTCGTCTATGAAGTCGTAAGCCTCTTTAA +GTTTTTGTTTAGTTCCTAATGTACCGTGCGGAGCTTAAACTTTTATCATGTATGTACAGGATTATTTGAA +TCTTGTGGTTATGCCCTAATAATGAGGGATTGTGATTCCATAACATTCCGTATTGACGAATGCCCTGTTC +CCCTCCTGAGCATAAAGAATGCTTACCTGAAAGTTAATGAAATATCTCCCGAAGACTTTGTTGATAGAAT +TAAGCATTCCGGCTATCTTTCAATGCTAAGAAAAGGGGAATTAATTAAAACTTTAGAATGTGATTTTAAT +CTAAATTTAAGAAAAAAGTGCGAGAAAAATCTGGAAAAAGGAGACAAGGCTATATTAATAATCCATGAAG +AAAAGGAATTAAAGTTTTTCGATATTGAGGTCTTGTAAACTTTACTCCTGAAGCAAGGCCTTGGGGTAAG +AACCGAGAACCTTCAGGAATTGGGTTTTTTCTTTGAGTTCTTTCAATGCCTTTTCTACTCTCTCTTCTTC +CTTGTGTCCTTCTAAATCTACGAAAAAGACGTAATCCCAAGCCTTCTTCTTTGATGGTCTTGATTCGATC +TTGGTTAAGTTAATTCCGTGTTTGTAAAAGACTTCTAAGGCTTTGTAGAGAGCTCCGGGCTCGTCTTTTA +CACCGAAAAGTATGCTCGTCTTATCGCTTCCCGTGGGTTTTAAATCCCTCTTCGCTATAACTAAGAACCT +CGTGAAGTTGTCTCCCGAATCCTGAATGTTTCTTGCGAGTATGTTGAGGTGGTAAGTGTAGGCCGCAACT +TCCGAGGCTACGGCTCCAGCTCTCTCATCTTCAAGGGCGATTTCACAAGCTTTTGCGGTGCTCTCTACTT +CTATAACCTGTACACTCGGAAGATTTTTCTCAAGCCAACTCCTGCACTGGGCAAGGGCCATTTTATGGGA +ATAAACCTTTTCAACGTTTTCTATACTATCCGAAGCCGAGAGCAAGTGTAGCGTTATGGGTATCACTATC +TCTCCCGCAATCTTTACGTCACTTTCCAGGAACATGTCAAGGGTGTAATTAACTACTCCCTCTATCGTGT +TTTCCACGGGAACTACGCCGTAATCCGCCCTTTTCGTTTCCACTTCCACGAACACGTCCCTTATGGTGGA +ACATGGTGTGTAGTGAGCAGAAAATCCGAAAAACTCAAGGGCAGCTTGATGGGTAAATGTAGCCTTTGGA +CCAAGGTAGGCTACTTTTATTTTCTTTTCTAAGGAAAGACAAGCGGAGATAATCTCCCTGTATATGTGAA +CGAGTGCCTCTTGAGGAAAAACACCGCCGTAAACTTCTTTGTTAAGCCTCAGTATTTTTTCAAAAATTTC +CCTTTCCCTTTCGGGGACGTGTATGGGGAGGTTTGCCTTTGACTTTATTTCCCCTATCCTCTTTGCAAGC +TTTGCCCTTTCGTTTAAGAGCCTGAGTATCTCTTCGTCTATCCTGTCTATCTCTTTTCTGAGTTCCTTTA +GCTCTTCCATTCCAGACTTAAAATTTTATGTTAAAATAACCTCTCTCGTAAAAGGAGGCATCGCATGAGA +GTAAAGGGACCTTCTTCCAGAAGGAAAAAGAAGAAAATCCTTAAACTGGCTAAAGGTTACAGAGGTCAGA +GGAGCAGATCTTACAGAAGGGCAAAAGAAGCAGTAATGAGAGCCCTGTACTACCAGTACAGGGACAGAAA +ACTCAGAAAGAGGGAATTCAGGAGACTATGGATCGCGAGGATAAACGCGGCAGTCAGGGCTTACGGTTTG +AATTACAGTACTTTCATAAACGGACTTAAAAAGGCCGGAATAGAACTAGACAGGAAGATCCTCGCGGATA +TGGCGGTAAGAGATCCCCAAGCTTTTGAACAGGTCGTTAACAAAGTTAAGGAAGCCCTGCAAGTTCAGTG +ATGGAAAAGCTCGACAAAATCCTCGAGGAGTTAAAATTACTCCTCTCTTCTGTCTCTTCCCTTAAAGAAC +TTCAAGAAGTAAGGAGCAAGTTCTTAGGGAGTAAGGGTGTCATAAAGGAGCTTCTCAAGAAAATCAAGGA +AGTTCCCTCCGAAGAGAGGAAGGAGTACGGAAAAAGAGTTAACCTACTCAAGGAAGAGGCTGAAAAGCTA +ATAAAGGAAAAGGAAGAGGAACTCAAGGAAAGGGAACTTGAAGAAAAGCTAAAAGGCGAATGGGTTGACC +TGAGCATTCCTCCGGCTAGGACTGTAGGTTCTCTTCACCCCATAACAGTTACGCTCGAGAGGATTGTGAC +GATATTCAGAGGAATGGGATTTGAGGTTGAGGAAGGTCCCGAGGTAGAGAGGGAAGAGTATAACTTTGAT +ATGCTCAACATTCCCAAGGAACACCCTGCAAGGGACATGCAGGATACTTTTTACGTAAACAGGGAGGGCT +ACCTTCTGAGGACTCACACCTCTCCCGTCCAGATAAGAACCATGCTCAAGAAAAAGCCTCCCATCCAGAT +AATAGCCCCCGGGAAGGTTTACAGGAGGGACGACGATCCCACTCACTCTCCTATGTTCCATCAGGTTGAA +GGGCTTGTTGTAAACGAGTATGCAAACTTCAGACACATGAAGTACGTAATTGAGGAATTCCTGAAGAAGT +TCTTTGAAACTGACCTTCCTGTGAGGTTCAGAACCTCATACTTTCCCTTCACGGAGCCCTCCGCGGAAGT +TGACATAGGTTGTGTTATATGTCATCAGGAGGGTTGCAGGGTTTGTAAACATACGGGATGGCTTGAAGTA +ATGGGTTGCGGAATGGTTCACCCTAAGGTTCTCGAAAACTGCGGTATAGACACGGATTTTTACCAGGGAT +TTGCCTTCGGAATGGGTGTTGAGAGACTCGCGATGCTCCTCTTTGGCATAGATAACATAAAGCTCTTTTA +CGAAAACGACCTCAGGTTCATAAAGCAGTTCTTCTGAAGGTTAAAATGAGAAAGCAGATCGTAGAACTAT +TTTTAATAATCCTCGCTGTTTTATTCATAAGGGAGTACATAGCACAGGCTTACACCATTCCCTCCGCATC +TATGGAGCCTACCCTTCTCGTAGGAGATTTCATACTGGTGAACAAACTCGTTTACTCGCTCTCTGAACCC +ATGCGGGGGGATATGATAGTATTCAAGTATCCAAAGAATCCCGACATAGACTTCATAAAACGCATAATTG +CAAGGGGCGGGGATACCGTTGAGTTCTTTCCTTACTACGATGAGAAAAACAACGTCCTTATATACAAGGT +TGCGGTAAACGGAAAGCTTTACGAACTCACCTACGAAGGGGAAAAGAACTATTCCTACGACTGCTACCAG +TACAGAGAAAAGCTCTACAGGGAAGACGGAGAAGTTATACAGCACAGCGTGTGTTTCAGGAATACACTTT +TAAAAGTACCAGGGATGGTCTATAACGCGATAAGTTCTGATCTCTGTCTGAAGTACAACGAAGACGGCTT +TTGCGTTAAGTTTGTAGTGCCCGAAGGCTACTACTTCGTAATGGGGGACAACAGGGACAACAGTCAGGAC +AGCAGGTTCTGGGGTTTTGTGCCGAGGGAAAACATAGAGGGTAAAGCTTTCGTGATTTACTACTCCGGAA +AGGTCCCGTCTCTCACTCCCGAAGAGGCTAATCCCCTTACGGCGGTAAGACAGATAATTTACGCTCTGCT +GAATCCGAGACCTTCAAGAATAGGTAAGCCTTTGATAGACAAGTGATGGAACTCCGAATTGGTTTTGGTT +TTGACTCTCACGAATTTGTAGAAGGAAAGTTATTAATTCTAGGCGGAGTGGAAATTGAAAAAGATTATGG +ACTGAAGGGGCACTCGGACGGGGACGCCCTTCTCCACGCTATAACGGACGCCATTCTCGGAGCCCTCGGA +GAGAGGGACATAGGTGAGATTTTTAAGGACACGGATCCGAGATGGAAAAACGCACCTTCGCGGATTTTCC +TTGAAAAGGCTCTGGAAGTAATGAGTGAAAAAGGATTTAACATATCAAATATCGACTGCGTAATTGTTGC +AGACAGACCGAAGATAGCACCTCACAAGGAAAGGATAAAGGAAAGTCTTTCAAAACTCCTCGGCATTCCG +AAGGAAAGGATTTCCTTAAAAGGAAAGAGGAGAGAGGGTTTTTGTGAAGGAAACGGACTCGTGTGTATGT +GTACGGTGTTGCTCGTTAAAATGTAAATACCCATGGAAAATTTCCTCAGCTTCTTCAGGATACTGATAAC +CTTTCCGGTAGTCTTTCTTATACTGGAGAAAGAATTTTTCCTCGCCTTCTGGCTTTATTTGGTAGGAGCT +CTGACCGACTGGTTTGACGGAAACCTTGCGAGAAAGAATAAAAGAGTTTCAAACTTTGGGAAACTCCTCG +ATCCTTACGCGGATAAGGTTTTTGTCCTGCTTCCCTTAATAGCCCTCGTAGAGGTAAAGAAGGTAAAGGC +AATCTGGGTAATACTCCTTACATTCAGGGAACTGAGTATTTCCTTTTTCAGGAGCGTTATGGTAGAAAAG +GGGATTTACATGGAAGCAAGCTTCACGGGAAAGCTGAAAGCCTTTCTTGAGTTCAGCGCTATATCCCTCA +TACTCCTCGGTGTTGAGCTCGGGAATTACCTTTTGATCCTCGCCGTGATATTTGCCTACATCTCCGCTTC +GGGTACCTCAAAAGGTTCTGGGCTCTCATTTAAAGAACTTGTTCGTTACGGGCATCCTCCAGTCCTTTCC +GAAAGCCCTGCTCGTGATCTTTGGTCCGATGGGTGCCTGCTTTCTCTTGTACTCGTTTTTCCTTATCATG +TTTATGGTCTTGTACACCGCATCCCTCGGAAGTCCTTTCCTGATTATCTCTTCAGGGCTCAAGTTCTCCT +CTATGTAAAGCATGAGTATTTGATCCAGTATCTCGTAAGGCGGGAGTACGTCCTGATCTGTCTGATTTGG +TCTGAGCTCCGCCGAAGGCGGTTTTTTAAACACTCTTTCGGGAATATCGGGGCTTATGGAGTTTCTGTAC +CTTGCGAGTTTGTAAACCCACGTTTTGTAAACGTCTTTTATCGGGGCAAAACCTCCCGCCATGTCCCCGT +ATATGGTTGTGTAGCCCACTGCCGTTTCACTCTTGTTTGAAGTGGAAAGAACGAGATAACGGAACTTATT +TGAAAAGTAAAAGAGGATGTTTGCCCTTATGCGTGCCTGTATGTTTTCGTCGGCAACGTCAAAGGTAATT +TCACATATTTCTTTCTCAAACTCGTTAAAGTAAGCCCTGTAAATTTCTTTTATCGGTATGACGTGAAACT +CTATACCGAGGTTCTGGGCTAGGGCTTTAGCGTCCTCGTAACTCTCCTTTGAGGAAAACTGAGAGGGCAT +ATACACACCTTTCACGTTTTCCCTTCCGAGGGCATCTACCGCAAGGCAGGCAACAAAAGAGCTGTCTATC +CCACCCGAAAGCCCAAGGACAACCTTCTCAAATCCGTTTTTCCTAACGTAGTCCCTCAGACTGAGCTTTA +GAGCGGCGTAAATCTCCTCCTCTTCCTTTGGGTTTTCCTCAATCCTTCCTCTAAAAAACTCTTTATCGGG +AAGAGAAACACTCCTTTTCACGTTCACTTTTTCCCTTCCGTAACTCCCTTCCCTCCACCTCAGATCGAGA +AGTCTCTTTCTCTTTGCTTCGCCGAGGTCCAAGGTAACGGTGAGTATGTCTTCTTCGAAAGCCTTTGCCC +TCGCTACGAGTTTACCGAAGGGAGAAATTACGATACTCCTTCCGTCGAAAACGAGTTCGTCCTGCCCGCC +CACGAGGTTCACGTAAGCAACAAAACAGAGGTTATCCTCAGCCCTTGACTTTAAAAAGCTCTCTTTAAAG +GAGTACTTGTTTACGTGGTAAGGTGAGGCGTTTACGTTTACAATGAGTTCCGCTCCCGAGAGTGCGGTTT +GCCTTTCAACTCCGTCGGGATACCATATGTCCTCGCATATGGAAAAGGAGACTTTATGCCCGTTTACCTC +TATCATTAATGGTTCTTCTCCTTTCCTGAAGTACCTGTACTCGTCAAAAACGCTGTAATTGGGCAAAAAG +TGTTTTTTATAAATCCCCAGAACTTCTCCTCTGTGTATTACCGCCAGGGCGTTGTAAAGGTCAAACTCGT +AGTATGGCAGTCCAACAGCGACGATAACGTCGTAATTCCTCGTGTGGTGAATTATTTGATCAAACGCTTT +TTCACACTCTTTCAAGAAATGGGGTTGTAAAAGGAGGTCTTCGGGGGGATAACCGCTCAGGGAAAGTTCG +GGAAAGGCTATTATGTGACTCTTTTCCGAGTACTCGTCTATAACCTTTAAAATCTTCTCTTTATTCCCTT +CTACGTCTCCTACGGTAAAGTTGAGCTGGGCGAGCGTGAGGTTGAGCATTAAATAAATATTAAACTACCC +TTATCTCCATCTCCTCGTCTCCGTACAGGTGTACTGCACAGGCAAGACATGGATCAAAACTGTGGATTGT +TCTGAGAATCTCAACAGGTTCCTTGGGATTGTGCAGACTGTGCCCTACTAAGGAAGCCTCGTAAGCCGAT +GGATTTCCCTTTGCGTCTCTCGGAGAGGCGTTCCAAGTCGTGGGGACTACGGCCTGGTAATTTTCGAGTT +TTCCGTCTTTTATGTGTACCCAGTGGGATAGAGAACCTCTAGGAGCTTCCATAAAGCCTACTCCTTTTGT +TTCCTTTGGCCACGTTGAGGGTTCCCACTTCTCAGGATTAAAGACGTCGTAATTTCCCTTTTTGACGTTT +TCCATGAGTTCCGAAAACCAGTTCTTCATGCTAAAGGAGTAAAGTTTTGTCTCGAGCGCTCTCGCGAAAG +TTCTTCCCATAGTTGAAAACATTCCTTCGAAGGGTACGTCCATTTCCTTTAAGTGTTTTTCAACTTCCTC +CCTTATACCGTACATATCCCTTGCATACAGAGCGAGAATTCTGGAAAGAGGTCCTACTTCAACCGAGTAG +TCCTTGTAACGGGGAGCTTTTAACCAAGAGTACTTTCCTTCGACGTTGAGGTATTCATAAGGGGGTTTGG +GACCCGTGTAGTTCAAATTAGTCTCACCTTCCCAAGGGTGTAAGGGTTTGTCGTCACCCACGGAGTATTT +GTACCAGCTGTGAGTGACGTACTCTTTTACCTCATTTATGTTCACTTCTTCAAAATCCTTTAGGTTTCTG +CCTTTTATGAAAGTAGGTGGTATGAACCACTTTCCTTCTCTCCAGGAGTCCTTTTCCGGTTCTCCGAGCA +CTAAGAAGTTTCCGAGCCCTTCCCCTTTAAAGAACCAGTCCTTGTAGTATTTCCCTAGAACTTTAATGTC +AGGCAGGTAAACCTTCACGGTAAAGTCGTACATCTCGTCTATAAGGGTTTTTATTCTTCCGAGTTTTTCC +ATGTTTATGGCCGTATCACTTTCCGGATTTATTGGAGCTGCCATACCTCCTACGGCAAAGTTCGGGTGTG +GATTCTTTCCTCCTATTATCGTGTGAACTTGAACTATCCTAGTTTGCCAGTCAAGTGCGTCAAGGTAATG +GGCTATGAGCATGAGGTTAAGTTCAGGCGGAAGTTTGTACTCGGGATGATTCCAGTATCCTTTGTTAAAT +ATCCCCAGCTGTCCCCTCTCTACCTGCTGTTTTATCTTTTTCTGAACTTCCCTGAAATATCCAGGTGTGG +ATTTTTCGTAATTAGACAAGGATTGGGCAAGCCTTGAAGTCTCATAAGGATCTGCTTTTAGAGCTTGTAC +GGGATTTACCCAGTCGAGGAGGTGAAGGTGGTAAAAGTGAACTACGTGATCGTGAACGAATATAGTACCT +ATTATTAACTTCCTAAGGAGGGAAGCGTTTACGGGGACGTTTATGGAAAGTGCGTCTTCCACTGCCCTGA +CTGAGGCTATTGCGTGGACCGTTGTACAAACACCGCATATTCTCTGGGCAAAAGCCCACGCTTCCCGTGG +ATCCCTTCCCTTAAGGATTATCTCAATCCCCCTTACCATCGTACCGGAGCTGTAAGCCTTCGTTATCTTT +CCGTCTTTTACTTCCGCTTCTATCCTCAAATGTCCCTCTATCCTTGTGACGGGATCAACTACAACCCTTT +TCATTCTTCATCCTCCAGAGCTTCCGCAACTAATTCCACAAGACTTAAAAACTTGTAATCCCTGTTCAGT +TCCTTTGAACTTTTCTCAAGGGCTAACATGCAGTTAGCACAGTAACAGGCCACATTTTTAGTTCCAGCCT +TGTCAAAGAGTTCCATCTTGGTCAGGAAAGCCTTTCTCCTGTGTTCATCTGCTTCGTGAACTACTACTAC +GCCGCCTCCCCCACCGCAACATATGTTCTTTTCGGGAAACTCAACCGAGTCCACGAACTTCTGCGATATA +TGCGTGAGGATTTCTCTCGGCTCCCTCAATACACCTCCTCTCCTGCCTATTTGACAGGAATCGTGAAGTG +TAACTACGTCCACAACCTTCTTGTTCAGTTTTATCCTACCTTCGTCAAGCATTTTCTTTATAAACTCAAC +GACGTTCAGAACTTCAAAATCCCACTCCTTCGGGAATACGTTGGGAGCTACAAACCTTATAGCCTGATAT +GCGTGCCCGCATTCGGGAGATATAATCGTCTTAATACCGAGTTCTTTAGCCCCTTTTAGAATTCTCTCCA +GCAATTCTTTTATAACTTTTTTATCTTGAACGAACATTCCGAAGTTAGTAGCCTCGTGTGCAACCGTTGA +GAGTGTCCACTTAACACCGCTTTTGTTCAATATTTTTGCCGCGGCCGCAACGGATTCGGGATACTTCATA +AGTTCTATTGAAGAAGGTATGTAGAGATACTCTGCCGGCTGGTCTACGGGCATTTCCACTTCCCACTCGT +CGGATATGAAATCAATTCTCTGGAGGAAGGTTTTCGTATCTACTCCTAAAGGACTTCCCTGCTCTATGGC +TCTGTTGGTGGCTTCTACGAGATCCTCCGGCGTGAGTCCTATCTGGGTGAGCGCTCCTCTCACTATACCC +ACGAGCATAGGTGTGTCTATTCCCATGGGACATATCTTCGTACACCTGTCACACATTGTACAGGTGTAGT +ACGCAAGTCTTACCTGCTCGTAAAGATCTTCGGGCTTTATTTTTACTCCGAAACCGAACAACTTCTTAAT +TCTTCCCCACAGTGTGTAGTTTTCCTTGTATATTTCCCTTAAGAGGTCAGCTTTGTAAGCCGGAGTTAGA +GTGGGGTCTATTTTTCCCGATATGTTCTCACCCATGTAGAAGTGGCAGGCTTCAGCACAAAGTCCGCACC +TTACGCACGCTTCTAAATAAGCTGCAACTTCGGAGTTTATTGAACTCTTGCAGAAATTGTAGAACTTCTT +TATATCCTCTTGGCTTACCTTTTCTTTATGAAAGAGTTTTACCATAACAGTCCCCCTTTAGAAGGAAACA +CCTCTCCTTCCAACTTTCCAGCCGTAGTAGAAAACGGAAACGAAGTAGTAAACGAAGTGTGAAAGTCTGC +TGAAGGGTATGTAGATTATAAGGAGTGCGGCGGATAGCATGTGCAGGGTAACGAGCCACACGTAATTACC +GCCTCCCGCCCAGTTGTTCGCCAGCAATCCCGTAAATATAACTATTCCGATTAACGTATTTGCTATGTAC +TCATCCGAGCCTGTCAAGAGCTTCAGAACCGGGTTAAAAATCCTGTGAACAGTTAGTGCTACAAGTGATC +CGAGAGCGGCGTATGCAAGTATATCCGATACTATCTGCGGCATGTACGGGAATTCAAAACCTATAATCTT +CTTCCATAAAAACGCGTGCTGAGGAACGAAAAAGGTAAGTCCGAGGAAACCTATGTGAAAGAGGAAACCT +CCAACGTACTGTATTCCCCTGTGGGCAAAGACTTCTCCGAAAAACCTCCACGCCTGAGTTGGTTTAAAGG +TTACCTTTTCCACGGCTTTCAGAAAGGGATGACCCTTTGGTTTTGAACGATCATGGGGAAGACCGAGTAT +TATTACTCTAAAGAACCTGTAAAGAATACCTATAAAGAACACGTAAACGGATACCGGAAGGAGATAGGAT +CTTACGAAGTCGTAAACTTTTACGTCTATGAGCTCCATTACTTTTCCTCCTTCTTTTTGTTTATCAACTT +GTTTAGAACACCTATACCGATCCCAACCGCAGCGCCTATTCCCACACCTTTCAGCGTATCCGAAATTCCC +GAGTATCCTTCCATAACGGACAGAGGGTTGTATATAAATCCCCTGTCCCAGAAGTCAGGTTCTGAGCATC +CGAAACAGGGGTGTCCGGATTGTATCGGGAAACTGAGTCCTCCGTTCCACCTCATGCTTGCACAGGCATT +TCTCGTTATCGGACCTTTACAGCCGAGTTTGTAAAGACAGTAACCTTTTCTCGCTTTTTCGTCGTCAAAA +GATTCCGCAAACTGTCCCGAATTGTAAAAGGCCCTCCTGTAACACCTGTCGTGTATCGTTTCACCGTAAA +ATTGCTTGGGTCTGCCGAGTTCGTCCAGGGGAGGTAATTTTCCTAAGGCTAAAAAGTGAACTATCGTAGC +CACCATTACGTCGCCTATCGGAGGACACCCCGGCACGTTCACAACGGGTTTATCCTTTACAATTTCGTAA +ACCGGAACCGCTCCCGTTGGGTTTGGACTTGCCTTGGGAATACCGCCCCAGGATGCACAACTTCCAACGG +CTATAACGAAAGCGGCGTGTTCAGCGGTTTCCCTCAATATATCAACGCTTGACTTTCCTCCGACCGTACA +GTAGACACCTCCATCCGCAGGAGTGGGAGATCCCTCTACTACCAAGACGTACTTACCCTTGTACTTCTTT +ATAGCTTCTTCCCTCGCCTCTTCCGCGTAAAATCCTGAGGGAGCCATCAGTGTTTCGTGGTACTCCAGTG +ATATGTAATCGAGGAGAACCTCTGTTGGAAGAAGGGTTGTGCTCCTTATAAAGGATTCGCTGCATCCGGC +GCAATCCTGAAACTCGAGCCATATGACCACGGGTTTTTCCTTCTTTTCAAGAGCCTGTGCAACCTTCGGG +TAAAGCGAAGGGGGAAGTCCTAAGAAGGCGCTAACAGCAAGGGAAAACTTCAGGAAATCTCTTCTCGAGT +ATCCTTTCCTTTTAAAAATTTCGTAAAGACTTTCCAAAAGTGCCCCTCCTTTAAGTTAAAAATAATGACT +TGGATCATGTTTGTCAAAATTTTTGAAGTCAAAGGGTATAATCAAGTTTATGGAAAGGATAGGAGCTTTA +GTTGTAGATCTGGAAGGGACGACCCACGAGATAACGGAAAAGTTAAACGAAGTTATAGAGGGCATTTACG +AAGAAGGGAACGAGGTTATTGACGTTAAGGTTACTTACGCAAAAGAGCACGGAATAGACGGCTTTGTGAT +AGTCTACACGATAGTATACAGGGGAAGGGAAGTTCCCGAAGAATGAGGATAAAGGTTAAAGTGAAGCCCA +AGTCCAAAAAGGAAGAAGTTAAGAAGATTTCCGAAGAGGAGTACGAGGTTAAAGTAAAAGAACCTCCGGA +GGGAGGAAGGGCTAACCAGAGGCTCATAGAACTCCTATCCGAGCACTTCGGTGTTTCAAAATCGAGGATA +AGAATAGTGAGCGGGCACACTAGCAGGAATAAGGTAGTGGAAATCGGATAAGATAATAACCATGTTTACG +CTCTAATAGACATGGACGGAGTACTCACCAAAGACAAGGAGTTAAATCCATTTCCCGATGCAAAGGAGTT +TATAGATTTTTTAAGGGGAAAACAACATCCCCTTCAGAGTAGTTTCCAACAACTCAACCCGTCCCCCGCA +ATTAATAATTGAAAAATTAAAGGAGAAGGGAATAGAACTGAAGGTTGATGAATTCATATCACCCGTCGCA +ATCCTCCCAGAGTACCTGAGGAAGGAAGGTATAAAATCCGTCTTCGTAATAGGAACACCTATGCTAAAGG +ATTTCTTAAAAGAGCAGGGATTTGAAGTGAGGGAAAATCACGAGGTAGACGCTGTAATAATAGGCCAGGA +CAAAGAGATAGAGTTTAAAAAGATAAAGAACGCAACATCTGCGGTTTTCTTGAAAGGGGCAAAGATCATT +CCCGTAAACCTGAGCAAGATAGTGAAGGACAGTGACGGTCTTTACTTTCCTGGTTCCGGATCCTACGCCT +ACATGTTCAAACACGCCACCAATTACGAGGGAGAAATCCCCAACTTAGGTAAACCTTCAAAGGAGTTTAT +AAACCTCGCTCTGGAGGGACTTCCAAGGGAAAAGGTATTCCTCATAAGTGACGATATTTACACGGACCTC +ATGGGGGCAAAGGAACTGGGGATAGGGACGATATTCATGACTACCGGAAAGTACAAGCAGGAAGAACTCA +AGAAGGCTAACTTCAAACCCGATTACGTTTTTCACTCTCTCAAAGAATTAATGCGAGAAATCAAAAAGTG +GCTCTCTTAATACTTTTCTTTCTTCTAGGACTTTCCTTCTCCTTGGAAGTTTTCTCGGAAAAACTCGAAA +TTAAAGAAAATGAAATAATAGCGGAAGGAGATGCGGAAGCTTACTACAAGAATTACTACATAAAGGCTAA +GAAGATAAAACTTTTGCGGGACAAGGACGAGGTTTACGCCTACGAAGACGTTTACATAAAAAACTTAAAA +ACGGGTTTTGAAATAAGGGGAAGTTTTGCTTACGTGAATATGAAGAAAAACAAAGGTTACTTTCTGAACG +CTAAAGGTAAGTTCAGAGAGTTTAACTTCGAGGCAAAAAAGATTGAACAGCTGGATAAGGAAAGGTTTAA +GGTTTACGAGGCCACGGTAACGACCTGCCCCTTAGATGATAAAGAACTTTACCTCTGTATATTCAGGGCG +AATATAACGAAGGAAAGGGCTCTCATTTTCCACAACAGATTGAAGTTCTTTAAAGTTCCCATTTTCTACC +TGCCCGTTTACCTGATTCCCCTCGGGGGAAGGAAAACGGGCTTCCTCATGCCCACGATAGGGAGTTCCAC +TTACAGTTCTTTTATATACATCCAGCCCTTCTTCTGGGCAATATCCCGCGACAAGGACATGACGATAACC +GCGGACTACAGAAAGGATCAGATGAAGGGACTTTCCTTAGAGTACAGACAAGCCTTTGACGAAGAAAGCG +ACCTGATAACTCAATTTTCTCTTTATAAGGAGGATAAAAAGAAGGGGGACTGGTGGAAAGGTAGGGAAAT +GTACAGGGAAAACAGGTTCAGGATATTTATGAAATACAGGAAAAAACCTTTTAAGATAGGTGTGGAAGAA +CTCTCAGACCCTTACTACTACGAAGACATATCCTTTAAACAGGAGGAAATCACGAAGCCCTACACGAAAA +CTTACCTGATTTACGAAAAGGAAACAAAAAACTACCTCTTTTACTTCCAGACGGTTCGATACAGGGATTT +AACGGAAGAGAAAAACAACGCTGTAAACCTCCTCCCTGAAGCCAGTTTCCACCTAAAACCCTTTTACTAC +AAAGGATTTAATTTCTCATTGGACTCTTCGTTTACGAATTTTTACAGGAATTACGACGGGAGCTTTATGC +GTATTTCTCTGGAACCTACGGTGGGAAAATACTTTGAATTGTTCAAAGTCAGTAATTATTCTTCTTTGAC +CCTTATAAACAGGTACTACCCGGATTCAGAAGAAGACAAAATCGTGAGTACTTTCAGGTTCAGACACAGC +GTTCCCCAGTACTTTTCTCTATCCTACGGAGGATTTAAATTCAAAAACTTCCTTGAGGGACTATACACCT +TTTCTCCAAAGGATTACGAGGTTCAGATATTCGATTATCAGGATGAGCTCAACGAAGAGAACAATTTCCA +GTTTACACTTGTAGGAAATCTATACAAAAACAGAAAGCTTATGGATTACTTCCTGAACACAGGATACAAC +CTTCTTGGCTCTTACACTTTTCCCACAGACGGAAAGAAGATTGACAAGAAACTCCTCCCCCTTTACTACA +ACGTCTCCGTATACCCTGTGGAAAACGTCAGGTTCTGGCAGGACGCGGTTTACGACTTTAACCTCGGTGT +CTTTGCAAGGAATGTAATCGGTACGGATATTTCCTGGAAGAATTTCTCCGTGGGGATTTCCAATTCTGTG +TACAAAAACAGTGAAAAGAAAGTTACAACGGATCAGATAGCTCTTAACCTCAAGTACAGCGGGGATAAGT +TCTTTTCAGGCATTTCACTAAATTACGACAGACTAGTAGATAAGGAGACTTACAGGAACGTTTACGTAGG +CGTAAAAGGAAAGTGCTGGAGTTTAGTGCTGGATTATAAGAGAAATTACTACAGGAACAGGGACGAGTAC +GTGGATCAGGTATTTTTGAGGTTCAACCTCTTCTTCAAAGAAGAGATAGAAATTCCTTTAAGACGTTAAA +CCGAGACAGCGGAAAGCATAAGGCTTTTTAATTTCCTCGTCTGGGCTTCTATGTCCTTCGCGCCGAATAT +TCCCGATCCTACAACTACAACGTCCGCTCCTGCTCTCACTACTTCGGCTATGTTGTTTTCCTTAATGCCT +CCGTCAATTTCTATCAGGCAGGAAGGGTTAATCCTGTCCCTCATCTCCTTGAGTATCCTCAACCTCTCTA +TTGAGCGTTCTATAAACTTCTGACCGCTGAACCCGGGGTTTACGGACATTAAGAGAACGTAATCCGCATA +GTAGAGGGCTTCTTCAATCGCTGAAAGGGACGTACCGGGGTTTACAACAACTCCCGCTTTAGCCCCGAGT +TCCTTTATAAGCTGCAGAGTCCTGTGTATGTGGTAGTTGTTCTCTATGTGCACACTTATCCAGTTCGCCC +CCGCTTCCACGAACTTTGGTATATACTTGTCAGGATTTTCTATCATAAGGTGGGCATCTATGGGAAGGGA +AGCCCTTTTTCTTATGTGAGATAGGATTTCGTACCCTGCGGTTATGTTGGGTACAAAGTGTCCGTCCATA +ACGTCGTAGTGGAGTATATCCGCACCGCCCCTAATCGTGGCTTGTATCTGCTCTCCTATACACCACCAAT +CACCTGCGAGGATTGAAGGAGCTAAAAGTTTCATAATAGTTATATGTTAATCGCTTTTGAGGGAATAGAC +GGTTCGGGAAAGACTACACAGGCGAAAAAACTGTATGAGTACCTTAAACAAAAGGGCTACTTTGTGTCCC +TTTACAGGGAGCCCGGCGGAACAAAAGTTGGAGAAGTATTAAGAGAAATTTTACTTACGGAAGAGCTAGA +CGAAAGGACTGAACTCCTGCTCTTTGAAGCATCCCGCTCAAAACTCATTGAAGAAAAGATAATCCCCGAC +TTAAAAAGGGATAAAGTAGTTATACTCGACAGGTTTGTCCTTTCAACGATAGCGTATCAGGGATACGGAA +AAGGTCTGGACGTAGAGTTTATAAAGAACTTAAACGAATTTGCGACAAGGGGTGTAAAACCCGATATAAC +CTTACTCCTTGACATCCCCGTGGATATAGCGCTGAGGAGACTGAAAGAAAAGAACAGGTTTGAAAATAAG +GAATTTCTTGAAAAAGTGAGAAAGGGATTTTTAGAACTTGCAAAGGAAGAGGAAAACGTGGTTGTAATAG +ATGCGAGTGGGGAAGAAGAGGAAGTGTTTAAGGAAATATTGAGGGCTTTAAGTGGTGTACTCCGCGTTTA +GTTTGATGTAGTCGTACCCTATGTCGGAGGAGTAGCACACCCACTCGTACTCTCCTTCGTTTAGTTCCAC +AGTTATATCAACTTCCCTGTCTTCAATCAAGTGTTTTTTTGCCTTTTCCAGGTTCTCGTCGTGGGGCTTT +CCGTCGTAGAGTAAGTATCCCCCTACGTAAATTTCTAGCTTGAATGGGTCTATGGGGAACTCTGTACTCC +CCGCCGCAGCTGCTATCCTTCCCCAGTTCGGATCCCTTCCGAATACAGCTGTCTTTACCAGTAAGGAGTT +CGCTATAGCCTCCGCTATTTCTCTGGCTTTTATCTCTGTAATCGCACTCCTCACGTTCACCCTTATTATC +TTCGTAGCTCCTTCACCGTCCGCCACAATTTGCTTTGCGAGGCTTTCGGAAACCTTTAGGAGTTCAAATT +CTACCGTTTCTGGATCCGCTTCCACCTCCCCTAGAGATATAATGCCGAAGGCGTCGTTCGTGCTCTCACA +CCCGTCAACAGTTATGGAGTTAAAGGTTTTTTCCGTTACGCTTTCGTGGATCCTCTTCAAGGTCAGGTAC +TCGAGATTTGCGTTCGTAAAAACGAAAGCGAGCATGGTCGCCATGGAAGGGTGTATCATACCCGCTCCCT +TTGCAAAACCGAAGGTTTCTACCTCCCCGGCTTTGGCAAAATCGTACTTTGGAAACCTGTCCGTTGTGGA +AATAACTTCGGAAGCCCTCTTCAAATCCAGAAGTTCAAGATTTGAGCAAGCTTGTTCTATACCTTTTAAT +ACGTTTTCTATAGGCAGGTACTTTCCTATTATTCCTGTGGAAAAAACGAAGACTTCGTCCTTTGGAATAT +CCAGTATCTGGGCTACTTTTTCAGCCATCATCTCTGCGTGTTTTATCCCTTCCTCTCCCGTTCCGCAGTT +GGCGTTTCCGCTGTTTACTACAAAAGCCCTAATCCTTTCTTTATCCCTTGCTATCCTTTCCGAGTAAATA +ACAGAACCAGCCTTGAAGTAGTTGTCCGTAAAGACGAAGGAAGCGGTGCATGGGTACGGAAGGTAAACGA +CGAGTATATCCGGATTTCCAGATTCCTTTAAACCCGCATTTCCTACGCCCATTAAAATTTCAGCCATGAA +TTTATTTTAGAAAATTACTCCGTACCTCTGGAGTCTCCTTTTCGCATCCTCGTACCAGGGTTCTCTTCCG +CTTGCAAATTTAAGTGCGAGCTTGTAGTTCTCTACTGCTTTTTTTACATCACCGAGCTCCTCGTAATCCC +TTCCGAGGTAGTAGTAAATACCCGCGTAGGAAGGTATTCTCTTCTTCGCCTCGTTTAGTGCCCTTATACT +CTCTTTGTACTTTTTGAGCTTAAAGTAAGCTATACCCTGAAGGTACCATCCCCACAGAAGGTAAGGATCT +AAATCGCTCACCCTTTTTGCGTACTCAAGGGCTCTTTTATACTTTCCGTGTTCAAGGTATATGGCGGAAG +CGTAGGACATGGCTATCTGGTTGTTCGGGAATAGCTTTATAGCCTCTTCAAACTTCTTCAGGGCTTCGTC +TTTTAGACCCTCCTTATACAGCTTCCTTCCTTCGTAATAAAGATCGTAGGATTTCTTAGTCGCCAAAAGC +TTTTCCTTTATTCTTTGAAACTGAGGTGAATCCTTTTTCAGGTTCGGGGGTAGTTTCATAGAGCTTATTA +ATTTAGACACTTCTCTTATTCGAGTATCGGGAAGGGGGTGAGTGGAAAGCCACTCTGGCGGGTAGTCCTT +TTCCATCTTCTTAAACTTCTTGAATGTTTCAATAAGACCGTGGGGATCGTAGCCCGCCTTTACTGCGAAT +ACCACCCCGTACTTGTCCGCTTCCCTCTCCTGATCCCTGCTGAACTTTAAAGCAAGCAAAGATGCACCAA +TTGAGGCGAGCTGAAGTGCTATCCTCGCGGTTGTGTCCCTGTCGTTTATCAAGAGGGCCCCTATCTGGAG +GAGGATGCTCAGACCGAGCATTTTTTCAAGGTACCTTGCGTAGTGGCGTGCGTTTACGTGTCCGAGTTCG +TGGGCAAGAACACCAGCGAGCTCACTTTCGCTGTCTAGCATCAGAACCAATCCCCTCGTTATGACTATTT +TCCCACCCGGAAGCGCAAAGGCGTTCAAAATCTTTGAGTTTACTAATACGAATTCGTAAGGAAGTTTTCT +CGGCGTGTGTTTCGCTATGGAATTTCCAAGCTCCTTCACGTACTCCTGAACCTCTTTATCAGGGTATATA +CCCTCGTACTCCGTTATCGCCTGAGGGAAAACACTATTTCCTATCGCGATTTCCTCTTCGGGGGGAAGGA +CGGTAAAGGTTTTCTTACCCGTGAGCGGGTCAACTACCTGAGTACAGGATACGATAAAAATGAACAAAGC +TGATATAAGAGCTCTTACCCTCATCAATAATTAGGTTAGCACTTTATGTATGATTTTAATTATGCAGAAA +AAGAACTTATGGCTTCACCTTCTTGGACTGGTAATCCTTACGCTCCTCTCTGCTTACGCGGTTGTAAAGT +ACCCTATAAACCTCGGTTTAGACCTCAAAGGCGGTGTTGAATTCCTGCTCGAACCGGATTTTAGTGTTGC +AATAGAGAGAGAGTATGAAGACCTCGCGAGAAATTTAAGGGAAAAATTATCAAAGTTTAACGTTCTTGAA +GTTTATGCAACGAAAGAGGGCGTAATAATAGAGTTACTCGATAAAAAAGAGGTAGAAAACATAAAGAAAG +TTATTCAGGATATAAACCCTAATGTAATTTTTGAAGAAGAAGGCGATAAACTCGTAGTTAAGTTTACACA +AAAGTATGTTGAACAGTTAAAGGAAGACATAGTAAGGCAGAGTATAGAAATCATCAGGGACAGGATAGAC +AAGCTCGGAGTGACTCAGCCCGTAGTCACGAGAGTCGGAAAGTACAGAATTTTGGTGGACCTTCCAGGAT +TTTTGGACGTTGAAAGGGCTAAGAAGATAATAGGCAGTACCGCTTCCCTGGAGCTAAAACTCGTAATAGA +TGTGTCAACCGATAGAAAAGAACTCGAGAAGAAGTTAACACCCGATAGGGAAATACTTCCGTCCAGAGAT +GGAAGGGAGTGGTTTCTCGTGGAAAAGGCACCTGTTATAACGGGGCAGGACTTGAAAACCGCCTACGTCG +GCGTTGATAACCTCGGACAACCTGCGGTGAACTTTGAACTTAAAGGAGAGGCTGCGGAGAAGTTCGGAAA +GTTTACAGAACAAAATATAGGAAAGAGACTCGCCATAGTTCTGGATAGAAAGGTTGTCTCCGCACCCGTG +ATAAGGAGTAAGATTTCGGACAGAGGACAAATAACCGGAAACTTCACGGCTCAGGAGGCGAGAGACCTCG +CCCTCATACTAAGGACTGGCAGCCTCCCCTCACCCCTCAAGTTCCTTCAGGAAAAGATAGTTGGGCCTTC +TCTCGGAAAGGACGCAATAGAGCAGGGGATAAAGGCGGGCATTTTAGCGATAATACTTCTTGCCGTGGTT +CTGATAGCACGCTACAAAACTGCCGGAATTACCGCAAACATTTCCATATTCCTGAACGTCCTTTTCCTCC +TTGCGAGCATGGCTTTCCTCGGGGCTACCCTCACCCTCCCGGGTATAGCGGGGATAATCCTGAACATGGG +TATAGCCGTGGACTCAAACGTCCTCATCTTTGAAAGGGTAAAAGAGGAACTGAGACTGGGAAACACCGTT +TCAAAAGCTATAGAACTTGGGTTCAAGAGAACTTTAAGTGCGGTTTGGGACACACACGTTACGCTTCTTG +TAGCTTCCGTTATACTCTTTCAATTTGGGAGCGGTCCCGTAAAAGGTTTTGCAACGACTCTTGCCCTAGG +AACTATAGCTAGTTTTATATCAAACGTCTACTACGCAAAGGTGTTTTTAGATTTGCTTAACTCCCTAAAA +ATCCTAAAAATATGAAATTAATCATTCTTTCCTTTTCCCTCAGGTTCTAACTTTTCCGTGGGAGGTGCGG +TCATGTTAAAAACGCTCTTTGTACTCCTGTTAATCATTAGCACAGCTTTTTCAATGACATTAAAGAAAGT +TGAAGAAAACCTCTACATGGTGAGAGGAAACGATGGACTTCCTTCCAAGGAAAACAAAGGTTTTATCTCC +AACGCCTACGCGGTTTTAACAGAAGAGGGATGGGTGGTTATAGACACCTTAACCACTCCCGAGCTCTCCG +AGGAATTTCTGAACCTTCTTAAAAAGGTTTCAAACAAACCAGTAATTTACGCGATAGTAACTCACTACCA +CCTTGACCACTGGTACGGGGCAAAAACCTTCAAGGATAAAGGTGCTAAGGTAATAGCCCACGAAAAACTA +AAAGAGTTCTACGATTCTGGCGAAGCCCTTCAAGTTCTGGAGGCTCAGAAGAAGAGGTTTAAGGGAGTGC +TTGACAGTGTAGAGCTCGTACCTCCCGACGAAGTTGTAAAGGATAAAAAGGTTTTAAAAGTCGGTAAAGA +TGTATTTGAGATTTACGCAATGCCTCCCGCGCACACAAACTCCGACCTCGTAATTTACTGGAAGAACAGG +AAAGTCCTTTTTGTAGGGGACCTCGTTTACATAAACAGGATTCCCTTTATGGGGGACAGGAACGCGAGTT +CCAAAGGGTGGTTAGAGGTTCTGGAAAGATTAAAAGAGTTTGACGCGAGAATGCTCCTCGGTGGGCACAA +CTATCCCATGAATAAGGATGCGATAGACTGGACCTACAACTACATAAAGTTCGTGAGAGACACGGTAAAG +AAGCTAAAAGACGAGGGCTACTTCATAGACGAGATAAAGGAGGCGTTTAAAGGAAACCCGTACGAAAAAG +TTAAAATGTATGAAGTTTTTCACAACACAAACGTGTGGAAGGTTTACAACGAACTTGATTTAGAACTTTG +AGGAGGCACGTTATGGACAAAGTTGAGAGGAGACTTTACGAGCTTTACGAGAAGGCTATCAATTACGAGC +CCTTATCCAAGGAGGAAGCCCTTTATATACTTGAGGTAGATGACATATACGTCCCCTTCCTCGTACACCT +TGCCCAGAAGATAAAGAAACACTACTTTCCCGAAAACGAAGTGGAGTTTTGCTCCATAATAAACGCAAAG +AGCGGAGCTTGTTCCGAGGACTGCAAGTTCTGTGCACAATCAAAGTACTACAAAACTCCCATAAATGTTT +ACAATCTCGTTCCCGTTGACGAGATGGTGGAAGGTGCGATAAGAGGTGTTGAGTTCGGTGCGAATAGGTA +CTGTATAGTTTTAAGTGGAAAGAGTGCAACCAAGGAGGAAGTTGAAAGGATAACTGAAGCAGTAAAGGAA +ATAAAAAATGAAGGACTCCCCATAAACGTGTGCGTGTCCGCGGGAACTCTGGACGAGGAAAGCCTTAAAA +AACTAAAAGAGGCGGGAGTAAAGAGGATAAACCACAACCTAGAAACTTCTAGAAATTTCTTCAAGAACAT +AGTAACCACTCACACGTGGGAAGATAGGTATGAAACCATAAAGAGGATAAAAAAGGTAGGACTCTCAACA +TGCAGCGGTGGGATTTTTGGCATGGGAGAGAGTAACGAGGACAGAGTTGACATGGCCCTCACCTACAGGG +AACTAGAGGTTGACTCCATACCCCTTAACTTCCTGATGCCCATAGAGGGCACTCCTATGGAAAACGCCCC +CGGAGTTGAGGTTATGGAAGCCCTGAAAATTATTGCCATGTTCAGGTTCACTAACCCAAAGGCGGAACTC +AGACTCTGCGGAGGAAGGGAACAAAACTTAAGAGATTTCCACGGAATGGCTACGCTCATGACCAACGCCA +TGATGGTTGGAGGATATCTCACGAGAGCGGGAAGGGACATAAAGAAGGATTATCAACTACTGAAAGATTT +GAAAGCTAAAAGAAAAGTAAGCGTGGAGTAATATTCCCTTCTCCTTTCCCTTCTTTTCACCTCAAAAATA +AAAATTTTTCTCCTAAATTAATTCATAGGAGGAATTTATATGCCTTTGTGGGGAAGGTTCAGAATATCTT +TCGACAGCTGGAAGATGATGTCACTCGATAACCATGTCCTTGAAGAGTCATCCGAGATAGGCGAAGTAAA +CGTAGAAACGAGTGAATGGAAACCTATAAATGGATGTATTCCTGAGGATTATGACGAAGAAAATTTAAAG +ATTGCATTTATAGACGGTGTAAGAAGAACGGAAAACATCGTTTACCTTGAAGATCCAAACAGTGCAAGCG +TTGTGGAAGGTGCCTTTGTTTCCATAGGCGCCGGTGCGATGGTTTTGTCCTACGGAAAGGTGAATTCCTT +GGAAGACTCATTAAAAAAATCCGTCGTGAAAAGGTACTTCCTTTTAAGGGACAACGTGGACATCTCTCAA +CCCACTATCGTGTTCTTAACACAAACGGGAAAGCTTGAATTTAAGGTTGACAGGGCTAAAAAGGAACTCT +CACCTTACGTCAACGAACTTATGGCTAATTTAGAACTCTGGGTAGCACAGCAGGTGTACAAGGCAAAAAT +GGCGGATTTGATGATAACCGACGGAACGCTCCACTACGTCGCAAAAGCCAAGAACCTTCCCTTTATAGGA +TACGTGAAGAAACACAGAAAGATTTACCTCTATCCTGAGCACATAAAGGTTTTACAAGAGCTCAAGGTCG +GACAGAGAACTCCCATAATTCTCATACACTCCCAGCCTACCATGGACTCCCAAAACAAGAGCTTTGACAA +GTACACGTGGTACGTGAAGTTAAACGAAAACGAGGGAATTACGAGCGTGGCCAGACTGGAAGTTCCCGCA +GAACTCGGTTTAGAGGAAGCGGTAAAGCTTGCGAACTTAACAGCTTACTTGATGCCCAAATTCGCCTCTG +CTGAGTTCAACGACAAGAGAGCACCTCAGAACTTAATCCCCATAAAGTACTTAGAAAATTACCTGAGGAG +GAGACTCGGAAGCCAGTCCTTAATAAGGAGACTCATAGCCCAGAGGATTATGGAGAGAGTATGAAGAGGG +TTTTAGTAAGCAGGTGTCTCCTTGAGTGTTGCTACCGCTACGATGCAAAAGACGTAAGGGTGGAAAACAT +AAAGGAATTACTCAAAAATTACGAAGTAATCCCTATTTGTCCAGAAGTTGAACTCTTAGGACTTCCCGTC +CCGAGACCAAGACTAAAGCTCGTTCCAGTAAAAGGAGAGATAAGACTTTTAAAAGAAGACACGGGAGAGG +ATTTAACGGAAGTTCTGGAGAAAAAATCAAGGGAATTTCTCGAAAAGGTAAAACCCATACACGCGGCTTT +TTTAAAATCAAAGTCTCCGAGTTGCGGAGTGAAAGACGCAAAGGTTTACAAGTGTCTAAATTGCGAAGAA +GAAGTGGGAAGGGAAAGCGGGATATTTGCAAAGGTTTTAATGGAAATGTTTCCGGATATACCGATAATTA +CCTTTTAATCTCCCCAGAAGCGTTCCTCTTTCCAGGGGTCTCCTACGTGGTGATATCCCCTTACTTCCCA +GTATCCGGGAACGAGATGGTCCAGAAACTCTATACCCCACACGTACTTTGCACTCTTCCACGCGTAAAGC +TGAGGGACTACGAGTCTTAAGGGATAGCCGTGTCTTTTCGGAATTGGTTTTCCAAACATCTTGTAAGCCA +GAATACTGTCTTCCTTTTCCAAGTACTCAACGGGCAGGTTCGTAGTATAACCTTCAAGGCAGTGTACGAG +AACGTACTGTGCAGTAGGTTTTGGCTTTACTATTTCCAAAAGATCCTTCGTAAGCACACCTTCCCACACG +ATTTCTGGAACGCTCCAGCGCGTTACGCAGTGAAAGTCCGCAACCACTTCCGCGGAAGGGAGTTTTAAGA +GCTCTTCGTAGGTCAGCTCTATGGGATTTTCAACCTCTCCCCAAACTTTGAACCTGTACTTCTCCATATC +CCAGTCCGGAATATCGTCAACGATATCGTAAACTATGGGAGCCTTTATCCACTTTTGTCCCGGCGGGAGC +CTATCCTCTTTCTTCTTTACTGTTGGGCTAATAATCCTCTTTTTCATAACGATTAAAAGTATTAGGCTAT +CCTTAAAAGATTTGTGTGAGATTTATCAAGGAAGAAAAATAACGATTTATGAATAACTTATAAAACCAAG +CTCTTCTGTGGTATAATTGCCTTTATGGAAAACAGGGAAAACCTCGTGGAAATTCCCATAGAGGAAGAGG +TAAAACAGGCATACATAGACTACGCAATGTCCGTAATAGTCGGGAGGGCAATTCCCGACGTAAGGGACGG +ACTAAAACCTGTTCAAAGGAGAATCCTCTACTCCATGTACGAAATGGGACTGCTTCCCGATAAGCCCTTT +AAGAAGAGTGCGAGAATAGTTGGCGAAACTTTGGGTAAGTACCACCCCCACGGCGATCAGGCGGTTTATG +AAGCGTTAGTTAGAATGGCTCAGGACTTTACCATGAGATACCCCCTGATAATAGGTCAGGGGAATTTCGG +TTCCATAGACGGTGATCCGGCGGCTCAGATGCGCTATACGGAGGCAAAACTCTCACCCCTCGCCGTTGAA +ATGCTTACGGACATAGATAAAGATACGGTAGACTTCCAACCTAACTTTGACGATACACTGATGGAACCCG +AAGTGCTTCCTTCAAAGTTTCCAAACTTGCTTTGCAACGGCACAAGCGGTATAGCGGTAGGACTCGCTAC +ATCAATACCACCCCACAACTTAACAGAAGTGGGAAATGCTCTGGTGAAACTCGCCCAGAATCCCCAGATA +TCCGTGGACGAAATTATGGAAATACTGAAAGGTCCTGACTTTCCCACAGGAGGAGTGATAGAAAACTTTG +CGCAGGTGAAGGAAATATACAAAACCGGAAGGGGAATAATAAAGGTTAAAGGGAAAGCTCACGTTGAGAA +AGTTCAAGGAGGAAGGGAAAGGATAGTTATAACGGAAATTCCTTATCAGGTGAACAAGGCAGAACTCATA +AAGAAAATTGCGGACAACGTAAGGAACGGAAAGATTAAAGAAATCTCAGACATAAGGGACGAAACGGACA +AGGAGGGAATCAGGATAGTTGTAGAGCTTAAGAGGGACGCAAAAGGCGAAGAGGTTCTCAAAAAACTCTA +CAAGTACACCCCACTTGAGAAAGGTTTCCCCGTAAACCTCGTAGTTCTAATAGACAAAGAACCTAAACTC +GTTGACATAAAAACGCTTCTCAGGGAGTTCATAAAGCACAGACTGGAAGTAATACTCAGGCGATCTAAGT +ACTTCCTCAAGAAAGTTCAAGACAGACTCCACATAGTAGAGGGACTGCTAAAAGCCATAAACTTCATAGA +CGACATAATAGAAAGGATAAGAAGGTCAAAAGACGCGTCAGAGGCGAGGAATTATTTAATGGAAGAATTC +GGGCTCTCTGAAAAGCAGGCTCAGGCGGTTCTGGACCTCAGACTCCAGCGTCTTACATCCTTAGAGAGGG +AAAAACTCCTTGAAGAAGAAAAGGAACTGAGGGAAAAGATTGAGTACTACAAGAAACTCGTTGCGAGCGA +AGGCGAGAGGATAAAGGTCTTCATTGAGGAGACCGAAGAACTCGTAAAGAAGTACGGAGACAAGAGAAGA +ACCTTCATAGGTGGTGTAAAGGAAGTAAAGGAAGGTTCAATTACGGTTGCAGTTCTTCAGGACGGCTCTA +TAATTCCCGTGGAAGAATTGCCTCTTGAAAAAGCTCCAGTTGTGAACATACTCAGAGTTCCCTTTACGGA +AGGTCTCTTCTTGGTTTCAAATAGAGGAAGAGTTTACTGGATTGCGGGTTCTCAGGCACTTCAGGGCAGT +AAAGTATCTCTAAAATCAAGGGAAGAAAAAATAGTAGGTGCATTCATAAGGGAAAAATTCGGAAACAGAT +TGCTCCTTGCAACCAAGAAAGGATACGTGAAGAAGATTCCGCTTGCCGAGTTTGAGTACAAAGCTCAGGG +AATGCCCATAATAAAGCTAACAGAAGGGGACGAAGTCGTAAGTATAGCTAGTTCCGTTGACGAAACACAC +ATACTCCTCTTCACAAAAAAAGGAAGAGTTGCACGCTTCAGTGTGAGAGAAGTTCCACCCTCCACTCCCG +GGGCAAGGGGCGTTCAGGGGATAAAACTCGAAAAGAACGATGAAACCTCTGGGCTAAGGATATGGAACGG +CGAACCATACCTCCTCGTCATAACCGCAAAAGGCAGAGTTAAAAAGATTTCCCACGAGGAAATCCCGAAA +ACCAACAGAGGTGTTAAGGGAACGGAAGTATCGGGAACTAAAGACACGCTCGTTGACCTTATCCCTATAA +AGGAGGAAGTAGAACTCCTTATAACGACAAAAAACGGAAAAGCCTTCTACGGACAAAATCAACCAGAAAG +ACATACCACTTTCTACTAAAAAGAGCATCCCAAGGACACGCTGGAAGCTGGAGGACGACGAAATAATTAA +AGTGGTAATAAAGAAAAGCGAATGAACGTAGTTTTATCGCTCGAGACGTGGGATATAGACGACACCCTTG +CTCTCCTTTTCCTCGCCCACTACCACCAGAAGGGCAAAATAGACCTGCTTGCGGTAGAGGTGGACAAGGG +ACCTCCCTCTCAGAATAATTACGTGAAGTACTTACTTCAAAAAATACATTTAAACGTTCCCGTATTCTCA +AGAAACGTGGAGGAAGATAAATCCGAACTTCCCGAGTATTACTACGAGTTGTTTGAAGACCTAAAACTGG +AAAGTCAGGAATCCCAAAGGAGAGAAGAACTTCTAGATCTTTTAAAGGGCAAAGAATTTAAACTCGTTGT +GGGCGGAAGCCTTAACTTAATTCCCTTTTTACTGGAAAACAGTGTGTTCCCAGAAGAAATATTCGTGCAG +GGAGGTTTTGCGGGGAAAAACATAACCGGTAAAACCCACGAAAAGTTCGGTGACAGATACTTTAAGGCGA +CTTTTAACTTCAACAAAGACGTAAAGGCGACGCTCAGAACCTTTGAACTCTTAAAGGAGTTCAGAATTCC +CACGTACCTGATTTCCAAAAATTTAAACCACACAATACTCATAAAAGAAGAAGACATCCCTCAAAAAGAA +CCCTCAACGAAGGCTCAGGAACTCTACTTTGAAATACTCAAAAAGTACCTCAGGAAGTACAGAAAGGAAA +AGAGCCTCCACGACGTTTACGCCTGTATAGCGATGTTTAAAAAGAATTTGTTCGTCTGGAAGGAGGTAAT +TCCCGTTTACAGGAAGGGAAGAAAGTACACGGAGTGGGGAAGCGTAGAAGCGAAGAGCAATATATGGATA +ACCGTAGACGGAAAAAGAGAAGAGATTAAGGATTACGCCGTTTTCAGGAAGGAGTTCTAAAACTTTGCCC +CAACTGAAAGCGTAAAGAGGTGAGCGCTTATATCCGAAAACTCTCCCTTTATCCTCTGGTTATCAACCTT +TCTGCTGTCCTTTGCAAGGTATAGGTAAGAGAATCCTACTTCCCAGTTTTTCGTAAGGTTGTATATCCCT +CCGAGGGAAAGAATCCATACGCTTTTGGGCTCCGGCAATTCAAACCCTAAGCTTTTTGAAGGTATCGGAG +ATTCACTGTACGCTATACCGAGCAGTCCCTTAAAGCTATCGCCAAATTTGTGCTGTAATCCGAACCTGTA +TGTGTTCACATCTTCCCAATCCTTCTCTATGGGTTTTCCGAACTGGTTTTCTGCGACAGGATCCTTGTAA +TTGAAGTCGAGGTAGTCGTAGGAGGACCAGAACGTTCTCTCGAGAGTAAGCTCAAAGGTAGTGTTATTCC +ACACGTATGAACCTGAAATTCTCAATTCTGCCGGAAGAGGAACGCTGACATCTCCCGAAGTATTCACTCT +ATGTAATCCTATATTTCCCTTCGCATCACCCTCTATATCCAAATCAACTTTTGACCTGTATACCGCGGAT +ATGTTAAAGTTCTCAGTGGGCTTGAAAGTGAAGGAGAGGTAGTAACCGGGCTTTACATCTGTATCCCCAT +CAAGTTTTAAGTTGTAAACATTCGGATAATAGAGTTTCACTTTTCCGCTTGCGTAAACTCCCCTCAAACC +TCCACCTACGGAGAACTTTTCGTTTACCCTGTACGACAGGGCAAAGTCAAGTTCGTAAACCTTTAGTGTA +AACCTCTTAGCGTAGGCACTCACCGGAACATCGTCCCACCTCTTGGAGAGACCTGCAGGTGTAACAAAGG +AAATACCGAACCTGAAATTTTTAACCTCAGGGAATACCATGTGGAAGTACGGGACGAAGTGTGTTTCGTC +CTCGGAACGCGTATCCACGTAAACGTAGCGTTTTTGAACAGGGTCAAGAACGTTTCCCTTAAACTTTATT +TTGGGCAGATATATTAATCTGCTTCCCAGTTCAAAGTACCACCTGTCCTTCAGAAATGACATGTTTGCAG +GGTTGAAGTGTACAGAATCGGCGTGCTCCACAGTTGAGGTGTAAGAAGCTGCGGTTCCAGTGGAACGAAT +GGACTGTTCAGGAACTCTATATCCAACCGCTAAGGAAATAGCCGGGATCAGAAGTGCAGAAAGGGCTAAT +CTTTTCACGCCTTACCTCCTTTCAATAATGATAACCGTTTGCGGAGTAAGTTCTCCGTTAACGAAACTCC +CTTCCCCTACAAGTACACTCTTTACCTTTCCCGAAAACGGACTTCTCACCTCCGTGTAATTTATCAATTT +CTTTATCCTTTCCATTTCCGCTCTTACTTCCTCTATCTGGTACTCTAAAACCTTCAGCTCAGTCCTTTTA +TCTTCGAGTACGCTTTCTGCAAGGAGGTCTCTGTTGAACATTTCCTCGTACCTTCTGTAGTACCTCTCCG +CCTTTTTTCTCTTCTCTTCCAGTTCCATGAGTTTTGCCTCGAGGGCTTTGAGCTTCAGTGTGTAGAGTTC +ATCCGAGATTTTTAAAAGTTTTTGTGCCTTTTTAACCGTATCCCCTTCCTTTACGAATACTTTTTGAACT +TTTCCTTTTACTATTACGTTTACAGGAATCTCCTCTGAAAAGACGAAGCAAATCAGGAGAAGGAATATTA +ACGCAATCCAAGAACCTTTTCCCACGCCTCTACCATCTCCTCGTCTATATCAACGAGAATAACCTTCTCA +AGACACTTTGGCTCAAACTTCCTTATCTCCTCAACCATAGCCCTTGCGGCAACTTCCTTTGGTACTCCGC +CGACTCCCGTTCCCATACCCGGAATAGCTACAATTTTAAAACACTCTTTATCCGCAAGCTCGAGAGCAGC +TCTCGTTGCCTTTCTTACCTTTTCCTCGGAGGAGGGCATGGCTGGTTCTTCCATAGTGGGAGCATGTATC +ACACCCTTGAACTTGAGTTTTCCTGCTGTAGTCAGGACAGCCGAACCAACGGGAATAGGAGCTTTTTCTA +CAGCTTCCCTTTCTATCTCCTCTCCACCAAGTCTTTTTATAACTACCGCTACTCCGCCCCCCATTAACCC +TCTGCTGTTTGCAGGGTTAACGATTACATCGGCGTCAACTTCCGTAATACTTCCCTTTACGACTTTTATG +TCCATAATGGAAAGATTTTAATCGAGAAGTTTCTTTACATCCTCCGCAATTAAGTTTGGTTTTTGTTTGC +TTGCAGAGTATATGAGTTTTATTTTTCCGTCTTTGGTTATCAAATAGATAAGAGCTGAGTGGTTCACGAG +ATAATCATTACTGCCCTTTTGAGGGACTTTTTCGTAAAAGACTTTATAAGCCTTTGCGACTTCCTTTATC +TCCTCGGGCGTTCCCGTGAGTCCCAAGAAGCTCTCGTCAAAGTACTTGGCGTATTGAGAAACAAGCTTCG +GAGTATCCCTTTCCGGATCAACGCTGATAAAGACCACCTGAACCCTTTTCCTTTCATCCTCGTCGAGTTT +TTTCATAGTGTTTTTGAGAACTTCCATGGCAGCCGGGCAAACGTCCGGACAGTGGGTGAAACCAAAGAAC +ACGAGAACTATGTCCTTTTCTTTGAGTATATCTTTAAGACATACTTCTTTAACCTTCCCGTTTTCTTCAG +TCTTCAAGCAGAAGTTGTAAGCCGGTTTGTCGTAAAGTATTCCGTTAAAGCTTTCCTTTTTTTGACAACC +TAAGATGAGTAGAATATATAAAAGGATTAAGTAAAGGAACCTCAGGCTCATCAGGGTATAGAATACATCT +CCTGAGTCATGAGGTCAACACCGCACTCCAGATTTTCAACCCATTCTATGAACTTGTTTACCATGTCTTT +TCCTTTGAATATCGCTCCGTGCTGAGGAGCTATTATTTCTATATCTAACTGCCTCACCATATTTGCCCAG +AATCTGAGTACCTTGTTGGAAGCCATGTACCTCCTGTGGAAACCTTCCATATACTTTACGTGTTCTTCGA +AGTTCTCAACAATAGTGTAAGGCTGGTTCAGAGAAGCCCCTAAATCTCCGCTGAAGAGTATCTTTGAACA +GGGGTCGTATAGCTGGAAGTTGCCGGGTGAGTGCATGAAGTGTGCGGGAAGTACTAAAAGTTCACACCCG +TTTAAATTTACCCTTGTTCCTTTATCGTCTATCGGAATTACCCTTTCCTCGTACCTGCTTTCCAGTCCGA +AGTGAGGTAAAAATCTGTACCAGAGTTTGGGAATTAAGGCTTCTGCGTTTGTCGTAAGGAGCCACCCGTT +TATTCCTGCAACTATATCGGGATCTTGGTGTGAGAGGAATATGTACTTTATCTGTTGAGGAGGAAGGTAC +TTAGATATATCGGATTTCAACTTTGCAAATACTTTATGTCCTCCCGGATCGAGGAGTATCCCCTCACCCT +TGTGTATTATGAGGTATTGATTAGCTTCCACTGCGCTCGCAGGAGTGAGTTCTTCGAAAAGTACTACCTT +ATGATCCTCGGTATCGTAAAGGATTTGCTCCGCCATAATTTATATGATAAAGCTCAAGAAAGGCAAATTG +TAAAATAATTTCCCATGCGAATAGTTAGCGGAATGAGACCCACCGGGAAGCTCCATCTCGGACACTACTT +CGGCGTTATAAGAAACTGGGTGAAACTTCAGGAAGAGCACGAGTGTTTTTTCTTCATAGCGGACTGGCAT +GCCCTTACCACCGCTTATAAAAACACCAAAGAACTCAGACAAAACATAAGGGAGGTTATGATAGATTGGC +TCGCTCTGGGACTTGACCCTCAAAAAAGTGTCCTCTTTATTCAATCTCTCGTAAAAGAGCACGCGGAACT +CTTTTTACTTTTCGGAATGATTACTCCAAAGAGCTGGCTGGAACTGAACCCGACTTACAAAGACCTAAAG +TACAACCTTCTGAGACTCACGGATTTGGAAAAGGAGTTCAAAGAAAAATTGAAGGAAAGAATTTCCGAAA +TCGTGAACCTCATTCCCTTTAATATAACTAAAGAAGAAAAATTCAGAGAGCACCTTCTTGAGAACTTAAC +ACAGACCATGATAGAGGCACTCTTTGAGGGAGAGATTGAACCGGAGATTTTAAAAAGGCTCAACGTGTCT +AAGAGGGATTTTTACGAAACGGATACCTTTGGATTTCTGGGATATCCAGTTCTACAAGCGGCGGACATAC +TCATTTACAAAGGCGAAGGTGTGCCCGTGGGAGAGGATCAACTTCCTCACATAGAACTCTCCCGTGAAAT +AGCAAGAAGGTTTAACAGACTCTACGGAAAGATATTCCCAGAGCCAAAAGCCCTCCTGACAGAAACTCCC +AAAATCCCCGGAACTGACGGAAGGAAGATGTCAAAATCTTACGGAAACGCTGTTTTCTTCTCGGACGAAA +AAGAAGAAGTGGAAAAGAAAGTGATGAAGATGTTCACGGACCCACAAAAGATAAGAAAAAACGACCCCGG +AAGACCCGAAATATGCCCCGTATTTTCCTGGCACAAGCTATTCACGAAAGATGAGGAACTCGTGAAAAAG +ATAGAAGAGGACTGCAGAGCCGGAAGGCTGGGATGTGTAGAGTGCAAAAGGATACTCCTCAAACACCTTG +AAGAGTTTTTAGAACCCATAAGGGAAAGGAGAAGGGAACTTGAGAAGCGTATAAACGAAATAGAAGAGGT +GTTTTACGAAAACTCCCGAAAAGCCAGAGAGATAGCCCAGAAAACCATGGAAGAAGTGAGAAAAGCCATG +AACCTTCCCTGATGGAATTTCTCTTACTTCCCTTTTTTCTTTTTATCCCCTACATTCTTTACTTCCTCTA +CCCGGTAAAGTTCATAAAAAATTTTAGAGAGGTGAACGAAGTCTTAGAGCCCGAAAGCTTTTACATCTAC +TCGTATGCCTTTCACGTGCACACCCAGTTTTCCTACGACAGCCTCGGCAAACCAGAAGACGTAAAAAAGG +CAAGGGAAATATGCGGATTGGATTACGTGATTGTAACGGACCACGAAGTAGACACTTTTAAACTCTTTGA +AGACAAAAACACGATAACGGGAATTGAAAAAAAGATAAACGACGAAAAGGGAAAACTGCAGGGAGATTTA +ATAGAGGTAGGAGACATAAAAGTCATTTCACACCACTTTAAAAAGAAGTATAGGTGGAAACTTGAAAGAA +ATAAAGATTACTTTTTTGAACTTATAAACTTAAAAGATTCTTTGGTTGAGAACAAAAAACACTTATTTTT +TTACCTTTTTCTCGGGACTTTCGTGTATCCAGTTTTTAAAAAATCTTATTTAAAGAACTTTGTTAAGGTC +ATAAAAGTAGAGGACTACGTTAAAAAGTACCTCTCCGAAGGTTGGGAAAACAAGGTTTTGGGAGGACTGG +ATCACCACGTTAAGGTTTACATTAGGGAAGTTGGTATTAGATTTTTATTCCCCTCCTACACTTTTTCGTT +CAGGCTGCTGAGAAACTTCCTTTTAAGTAAAAAACCCGCAAGGAATAAAGAGGAATTCCTGAAAGCTTTG +AGAAGTGAACTCAACGTCATAAGCTTCAGCGAAAAGCCTTCGCTTTTCTGGGTTAAAAATTCAACGCTTT +TTGTTTACACTCCCTACCCGAACGTGATTATCAGAATCTTTAGTAAGGATAAAGTAAGGACTTTCCTCGG +TTCTAACTTAAAGTTTTCTCTGGAGCGTGGGAACTACTTGGTTGTCGGATACATCTACTCTTTCCGACTC +TGGAAGTTCTTCTTCGGAGTGAAGCCCCTCTTTGTTAGCGACTTAATAAAAATTTCTTGCTAAATTTATT +TAATAGAAGTTTTATCAAGGAGGTGGGAATATGAAGGTGAAGTTAACCGATAGAGACGCCCTTATAGTCG +TTGATATGCAAAAGGACTTTATGCCCGGTGGTGCACTACCCGTTCCAGAGGGAGACAAGATAATACCGAG +GATAAACGAGTACGTCAAACTCTTTGAAAAGAAAGGACTTCCTGTTTTCTACACGAGGGACTGGCACCCA +GAAAATCACATATCCTTCAAAGGACACGGCGGTATATGGCCACCTCACTGTGTTCAGGGAACGGAAGGTG +CTAAGTTCCACGAAGACCTGTACATCCCCGCGGACAACAAGTTCATAATTTCAAAGGGAACTTCTCAGGA +GTTTGACGCGTATTCCGGTTTTCAGGGAACGATTTTAAATGACCTTTTGAAAGAGAGGGGAGTAAGAAGG +ATATTCGTGTGCGGAGTGGCAACGGATTACTGCGTTAAAAACACAACGATAGGCGGTATAAACCTCGGCT +ACCAGGCCTTTGTTCTGGAAGATGCGATAAAGGGCGTGGACGTGAACCCCGGAGACGTTGAGAGAGCAAT +AAACGAGATGATGGAAAGGGGAGCTGCCTTTATAAAGATTGAAGATATAGTAGATTACAAAAAGTAATTA +AAAAAAATTGACATAATTTCACTAAGGTTGTATAATAAAAGGCAGGAAAGATAGGAGGTGATAAAATGGC +TGAAAAGAAGGAAAAAATAATTGGGATAGACCTTGGAACTACGAACTCCGTTGTTTCTGTAATGATGGGG +GATGAAGCGGTAGTAATCCAAAACCAAGAAGGTTCAAGGTTAACCCCCTCAGTAGTTTCCTGGACCAAGG +AAAAGGAAATTCTGGTAGGAGAACCCGCAAAGAGAAGGGCGATACTGGATCCTGAAAACACCGTATACGA +AAGTAAAAGGTTCATAGGTAGGAAGTTTGAAGAAGTAAAGGAAGAGGCAAAGAGAGTATCTTACAAGGTA +GTTCCCGATGAAAAGGGAGACGCCGCCTTTGACATACCGAACGCCGGAAAGCTCGTGAGGCCTGAGGAAG +TAGGAGCACACGTTCTCAGGAAGTTAAAGGAAGCTGCAGAAGCGTTCCTCGGAGAACCCGTCAAGAAAGC +GGTGATAACCGTTCCCGCATACTTCAACGAAAGACAGAGGCAGGCGACAAAGGACGCGGGTAAGATAGCG +GGACTTGAAGTTGTAAGGATACTGAACGAACCCACCGCCGCGGCAATGGCTTACGGACTCCACAAGAAGG +ACAACGTAAGGATACTCGTTTACGACTTCGGAGGAGGAACCTTTGATGTTTCCATACTGGAAGGCGGTGA +GGGCGTAATAGAGGTAAAGGTAACGGCGGGAGACACGCACCTTGGCGGTGCAAACATAGACGAGAGGATA +ATGGACTGGTTAATTGAAGAGTTCAAGAAGGAAACGGGAATAGACCTGAGAAAGGACAGAACCGCACTCC +AGAGACTCAAGGAAGCTTCCGAACAGGCCAAAAAAGAACTCTCCTTCAAGATGGAAACGGAAATTAACCT +GCCGTTCATAACCATAGACCCCAACACTAACCAGCCCCTCCACCTCCAGAAGAAGCTCACCAGAGCAAGA +CTTGAAGAAATGATTAAAGACATCGTTGACAGAACCATAGACATAGTTAAACAGGCACTAGAAGACGCCA +AACTAAAGCCCTCCGACATAGACGAAGTGGTTCTTGTAGGCGGTTCAACGAGGATACCTTTAGTTCAGCA +AAGGATTAAGGAGTTCTTCGGAAAAGAGCCCCACAAGGGACTGAACCCCGACGAAGTTGTAGCGATGGGT +GCGGCAATTCAGGCAGGTGTTCTCGCAGGAGAAGTCAAGGAAATCGTTCTCGTTGACGTAACACCCCTGT +CTCTCGGAGTTGAAACCTACGGAGGGGTAATGACTGTTCTCATTCCCAGAAACACCCCGATACCCGTCAG +AAAGTGTGAAATCTTCACAACCGCCCACGACTATCAAACGGAAGTTGAAATACACGTCCTTCAGGGTGAA +AGACCTCTCGCTAAGGACAACAAGTCCCTCGCTAAATTCTACCTGACGGGAATACCTCCGGCACCTAGAG +GAGTGCCCAAGATAGAAGTTTGCTTTGACATAGACGCGGACGGTATACTCCACGTTACCGCAAAGGACCT +CGGAACGGGTAAAGAGCAGTCCGTAAGGGTAGAAATATCCTCCGGACTAACGCCCGAAGAAATTGAAAGG +ATTATCAAGGAAGCTGAAGAGCACGCCGAAGAAGACAGGAAGAAGAAAGAACTCATTGAAGCTAAGAACC +AGCTTGACCACCTCGTTTACCAGCTTGAAAAGGCACTAAAAGAAGCGGGAGACAAAGTACCCGCAGACGT +AAAGAGCGAAGCGGAAAAGGTTATAGAAGAAGCTAAGAAAACCATAGAAACCGCAACGGAAATTGAACAG +GTAAAACAAGTTACGGAAAAGGTTCTCCAGGTTTCCTCAAAGATGGGAACCACACTCTACGGTGAAGCCG +GAAAACAAGCGGGCGGAGGAGAAAAGAAGGACGAAGGTGGAGAGGGAGAAGTAGAAGCCAAACCCGTTGA +TTAATCTCCCTTCTCCTTCCTTAACTTTCTTTCTTTAAAAACTCAAGCATACTCTTAATCCACTCGTAGA +GTTCCTTTGTAATTTCTTCGTAAGACTTCTCGTCCGGATCTACAGGCTTTCCGAACATTATTTTTATCTT +TTTAGGTTTCGGGAACTTGTCGTAAACGGACCAAGCTTCGTAAGCCCCTTCTATTGCAACGGGAACTATT +GGAACACCAAGTTCTCTGGCGAGTATGGCGACTCCTTTTTTGAATTCCATTAATTCTTCTGTCCTCGTCC +GCGCACCCTCGGGAAAGATCACCACTACTTTTCCCGACATCAAGGCGTAAGCGGTTTTCTGGAGGGATTC +TTTTAAACCTTTGTTTACGTTTACTGTGATGACGTGAGCGAGTTTACCGAAGGTTGAAGTTATTGGATTT +CTGAAGTAGGTTTCGTCTCCTAAAAAGTAAGTTTCGTGGGCTATTTCCTTTGGAAGAACAGCGGCTATGG +CGAAGGCGTCTAAATAGCTCTGGTGATTTGGTGCAATTATAAAGGGAGGCTTGGGCAGGTTTTCAAGACC +TCTCACGTCTATCCTGTGGTATAGCTTGAAGTAAAGTTTTAAAAGCTTTCTTCCGAGTTCAAAGATGAGG +GGGTAGTGGTAAAGCTCGTAAGGCTTTGCCTTTGTGAGTATATCTTTCCAGGAAACTTCTTTAGTATCCA +CACTTTTTTTCTTACTGCGAACGAGTTCTATGAGGTCCTTTACCACTAAATTTTTTGACAATTCCTCTTC +CGAAAGACTGACTCCGAAGTTTGTCTCTATAAATCCAAGAAGTTCTACCTTAGCAAGGGAATCAAGCCCC +AAGTCAATTTCGAGGTGATCTCCGGGTTTTACTTCCTTCTGAGAAATTTTTTCAAGAAATTCCTTTATTA +TTCTTCCTTCCTCCGTTTCAAATACGCTGTAATCCTCCGTTTTTTCTTCTTTTATTTCTTCAGCCTTTTC +GTAAATTTGCGGAAGCAAAAATCTCCTCAGTTTCCCCAGTCTAGTTTTGGGAAGTTCCGTTTTCACGATT +TTGAACCCGACTACCCTCTTCCACTCCGGGAGTTCCCTGTTTACTTTGTCTATTACTTCCCACTTTATCG +TTTCTTCCAGATTAGTTATTCCTAATTCTTTAACTTTTTCAAAATCGGGGTAAATTAAAGCGAGGAGCTT +GCCATCTTTTTCAAAAACCCCGACTTCCTTTATGTATGGAGCTTTTGCAAGGATTTTACTCTCTATTTCC +TCCGGGAATACGTTCTTACCGCTTCCGAGGACTATTATTTCTTTCTTCCTTCCCGTTATGTATATATATC +CTTCTTCGTCTATCTCTCCGAGATCTCCCGTGTAGAACCAACCGTTTATTATTACCTTTTGAGTTTCTTC +GGGTTTTTTCCAGTACCCCTTCATTACGTTGTCTCCGCGAACAATGATTTCCCCTTCACTCGTGGTCATC +ACTTCAACGCCTTTTATCGGTACACCCACCGAGCCCAGTTTTATTCTGTTCGGAGGATTAAAAGAAACTA +TCGGAGAGGTTTCCGTGAGTCCGTAGCCTTCTATTACGGTAAACCCGAGTGTTGTTAAGTCCTGGGCGAT +ATCCAGAGGTAGTTTTGCCCCTCCGCTTACCATGTACTTTATCCTTCCACCAAAGGCATCGTGAACTTTT +TTAAAAACCGTTTTTCTTATTTTCTGGTTTTTAACTTTTTTCATTAATTTAAATAAATTTTTCGCGAGAA +CGTTTTTGTTTATCTCCTCCATAATCCTTCTGTGGAAGAGCTGGTAAAGCCTCGGAACACCTATTAAAAC +GGTTATCTGGTACTTCTGAAGTTTCTCGATTATGTCTTCCGGTGTTAACTTATCCAGAAAAACTACCGTT +GCACCAAGGTAAAGAGGCAATAACATAGTAGTCATAAGCGGGTACATATGGTGGAAGGGGAGAATGGCGA +GGGTTTTGTCTTCCTTTCCCGCTATTCCTACCTCCGATACACCTCTTATATTTGACATGAGGTTTTTGAA +GGTAAGCATAACACCTTTTGGATTTCCCGTAGTTCCAGAGGTGTAAGGAAGAACGGCTACATCGTCTTCA +TCTCTCCTCACTATACCTTCCCACGGAGTGGGTAGTACAAGGTTGTCCACGTTTACGATTTCTACTTTCA +AATCTTCAGAGGCTTCCCTGACCCTCGGATAAGTTTCATCTGAACAGAAAATTATTGAAGGTTCTGCGTC +TTCAAGAATGTACCTTATCTCTTGAGGAGTTGACATAAAGTCTATGGGAACGACTATTCCACCCTTTTTC +CACGTTCCGTAAAAGGCGTAAACCCATTCGGGTCTATTTTCCATTACTATGCCTACTCTTTCGTTAGGCG +TTATGTCCATTAAGTTTGCGAAAGAGGCTATATTTTCGAGGAGTTCAGCGTAGGAGATTTCGTTTCCTTG +ATGAATTAAAGCAGTTTTCCCGAAATCCCTCAAAAATTCCATATAAATACTTTAAAGCTAAATCTGGATA +AGAAAAGTTATGCGAGAAAGAGAAACGATAGCGTATTTCCAAGGAACAATCCCTTATTGTTAGGGCGTAA +CTGACACCAGCAGGTCCTATCACAAGTCCCATCAAAAGGTCGCAATCCCTCACTATTAGGGCGTAACCGG +TCCAAGTTGTTCCATCAGAAGAAACAGAAATGGTGTCGCAATCCCTCACTATTAGGGCGTAACCCTGCGT +GCCTGTGTCTAAAAAATAACGCTTTATCAACAACTTATTAGACACCCGATCCTCCCGAAACGAATGTTAA +TTTCCGCTAACCCGAGGTTCCGCAAACTTGAGCATACCTTTATAAAATTTCCATCCTTGATTTTCAATCC +CTTAAAGCTTATTGCATCATGATTTCATCTCATCACGCCCTCAAAACATCACTCGTTAAGACCCATAAAC +CATATTCACTTGCCAAGGAGCCCGAAAGCCCTCAGCAGGGCTTTAAATTATTATACTACTTCTTTTCTCT +CTTTACGTAAATGTTTATCTCCACTCTGTTGTTCCTTTCAATCAGGACGCTCTGGCGCCACCTGTAAAGG +GGACGTTTGTCGCCGTAGGATACCGCAACGAGTTTATCGTGGGGAACGCCTCTGTTTTCGAGGTAACGGA +TAACTTCGGTTGCCCTTCTGCCCGCGAGTTCCCACTTGTTTCTAATAATTGGATTTTTTATTTCTACCGT +AGGGCCAACGTGCCCTTCCACCCTTATACTGGAAATTTCGTCAGAAAGAGCTATCAAAAGAGGGGCTATT +TCTTCAAGGGTTTTTCTTCCCTTTTCTGTTAACTTATAATCGCCGTTTTCAAAGAAAATCCTGTCAAAAA +GTCTGAGTTTTATGTATTCTTCCGCAACTACAACCTGATAAGCCCAGGGAGGCAAAACCTTACTTATACG +TTTTTTTATCTTGACCGCGTAATCCTTCGGATGAGTAATAGGAGGGACAACGGAATTCTTAGGAGGATAA +AGTTCTGGATTTTTCCTGAAGTAAGATAAAAACTTTTCAAGGGCGGGTATCTCAAGGGTACTCATGGCGT +ACAAGAGTATGAAAAATGTAAGAAGCAGGGACATTAAGTCGGAAAAGGAAGTGAGCCAAGCTGGCGGTTT +TGGACACTCTTCCTTCTTCTTGTAAGCCATGTTTCCCTCCTCAGGGAAGGAGCTTTACGCAGAACTCCAC +TCTCCTGTTTTTTTGCCTGCCCTGTGGTGTGTCGTTGCTCGCTATCGGCTTTGTGTCCGCGTAGCCAAGG +GCACTGAGTTTGTCCGAAGGGTAACCGCATTCTTTTTCAAAGACCTCTATTACGCTTATTGCCCTTGCCA +TAGAGAGTTCCCAGTTGCTGGGAAATCTCGGCGTGCTTATGGGTCTGTTGTCAGTATGACCTTCTATATC +CACGGGTAATGCGTAAGGTTTTAACTTGTAGCAAAGACCGAGTATAAGCCCCTTTGCTTCCTTCATGAGT +GTGTCCTCGCCGGGTGGGAAAAACTTATCCGTGTTTACACGTATCCTCAAACACTCACCTGTTAGGGCGT +AATCGCTCCATATGCCTCTTTTGCTCATCTCGGCCTTTATCTCCTGAGCTACTTTCTTGAGTTCCTTGTA +CTTTATTTTCCGAAAGTGAAAGTTCTCCATAGGTATTTCTATCCTTCTACCTTCAGGCATAGTTCCTTCT +TCAAAGACTACGGACTGCGCCCCGAAGGCTGAAACTATTCCCTTCAGAACCTGATAAAACTTCTCAAGGG +AGATTATGCTCATGGAGTAGAGAAGGATAAAGAAGGTAAGTAGGAGTGACATGAGGTCTCCAAAAGACGT +GAGCCATGCGGGCGGTTTTGGACATTCCTCCTTTTTCTTGTAAGCCATCCGTTAAACCTCTTCGGGCAGT +TCAACGCCGAGCATAATGGCGGCTTCCTGCTTGACGACGTTTGGATTTTCTCCCTTCTGTATCTTTTCAA +TAGCCTCTATGTAAATGGTCTTTACGAGAACTTCCATGTCCTTTGCTTTTTTGAGTTTGTTTGCCACGGG +AATTGCAAAAGCGTTTGCGAGGATTGCACCGTAAAGGGTCGTTATCAAAGCAACTGCCATACCGGGCCCA +AGAGCGGAAGGGTCGTTTAAGTTCCTGAGCATCTGTATAAGACCTATCAGCGTTCCTATCATACCGAAGG +CGGGGAAAAGGTCTGCGAGCTTTTCCCACACCGCGACTTCCGTTGACATCTTTTCGTCCAGTTGTGCCAG +CGCCATCTCAGCTGTGGCCTTTATGTCGTTTATGTCTATGCCGTCCACGAGCATTCTTATCATGTCTCCC +AGAAGCGGATCTTTCTGGTAGTAAAGTTCTATGTCTCCCTCAAGGGCGAGTATCCCTTCCTTCCTCACCT +TTGAAGCTATCTCACCAATCGTCTCTATAACGTCGTTGAGGTCGGGAGGTTTCCAGAGGAACGCCTTTTT +TATAGCGAGAACGCCCCTTATAAAGTCCTTTAAGGGAAATGCTCCCATGGCGGCGGCCATACCACCGCCA +ACGACGATGAAGATTGAAGGAACGTTTATGAACGCAGTTATACTTCCGCCTATTAAAATAGATATGAGTA +TGAGTAAGAAGGCAGCGATAATACCTATAATCGTTCCTACGTCCATTTCTAAATAAATTTATCGGATTTC +CTTTTTAAAATTTAAATTATGAACGGATACTACGTAGTTTTAATAACCGTGCCCGTGGACAAAGGGGAGG +AGCTTTCAAACTTTATAGTGGAGAATAAACTCGGAGCATGCGTTAACGTTGTTCCGGAAGTTAACTCCGT +TTACTGGTGGAAAGGGAATATTGAAAAGGACAAGGAAGCCCTTCTCGTGGTAAAGACCTCCGCACAGAAG +TTCAAGGAATTATTGGAGAAGGTAAAGAGCGTTCATCCCTACACTGTTCCCGAAATAATAGCCCTTCCGA +TACTTGCAGGAAATCCAGATTATCTAAACTGGATTGAGGACAGCCTTAAATGAGACCTCTAAAGCTTGAA +GTAAAGGGCTTTACCGTTTACAAAAAGCCACAGGTAATAGACTTCACTCCCTTGAAGTTCTTCGTCATAC +AAGGGAAAACGGGAGCGGGAAAGACGAGCATAATAGACGCAATCACCTACGCTCTCTACGGAAAAGTGCC +GAGGTACGGGGCAAGCGTTGCAACGAAGTACGTCCTTTCCCGTGGAGAAAAAGAGTTAAAGGTAGCCCTC +GACTTTTCCCTGAGGGGGAGAAATTACAGGGTTGAGAGGTATTACAGGGAGTTCCCAGAGGACTCTCAGG +TAAGGGTGTACGAGGAGGGAAGAAGGCTAAACATAAAAGCCAACGAGGTGGAAAAGTGGCTCTTTAAGAT +TTCAGGGCTCGATTACAAGACCTTCACAAAAGTAATACTCCTTCCACAGGGGGAGTTTGACAGATTTTTA +AAGGAGTCCTCCGAGAGAAAGAAAATACTCATAAACCTCCTCGGACTGGAAGAACTTGAAAAAGTAAGAC +AACTCGCAAGCGAAACCTTCAAGAACTTAGAGGGAAAGAGGGAAGCCCTAAAGAAAGAGTACGAACTCCT +CAAAGACTACACACCAACAAAAAAAGAAGTTCTGGAAAAAACCCTGAAAAATTTAGAAGAAGAACTGAAA +GAACTGAAGGAAACGGAGGAAAAATTAAGGCAGGAACTCAAAAAAGCGGAAGAAAAAGATAGCCTTGAAA +GGGAACTTTCTCAAGTTGTGACAAAATTAAAGGAACTGGAAAATTTAGAAAAAGAAGTAGAAAAACTAAG +GGAAAAGTTAGAATTCTCAAGAAAGGTAGCTCCTTACGTTCCCATAGCGAAGAGGATTGAGGAAATAGAC +AAAAAATTAACGGAATTGAAGGTCAGGAAAAATAAACTCACCAAGGAGCTCGCAGTTTTAAAAGATGAAC +TTTCCTTTGCACAGGAAGAATTAAACAGGATTGAAGCGGAAAAGGAGAAGTTCAAGGAAGAAAAGGAAAG +GGAAAAGGAACTGGAGCACAGGCTTAAAAAACTGCAGGAAATAAAGGAAATCTTAAAGGAACTCTCTCAA +CTCTCATCAAGCTTGAAGGAAAAAGAAAGAGAATACGAACAGGCGAAGCAAGAGTTTGAGGATTTATCCG +AGAGGGTGGAAAAGGGGAAAAAACTCGTTGCTGAAACCGAAGAAAAACTTGAAAAGATAAAGGAACTTTT +CTCTGAAGAGGAATACACGAGCTTAAAAATGAAAGAAAGACTCCTCGTTGAACTTCAAAGAAAGTTAAAG +GAACTAAAAGAAAAGGAAGGACAACTGGAAAATTTAACGCAAAAATACAAAGAAAAGAAAAAAGTTCACG +AAAAAGTTTTAAATGAATTGAAAGAGCTTGAAAGGGAGTTAAAGGAAAGGGAACTCCACTACCACGCTCA +CATGGTAGCCAGCTATCTCTCTCCCGGAGATACGTGTCCCGTTTGCGGAGGAATATACAGGGGAAAGGCT +CTGGAAAACGTGGACGCGGAAGGCATATCCGAACTGAAGCACGCTAAGGAACTGAAGGAAAAAGAAGAGA +GGGAAATCGACACAACTCTGAAACTCTACGCCCAGAAGATTAATTCCTTAAAAGAGGAAATGGAGAAGTT +AAGGAATGAGGTGGAGGAACTCAGGAAAGAAATCCCTGAAAACCTTAAAGAAAGGATAAAGAAACTTGAA +GAATTAAGAATTGAAAAGGAGAAATTAGAACATAAACTGAATAAGTACAGAAAGGCTTTAGAAGATAGAC +AAAAGCAAAAGGAAGAAGCACAGGCAAAACTCCACAAAGCTCAAACAGAATTAGAACTCCTGAAGGAGAA +AATAAGGGAAAAGAGTAGGCTCGTTAAGGAATTTAAAGAACTCTACCGTGTTGAAAGACTAGAAGACTAC +GAAGAAAGCTTAAAGGAGGAGATAAATTACATTAACTCAAAACTTCAGGAAATTGAAGAAAAGGAAAAGA +AACTCAGGAAACACTTTGAAGAACTCAGCTCCAGAAAGTCAAAGCTGGAAGGAGAACTCTCTGCCTTGAA +CGAAAGCATAAACTCCTTAGAAGAAGAGAGAAAGGAAAAACTGAAGGAACTCGCAAACATTTACGAGGTC +GCAAAATCTCCTAGGGAAGTTGTAGAGCTTTACCTCGGAGACAAAGAAGCGGAGCTTGAGAGGAAGATAA +AGGAGTTTGAGGAAAGTTTTCAGTCTCTTAAACTCAAAAAGTCGGAAATTGAAGAAAAGCTTAAAGAATA +CGAAGGTATAAGGGAGTTAAGCGATATAAAAGGAGAGTACGAAAGTGTAAAAACGCAATTAGAAGAAAAA +CACAAAAAGCTCGGAGAGGTTAAAAGGGAGCTTGAACACCTCGGAGAAAGGCTCAAGAGAAAGGAGGAGC +TCCAGAAGGAGATTTCCGAACTTGAAAAGAAGTTAGAAGTATACAGAGTGATAAGCAATGACTTCCGGGG +AGACAGGTTCCAGAAGTACGTCTCGGAGATAATGCTCCAGAAGGTTGTAGACAGGGCGAGTGAGTACTTC +TACAAATTTACGGGAAATTACTTCTTTGAGCTCGAAAGGGCGACGAAGGGAAGGGACAAGGACATAGTAG +TTGTTGAGAGTTCTACGAGCCAGAGGAGACCGGTGAGCAGTCTGAGCGGTGGAGAGACCTTTTTGGCTAG +CCTTTCCTTTGCCTTTGCGGTAAGCGATCTGCTTTCTGGAAGTGCAAACCTCGAGAGCCTCTTCATAGAC +GAAGGGTTCGGAAGTCTTGACCAGGACATGAGGGAGAGGGTAAGCGAAATTCTGGAAGCCATAAAGACAA +ACGTGAACAAGATGATAGGTATAGTCTCTCACATTCCGGACTTTGCGGAGAGATTTACGGAAAGGATAGT +GGTGGAAAAGAAAGGGGACTACTCGGAAGTAAGGGTTATTTACTAAATTATGACCTTCACTCCCAGTTTT +TCTATCTCCTCTACAACCTTTCTGTCAGCCTTTAGTTTCATATCTTGTGGGAGTGCTAAATCAACGAAGT +AGTCTCCCAGATCAACCGTGAGAACCAAGTTGTATCCGTCCTCCGTCCTGTTGTTTTCAATAATTCCCTT +TAGTTTTTCGGCAACGCCGTTTAGGGCTTGCTCTCTTTTTAAGAATATATAAAGGGTATTCCTCATCTCC +TTTGCGAACTCCTCAGGGGAGAAAACCTCTTTCACCACGAACTTGACATTTTCCGTTTCAAGGTCCTCGT +CCAGAAAACCTTTGACTACCACTACTCTGTCCTCTTCTATCAGTTCCTTTGCCTCTTCGTAAACTCCCGG +GAAGACGACACACTCTATTAGTCCCGTCTTGTCAACGAGGTTGAAGACCGCCATGTAATCTCCGTTTTTC +GTCTTTTTTACTTTGAGTTCCGTGATAACTCCTGTAAGCACCGCTTCGCTTTCCTTGTCCCACTCTTCTA +AATCTTCAATGGGTGTGTAGCGGTTCTTGAGGAGCTTTTCGTAGTTGTCAAGGGGGTGCCCTGAAATGTA +AAAACCGAGAACTTCCTTTTCAAGCTTTAAGGGGTCGAGTTCTTCCACTTCTTCTTTCGGTGCACCGAAA +AGGGAGTTTTGTGTAGCCATTAATGCTTTTTCAGAGTTTGCCACTTTAGCGAGTAGTTCTTTCCTCTTTT +TCTTAGTAAAGTCAAAAGCCCCTGCCTTTACGAGTGCTTCCACGACTTTCTTGTTTATCTTCCTGTTCTT +GGTTTTGTTTATGAAGTCCGCAAGCCCTTTGAACTGCTTATACTTCTTTCTAGCTTCAACGATTATCTTA +GCAGTTTCCTCTCCCACTCCCTTTATCCTCGCAAGCCCGAACCTTATCCTGTTTTCACCTTCTATCGTAA +ATCCTACATCACTCTTGTTTATGTCGGGGGGAAGTATCTCAAATCCGAAGAGTTTAGCGTCTTTTATGAG +GTTGAGGAACTTGTTGTCGTTCTTTTCAGTTGTGAGTTTTACCGCGAAGAACTCCGCGGGATAGTGGGCT +TTAACGTAGGCGGTCCAGTAGGAGATGTACCCGTAAGCTACCGAGTGAGACTTGTTGAAGGAGTAGGAAG +CGAACTTCTCTATGTCTTCCCAGAGCTTCCTTATCTTTTCTTCAGGGTATCCCCTTTCCACCGCTCCCTG +TATGAACTTGTCTTTCATCTGAGCCATTAAATCCGCTTTCTTCTTACCTATCGCCTTTCTGAGGGTATCC +GCCTCTCCGGGAGTAAAGCCGGAAAGTATCTGAGACATCTTCATCACCTGTTCCTGATAAACGATTACTC +CGTAGGTTTCCTTAAGGACGGGTTCAAGCTCCGGGAAGGGGTACTCAACGGGTTCTTTTCCGTGCTTTCT +CTTAATGTATGTGTCAACGAGTCCGCTCTTTAGAGGTCCGGGTCTGTAGAGTGCGAGGACCGCAACGATG +TCGTCAAAGCTGTCGGGCTTTAGTTTCTTCAGGAGTTCTTTCATTCCCCTGCTTTCGAGCTGGAACACTC +CCGTGGTTTTTCCTTCCTGAAGGAGTTTGTAAACTTTCGGGTCGTCAAGGGGAAGTTCAAGGAAGTTTAT +ATCCACTCCGTGTCTTTCCTTTATGAGTTCTTTCATGAGTTTCAGTTCTGTGAGGGTTTTGAGTCCGAGG +AAGTCCATCTTCAGGAGACCGAGTTCTTCGAGCTGAACCATGTCGTACTGGGTTGCGACTTCGCCCTCTT +TATCGTAGTAGAGGGGAACGAGCTCGCTCAAGGGCTTTGGTGCTATAACCACTCCCGCGGCGTGGAGGGA +GGTGTGTCTCGTGAGACCTTCAAGCTTCAGGGCCGTCTCAACGAGCTGTTTTATCTCCGGACTTTCTTCG +CATATCTGTCTGAACTTCTTTACGTTGTCCTCTATGTCCGTTCTGTGTTCTCCGTACTTCTGAAGGAGTT +CCTCCACAGGCGTTTTGTACATCTCTTCCAGACTGAGCCACGTTCCCTGAACGTCCCCCTGAGGAATGAG +TTTTGCGAGTTTGTCCGCGGTGGAGTAGGGGAGTCCCATGGCCCTTGCGACGTCTCTCAGTGTTTGCTTC +GCCTTCATTACGTTGTAGGTGATTATCTGAGCTACGTTGTCGTGTCCGTACTTGTTCCTTACGTACTCTA +TGACCTTTTCCCTGTTGTCCTGACAGAAATCCACGTCTATATCCGGCATGGAAACCCTTTCGGGGTTTAA +GAACCTCTCAAAAAGGAATCCGTGCTTTATAGGGTCAACGTCCGTTATTCCGATGGCGTATGCGACGAGG +GAACCTCCAGCACTTCCCCTTCCGGGTCCAACAGGTATGTCGTTTTTCTTAGCCCAGTTTATGAAGTCCT +GAACTATCAAGAAGTATCCCGCAAAGCCCATTTTGTTTATAACTTCCAGTTCGTACTCGAGCCTCTCCCA +GTACTCTTTAGTATCCTTAGCTTGTCCCCTTTCTATCCTCTGTCTTAAACCTTTGTACGCGAGTTCTCTG +AGGTATTCCTCAAGGGTTTTGTCGGGCGGAACGTCGTACTTGGGAAGGAGGTAGGTGGAGTTTTCAAATA +TCTCAAAGCTGTCCGCTGTCTTTTCCATTACCTCGAGAGTGTTCAGGAGTGCCTTTTCCCAGCCTTCGAA +CTTACCTTCAAACTTTTTCCACATGTACTCGGGTGGAGCAAAGTGAAGGTCTTCGTTTGAACACTTGAAG +TTTCCCGAACTCAGTTCGTGAATGGTCTTTTTCATTTGAAGTGCCATAAGAACCGTGTGGGCGTACCTGT +CTTCGGGATTGAGGTAGTGGGCGTCCTGCGTCGCTATGAGTTTCACATCGTACTTTTTGGCTATCTCTAT +TAAGTTCCTGTTTGCCACTTCCTGTTCTGGAATGTTGTTCGCTTGAAGTTCTAAATAAAGGTCATCTCCG +AATATATCCTTGAACTTCTTTACCCATTCCTCCGCCTTTTTCACTTCGTTTATAGAAGCGTAGTAGGTGG +GAACACCTTTCAGGCATGCGGTAAGGGCTATTAGGCCCTCCCCGTACTTTTCAAGGAGTTCGTAATCAAT +TCTGGGTTTGTAGTAAAAACCTTCTTTGTAGGCGAGGGTTGAGAGCTTCATTAAGTTCTTTAGACCTTTG +TCGTCCTTTGCTATAAGTATGAGGTGGTGGTTGTACTTGTCGGTTATGTTGTCCTCGCTCGTTTTAGTCT +TTCTGTCAAACCTCGAACCCGTGGTAAAGTAGGCTTCCATGCCGATTATGGGCTTAATTCCTTCCGCCTT +CAGGGCTTTGTAGAATTTATACGAACCGAAGAGGTTTCCGTGGTCTGACATTCCGACAGCTTTGTATCCA +TACTCCTTTGCCTTTTTCACGAGCTCGTCTATCTTTATAGCCCCGTCCAGGAGTGAGAACTGGGTGTGCA +GGTGAAGGTGGACGAAATCCTTACTCATAAATCTAAATTTTAAACTCCCGACCCCGCTATGTGCCTCCCA +CCGTCCACGCAGATTATTTCTCCGGTGATACTTTCCGTTTCCAAAAGAAGGAGCGTTGTGCTTACCACGT +CTTTAACGGAAACTTCCCTTCTCAGGGGCGTTCTCGCGAGTATCTTTTTCCACTCCTCCTCCGAGTAGTT +TTCCGCCTTCATCACGGGACCGGGAGCAACGCAATTCACGAGAACGTGAGGTGCAAACTCCTTTGCCAGA +ACCTTTACCGCTGTGTGAAGGGCTCCTTTGGCGATAAAGTAAGCACTGAAACCCTTATAAGGGGATATGT +TTGTAGCCCAATCGCCGAAGGCAACTATCCTTCCCTTTACGTTTCCTTCATTTTTGAGCATAACTTTATA +ACACTCCACAGAGATAAAGAAGAAAGCTTCCGCTATGGGTATGAAGTGATAGTAAAGATCCTCCCGCGTT +GTTTCTGTGAGCTCTTTTCTCTCATAGGGTGAGGCGAGGTGAACGAAGGCGTCTATCCTGCCGAACTCCT +CGTAAGTTCCTTTTACAAGTTTTTCATAGTCCCCGTACGCGCACAGATCTGCCCGAAATCCCTTTACCTT +AACTCCTTTTCCCTTTGCATACTCGGTCAGTTCCTCCACCGCTTCTCTGCTTGACCTGTATACGACGCTC +AGGGAATAACCTTTATCTATCAAAGCTTTAGCAACTTCCTTTCCTATCCTCCTTACACCTGTGATTAAGG +CAACGTTCATGAAAGAAACTATAATATCTTCCATGGAGAAGTTTATTCAAAAATTTTTTGAAGAGCTTTA +CTTAATTCTTTTTGACTACGCTCTTAAGATAGCTCAAAATCCAATAGATGAGCTTTTAATATTTGGAAGT +ATAGCAATTGCCTACACGGTAATTTACATATCGGGTCTATTCTTTGCAAGAAAGATAAATCTACCCTACA +TAAGGAAAATCCTTGAAATAGGTATTAGCGTCATATTTTACTTCTTAGTTTCTCTTTTGGAAGGGAAATT +CCCCCAGGTAGAAAGCCTGCTACTATTAAAAACGCTCTTTCTAGTTCAAACAATTCGTGTATTCATCCTT +TCCCTTGAGGCTTTTCAGGCTTTTGGATTTACTACCAAGCTTTTAATAAACATTTTTTCTATCCTCGGCG +GTATTTCCTTTTTCATTATAAAACTGTCTCCCTTTACAAGAAGAAAAATATAAAGTTTCTGCTATTGAGT +AAAACGTTTACGTTCCTCTACAAATTCTCTATTGCCCTGCTTTTGTGGATATTCTTAAGGACCCTTTTTA +AAGTCGCGATTAAAAGGTTTAAAGGTAGCGGTTTTGAATCCGTGCTTAATTCCCTCTGGTTTGTTTTGAG +TGCGTCTTACGTGGCGTTTACAGGCGCATGGATACTGAATCTCGTTAAGTTCTCCGTGGACTTTATAGTA +GACGTTGCGGTATTTTTCGTAATTTTCTTGGTCTACGCTGCGGTATTCGGTTACTCGGTTTATCTGATAG +GTAAATTCTTCGGCGACACGGACGGTTACGAGAATCTCCTGAAGAGCTTTAAAAAGTTCGCTTATATGTT +TTCCATATACATACTCTACAAAAGCCTTATCTACTTGACGAACATTGAAGTCCTCGTAAAGAAGCTTGAA +AGAATATACATACTTGAGACGGAACTCGTTAAGATTTCTCTCTTTTCCTTTGTGGAAGGGATATACGTCT +TCTTTGTTCTGAAGTACTTCTTTGAAACACTCGGAAACCTTTTCTACGTTGTGTATATGAAAAAGGACCA +AGAAGTAGAAGCGGGTTCCTTTAGAACAATTACCGTAAACCTCGGTTTACTCCTTTCTCTCCTGATAGCG +GGTGTGAGTATAGGGATTACGTGGAAAGCTGCTGTTCCCATAGCGGGCGCCCTCGGCATAGGTTTGGGTT +TTGGACTTCAGACCATTTTCAACAACTACGTCAGCGGGTTTATACTCCTCCTTAGCAAAAACATAAAAGT +GGGTGATTACATAGAAATTGAAGGAAAGGCCGGCGCCGCTGTAGGAGCTGGAGGAGACACGATTTTCGGA +AGAGTAGTCAGTATAAATATCCTTACAACCATTGTAAGGACTTGGGACAACGTGGAAGTCGCCATACCAA +ACTCCGAATTCCTGTCGAGCAAAATAGTCAATTACTCTATGACTAACCCAATAGTGAGGGTCAGGATTCC +CTTCGGAGTTGCTTACTCTTCGGACCCAGAAAAGGTAAGGGAAGTGCTAATAAGAGTGGCAAAGAGGATG +CCCCACGTACTGCCATCTCCTGAACCGGACGTCTGGTTCCACGAAATGGGAGACAGTGCACTTATATTTA +TCCTGCTCGTATGGGTGGACCTGAGGAGGTTAAGGCGACTGAAAGCTTTAAAGAGTTCCATTTATTATGA +GGCGTGGAAGGAACTAAAAAAAGAGGGAATAGAAATACCGTTCCCGCAAAGGGACGTGTGGTTCAGGAAC +AAACTGAAGGTAGAGATAGAGAAAGACATCAAGCCCGAGCAGTGAGCTCTTCTTCCTTTTCTACTTCTAC +GATAAGGTAAACCTTGTCCCCTTCCCTTACCTTATCTACCGTTTTCAAACCTATAACGCTTCCCTTTTGA +GCCACTTCGACAGGCTTTCCGTCTATTTGCATGCTTTCAACTTTCTGCCTAACTACTCCCGTTTTCTTGC +CTATTATGTGTATCGTGTCTCCGAGTCTCAGGTCTCCCGCTTCAAGTTTTACCTCTGCAACGCTTATCCT +CGGGTAGAACTTCTGAACCTTTCCGACGTAAACCTTTTTCTCCTTAGCCACGCTCTCGTTAACGCCGAAG +CTCGCCTTTCCGAAGTAAAAACCGCTGTCCCACTCCCTGTGGTAAACTCTGCTCACCATGTCTATGAGTT +CCTGTCTGAGTTTCTCGTTAAAGCTTCCTTCAAGGAGGGCGTCCCTTGCGGTTCTGTAAGCTTTAGTAAC +CATGTAAACGTAGTCCGGATTTTTGCTCCTTCCCTCTATCTTCCACGCGTCTAAAAACATAAGGTGCTCT +ATTATGTCAAGGGTCATCAAATCCCTTGCGGAAAGGACATAATCCTCTCCGAGAACGTACTCAGCACCTT +TTGCGTTAGGATTGAGGTCTCTTATTACTACCTGAAACTCGTGCCTGCACACTTGATAACACTCTCCCCT +GTTTCCGGACTTTTTGAATACTTCGTGACTTAGGAAACACCTTCCCGATATAGCCATACACATAGCACCG +TGGACAAAAGCCTCAATTTCAAGGTTTGTGTTTCGCTTTAGCCTTTTTAATTGCTCGAGGTTTAACTCCT +TTGCGGGGACAATCCTCTTTATCCCGAGGTTCTCAAAGAACTTCGCACTTACCGAGTTCGCTATGCCCGT +CATAACGGAAGCGTGAGTCTCTATTCCCATCTCAAGGGATTTGGTCATAACCGCAAAGTCCCAGGCTATT +ACTGCGTCTATACCGCTCTCTTTTACTCTGTGGAGAACTTCCTCAACGTAGGGTATGTCCTCGTCAAAGA +CTATGGAGTTCAGGGTGAGGTAAGCCCTCGCTCCGTGCTCCGCACAAAACTCCTTTATCTCCCCAAGCTC +ATCCATGGAAAAGTTTTTCTTCAGGGAACGCTGGTTTAATTTATCAAGACCGAAGTAAACCGCTTCCGCT +CCGGCTTTCAAGGCTGCGGATAAGCCTTCCCAGTTTCCCGCGGGTGCCAAAATCTCAGGTTTTCTCATGG +CACAAAATATTAAACTCTCTCAAAGCCCTTGACTATGATTAAATTTTAAGTAAAATTTAACTTATAAGTT +AAATGTGGATACGAAGAACTTTTACAGGTTGGATGATGGAAGCGGTAAGTACGAGCTATGGATATGGAAA +GGTTTCGATGAACAGTTTGAAAAAGTTACAAAGGGAGACACTAAAAGTCGGAAGAAAATTCTTACATGGA +TTGAAAGACTGTCACATGGAATTCCTACACAACCTGAAAAGGCAAAAGTGCTTAAGGGAAATGCGTGTAA +AGGGTTATCAGGTCCAGTAATGGAGCTCAAACCTAAACCTTACAGAGTTTCATTTATTTGTTTGTGTAAT +AAGTACATCTTAGTAGGCACTATATGGAGGAAAAGAGCTAATTCAAGGGATAGTTCGGAAATAGACAAAG +CTTGTAAATTGATGAAGGAACTTGTGGAGATGTTTTTAAAGGAGGCCGGTACATGCTGTTAAGGACGTTG +AAGAAAAACTTACAGGGTAACGCTGATTACATATACGAAAAATTGAAGTTTGATATTTCGGAAGAGCTTG +CAAAACTTATGAAACAGAAAGGTATTACGAAGAAAGAATTGGCACATAGAATGGGCGTATCACCTGCATA +CGTTACTAAAATATTTAGTGCGGAAAATATCTCACTTAAGGTTATAGCAAAGGTACTTTCCGCTTTGGAA +GCAGATAATTACACCCTAAAGTTAATTCCTGAAGATAAAAGCTTACTAATAGATGAACTGGATAAATGGT +ACTATAGCTTTAAAAAGACTTACAGATATATACAACCAGAGGAGATAGAAAATGAAATTAAAGAAATCCC +CACTGCAGCTTAAAACTGTGAAAATAGTTCTTTTCACATAGATTGGGATTTAGAAAACATAAACGTAAGG +GAAATTAACCCTCAAGAATACGTTGTTGATTTAGATTTTGATATATTTAGCGTTCAGGGGAAAAATACTT +CCAATAATCTTTTTCTTATAGAGCTCCTTATAAAGATAAATTATTCAAAAAGAAAAGAAAAGAAATTCCC +TTTCAAAGCTAAGTTGAAGCTTAAAGCGTTATTTGATTTTATAGAAGATGTAGATGAAAGCAAAAAAACG +CAGTATTTGTTATACAACGGCCTATCCATACTGTACAGTTTTGTGAGAGGGTATCTATTTGAAAAGCTCG +ATTTACTTGTTCCTGATCACAGGATAATTCCCACAGTAAACCTTTTAGATTTGATTCAGAAGAAGGCAAA +TGTAAAATCAAAATTATGAAAAAAATTCTTCTCTCTCACGGAGGAGGCGGTGAAGAAACGCAGAAACTTA +TAAAGAACCTCTTTTTAAAGTACTTTTCAAACGAAATTTTAAACAAACTTGAAGACGCCTCACTCCTTAA +TCTGAGCGGTAAGGTTGCCTTCACAACGGATGCCTTCACGGTTTCACCGATATTTTTCAGGGGAGGGGAT +ATCGGAAAACTGGCCGTTGCCGGGACTGTAAACGACCTTTCGGTTATGGGCGCAAGGCCTAAATATCTTT +CCGTTTCCTTCGTAATAGAGGAAGGTCTCTCCTTTGAAGAACTTGAAGAGGTAGTAAAGAGTATGGCACA +AGAAGCGTCAAAGACGGGCGTTCAGATAGTAGCGGGGGACACGAAGGTAGTTCCCAAAGGGCAGGCGGAC +AAGTTGTTCATTTCCGCGTCCGGAATAGGAGAAGTCGTTTACGAAGGGCTTTCCGCCCACAACTTGAGAG +AGGGAAACGTGATAATAGTTTCGGGAAGCGTGGGAGACCACGGAGCTTGTATCCTGGCACAGAGAGAAGG +TATGGAGTTTGAAGTTCCCGTGGAGAGCGATTGTAAGAGTTTGTGGAACATGATTGAAAAGGTTTTGAGT +AGCGGTGCTGAAGTTCACGCCATCAGGGACGCAACGAGAGGCGGACTTGCAGGTGTTCTGAACGAGTGGG +CAGAGCAATCAAAGGTAACCATAGAAGTTGAAGAGGAAAAGATTCCCGTAAAAGAAGCCGTGAGGGGACT +TTGTGAACTCCTCGGATTTGAACCGACTCACCTCGCAAACGAGGGAATGGCAGTATTTGCAGTGGCATCC +CAAGACGCCCAAAAGGTTTTAGAAATCCTTCGCTCCACTCCCGAAGGCAAGGAAGCCCAGATTATAGGAA +AGGTGGTTAAAAAGGGAGAGCCGAAGGTAATACTTAGCACTCCTTACGGAGTAAAGAGGGTTATGGAACC +GCCGGCGGGAGAACTCCTTCCGAGGATTTGCTAATGCACGAGTTTTCAATAGTTCAGAGTCTTCTCACAC +TGATAGAAGATTACGCAAGGGAGAACAACGCAAAAAGCGTTACGAAGGTCGTTGTAAGTATAGGCGTCCT +TTCTGGCGTAGAACCGCACCTTCTTGAGATGGCTTTCAACACCTTTAAAGAAGGAACGGTTGCTGAAAAG +GCGGAGCTTATTATGGAAATAGAGAAGTTGAAGATAAAGTGTATGGACTGCGGGAAAGAGAGCGAAAAGG +AAGAACTGAATATGCTCTGCCCCGGGTGCGGTTCCCTGAACACTCAGATAATAAGCGGGCAGGACATGTT +TTTAAAGAGTTTGGAATTAGAAGTTGATTGATGTTAATTTTACTGGACACAGGTATTCACGAAGTTGCAT +TCTTTACAAAATACGAAAATTACACGCTCTGCACCGTTGGGAGGAGGGAAAACTCAAAGGAAGAGGCACT +ACTCGGCTACAATTTGAGGTTCTTTACCTTCGGGAATTCCTCTTATTCTTACACGGTAGAGACCGTAAAA +AGAAAATGTCTTGCGGGAGTAGTTACTAAAGGGAATATAAACCTCGTGCTTTACACGGGAAATGGAATAC +AAAATGTTTACGAGTTTTCTTCAAACGGAGAACTTATGCTGTGGCAACTGCTAAAAACGGAAAAGGGTTA +CTTTTTGGTCGGCGGTGTGAAGCGAAACAACTGGGACGCCTTCGTAGCATTTCTTGACAGGAACTTTAAG +GTTAAGTGGAAGAAAAGGCTTGACTTTTTGGAGGAGTACTTTTACTCGGTTGCCGAGAAAGGGAACAAAG +TTTACGCGGTAGGGAGAATAAAGAGGGGGAAAAACTGGGATGCCCTCGTTTGCATCTTTTCGGATAACGG +AAAACTTCTGGAGAGTTATTCAATAGGTTCTGAGGGGAAGGACTACTTCAGGTTTGTAAAAAATTTAGGC +GGAGAAGTAATAGCCGTAGGAAGGAGCGAGGATAAGTTCGGAGACAGCGATTTTTTAATTTACGACTTTA +AAAATTACTACCTCTACGACTCGGGGGAGTACGATTACGCAAGGGCTGTAAACTCCTACGGAAACAGCTA +CGTGATTGCGGGTGAAACGAGGTTTAAGGGAAATAACGACGGGATTTTTATTCTTCTCAGCAAAAACTTC +AGACCTGTTAGGGCATTTAAAATCGGCTGGGAAAACACGGATGCGGTACGCTTTATGGACAACCTGTTTT +TCACAGGATACACTTACTCCCTTTCCTTTTCCGCGGACCTGATTTTGGGAGTGTTTTCAGAAGATTTTGA +AAAGGTTGATGTAAAAAAGGTAAATAGAGTTCTTAAAAAGGAAAAAGTTCACTTGAGAGACTTCCTTTCA +AGCTCCTGCGTTTAAGATGAGGCTTTCGCCTTTTCAAGCGTATCCTTTACTTCTTTCCTTACCTCTCCTC +CTCTCCAGGGGTCCTTTAGGGTTTCGAGCATGTACGAGCGGTCCACCTCGTCGTCAAACTCTTCAAAGTC +TATACTCTTTAAAAGCTCTTTTGCTTTATTGTTTAGCTTTTCCGGCACTTCCCTTCCCGAAAGCTCGCAC +CAGATTAGGGTCCATGCCCTTGCGAGGGCGTAAGGATGGTATCCGCCTCCTCCGAGGTATACTCCCTCCC +CGAAAACCTCACGAACGATGTTGAAAGCTTTTAAAAAGGCAACGTTTGAGAGGTTGAACTTGGAAAGGTA +ATCTTCAAGGAGTGGGTCAGTTCCGAGTTGAAGAAGGTAAACCTCGGGCTCAAATACTTCTTTGACTATT +TCCAGAGATTTTTCTAGGGCAAAGAGGAACTCGTTGTCGTTCAAGCCCTTTGGCAGGGGAATGTTCAGGT +TGTAGCCCTTTCCTTTTCCTTCTCCTATCTCCTCCAGGAAGCCCTTCTCAAAGGGAAAGGCGTACTCGGG +CGACTGGTGAAGGGACAGGACGAACACCTGGTCTGTATCGTAAAAGGCTTCCTGAACACCGTCGCAGTGG +TGGGCATCAAGGTCTATGTAGAGTATTCTCTTAAAGCCTTTTTTTCTCAAGTACTCAATTCCCACAGCGG +GGTCGTTTATGTAGCAAAAGCCGTTTGCCCTGCTTTTAAAAGCGTGGTGCATACCTCCCGCGGGATTGAA +AGCTACATTTCCCTTTAAAAATTCCTCTATCGCCTGCACTGTTGAACCCGTTGCGAGAGAAGAGCCTGTA +AACATCGCGTAAGATACGGGGTTTTCGTATCCGCCTATGTTGTACTTTTCCCTAGCTCCCTTCGGAACGC +ACTGACACCTTTCCGCTTCCATTAAAGTGTTTATGTAGTCTTCCGTGTGGAATAAAAGGAGTTCTTCTTT +AGTTGCGGGTCTGCTCTTGATTAATTCCTTCTCATCTATAAGGTTCATGGCATCTAAAAACCTAAGGAGT +AGGGAAACTCTTGGTATTTTAAGAGGATGGTTTTTGGGATATCTGTACTTTCCGTAGTCTAAAGTTCCGA +TAAGTTTAACCTTCTTCATTTGGCTGTCTTACGAGAAGCAGGGGAAGGTCCAGGTTGTGCATAACGTAGG +TCGTCACGCTTCCCAAGAAGAATTCCCTAACTGGTCCTTTTCCGTAAGCTCCCATAAAAAGGGCGTCCAT +CTCCTTTTCCCTGCAAAAGGAAACTATTACTTCCTCGGGAATTCCCTTAATCCCGTAAAAGTGGTGTTCT +TCTCCGAGAACTTCCTTTACCTCCTCTTCCCTTTTCTTTGCCTCTTCAAGGTTTTCAACTACGCTCAGGA +CGTAGATCTCGTATCCGTAAGGTTCTTTTAAAGCCCTGGAAATCTCCAGAGCCCTTTTTGAGTTTTCCTT +TCCGTCGTAAGCCACACAAACTTTCTTTATTTCTCTGTCCTCCTCAGGGAACATGAATACGGGACAGGGG +GCGTTTCTCGCCACGTTCTCCGCATTTGAACTCACGAGGACGCCTTTTATGAGCTTTTTCCCTTTCTTTC +CTATAAGTATGAGATCCTCTTTGTCCGCCTCTTTTACTATTTCCTGCCAAGGGATGCCCTGAACCTGGAC +TATGGACACCTTTACGCCTTCCTTTCTTCCTTCTTCCGCGAAGGTCTTTAAAATTAAATCTCCCTGCTCT +TCAAGGAATTCCTTTACTCTTGCGGATATTCCCGGGTAGAAGGTAAAGCCGAGGATAGAGGACAAATCAA +GGAGAAAGCTCTCGTCCATAAGTCTTTCGTCTATTACGTACATCCCTATTACGGGGATATCAAAGTGTTT +TCCTATCTTAAAGGCGTGCCTTGTGGCTATCAAAGAAGCCGGTGAGCCGTCAATTCCCACGATTATCCTG +TTAAACGTCAAGGTGCTTTACCTCCTTCGCGTAAGCTTCTATGAATTCTCTCCTTGGCTCTACCTGTTCT +CCCATGAGTATAGTAAATATCCTGTCCGCCTCAGCGGCATCCTCTATCTTTACTTTCTTGAGTCTCCTAG +TTTTTGGGTTCATGGTGGTTTCCCAGAGCTGCTCTGGATTCATCTCACCGAGACCCTTGTACCTCTGTAC +TTCCATTCCCGAACGTGCGAAGTCCATGAACTTGTCGTATATCTCTCCGAGGGAATTAATTTCCACCTTC +TTGTTTTCAAAGAACACCTGAACGGGAAGGTGGAGGTGTATCCCTTCCAGAACTTCCCTGTAAGAGAGTG +AGGAGAGGAAGTTCACGTCTATTATCGTTTTCGTTCCCAGTTTGTCGTCGTAGAAGATAATGTCGTAAGC +ACCTTCTAGTTCGTTGTACTTGGTATCCACCCTGTAATCGCCAAGTTCCTCTTCCATGAGGTGAGTTATT +TCCTTAACCCTTGCGGGATTTCTAAGGTCCTCTTCCCTTACCCTGTGTGTGAGTAAAAAGTTCACAAGGT +TTTCTCCCTTGGACTTTACAAGCGCCCTGTAAGCGTCCTCGTAGTCCTTCAGGTCTATAAGGAGTCTTAC +GAGCTCCTCACCCTTGAACTCTTTTTCCCTTGCGTCTACAAGTCTTCCCTTTTCCCTTATCTCGTTTAAG +AGAAAGTGTTCAAACTCCTTGTCGTCTTTTATGTAAATCTCCTTTTTGCCTTTTTTAACTCTGTAAAGAG +GCGGTTCGGCTATGTAAACGTAGCCCTCTTCCACGAGTTTGGGCATAAACCTGTAGAAGAAGGTGAGAAG +TAGCGTCCTTATGTGCGAGCCGTCCACATCCGCGTCCGTCATGAGTATTATCTTGTGATAGCGGAGTTTT +TTTAGGTCCAGGTCCTCACCTATACCGCAACCCAGAGCACTCACTATGGCCTTTATCTCGTCGTTTGAGA +GAACCTTGTCTATTCTTGCCTTCTCAACGTTTATGATTTTTCCCCTTAAAGGAAGTATAGCCTGATACCT +TCTGTCCCTCGCCTGCTTCGCGGAACCTCCTGCAGAGTCTCCCTCCACGAGGAATATCTCACACTTGGAA +GGGTCCGTTTCCGAACAGTCTGCGAGCTTTCCGGGGAGAACTCCCTCCTCAAGGGGGGACTTTCTTCTAA +CGAGTTCCTTAGCTTTTTTTGCCGCTTCCCTTGCTAGTGCCGCCTCTATCGCCTTTTCAACTATAGCCTT +CAGAACGTCCCTCTTCTTTTCAAAGTAAGAAGTTAAGAAATCGTACGTGATGCTTTCCACTATTTGCTTT +ACGTTCTGGTTTCCGAGTTTTGTCTTAGTCTGTCCTTCAAACTGTGGATTTGGGACCTTGCAAGCAACTA +CCGCGGTGAGCCCTTCCCTTACGTCTTCACCCGTAAAGCTTTTTTTCAGTTCTTTTGCGAGTTTAAGTCC +CTGAGCCATTCTTATTACAGCTTTGCTGAGCCCGCTCCTGAAGCCCGTTACGTGAGTTCCACCTTCCACT +GTCTTTATGTTGTTCACAAAGCTCTCTATCCTCTCCTTGTAGTCTTTCACGTACTGGAAGGCTATGTCAA +CGATAACTCCTTCCTTTTCTCCCTGTATCCTTATGATGTCTTTAAAAAGGGGCTCTTTTCCTTCGTTTAA +GTACTTGACGAGTTCCTCTATTCCTCGGTCAAACTTGTAAATTAGATGCTTTCCGAGCCTTTCGTCTGTG +AGTTCAAACTTAACCTCGGGGTTTAGGTAGGCGAGTTCCCTTACCCTCTTTTCCACTATGTCAAACTTAA +TCTCAGTAGTTTCAAAAATCTCGGGATCGGGCTTAAAGCTTACTTTTGTGCCCCTCTTTTTCGTCTCACC +TACCACGTGCAGGGGTTCTACTACCTCTCCCCTCTTGAAAGCCATTCTGTATATCTTTCCATCTCTGTAG +ACTTCCACTATGAGCCACTCGGATAAGGCGTTTACCACGGACGCTCCAACTCCGTGAAGACCGCCAGAGT +AGGTGTAGACTTTCTTTTCAAACTTTCCTCCCGCCCCGAGCATAGTAAAGACCATTTCAACTGCGGGTTT +TCCCGTTTCAGGGTGAATATCTACGGGAATTCCCCTTCCGTCGTCTTCAACGGTCACTGAATTATCCCTG +TGTATGGTAACGGATATATTCCTAGCATAGCCTGCAACCGCCTCATCTACGGCGTTGTCAAGTATTTCCC +AGATGAGGTGGTGAAGACCCCGCTCCCCTATATCGCCTATGTACATAGCGGGGCGGAGGCGAACGTGTTC +AAGTCCGGAGACCGCTTTTATAGCCTCGGCGGTGTACTCCTGAGGGGTTTGAGACTGCCTTTTCTTCATT +CTAATATTATATATTTAACTAGTCAGCCCCTCCTCCTTGAGCTTTTCTTTTTCCCCTTCTTTCAAGGGTT +CGCACCTGTTCACGTTTCCAAAACACTCGGGACAAAGGTCAAAAAACACCAAGACTCCGAGTCCCCCGAG +CATCATGTTAACCTGAGTCACCACGAGGTTTTCCTGCCTTTCGGGGAGTATCTGATACTCCTCTAAGGTT +TTACCGCAGAGGGTTTTGTTTTCAGCGTCCCCCAGCATGTGGAACTGAAAGACGAGCCTCTTTGTCCTCC +TGCACTTCATCCACTTGGGCTTTAGGTCAAGAATCACGAACTTTATCTCAACGTTCTGGTCCGCTATCCA +GCCTTTTTCCTTTGCCTTTTCTAAGAGTTTTTTCATCTTTTCAGGGTCCATCAACTGCATTCTCTTTCCT +CCTCCTTTTCAGAATATACCTCTCAAGAAGTTAATTCAATGAGACTCTTCACTTTTGTTAAAAAGTGATA +TTCATGCGTTTGTTCGTTATGGTGTTTTTCTTAATTTACGGCCTCATGCATTACTACCTCTACAGGAAAA +CGCTTTCCGCCTTCAATCTGTCCCCAATACGTAGGATGCTTTTTGCACTCTTTTTTATTTTCACAACTGA +GAACGCCAAGTTAAGGGTGAGGAGAGTGGGGAATTTATACTTTTAATTTTAAAGAACTTCTAATACATTT +TCAGCGATTGTCTCTCCTATAATCCAATAGTTTACCTCAAGTTCTTTCGCAGTCTCGTCAATTTTTTCCA +ACTTTTCCTTATTAATTGTAAAAAGTAGCCCTCCTGAAGTAACGGGATCTGATAAAAGTATTAATTTCCA +ATTGTCAAGATTGCTTTTTAAGTAATTTTTAACAAAATTCAAGTTTTCTATAGCACCTTTAGGATAAATT +TTCTTTTTAACCAAATTTTCCGAAAGTTGATAATACGGTACCTTTTCAAAGAAAATACGCGCACCTATAT +TAGAGTTCTTACATATATTCCAGGCATGTCCTAACAAACCAAATCCGGTAACGTCTGTACAAGCCGTTGC +ATCAAGGGAAAGCATTAAATTTCTAGCTTTATCGTTAAGAGCAAGCATGTTTTCTATAGCTTCATTTATA +TCCTCTTCTTTCAGTATACCTTCTTTTAATCCTTTTATAAGGATACCCGTTCCAATAGGTTTTGTCAGTA +TGAGTAATTGACCGACTTGTGCACCACTTTGTGTTATGTATTTCCCTTCTGGACATATTCCTGCAACAGA +AAGCCCAAATTTCGGTTCCTTATCGTCTATTGTATGTCCTCCCAAAAGAACTGTTTTTGCTTCCCTTAAC +TTGTCTAATGCTCCTCTAATTACTTCCCTAAAAATCTCTATATCGAGTTCGCAATTATTAAAACAAGATA +TTGCCAAGGCATTTACTGGAATACCTCCCATAGCATATACATCACTTAAAGCGTTTGCAGTACTTATTGC +ACCCCACAGATAAGGATCATTTACTACGGGGGTAATTATATCAACCGTATATACCCAGATTATCCCATTA +TGTTCGTAAACACCAGCATCATCACCTATGGAAACAAGCGTAGATTCATCTGTATAAATATTAAATCCCT +TCAAAATTTCCTGTAGGTCACCCGGACCTACTTTAGCTGCTCAACCTGAAGAACGAACTAACTTTAATAG +TTCAACCATACTACTTAAGTTTATAAAGAATGTTCCACTCTTTTGTTTTTAATTTTCTAAATGAGCAAAT +GGGGAAAATTTGAAATTTTATATACTTAATAGTTCTTGTAAAGTTTTTTTAATAGTTTTCAAGTCTTCAT +GGAATACCGTTCGCATATCAAAGAGCAGTTGGTCTTCCCTTATTCTACACACAATAGGTGGTTCCGCTAA +TCTTAGTCTTCTACTTAATTCCTGAGAAGACAAACGATCGTGTCTAATTGCCACACAGTAAGTAGGAAGT +TCTAATTCAGGCAGGGATCCACCTCCTGGTTTTGCTTTATCCTTAATAACCGATATTTTAAGCCCAGGTA +TATCTTTTAAAAGTTTTTCTAATCTCTTTGCCTTCTGTCTCAACGCTTTTTCATCCTGTGTAAGCATGCG +TATAACAGGTATATCCTCGTATCGCTTCTCAAAGTATAGTTTAAGCGTCATCTCCAGACCTGATAAAGTT +AACTTATCTATCCTTAAAGCCCTTGCAATGGGATTTTTCTTTATTTTTTCTATTAGGTTCTTCTTTCCTA +CAATAATTCCCGCTTGAGGTCCACCTAATAACTTATCTCCACTGCCAGAAACTAAATCTATTCCTAAGGA +TATACAATCTCTGAAATTAGGTTCATCAACTGATATTCCAAATTCTTTAAGATTTATCAGTAAACCACTA +CCAGCATCATAGTACGTAGGAATACCGTACTTATGTCCTAATTTTACAAGGTCTTCCAATTTTACTTCTT +CTACAAAACCTTCCATGTAGAAATTACTTTTGTGTACTTTCATAAGTAAAGCTGTGTTTTGGTTTATAGC +ACCTTCGTAGTCGCTCACCTTTGTCTTATTTGTTGTTCCCACTTCTCTTAAAATAGCTCCTGATTTTTTC +ATTATGTCTGGAATTCTAAAACTACCACCTATTTCTACAAGTTCTCCTCTAGATATGATTACTTCTTTGC +CTTCTGCTAAAGTATTTAAAACAAGAAATACAGCTCCAGCATTGTTATTGACAACAAAAGAAGATTCTGC +TCCCGTAAGTTCATTTAAATACTTTTCTATATGTGCTATTCTTGAACCTCTTTTTCCTTCCTCAAGGTTG +TACTCCAGATTTGAATAACCATTAGCTATTTCGGATATGAAATTAATTACATCCTTACTAAGAGGTGCTC +TACCCAAATTTGTATTTATCACCACTCCCGTAGCATTTATTACTCTTTTTATATTAGGCTTCATTAAACT +TTTTATTTTTCTCTCTACATCTTCTAAAAAACCATTTAAATCCTTTCTTTTACCCTCTATTATTTCTTTT +CTATATTTTTCCGCAACTTCTCTTGCTGCCTTAACCACATATATTTCTGGATATTTTTTTTTAAATATTT +CAACTACTTTTGATATTTGTGGTATCTGTCTGAGTAGACTTTTCATAGATATTAAATTTAATTAATAAGA +GCAATGAAGTATATTTTATTTGCAACGGCAGGTCATGTTGATCATGGAAAAACGACTTTGATAAAAACCC +TCACAGGCATTGATACAGATAGGCTTCCTGAAGAAAAGAAGAGAGGGCTTAGTATCGATATAGGGTTTGC +TTATATAGATTTCCCCGATATAAATACAAGGTTAGAGATCATTGACGTTCCTGGACATGAAAGGTTTATA +AAAAATGCTATAGCGGGTATTTGTTCAGCATCTGGATTGATTCTCGTAGTAGATCCAAATGAAGGGATAA +TGCCACAAACAATAGAACACCTAAGAGTAGCAAAAAGTTTTGGTATAAAACATGGTATAGCTGTATTGAC +TAAGATGGATAAAGTAGATGAAGAACTTGCACATATAGCAGAAGAAGAGTTAATAGCATTTCTGGAAAAG +GAAGAAATGAATATGGAAATCGTCAAAGTCTCTGCAGTAACAGGGCAAGGCATTGAAGATTTAAAAAATT +CTATAAAAAAGCTATTGGAAAGTATTAATAATCTGAATAAACATAAGCCGCTACGTATATTTGTAGATTC +TGCGTTTGTTGTAAAAGGATACGGGACAGTTTTAAGAGGAAGCTGTTTTGAAGGAGAGGTTAAGGAAGGT +GATAAGGTAGTAGTAGAACCTATAGGGGTTATTTCAAGAGTTAGAAAAATGCAGAACCACGGAGTGTTCG +TAAAGAAAGCTGTTGCAGGAGAAAGAATTGCTTTAAATTTACCCGAAGTGGATGCAAAAAAAGTAAAAAG +AGGCTTTTTAATTTTAAAGCCTGAAAGTTATGAGAAGAGTAATGTTCTTATTGTAAAAACCGAAATAGAT +CTTAAACCAGGGAAAATATATCAAGTATTTTTCGGTATGAGAGAAACGGTTGGAAAAATAAGTGTTATTG +ATAAGGGTATTTATCTGGTCAGACTTAAGGAAAATGCAATTGTACGCAGGGGAGACAAATTAGTCGTACT +TGATTCTTCCGGAAACTTTTTAGGAGGTGCAGAAGTATTACATCCAAAAGTGAGAGTAACTAAAAAAGCT +TTTATAAAAAAGAATATAAAAGATTTATTAGAAAACTTTGAATGTTATTTGCTGAAGGAAAGGGGACCCA +TAGGTCTAAAACTTGAGTTCTTTAAGAGAATTACAGGAGTAAGCCCAAAAGTAGCAAATTTGAAACCTGA +AAGTATTGAAATAAGAGGGGTTTATTACTTGAAAGGATTTATTGAAAACTTAAAATTAAAGATAAAAAAA +TTTTTGGATACAGAACTTCAAAACGCTTTTGGTGTTGATAAAGAAAAAGTTAAAAGTATGTTTTCCTTAA +ATGAAGAATTACTCAAGTATATACTTGATGAACTAAAAACCTATAAAATTGTCAACGAATTAATAATTGA +CGAAAGAAAAAGTGATCTTGAGAAGAATGAAGACTTTCAAAAGTTAATGTCTATTCTTAAAGGAGGAATA +AAAGAGGAAAGGGAAATTATATTGGAAGGAATACCAAAGGAAATTCTCACTCTTTCTATAAAAAGAAAAT +ACGCTCATAGAATAGGTGAATATCTCATAATATCCGATGAACTCTTAAAAAAGTATATTAATGAGCTGAA +AGAACTTGGAAAGACGTTCAATGTTCAACAAGCTAAAAATAAACTTGGATTAACGAGGAAGTACCTTATC +CCGCTTCTTGAGTATCTCGACTACTTAGGACTTACGGTAAGGGAAGGGAACGAGAGGAGGTGGAAGCGCT +AAGCCCTCACCAGTTTTATCCTGTAAACGAAGCTCTTTGGCTCGAGCCAGTTCAGGGGTTCACCTTTCAC +CTCCGCGTAAGGGTATCCAAACAGGTTCAGGGGTTTTACCCTCTGAGGGGGTTCTAAGACGAAGTCCCTT +CCCCAGTTGTAGGCTATCCAGTGGGGATCCCAGTTTCCGAAGAAGTAGCGACGGGCGAAGTTCACCCTCG +GATGATTGCGTGGAAGTTTTTCTTTGAGTATAAGTTTTGTTACGTCCGCGGGATCTACCGGTATCCACTC +CCCCGCCCAGAACTCTGCCCTGCAGTGCTGTGCCTTAGTTATGTCTTTACTTCCAGGCTTTATGGAGAGC +CCCTCAGAAAAGCTCGAGGGTAGCACCCTTATACCGAAGACTTCCCTTGCCGGAATGCCCACCGATCTGC +ACAGTGCGACAAACAGGGAACTCTGATCAGCAGACTTCCCTCCTATCTTCTCTCCCTTCTCAAGGAGTTC +GAGCATGAGGTTAACGTCTCCTGGTCCACATCCATTTACCTTCTCGTCCCTGTAAGTATTATCCACAACA +ACCAGTTGTATATAGCCCAAGCCTTCTGAATGGGTGTTTTCTTTCCTTCGGTTATCCTCATCGCTATCTC +TTTAACCTTTCCCTCGGTAGGGAGGTGTTTCGTGGATTGCAGGTAGAGAGCAAGTTCCTTAGGAGTTTTA +AAATCTTAATCTACGAGACTCACCCTTCTGGGAGAAAACTCTACCGAAACTTCGAGCTTAAGAACTTTTT +TGCTCTCCCCTCGAGGAAACTCGGCGTAGAGGGTAGGAGATCCATAGACCTTGTCCCTATAAATCCCTGC +ACGCCTATAAGTTCCCTCAAACCTTAGATCTAGAACCCTCTGGTAATCAGTGTTTATAGGAACGGGAAGC +CAGGGGCAAGCTTCTCCCTTGTAAGGTAAATCTACATCGTAGCTAAAAGTAACTTTCCTTGAAGAGAAAG +AGAAACTCGATAGCGTAAAGGATAAACCTAAGGCGGATGCTCCTTTTAGAAAATCTCTTCTATCCATAGT +TAACAATCTCTTAATCCTAAAAAAATTCAAACGAAAGTTTAAAATTCTCCAAATTTTTTCTTCGAAACTC +TAAATATAAATATCTTTTAATAATTTTTATTTTATAAATGTAAAATATGGGAGGTTCTTAACGAAACAGA +TGATGGATAGAGAATAGAGCAAGAGCATAGCGAAGATAAAGGAAAGAGCGAAAAAAAGCTTTAGTTTTTC +GTTTAAAGGCTACTAACTTATCCCTTAACTTAGAATGCAGAGCTTCATTTCTATTGACTCTCCCATACTT +CCTCACTATGTGTCTGTCCCTCGGTAACCATTCATATACTCTATACGCATCCGTCTCATACTCCTCCGCT +TCAGGCATTTTCGCCAAAATCTTTAAAAAAGTCCTTAAACTCCTATCTCCCGCAAATAGAAATTTTTTTA +TGGTTCCATCTTTCAGTTCCACTACTACAGACCATATCCACACTTCATTCCCTTTTGTTCCTACATAACT +CCACATCTCATCAGTAGGTTTGTTTTCCATGTTGTCTTCTGTTTTTACCACCTTTTCGCTCCCGTACTCA +GGACACCTCATAGCTTATATTCTCTTATCATCTCTTTTGTGAACTACCATATGGAAAAGAGATGGTACGA +AATTTATTTTTTCATTTTATGAAGGATATTGATTTGAAATTGATTGAAATATTCTGTTATGTTTATGAAT +ATAAAAGTGTTACAAAAGCCTCAAGTGAACTTAATATGTCTCAATCTACTATTTCATTTCATATGAAAAA +TTTAGAAACTCAATTAGGCCAAAAGTTATTTTATCGTAAGGGAAAAACGCTGATTCCAACTGCGTTTGCG +GATAAGTTATACGAGTATGCCACAGAGCTAACAAATTTCAAGAGACGTATGCTTGAAGATATAACAAAGT +TTTCTGGAAAAAACGGGGGTGTAATCAGAATAGGTGCCAGTAGTATTCCAGGAAACTACCTTCTTCCACA +ATTACTTGGGGAATTTATTGAAAATTTTAAAGGTTATGTAAACGTGGAGCTTAGAGTAAGTGATAGCCAG +GATATATATGAAAAAGTAATAAATGGAGACGTAGATTTAGGAATTATAGGTTATCTGCCGAGAACAAATA +AAGTGGATGCTATTAAATTTTATACCGATAGAATACTAATTGTAGGCAATCCAGAACTTGAAGATAAGGT +ATATACCTTAGAAGAGCTGATAAACTTACCTTTAGTTATAAGAGAAGTTGGTTCAGGAACGAGAAGTATT +GTTGAAGACAAATTAAGAGAAAAAGGTTTATCCTTAAAAGAAATGAATATAGTAGCTGTATGTAACAGTA +ATGAAGCCGTTAAAAATACGCTTAAATACGTTAAGGGATTTTCCTTCCTTTCTAGCTATGTTGTAAAAGA +TGATAAGTTTTTGATTAAATTAAAAGTAAAAAATTTTGACGATATAACCAGACAGTTTTACTTAATTCGA +GACAAAAAACGTCCCTTACCATTTCTTACACAGGAGCTTATTAAGTTCTTAATAAAAGACATTTATGTTT +AATTTTTCGAACATTTTCATTGAATAATTAAATAAATAAGTTATGTGATATTTGAATATAAGGAATTTAT +TAACATGCAATATGCATTGATACACAATAAAAAAATGTTCATATGCCTATTTTTAAAATATTGTTTTGAA +AATTTTGTCTTTTTTTTAAATTTTTTCATGATTTGAAAGGGGAATAAACTAAAAACTAAGAATGCTTAAA +GGAGGTGAATTACATGGATATTTCAAGGAGGGGTTTTTTAAAACTATCAGTAGGTAGTGTTGGAGCTGGG +ATATTAGGTGGTCTCGGTTTTGATCTTACACCTGCTTATGCACGTGTAAGAGATTTAAAAATAACAAAGG +CAAAAGTAACAAAAAGTATATGTCCTTACTGCTCCGTATCCTGTGGAATACTAGCCTACTCCCTTTCCGA +CGGAGCGATGAATGTTAAAGAAAGAATAATACACGTAGAGGGTAACCCGGATGACCCGATAAATAGAGGA +ACTTTATGTCCTAAAGGGGCAACCTTAAGAGATTTCGTAAACGCTCCTGATAGGCTTACCAAGCCCTTGT +ACAGACCTGCAGGATCTACAGAATGGAAAGAAATAAGCTGGGACGAGGCTATAGAGAAGTTCGCAAGATG +GGTAAAGGATACGAGGGATAGGACCTTTATACACAAGGACAAGGCTGGAAGGGTGGTGAACAGATGTGAC +TCCATAGTTTGGGCTGTGGGCTCACCCCTTGGGAACGAAGAGGGGTGGCTCATGGTAAAGATCGGTATAG +CCTTAGGTCTCTCGGCACGAGAAACGCAGGCGACTATATGACACGCACCTACGGTGGCCAGTTTGGCCCC +AACCTTTGGAAGAGGAGCAATGACTAACAACTGGGTGGACATCTCCAACTCTGACCTCGTATTCGTAATG +GGAGGAAACCCGGCGGAGAACCACCCCTGTGGTTTTAAGTGGGCCATAAAAGCTCGTGAGAAGAGGGGTG +CAAAGATAATATGCATAGACCCAAGGTTTAACAGAACCGCCGCTGTGGCAGATATCTTCGTTCAGATAAG +ACCGGGAACAGATATAGCTTTCCTCGGAGGTCTGATTAACTATGTCCTTCAGAACGAGAAGTATCAGAAG +GAGTATGTGAGACTGCACACAACAGGACCCTTCATAGTGAGGGAGGACTTCGGCTTCAAGGACGGACTCT +TTACGGGATACGATCCTAAGACGAGGAGCTACGACACGACCACCTGGGACTACGAGTTCGATCCTGCTAC +GGGATATCCCAAGATGGATCCCGAGATGAAGCATCCCAGATGTGTTCTCAACATCCTGAAGGAGCACTAC +TCGAGGTATACCCCGGAGGTCGTCTCCCAGATATGTGGATGTTCCAAGGAGGACTTCCTCAGAGTTGCAG +AGGAGGTGGCTAAGTGTGGAGCTCCCAATAAGTTCATGACAATCCTCTATGCCTTGGGATGGACCCATCA +CTCCTACGGAACCCAGCTCATAAGAACTGCCTGTATGCTTCAGCTTCTGCTTGGAAACATAGGTTGTCCG +GGAGGAGGAATAAATGCCCTCAGAGGTCACTCTAACGTTCAGGGTATGACTGATCTCGCCGGGCAGAACA +AGAACCTCCCCACCTACATAAAGCCTCCCAAGCCGGAGGAACAAACCCTCGCCCAGCACCTTAAGAACAG +GACACCGAGAAAGCTCCATCCCACCAGCCTGAACTACTGGGCAAACTATCCTAAGTTCTTTATCAGCTTT +CTCAAGTGTATGTGGGGCGACGCCGCAACGCCTGAAAATGACTTCGCCTACGACTATCTATACAAACCCG +AAGGAGGCTACAACTCCTGGGATAAGTTCATAGACGACATGTACAAAGGAAAGATAGAGGGAGTGGTAAC +CGCAGCCCTTAACTTCTTGAATAACACACCTAACGCCAAGAAGACGGTAAGGGCTCTCAAAAACCTCAAG +TGGATGGTTGTAATGGATCCTTTCATGATAGAGACAGCCCAGTTCTGGAAGGCGGAGGGGTTAGACCCGA +AAGAAGTCAAGACGGAGATTCTCGTCCTTCCAACGGCTGTATTTCTCGAGAAGGAAGGTTCCTTCACCAA +CAGCGCGAGGTGGGTAAAGTGGAAATACAAGGCTACCGATCCCCCAGGAGATGCGAAAGACGAATTCTGG +ATATTTGGAAGATTCTTTATGAAATTGAAAGAATTTTATGAAAAAGAAGGAGGAGCTTTCCCCGAACCGA +TTCTCAACCTCGTCTGGCCCTACAAGAATCCATACTATCCGACTGCAGAAGAAATACTTACCGAAATAAA +CGGATACTACACAAGGGACGTGGACGGTCACAAGAAGGGAGAGAGGGTAAGACTCTTCACTGATCTGAGA +GACGACGGATCAACTGCCTGCGGGGGATGGCTCTACTGTGGCGTATTCCCGCCTGAGGGCAACCTTGCAA +AGAGAACTGACCTCAGCGATCCCCTCGGTCTGGGAACCTATCCGAACTACGCCTGGAACTGGCCCGCCAA +CAGGAGGGTCCTCTACAACAGAGCCTCCTGCGATGAAAAGGGAAGACCGTGGGACCCAGAAAGACCCCTC +CTGAGATGGGATCCTGAAAGAGACATGTGGGTAGGTGATATACCTGATTATCCTGCTACCGCACCTCCCG +AAAAGGGTATAGGTGCTTTCATAATGCTCCCAGAAGGAAAAGGAAGATTGTTTGCAGCAAAAAGCTATGT +TACATTCAAAGATGGGCCACTTCCCGAACACTATGAACCTTATGAATCTCCCGTGACGAATATTCTCCAT +CCTAATGTTCCTCACAACCCCGTTGCAAAAGTATACAAATCTGATCTGGATCTGTTAGGAACTCCCGATA +AATTCCCTCATGTTGCTACCACTTATAGGCTAACTGAACATTATCACTTCTGGACAAAGCATCTGTACGG +TCCTTCACTGCTTGCACCAGTAATGTTCATTGAAATACCTGAAGAACTGGCAAAGGAGAAAGGTATCCAA +AACGGAGACTTAGTTAGAGTTTCTACTGCAAGAGCATCAATAGAAGCTATAGCTTTAGTAACAAAAAGAA +TAAAACCTCTAAAAGTTGCAGGAAAGACCGTATACACAATAGGTATACCAATACACTGGGGATTTGAAGG +TCTAGTGAAAGGTGCCATAACAAATTTCATAACGCCCAACGTCTGGGATCCCAACTCTAGAACTCCTGAG +TTTAAGGGCTTTCTTGCAAACATTGAAAAGGTGAAAACTTAAGGGAGGTGTAAAAAATGAGCACATTAAC +TACTGGTGGAACTGTAGGGCTTGGGATTAAGAGACTTTCCGCTTCTAAAGAACCAGACACTTCCGTAAAA +ACTTATCCCGAACTTGCGATTCTCGTAGATGTCTCTTCTTGTATAGGTTGTAAAGCCTGTGAAGCGGCAT +GTCAGCAATGGCACGATACAACTCCTCCCATACTTTCTCCAGAAGAAGTAATAAAGAGGAAAATAGCTGG +TTACCAAACTCATCCCGATCTGCTGCCGGAAACATTTATGCTAATGAAGTTTAAGGAAGGAGAAACAAGC +CGTGGATTTACTTGGTTTATAACCAAATACCAATGTATGCACTGCAGGGAACCGGGATGTCTGATCGCCT +GCCCCTCCCCCGGGGCGGTAATCCAGTACCAGAACGGCGTGGTGGACTTCGACCACTCCAAGTGCATAGG +TTGTAAAATGTGCTTGGTGGGCTGTCCCTTTGATATTCCGAGGTACGATAAGAATAACAAACCTTGGAAA +TGCAACTTCTGTATCGACAGGGTAAGTGCAGGTTTAGAACCAGCCTGCGTGAAGACCTGCCCAACCAACT +GCCTCTCCTTCGGCTTTAAGGAGGATATGATAGAGAGGGGTAAGAAGATAGTGGAGAGATTAAAGGAGAG +GGGGTACCCGAACGCAACCCTCTACGATCCTCCGGGTGTCGGTGGAACGGGATACATTTACGTTCTTCCC +CACGGTGATCATGTGAAGGACTATCAGCTTCCCGAAAACCCGAGGGTGGATGCATCGATAGGTCTGTGGA +AGGGTCCTCTGAAGACGATAGGAAGCATAGCCTTTTGGGGCACACTTCTGGGTGTGTTCCTTCAGTTGAT +ACTCTGGGGACCGATAAAGGTCCTCGGCGGAAAGGAAGAAAAAAGTGAGGAGGGTTAATCATGGCGGTAG +AGTACAAAAAGGCTTACGAAGAGCAGATAGAGAGGTTCTCAGCCCTCGACAGGATTCTCCACTGGACGAC +AGCCCTCGCCTTCCTTTACTGTTTCCTGTCGGGGATAGGGATAGCCTACGCCAAGTTCCACTGGCTGCTG +ACCTTTCTCGGTGGTGGTGAATTCGCCCGCTGGCTCCATCCGTGGGCCGGCGTCGTCTTTTCAATAGGCG +CGGTCCTTATGATCCTCAAATGGGCAAGGGACATGGTGATCACTAGAGAGGACATAGTATGGCTGACGAA +GATAAAAGCCTACATAAGCGGAAGGCACGAGGAACTTCCCGAGGTCGGAAAATATAATGCAGGGCAGAAG +CTATACGCCTGGGTGGTCTTCCTTAGCGCTATAGTCTTTTTCCTTACGGGTATACTTATGTGGTTTCCGG +AAAACTTCAGTATGGGACTAGTGCGCTGGTCTGTGGTTATACACGAGATAACTTTCATAATAGCCGGAGC +CTTCACTATAATACACATCTACATGGCAACCGTCGGAGTTCCGGGCTCCATATGGGGCATGATAGGAGGA +AAGGTATCAGCCACGTGGGCTAAGTTCCATCACCCCAAGTGGTACAGGGAGGTGGTAAAGAGGTAAGTGT +CATGAGAAAGCTTAGGTGTTTGAGCAGTGGGATGCGCTCTGCGCCGTCCTTTTTTCTTTCTCAATAGCAC +AGGAGCTCAAAACACATGCAGACATAGTGAACCAGAAGGGCGAGAAGATAGGCAAAGCTGAGCTCATACA +GACCAACAGTGGAGTTCTCATAAAGCTTGAAGCCTCAAATCTACCACCCAACGCGGAGCTTGCCTTTCAC +ATCCATGAGCTTGGCAAGTGCGACCCTCCCGACTTTAAGTCCGCAAAGGGACACTTCAACCCCTTTAAGA +AAAAGCACGGCCTTTTAAACCCCGAAGGTCCCCACGCTGGAGACATGCCCAATATTCACACCGATGATAA +GGGAAACGTAAGGGTTCAGGTATTAAATCCCTTTGTAACCTTGAAAAAAGGAAAGAAAAATAGCTTATTT +AAAGAAGGCGGAACGGCACTCGTCATTCATGGCGGACCTGACGACTACAAGTCTGATCCCGCGGGAAACG +CAGGAAAAAGGATAGCATGTGGGGTGGTGAAATGAATATATTCAAGCAAAAAGAAAGAGAATTTGCTTTA +AATAGGATTCCTGTTTTGAAGGAAAAATTTCCAGAATCTAACCAAATACTGAACTTTTTATCTCATATTC +TTGAATACCACAATTCTATTATTTCGGAGATTTCAGATTTAAGTATATCTCTTGATAACCAAAATATAGA +AAGTAGATTAGGAAAAGGTAAACCCGCTTTAAAGCTTTCAGAATATGATTTCGAACCTTTCCTCAAGTAC +TTTTATCCTTTATTGAATATTGTCTATGAACATGGTACCCCACAAATGAAAGAAAGAGTAGAGCATTTAC +AAAGTCTTGAAAAAAAAGAAATATTATCTTTAATATCTTCTTTTTTAGAAAATGGAATTTCGGACGATAT +GCTGAGATTCTTCCTTATATCTTATCTCCAACCTATACTCTATACATTTGCAGATAAGGTTAAATTCGAA +CACGAAAGATGGTTTAAAAATTACTGTCCAGTTTGTGGGTCTAAACCGTCAGTTTCATTCATTATGGATA +CGGAAGATTGGGAAGGAGCACGTTTTCTGAGATGTAGTGTTTGTCTTACTGACTGGCTCTATGTAAGAAC +AAAATGTGTAAATTGCGGCAATGTAGAAGACGATAGTTTAGATTATTTTATAAGTTCAGAATTAGATTAT +ATAGAAATTCAAACATGTAAAAAGTGTAATAGTTATATAAAAATCATAGATCTTAGAAAAGATGGACTTG +CAGTGCCTGATTTAGAAGATATAGCTTCTGTTAGTCTTGATTTATGGGCTCAGGAACAAGGTTTTATAAA +AGTTGAAAGGAATTTTATGGGGTACTAGCTGTGAAAAGGAGAACGTTTTTAGAATCTCTTCTATTTCTTT +TTTTAATAAAAACGGGTTTTAGTATGGAACGAAAGATAGACGTTTTAGGATGTACCTTGTGGACTGATAG +ACTTTACAGAGTCGAACCCTATAGAATGTTATTCCAATGGGTAAAGGATGAAGGAAATGGTATTTATTCT +GTAGGAATGGCTTCTATTTTAGCTGCTCTAGCGTATCCACTTTACTCGATAAAAATAAAACCTGTTGGCA +CTAAGCTGGAGTACGACGAAGCATTAGCAATAATTGAGGCGGGGAAAAGAGTTGCAACATTCCCGACACC +TCTATCTGGCATAGTGGTAGATGTAAATGAAGAAGTGATTAAAAATCCTGAGCTTATAAATAAAAAACCT +TACAGTTCTTGGATTGCTAAGCTAAAAGCTACAAACTTAGAAGAAGTAAAGAACTTACAAAGTGCAAAGG +AGATAGTTAAGACGGTGAAAGATTTTATAATTTTGGAGGATGTAGATTGTTCTATTGTAGAAGAATAGAA +GGGAGAGGTTGGCCGGCTGGTGCCGCCCCGGGACTTCAAATCCCGTGGGAGGTCCCGCAAGGGAGCTCCG +GAGGGTTCGATTCCCTCCCTCTCCCGCCAATAAGTTGTTATGATTTACTTTGATAACGCGGCAACTACAC +CTGTACTTCCAGAAGTAAAAAACTTCCTATGTAAAGCACTAGACATTTATGGGAATCCATCAAGTGTACA +TACACTAGGCAAATTTGCAAGAAGTGAAATAGAAACGGCAAGAAAAACAATTGCGAATTATTTGAAAGTA +AAACCGGAAAATATTATTTTTAACTCTTGTGCAACTGAAGGAAATAATACGATAATAAGAACGATATTAA +ACAATAAAGATAGGGGCAATGTAGTATTATCAGCAATAGAACATAAATCTGTGAAAGAGGCAATAAAATT +TTGGGCAAATAAAAGTATAGAAATAAGAGAGATTAAAGTAAATAAAAATGGAGTAATTGATTTAGAACAC +CTTTACCATTTGATTGATAGTAATACAATTTTAGTTTGCGTTATGTATGTAAGCAACGAATTCGGAACAA +TTCAGCCTATACAGGAAATAGCTAAAATTTGCTCCGATAAGGGTGTACCATTGCTAACAGATGCAGTGCA +AGCAATAGGAAAAATCCCAATTGAACTAAAAAATATATCCTATGCGACATTTTCTGGACATAAATTTCAC +GCTATAAAAGGAAGTGGATTTTTATACATTTCTGACGAAGCTAATTATGAGCCTCTTATAGTTGGTGGAG +GACAAGAAAATGGAAAAAGATCAGGTACAGAAAATGTTGTAGGAATACTTTCGTTAGCTAAAGCACTTGA +AATAATTGTTTCTAACTTTTCGCGCTATCAGGAACAGCTTAAAAAATTAAGAGATCTTTTTGAGAATCTA +TTGCTTGAAGCTTTGCCAGATGCTCAAATTGTAGGAAAAGATGCAGAAAGAAGTCCCTCAATATCTTCTG +TTATTATGCCTAAATTTTTCGGAGCAGAAATAGTTAATAAATTATCAGAAAAGGGAATATATTGCTCGAC +TGGATCAGCCTGTTTATCAGGAGAATATGAGCCGAATAAACATATGTTGAAAATGGGGTTTTCTCAAGAA +AAAGCTTTAAGAATGGTACGCTTTTCATTTGGTCTTTTAAACAAAGAGGAAGAAGTAATAGAATGTATAG +AAAGAATAAAAGAAATTTATAGATTAAATTAAAACGTCCATCAACACAATTCTATAAAGGTGTAGAAAAA +ACAGTTTAGATATTAACTTATCACAGCCTAAAGAAAGGTAAGAAAGGCTGAAGAAGCAGTTAGAAGAACT +ATTTAAAAAGTTAGAGAAACGAATGAGGTAGACTCGTCAATAAAAGCAAAGTCAGTAATACTGTATTTTA +ACGGAATATCTTTCAGAAAAGCAGTTCAAATAATAGAACAGGAAACTGGTCTACGTGGATGAAACGAAGA +TAAAAGCAAGGGGCAAGCAGTATCGGTGGAAATCTTGCAGGGAGCTAAAATGCGGATGAATACATGAAAC +TTTTGAAGTAGAAATGTGGTAAAGAGGTGGTTCAAGCATATTAAGCAGAGGATAAAGGGCTTTTACAAAC +TCTTTCTCCTTTATTACTTTGTTTATTGCGGTTCTGCTCGGTGCCTACAGTCATTTAGAAACATACTTCT +TACGGGTTGAAAAGTACACCATAGAAACCGAAAAGCTCCCGAAAGGTACGGAGATAAAGATAATGAACGC +CTCGGATATGCACTTAGGTCCCGTAATGAGGGAAGACAGGGTGGAAATGGTGAAAAGGGTCTACGAGAGG +GAAAAACCCGATATTCTGGTTGCCACAGGGGACACCGTAGACGGGAATATGAAGAATTTAGACTACCTCG +CCCAAATGCTCGCGGAGCTAAATCCTCCTCTCGGAAAATTTGCGGTCTTAGGAAACCACGAGTATTACGT +TGGTCTGAATCAGTCGTTGGACTTCTTGAGGAAAGCGGGATTCAGGGTTTTAAGAGGTGAAGCGGTTGAA +ATTAACAATTTCCTCGTTATAGCTGGAGTGGACGACTCGGACGGAAAAAGACTTGGCTACAGAGTTTTTA +CAGACGAACTGGAAGTTTTAAAAAATGTGGACACTAAGAAGTACGTTATCCTTTTAAAGCACAAGCCAAG +GATAAAGAGGGAAGCGATAAAATACGTTGACCTCGTCCTTTCGGGACACACTCACGGCGGAGTTCTCTTT +TTCGTAGGCTACACGATTTTAAGACTTATATTTGAAACGGACAGGGGAATTAAGGAACTCGCTCCCGGGA +AGTACATAATTGTGAGCAAAGGTGTGGGAACGGGAGGACCACCTATGAGGCTTCTATCCCCGCCGGACGT +GGTTATAGTGACGATAAAGGGAAAGGGAAATTAACCGAACCTTCCGGTGATGTAGTCTTCCGTTAACTTC +TTCTCAGGTTTTGTGAATATCTTTTCCGTTGGGCCGAACTCTATCAGCTCTCCCATGTACATAAAGGCGG +TAAAGTCAGATACTCTAGCAGCCTGTTGCATGTTGTGGGTAACTATAATTATCGTTACCTTCTTTTTGAG +TTCTACTATAAGATCCTCAATCTTTGCCGTGGAAATTGGGTCAAGGGCTGAAGTTGGCTCGTCCATGAGG +AGGACTTCTGGCTCAACGGCTATTGCTCTTGCTATACAGAGCCTCTGTTGCTGACCTCCCGAGAGTGAGT +AAGCGTTCTCGTGGAGTCTATCCTTCACTTCGTCCCAGAGAGCCGCATCTCTTAGAGCCTTTTCAACCTT +TTCGTCGAGTATTGACTTTTTCTTTATCCCCCTGAGTTTGAGCCCGTAGGCCACGTTCTCGTATATGGAC +TTCGGGAAAGGGTTTGGCTTTTGGAACACCATACCTATACGCATCCTAACGAGTAGAGGATCTACGTTCT +TTCCTATGAGGTTTATCTCGTCGGGATATAAAATAGCTTCCCCTTCGTACCTCGCTCCTTCGTAAAGGTC +GTGCATACGGTTAAAACACCTCAGAAGCGTAGTCTTTCCGCAACCCGAAGGTCCGATTATCGCGGTTATC +TTGTTTTCGTAAACGGGGAAGGTGATGTCTTTTAATGCGTGGTAATTCCCGTACCAGAAGTTGAGGTTCT +TTACGTCTATCTTGATGCCCCTTTTGGAAGTCATACCATTTAGAAATTTTACAGGAATTTTTATTAAGCG +CTAATTAAGATGGTAGGCGCGGGGGGACTTGAACCCCCGACCTCCGGCGTGTCGGGCCGGCGCTCTCCCT +ACTGAGCTACGCGCCTTTGCAGAATATATTATACTTCAAATTTATGAAATATTTAGGACTTTGCACAGAC +CTCTACGAACTCACCATGGCACAGAGTTACCTCTACGAAGGCAAAACCGGAACCGCTGTATTCTCCCTTT +TTGTAAGGAAACTCCCCGAAAAGAGGAACTTCCTGATATCCGCAGGGCTCGAAACCTTGGTGGAGAGGAT +AAAGAACTTCAAGTTCGGAGATGAGGAGATAAAGTATTTAAAGAGCCTGGGAATTTTTAAAGACGATTTT +CTGGACTACCTCAAGGACTTTGAATTTTCTGGAAATGTTTACGCAATTCCCGAGGGAAGGATAGTATTCC +AAAACGAACCTCTCGTTCAGGTAGAAGCTCCGATTCCCGAAGCCCAACTCCTTGAGACGTTGGTAATAAA +TACTATACAGTTTGAGACAATGATAGCTTCAAAGGCGGTGAGGAGTTATCTCGTGGCTAAAGGGAAGAAG +CTCGTTGATTTCGGTTTCAGGCGGGCCCACGGCTTAGAAGCGGGAATCCTTGCAGCGAGGGCTTCCTACA +TCGCCGGTTTTGACGGGACTTCAAACGTCGAGGCGGGAAGGGAGTTCGGTATTCCCGTTGTGGGAACTAT +GGCACACTCCTACGTGATGATTTTTGACAAGGAAGAAGACGCCTTCAGGGCTTTTGCCAAACTCTACCCC +AAGAACGCTATATTCCTGATAGACACCTACGATACCATTGAGGCGGCAAAAAAGGTCGTAGACCTCGCAA +AGGAAGGCGTACCCGTTGTGGGAGTCAGAATTGACAGCGGTGATATAGTGAAGCTTTCCAAGGAAGTGAG +GAAAATTCTGGACGAAAACGGACTGAAAAATGTAAGGATTATAGTGAGCGGTGGCGTTGACGAGTACAAA +ATCAAGGAATGGTTTGACAGAGGCGCTCCCATAGACGCCTTCGGCGTAGGAACGAAGTTCATAACTTCCG +CAGATGCCCCATACTTTGACATAGCCTATAAGCTCGTTGAGTACGAAGGAAAACCAAAGTACAAACTCAG +CCCCGGTAAAAAAACATTCCCATACAAGAGGCAGGTCTACAGGTATTACGAAAACGGAAAGATGAAGTAC +GACGAGACCGCCAAGTGGGAGAGCAAAAGGGAAGGAGAACCTCTGGTAGAACTCGTTATGAAAAACGGAA +AGCTAATAAAGGAATTGCCTAGCCTGAAGGAAATAAGGGAAGTTGTGATGTCGGAACTAGAAAAACTCCC +CGAAAATTACAAGGACATAACGAAACACTACGAGTACGAAGTAAAGATCTTAGACTGGGAGTAATTCTTC +TTTCACAATTATCTTTTTATTCTCTTTATCCACTTTGAGGACTATATCCGAGACAAAGGGAACGAGTAAG +TTTTCCTTATCGAGAACCAGAGCGTCGTAAGGACCCATATCCTGAACCCTTTCAACCTTTCCGAGTTTCT +TTCCCTTGTCCGTTTCAACCTCCATTCCCACAAGTTCATAAGCGTAGTACTCCTCTTCTCCTAACTCTGG +CAGTTCTTCCTTGGGAAGGAAAAGCTTAGCCCCTTTAAACTGTTCAACCTCGTCTATTGAATCGTACCCC +TTGAACTTTATAATTACCTTGTCGTCAATGAAGTCCACCCATTCAACCTCAAAGGGAACCCAATCTCCGC +CTTTTCTCTTTAAGTAAACCTTTTCAAGGTTTTCAAAGACCTCCGGAGGTGCGTAAGGTCTCACCTTGAG +TTCTCCCTCAAGTCCGAAGGTGTCCAGAACTTTTCCTATTACCACGTACTCCTCCATCAATTTGTAATTT +TATCCCTTAAATAACATACCGACCGGTCGGTATAATAATAGTGTGGGAACTAAGGAGAGAATTCTGGAAG +TTTCAAAGGAATTGTTCTTTGAAAAGGGATATCAGGGAACGAGTGTTGAGGAGATCGTAAAGAGGGCGAA +CCTTTCAAAGGGAGCCTTTTACTTCCACTTCAAAAGTAAGGAAGAATTAATAACCGAAATAATAGAACGA +ACGCATAAAAAAATAATTTCCCTGTTTGAAGAAAATAAGGAAAAAACTCCCGAAGAACTTCTGGAAATGT +TCCTTGAAGTACTCTACAGGGAGAAGAAAGTAGTTTACATATTCCTCTTTGACCTCCTCTGTTCCGAAAA +ATTCAGGAATATTTACTTTGAAAAGATAGAGGACGCTAAAAGAAGGTTTGAAAAATTCCTTGAAAAGCAC +TTCCCTTCAAAGGCTGAGATACTCTCCGAAATAATACTCGGTTTCCTCAGGCAATTAATCCTGCACTACG +TTATAAAGGAAGAAAGGGAACTCCCATTCCTAAAGGAAAAACTCAGGGAAGGGTTGAAGTTAATCTTCGA +GGGAGTGAAAAAATGTGGATAATACTGCTCATCCCGACACTTTTATTCTCCTTAGGGCTTCAGGAACTAT +GGAAAAGTGCCCTCAAGAAAAATCCCGAAATACTTGCCCAAAAACAGGACATTAGAGCCAAGGAGTATAA +ACTAAAGGCTACAAAGAACTTATACTTCCCTCTCTTTGAAGCGCAGTACTCCCGCGCGTGGCTCAGTGAA +AAACAAAAGCTTGAGGTATTTCCCTTTTCCTTTGATATGACGAAAAAGAATTACGAGAACTACTCAATCT +CCCTGAAGGAACTCCTCTACGACTTCGGAAGACGGGAGAAGTTAATAGACATTTCGGTAAAGGAACTAAA +AGTGAGTCAATATTTTTACGAGGAAAAGAAACAAGAAATTTTGTACAAGGTTGCGGAAAATTACTTTAAC +GTTCTGAGCGTTAAGGGAAAGATAAGGATTTATGAGGAGGAATTAAAAGCGGTAAAATCCCAGTACCAAC +TCGCAAAAGCTTACTACGAAAAAGGACTCGTTGCGATAACGGACCTTCTTCAGGCAAAGGTTCGCATACA +CGAAGTTAAGGAAAAAATAAGAAAAGAAAAGGGAAATCTTGAAACGCTACTCGTGAACCTCTCAAACCTC +ACGGGAATAGAGAAAGAAAAATTAAGGAATATTCAAGAAATTGAAGGAATTCCTGAAATCAAAGATCTCA +GTTATTACCTGAAAACGGCGTACGAAAGGAGGGGAATTTTAAAGGCTCAAAAGGAAAAGGTAAAAATACT +TGAGAACCTTGCAAGGATAAAAGCCCTTGAGTATGCGCCACAAATTTTCGGAGGTTTAACTTACTACTAC +ACCAACCAGAATCCAAACGTAGAACCAAAAGGTTTATTCAGTTATTACGTGGGAGCTACCCTTTCATTCC +AAACTCTAAAACCCTACTACGAACACCTTTCCCTGAAGAGGGAAAAAATAAAAGCTTTAAAGGAGCTTGA +AAGTCTGGAAAACTCAATAAAACTCCAAGTAAAGAGTGCTTATGAGGATGTTTTAACCGCTAAAGAAAAC +CTGAAAACCGCAAAAGAGAGACTCAAGTTTGCAAAAAAGTACTACGAACTCGCTTTGGAACAGTACAAAA +ATCAATTAATATCCCAGACGGACCTCCTTATAGCGGAAGCCACCTTAACGAGTGCAAAGGAAGCCCTCCT +GATAGCGAAAAACGAACTCTGGAAGGCTTATTACAGACTCCTTTGGGCTTCTTCCCTTCTGGAGGTTGAA +AGATGAAAAAGTACATAGGCGTTTTTACGGTTGTGGCTTTAATTGTGGGCTTTGGGATTTACGCCTTTTT +CTTCATAAAACACAGAATTGAGTATGCCATAACAAACGCAGTCTTCGTTAAGGCGGACGAGCTTTCTTAT +CTGTCCTTCAGAGTAAGCGGAAAGGTTATTGAAGTTTACAAAGACCTCGGAGATTACGTAAAAAGGGGGG +AAGCCCTTGCAAAACTGGATCCGACTTATTACGAACTTGAGAAAAGAACACTTGAGAAAAAAATGAGCGC +CCTCCTTGAAAAGAAAAAAGCCCTTGAGATAAAAATTCAGAAGCTGGAAAAGGGACTTCATATAAGCCTG +AGTGCTAAAAAACTAAAAGTTGAGAGTTTAAAAAAGAAAAGGGAAGCCCTACGGGAAAAACTCCTTCAAG +TGGAAGAGAAAATAAAACTCGTTAAACTTGACTGGGAACGCTACAAATCCCTCTTCCAAAAAGGACTTAT +CCCGAGAAGGAAGTTTGAAGAAGTAGACACGAACCTGAAAGTTTTACTTCACGAGAGGGAATACCTTGAA +AAGAGCATACAGGAAATTAATACGGAGATAAAAAGGGCAAAGAAAGGCATTGAAAATGCAAGGAATGAGT +TTAAAACAATAGAGGAACTAAAAAAGGAACTCTCCTCCCTTGAGGAAGAAATAAAGAGCCTGAAAGAGAG +GATAAAAACCGCAGAGCAGAAGATAAAAGACACGGTTTTGATTGCACCTTTTGACGGAGTAGTTGCAAAG +AGGTTCATAAGCAGGGGAGACGTTGTTAGGGCGGGACAGCCGGCCTTTGCCCTTGTAAACCCTGAAAGCT +TTTACGTAGAGGTTTTACTCGAAGAGACGAAACTCAAAGGCGTGAAGGTGGGAAATAAAGCTTACGTGAG +ACTTGACGCTTACCCTGACATCCTTTTTGAAGGAGTTGTTGAGGAGATTTCCCCCGCTTCCGCAGCGACT +TTTGCCTTAGTCCCCAGAGATGTATCCGCGGGAGAATTCACAAAAGTTGTTCAGAGGATACCCGTAAAGA +TAAAGATTACGAAAGGGGATTTAAGCCTTCTGAGAGTGGGAATGGGCGGTGAGGTTGAGATAAGGAGAAC +GAGATGAGTGAGTTTTACGAGAAAATAAGCCCTTCCCAGAGGATTTTTCTCACCGTTTCCCTTATGGTCG +GAGTCTTTATGGCAATCCTTGACACCACTATAGTTGACATAATAGTTCCGAGACTCACAGGACCCCTTTC +TACGGACCTTTACGGCGTTCAGTGGGTAATAACGTCCTACATGACCGCAGCGGCAACGGGAATACTCCTC +GTTGAGTGGCTTGAATCCAGAATAGGTTTAAAAAAAGTTTTCCTGATTGGGCTTTTTCTCTTCACAACTT +CTTCCTTCTTTGCGGGAAGGGCAAACTCCCTTGAGTGGATGATAACGGCGAGAACCTTTCAAGGTTTCGG +GGAGTCTTTGATAGTGGTGAGTGCGGAAGCGATGCTCTTTTCCGCTTACCCGCCCTACAAGAGAGGACTT +GCGATGGGCATTTACGGACTTGGAGTGAGTTTTGCCCCGGCTCTCGGACCCACACTCGGAGGATGGATTA +CCGAACTCATAGAGTGGAGGTGGGTATTTTACATAAACATACCCATAGGGATAATAAACTTCGTTTCCGC +TCTTTTCTTCCTTCCCGAACACAAACCAAAACACTCCGTTTCCCTGAACTTCATCTCTTACTTTTTCATC +TCCGTTGCCACCGTTTCCCTTCTTATAGTCCTTTCCAAGGGGCAGCAACACGGCTGGTTTTCCTCCGACT +TCATAGTTAAGATGTCTTTCCTGAGCTTATTTTCCTTCCTCTTTTTCCTGCTTTCTGAGATGCTATCCAG +AAACAAACTCGTGGACCCTGAAATATTCAAGATAAAGGAGTTCACGATAGCCTTTCTCGTTTACTGCCTG +CTCCTTGGTTTTTCCATGTATCAGGTCTTTTACTTACTTCCCCTCTTTTACGAGAGACTGAAAGGACTTC +CCACCTTTGAGGCGGGACTTCACATTTTACCCTTAGCTCTGGCGGTTGGGATTTCCTCACCGATTGCGGG +AGTAATAAGCGACAAAGTTTCCGAAAGGCTTCCCCTCTTTATAGCAGTTGTTCTTTACCTTTACGCTTCC +TTCTTCATACTTCCGAAGTTCAATTACTACACACCTTCCTGGGAATCTGCTTTCAAGTTGATAATACTCG +GCATAGGTATGGGATTTTTCTTCGCTCCCATTACGAACCTCGCTCTCAAAAAACTCGGTGATAAGACCAC +TCTTGGAGTTAGCCTTATGCACTATATAAGGTTCGTGGGAGGTTCTTTCGGAACTGCCCTTGCCACAAAC +GACATCCAGAGGTATATGTGGGAAAACTTCCAGAGGAGCACGGAGATACAGAACGAAAGAATACTCTCCG +AGTTCTTAGAAAAAATTTCGTGGCTCTTCTGGATAGGAGAAAAGAAAGTTAAAGCTCTTTTTTATCAGGT +TGAACAACTTCACGCCTTTTCGGACAGCTTTATGAGAACCTTTTTCGTTGCGGGACTCTGGGGACTTCTT +GGAAGTTTACCTATCTTTTACCTTTTCTTTGAACTTCTATACGAAAAGTTTATAAAGAAGAGGGCTTAAA +GCCCCCTTTCGGCGAGGTATATAACGAGGTCCCTGAGTCTGCAGGAGTAACCCCACTCGTTGTCATACCA +CGCGGCAATGTGGACAAGGTTGTCTATCACCTGAGTTAAAGGAGCGTCAAATATAGCGGAGTGCGGATTT +CCGACTATGTCCGTGGAAACTATGGGGTCTTCGCAGTACTGGAGTATTTCCTTCAGGTAAACCTTTCCGC +TTTCCCTGTACTTTTGAGCGGCTTCCCTGAACTTTTCGTTTACCTCTTCAACCGAAGAAGGAGCTTTATT +TACAACGACCGTAAGGTCTATGAGTGAGCCGTCCGGTACGGGAACTCTCCTCGCAGTTCCGTCAAGTTTT +CCTTTAAGCTCAGGAATTACTTCACCTATTGCTTTAGCAGCTCCCGTGGTGGTGGGAACTATGTTTATAG +CCGCAGCCCTTGCCCTTCTGAAATCCTTGTGAGGAAGGTCCAAGAGTCTCTGGTCGTTGGTGTAAGCGTG +AACCGTTACCATGTATCCCTTTTCAACTCCGAAGGCTTCGTTCAGAACCTTTACACAGGGAGCTAAACAA +TTGGTTGTACAGGAAGCGTTTGAGATTATGTTGTGCTCCTTTGGATTGTACTTCTCTTCATTCACTCCGA +GTACTACAGTAATGTCGGGATTCTTAGCGGGAGCGGTGATGATTACCTTTTTCGCCCCTCCCTGTAGGTG +TTTGGAAGCGTTTTCCCTGTCTCTAAACACTCCCGTAGCTTCTATTACAACGTCAACCCCGAGGTCCCCC +CAAGGAATTTGGGAGGGGTCCTTTTGAGCGAAAACCTTTATCTCTTTTCCGTCAACCACGATAGAGTCGT +CTTTCGCTTCAACGCTTCCCTTAAATATCCCGTGAACCGAGTCGTACTTCAGGAGATGTGCAAGGTGCTT +TGCGTCTGTGAGGTCGTTAATCGCAACGATTTCTATTTCTTCTCTTCCCCAGGAAGCTCTGAAAAAGCTC +CTCCCTATCCTACCGAATCCGTTTATCCCTACTTTTATAGCCATAATTCTTAATTATACTCGTGGAACTA +TTTTATATAAACTTATGAAGATACTCGTAATCGGAGGACCTACAGCGATAGGAAAGTCAGACCTCGCATG +TTGTGTAGCACAAAAGCTGAACGGTGAAATCATAAGTGCGGATAGTATGGCGGTTTACAAGTTCATGGAC +ATAGGAACAGCAAAACCTCTTGAGTGTATGAAAAAAGTTCCCCACCACCTCATAGACGTAGTAGAGCCGG +GCGGATACTTTGACGCAAAGATTTTTGAGGAAATGGCAAAAGAAAAGATAGAAGAGATAAAAAGAAAGGG +AAAAGTCCCCATAGTCGTGGGAGGGACTTATCTCTACATTCAGGCACTCCTTTACGGGATAGACGAGACT +CCAAAACCCGACTGGAATTTAAGAAATAAACTCTACGAAATAGCCAGAAAAAAGGGAAACGATTACCTTT +ATGAAAAGTTAAAAGCCATAGACCCAAAATACGCAAAAAAAATACACAAAAACGATTTAAGGAGAATAGT +GAGAGCTCTGGAAGTTTTCATAAACACGGGAAAACCCTTTTCCTCCTTCCACTCTTGGAACAAACCTAAA +ATGGACTTTGTAGGGATATACCTGAAGAGAAGTCCCGAAAGTTTATACAAAAGAATAGAAAACAGAGTTT +ACGACATGGTAAAGGACGGACTCCTTGAAGAGGTTAAAAAGTTATTAGAAATGGGATACGAGAACTTCCT +GACTTCCGGGCAGGCTATAGATTACAAGGAATTTGTTCCCTGTGCAAAAGGGGAGAAGAGTTTAGAAGAG +TGTATAAAAGAGGCGATAAAAAACACAAAGAAACAGGCAAAGAGGCAGATAAGATGGTTCAGAAAACAAG +GCTGGCACGAAATAGACCTTGACAAACTGAGTATTGAAGAAGCGTGCGAAGAAGTTGTGAGGATTTATAA +AGATGCAAATAAAACTAAGTGAACACTTTTGGTATAGATGGGATAAGAGAAAGGATTTTATGCTGAAGGA +AGGCATAACACCAGAGAAGATAATAGAATTTGTATTAAATCCCGATTTAACTTTTCCTGACCCTATTTAT +CCAAATAGAGAATGGTGAATTAAGAAGGTAGGAAGTAGGTGTCTTAGAATTGTAATTGAATTAAAAGAAG +ATAAATTAGAAGTTGTAACTGCATTTTTTGATAGAACTCTCAGGAGGAAAGGACTATGCGAATAAAGTAT +TTTCCCGATACTGACACACTTATTATAGATATAAAGGAAGAACCTATAGCGGAGAGTGAATATCTTGAAG +ATTTAGGAGTTATAATTGACTACAATGAGAAGAACGAAATAGTGGGCTTTGAAATACTAAACTGGTCCAA +ATTCCAAAAAGAAGGAAAGGAACTCAAGCTTCCCGTTTATATTTAATGATGATATTTACCATATCGCATA +TAAGAATAATTGAATAAATTCTCATAAAAGGAGGTGTGAAGTATGGCTGAGGAAAAGAAGGAGCAAGTTC +AAGAAACTAAGATGCCGACAAGAGAAGAGATTGAAAAGGTTCTGGACGAAATTAGACCCGCTCTCAGGTT +TGACGGCGGTGACGTTGAACTTGTAGACGTTCAAGAGGACGGAACCGTGCTCGTTAGACTTGTCGGAGCG +TGCTCAGGTTGTGGTATGTCAGTATTGACCCTGAAGGCTGGAATTGAGAGGGTATTAAAGCAAAGATTCC +CTCAGATAAAAGAAGTAAAAGACGTGAATATGGACATACCCATGACTTTTGGCTTTTAAGCCCCTTCCCT +TTTCTTCCACTTCGTTCCCGCAGGAGTATCTTCCAAGACAATTCCGAGTTCCTTTAATTTGTCCCTTATG +TAGTCTGCAACTTTAAACACCTTTTCCTTTCTGGCTATATTTCTGGCTTCTATGAGTATCTGTATTAATT +TCTCGTCAAAAACCTGACCCGCTTCCAGTTCCCTTTCAACCACTCTCTCAACCTTGCACTCCGGATATAA +ATCCTCAAGGAGTCCGAAAATCTTTTTCATGGTGTTTAAGAGAGATTTTGACGCAAACTCGTATGCGGAG +AGTTCCCTGTCCGTTATCTTTCCTTCGGAGTAAGCCTTGTTCTTTACCTTGTTCAGTTCTCCTACGAGCT +TGTAGACGTGGGAAAGTGCCTCAGGGGTGTTGAAGTCGTCGCTCAGGGAAGCGTAAAAGTTCTCCTCAAA +CTCCTTAACTTGCTCGTAAAGGGGGTGAGTTCCTCCCTCTTTGCTTTCAACCACCTGTAGTTTTTTAAGT +AGTTCAAGGTCTTCTATGGCGTTCTTCAGTCTCTCGTAAGCCTTAAGAGTCTCTTCCATCTTTTCCCATG +AGAAGTCAAGGGGACTCCTGTAATGGGTAAAGAGAACCAGGAGTCTCAACACATCTGGGTGATACTTTGT +GTAAACTTCCCTCAGGGTTACGTAATTTCCGAGGGATTTTGACATTTTCTGACCGCCTACGGTAACGAGT +CCGTTGTGCATCCAGTATCTTGCAAAGGGTTTCCCCGTTATCGCTTCCGCCTGAGCTATCTCGTTCTCGT +GATGTGGGAACACGAGGTCAAGTCCTCCGCCGTGAATGTCTATGGTCTCTCCGAGGTGCTTAAACACCAT +CGCCACGCACTCGGTGTGCCATCCCGGTCTTCCCTTTCCCCAGGGTGAATCCCAGGCGGGTTCTCCCGCC +TTTGAAGCCTTCCAGAGGGCAAAGTCTAAGGGGTCCCTCTTCTTTTCGGAAGGCTCAACCCTTGCACCTG +CAATTAGTTCCTCTATATCCCTCTTTGAAAGCTTTCCGTAGTCCTTGAATTTCTTGACAGAAAAGTAAAC +GTCTCCTTCCACTACGTAAGCGTATCCCTTTTCAACGAGTTTCTGGATAACTTCTATAATCTCGGGTATG +TGCTCGGTTACCCTCGGCTCTACGTCCGCGGGTCTCACCCTTATGTTTTCCATGTCTACGTAATACCGTG +CTATGTATCTGTCCGCTATCGTCATAAAGTCCGTGCATTCCTGCTTTGCCCTGTTTATTATCTTGTCGTC +AACGTCCGTAAAGTTCCTTACGAACTTTACCTGATATCCTAAATGTTCCAGAAACCTCCTGAAAACGTCA +AAGACTATTAAGCTCCTTCCGTGTCCTACGTGAGAGTCGTCGTAAACGGTTACACCGCAGGTGTATATTA +GAACTTTAGGGGGATTTATGGGAACGAACTCCTCAACTTTTCCGGAAAGTGTGTTATATATCCTCAAGCT +CATAGTTTTATTTTAATTTAAACTTTTTCTCCCATTCCCAAGCGGTTTTAATTATGAACTCAAGGTCGTC +GTACTTAGGTTCCCAGTTAAGAACCCTTTTAATTTTCTTGTTGTCCGCCACCAGAGCAGGCGGGTCTCCC +TCTCTCCTCGGAGCTTCCACAACCTTAAAATCCACCCCCGTCACCTTTTTAACTGCGTTTACCACCTCAA +GGACTGAGTAGCCGTGCCCGTATCCGCAGTTCAGAACCTCGCTCTTTCCTCCGGAAAAGAGGTATTCAAG +GGCGAGAATGTGTGCCTCCGCAAGGTCCGTTACGTGTATGTAATCCCTTATACACGTGCCGTCGGGAGTA +GGATAATCAGTTCCGTAAATTTCAAGTCTGTCAAACTCTCCCGCCGCCGTCTTCACCGCCCTTATTATTA +GGTGCGTGGGGTTTGGGTATGCAAAGCCAATTTTTCCCTCGGGGTCCGCTCCCGCCACGTTGAAGTACCT +TAAAGATACGTAATTAAAATCCTTTCCTGAATTTTTTAAGTCCCTTAAAATCCTCTCAACGGTTGCCTTT +GTCTCTCCGTAAGGATTTATGGGGTTCAAGGGTGCGTCTTCCTTTACAGGAATACTTTCGGGTATACCGT +AAACCGCCGCGGAGGAAGAAAACACAAACTTATTTACTCCGAACTCTTGCATCACCTCCAGCAGGTTTAT +GGTATTCACAACGTTGTTTCTGTAATACTTTAAGGGCTCTTTTACGCTTTCGGGCACTACTATGTAAGCG +GCAAAGTGCATAACCGCGTCTGGTTTGAACTCTTCAAACACCCTTCTTAAAGTTTCCTTATCCGCAAGAT +CTGCCTTTACGAGTTTTCCGTAGAGAACCGCCCACTCGTTTCCCGTTGAGAGGTTGTCGTAGATGAGAAC +CTCGTACCCCTTCTCTCCCAGAGCCTTAACTACATGAGAACCTATGTAACCCGCTCCTCCCGTGACGAGA +ACTTTTTTCATAATTATTTATATTCTCATGTTCAAAGTAGGAAAGGTTTCTTATTTGAACACGCTTCCTC +TTTTTTACTCCCTTGAAGGTTTTGAAGTCGTGGAAGGTGTACCTTCAGAGCTTGTTGAAAAATTGAGAAG +AGGAGAAATACATGCGGGAATAGTTTCCTCCGTTGAGTACTTCTTCAACCCTCAGGATTACTTTATACTT +TCCGGCATTTCCATATCCTCAAGGGGTTCGGTTTGCTCTGTAAAACTCTTCTCAAACGAGCCGATGGAAA +AGATAAGGGAAGTGAACATTACAAAAGCTTCACTAACTTCAAGGGAACTTCTCTTTTACCTCTTTGAAAA +GAAGTTTGGTTTTGTGCCGAAAGAGAGTGAAGAAGCACAGGCAAAACTCCTTATCGGTGATGAAGCGATG +GAACAAAAGGGATATAAATTCGTTTACGACCTCGGAGAGGAGTGGTTCAAACTCCACGGACTTCCTTTTG +TTTTTGCTCTATTTCTCGTAAAGAGGGATGCGGACATAAGTAAAGCAAAGTTCTTAAAAAAAGAAATTAA +GAAAAGTGTTAAAAACTTCTTTGAGGAAGGGATTAAAAATATTAAGAATAAAGAATACTTTAAAAACTGT +TTAGATTACTCCTTAGGAGGAGAACATATAAAGTCTTTAATAAATTTTTACGCTTATCTCTCAAGGAAGT +TTAAAAAGCAAGTACCGAAGTTAAAGTTCGTGCTTTAGTGTGAGTAACATCTGTATATATTAAAACTTAT +GACTGCGGTAAGCCAAGAAATAATGAACTACATAGAGGAGAAAGTAAACAGGGCAAGAAGCGTTCTGAGA +GAACTCACTTCCCTCAAAACTTCCGTAAAGAACGAAACCCTCTTAAAAGTAGCAGAACTAATAGATAAAA +ACAGGGATTACATAAAGGAAGAAAACAGGAAGGACGTAGAAAAGGCAAAGGAAATGGGATTGAGACCTGC +AGTTGTAGACAGGTTGGTTCTCAACGACAAGAGAATAGACGGAATGGTAAAAGTACTCAAAGACGTTGCC +TCCTTACCTGATCCTGTAGGTGAGATTATAAAAATGTGGAATCTCCCTAACGGTCTGAAAGTGGGAAGGA +TGAGAGTTCCCTTGGGAGTGATATTCATCGTTTACGAGTCAAGGCCGAACGTCACTATAGAAGCCTCATC +CCTTTGTATGAAGTCCTCAAACGCAGTTATCCTGAGAGGAGGCAAAGAAGCCATAAACTCTAACAAAGCA +CTCGTTAACCTAATAAAGGAAGCGTGCAGGGAAACGGGATTTCCCGAAGATGCTGTTCAGTTCATAGACA +GATCCGAGAGGGAAATAGTGTGGGAAATCCTGAAGATGGAGGGCAAAATAGACGTTGCCATTCCGAGGGG +AGGGGAAAGCTTGATAAGGGCTGTTGTTGAACACGCAAAAGTTCCCGTCATTAAACACTACAAGGGTGTT +TGCAACATTTACGTTGACGACGAGGCTGACCTTGAAAAGGCTTACCACATAGTTTACAACGCAAAGGTTC +AAAGGCCTTCCGTCTGCAACGCTGTTGAGAACCTAGTAATAAACAGAAAAATACTGAAAGAGTTCTTCCC +GAAGATGGCTTACTACCTCGGAAAGGCGGGTGTGGAACTCAGGTGTGATGAAGAAAGCCTGCAGGTTATA +AAGGAAAACCCGAAACTCTCCTTTGTTAACGCAAAACCTGCAACTGAAGAGGATTACTACGAGGAGTTCT +TAGACTTAATACTCGCCGTGAAGGTGGTAGACGATGTTGACGAAGCGATAGCTTTCATAGAAAAGTACGG +CTCAAAACACTCGGATGCGATAATCACGGAAAACTACACAAAGGCTATGAAGTTCTTAAGGGAAGTGGAC +TCCGCCGCCGTTTACGTTAACGCGTCCACGAGATTTACCGACGGAAACGAGTTCGGACTCGGAGCGGAAA +TGGGGATCTCAACGGACAAGATCCATGCAAGGGGGCCCATGGCACTCGAAGAGCTGACCATACCGAAGTT +CGTAATACTCGGAGAAGGGCAGGTGAGGGACAACTTCGGTGTTCCCGAAGAGTGGATGAAGGAGTTTTAA +AGGAGGCTTGTGATGACTCAAAAGAAGCCCATAAGGGATCTCATTGAAAGCTGTATAACAAAAGTAGAGG +AACACTACAAGTTAAAGGAACTCTACCAGAGACTAAACCAAGGGATAAACGTTGAAGAAGTTCTCAAAGA +AACCGTGGAAGACTACAAGGAAAAAATGGAAAAGTACATTTTAGAAGTTCTGGAAGAAATAGAAAAGTAT +TGCGAGTACAGGGAGAGCTTACACGGAGATCAGAAGAAGGAAGCGGAAGAGGAACTATGCGAGTGTGAAA +AAGATCTTTACTGCACTATAGCGGAGCTCTTCGAGCTTTACCACTTCTTCAGGGAACTCGAAAACTTGAG +TAAGGAACAGATAAACGAAGCGGTAAGTATACCCGTTGAAATAATCTACAACGTTGTTTTGAAGCTAAAG +GGTATAGAGGAGAAAAATCAGTGATTTTAAAGGTTCTAACCATAGAATAAAAAGCGTATGGAAAGGGAAA +AAAGCTTAAAAGTTCTTGCTTTTAGTTTCCTATTAATATTTCTCTTTGCTTTTATTGAATTCCTCGGCGG +ACTGCTCACAAACAGTTTGGCTCTCCTCTCAGATGCCGGCCACATGCTCACGGACGCTGTATCCCTTTCT +ATAGCACTCGTTGCCCAGTACTTAGCTCTCAAAGTAAAGACGAAGAGGACGACTTACGGACTCTACAGAC +TCGAAGTTCTCGCCGCACTCGTAAACGGAGTCTTCCTCTTAGGACTTATAGGCTACATAATCCTCGAAGC +TATTCACAGATTTGAAAACCCTGAACCAGTGAAACCTCAGATGATATACATAGCCTTTGCGGGACTGATT +GTTAACCTCGTAGTGGGATACATACTCCTGAAGCATTCTGAAGAGAACATAAACATTAAGAGTGCGCTGC +TTCACGTGGCGACGGACACACTCGGTTCGGTTGCAGCGATAATAGCGGGGATAGCGATCGTTTTCTGGAA +GTTTTACCTTGCGGACCCAATTCTGAGCGTTGCTGTAGCCCTTTTAATCCTGCCTTCCGCCTACTCGGTT +ATAAAGGAAACCGTAAACGTACTCCTTGAAGTTGCCCCTTCCCACATTAACACGGAAGAACTCGAAAAGG +AACTCTTGAACCTTCAAGGTGTAAAAGGCGTTCACGACCTTCACGTCTGGTCCATAACACCCGGAACGGA +AGTACTTACGGTTCATGTGGTTGTTGAAGACACGAGTATATGCAACGACATATTGAAGGAAGTTGAAAAG +ATAGCCCACAAGTACGGTATAAAACATACCACGGTACAGCTTGAAAAGGAAGGTTACGCCTGTGCCGAGT +GCTGTCCCCTTCTCTCTCCTCAAGGGTTAAAGTTCCATCACCACCATCACCACGGCCACGAGCACGAACA +CTGAGTTAAATTATCTTTATGGAAAAGACTTATAAACTTCCCATAGTCTTGGGAACGGATCCCGAAAACA +CTATAAGGATTGACAAACTCCCTCCCCTTAAGGGTGCCTTTGCGGTTCACATACACGAGTCCGAAACCGA +GAACAACGCACACATAAAGCTCGAGTACGGTGATACGGAGTACTGCCTTTCCCTTTACGTGTTTAACTAC +CCAAAATTCTTAAGGAACGAAACCGTTAGAGTAAGGAATTACGACCTTTGGCCCAAGTGGATCATGTTTG +CCGCGAGACTGCCTAACGGAAAACTCCACCCCAAAAGCGGGGGAAAAGTGTACAGGGAAGACGCCGTAAT +AGTTGGAGAGGGGAATTACGAACTCGAAAACCCTTTTATAAGTTTCAAATATTCGGACGGAAGGATTTTA +AACTTTAGAATAGAGTTCTACAGGTACTTAAGGTACAAATCTCCGAAGTACGGTCCGAGTTTTAGGAGCG +AATACTGGTTTATAGGGGTAGATTGATGCTTTTACTGCTTCTTCTCGTCTCCATAGCGTTTTCAGTTCCC +AAACTTGTAAGTCCGGAATGGTTGAAAGAAAACTTAAGTAAAAAGAATTTGGTAATTATAGAATTCGGAG +ATACCCAGTCTTACCTTGTTGAAGGGCACATTCCGGGAGCGGTTTTGACGGAAAAGGAGCAGTGGAGGAA +GATGGATCCCGAAACGGGAGCTCTCGTGAGAAGAAGTGTGGAGTACTACGAGAAGTTATTCAGGAGCTGG +GGAATAAACAACGACTCGGAGGTGGTTATCTATTACAAGGGAAACACAAGGAACGAAATACTCGGTGCAG +TTTACGCCTACTGGGTATTTCACCTCCTCGGACATAAAAGGGTTGGGATACTTGACGGAGGTTGGAAGGA +GTGGATAAAAAAGGGATACCCCGTGAGTTACGAAGAACCGGAAATAAACAGGGGAAACTTTAAGGCAAAG +TACAATAAAGAACTTGAAACTAACTGGAAGTACGTTTACGAAAATATAGGAAAAATACCCATAATTGACG +GCAGATTGCCTGATTTTTACTTCGGTATAGGAAAGTTTCCGGCAGCTAAAAAGTACGGACATATCCCCTG +TTCTGTTCCTTTCTCATGGGAGTGGTGGGTAAAGAGGGATAGAGAGACAGAAAAACTTTACATCGAATTT +CCCTATTATGCAAAAGAGTTTTTAAGGAACCAAGGCTTAAAACCCGAGGACGAGGTAATACTCTTTTGCT +TCGGAGGAACTGGAGCCGCTTTCCTTTACTGGGTGTTTGACGTATCCGGACACAAAAATATGAAGGTATA +CGACGCTTCAAAAAGGGAATGGGAAGCCCTCAACTTACCTTTAAACAGGTACGTATGGGAAACCTTTAGG +GATTGTAGAAAGTTCTTTTACACTAATTAAGTATGACAGGGTATATTAGATTTTTTCTTGCTTTTCTAGT +TTTAATTTCCCATTTAGGTATTAGGTTTAAAGGAATGAATGAAGGGGTTTTTGCTGTTGTAATTTTTTAT +ATATTAGCTGGACATGTAGTGACAAAACTTTTCCTCGAAAAGATTAAAAGTAATGATATTATTAAAAGGT +TAAAAATATTTTATATAGAAAGATTTTTAAGGATTTTCCCAAGGTATGTATCAATTTTTTTCTAACTCTT +GTCTTTTTATTTCTAACCAATTACGGAAACCCCTATATAAATTTCTGCAACTTTCTTTTAAACTTACTAA +TAATTCCCCTTAACTACTATATGTATTTAGAAAATTGTATAGTAATACTAACATCCACTACACCTCCTTG +GTGGGCTATACCTCCTGCCTGGTCCTTAGGAGCAGAAATACAAGCATACTTTCTTCTTCCAATACTTTTG +ACGTATAAAATGCTTGGCTTGAGTGTTTTCTGGATATCGTACATTATTTACTCATTGGCTAATTTAAATA +TAATACACTCTGATTACTTCGGTTATAGATTAATCCCAGGAGTTATATTTATGTTTCTTTCAGGTGCTTA +TTTACAAAAAATAGTAAGCGGAAAAGCTTCCCGCCTGGAAATGCTTTCTTTGATAATAATATACATTATA +AGTCTTTTTTGGCTTGTATTTTTTATAATAATTAAAGGAAAATACGGAGCTTATACAAGAGAAACCTTAT +TAGGCTTATTAGTAGGTATCCCTCTGGTTTACACTTTGCTAAAAATTAGAAGAAAGTTTTATTTTAATGA +CTTATTTGGAAAACTTTCATACGGTATATTCCTTTCACACTTTTTATCCTTTTGGATTCTTGAGTTTGTA +AATTTAACACAAAATATAATATCTATGATATTCCTATCCTTAATAATTTCGGCTTCAGTATCGTATTTAA +TCATTACCCTTATAGAAAATAAGGTTGAAAAAATAAGATACAACCTGACGAGGTAAAATAAGAAGGAGAA +AAAAGGTTAAGCAAAACTATGTGTCTGTCCCTCGGTAACTATTCATATACTCTATACGCATCCGTCTCAT +ACTCCTCCGCTTCAGGTATTTTCGCCAAAATCTTTTAAAGTTGTCTTCCGTTTTTTACCACTTTTTCGCT +CCCGCACTCAGGGCATCTCATAGCTTATATTCTCTTATCATCTCTTTTGTGAACTACCAAACTATAATAC +ATAGTATGAGATTCTCCATAAGAAATGTTAGCGAACAGGAAGTTAAAAGGGAAATAAGACACATATTGGA +AGAAGTTTCTTCCGATAAAGATGAAATATCTAATAAACATAAACCTACAACTGTAGTAAAACCCGTTGAC +TTTGAAAATATAGATTTAAACTACCTGTTTTCCTTAAACGGAGCTGAATTTGTTAGAAGCGCCTACAGGT +TGGTTCTTGGTCGAGAACCGGATCCTCAAGGTATAGAATATTTTCTTTCAAAATTATTCTCAGGCGAATA +CACTAAAGGAGATGTTATAGTACACCTTAGATTATCTAAAGAAGGTAGAAAAAGAAAAACAAAGATTAAA +GGTTTTTATAAACTAGCTATACCTTTCTTTTTAAAAAGAGTACCTATAATATCTAAGTTTTATAATTTAG +GCAAATTTCTGATCTTCCCTGAAAGATTTTTAAGGAGACTTATAGCTCTTGAAAATTTCTCTTATACGCA +TATATTGGAGCTTAAACATGAATTGTACATTTTAAAACAATCCACAAATGAAAAAATAAGATTCCTAGAG +GAAATTACTTCACCACTCAGAAAGATAGAGGTTAATAATATATGGACAAAAGAATTCAACTTTGGAATTG +AGAATAAAGAAAATTTTTACGCTTCCTTTGAAAATGCATTTAGGGGAGGGTACGAAAGTATAAAAGAAAA +GCAAAAAATTTACTTAGATATCTTAAAAAAAGAAGGAGTAAGAGGAAAGGTGTTAGACGTAGGTTGTGGA +AGAGGGGAGTTTTTAGAACTATTAAAACAAGAAGGCTTTGAAGGCATTGGAATAGATGTTAATAATTATT +TAATAGATTTATTAAAAAAGAGAGGGTTTAAAGTTTTTAATATGGATGCCATTTCGTTCCTAGAACAATT +TGATGAGGCTTTAGACGCAATAACTGCTTTTCAAGTTATTGAACATATGTCTATTAAATACTTAAAAAAA +TTCTTGGAACTTAGTTATAAAAAGCTTTCTAACGGTGGGCTTATAATTCTTGAAACGATAAATCCTTGGA +ACATAGAAGCGTTCGCAAGGTTTTACTTAGACGAAACACATGTAAGACCTATTGTGCCAGAGTATCTCTA +TTTTCTACTAAAATACATAGGATTTAAAGATGTTAAGGTAATTTTTCTTTCTCCTTTAGAAAAGGAAATA +TTCAGTTTTCAAAAATTAAAATATTACTACTTGGATTATGCGGTTATTGGAAAAAAGGAGGAGTGAAGAA +TGGATAAAATTACATTTGATACGTTTTCACCTTTTTACAATATACTTTTACTGGTACACAATAAAATTGC +AGATCTAATAAAAAATGAAATCGTAAATTTCTCAAAGTTGGAAGTAAAATTCCACACTTTAAACTCCGAA +ATAGATGAAGAAACTTTATACAGATTAACAGATTTAATAATAGCAGACAAATCAACTAAAGAAGAGTATT +TAATAAAAGGAATACATGAAAATATACCAATAATTTTTATAGGTGATGATGAAAATTTAAAACCTTATAT +AAGTGTAGCGTTTAATACAAATGAATTGAAAGAACTTGCAGGGTTCGTGAGGTTAATTCAAATAAACAGG +AGGTTAAGGAGGGCAATAATAGAATCACAAAGAGAGAACCTGAAAATAAACGAGGACGGTATAAAAATAC +AAATAGAAGGATCTTTTGATAGTTCTTATAGCTTGGCTATAGTAAATAGGGAAATAGCAAGAGCTTTAAA +TAAATTATTTCCCGGTAAAGTTGCCCTTTATTCTACGGATGGGTACGGAGATTTTGAACCTAATGTGGAA +TTTTTAAAACGGGATAAAGAAGTATACGAAATGTGGGAACGTTCCTCAAAAGGATATCATGCGGAAATAG +TTATGAGAAATCCTTACCCCCCAAGGATATACGATATGAAAGGGGTTATAAACAGTATGACTTCCTACGG +ATGGGAGGAATCAGAATACCCTAAAGAATATCTTGAAGATTTCAATATATATTTGGACCTTCTGCCCGTT +ACGTCACCTTATGTTGAAAAAGTTATGATTGATAACGGAATAGCCATACCGGTGTTTACGGTAGGACTAG +GAGCGGATCACGTTTTGAGGTTAAAACCGGAGCCCTATCCCTTAAAGACAAAAAAAAGATTTAAGTTCCT +TCACGTATCCTCCTGTTTTCCCAGAAAAGGTGTAGATATACTTTTAGACGCTTACACTTCCGTTTTTTCT +GGAGATGATGATGTTGTATTAATTATAAAAACATTTCCAAATCCCCATAATAATGTAGAAGAACTTATAA +AAAAGTACACGAAAGATAAAGAAAATCCGCCTAAGATTGAATTGATAAATAAAGATATACCTTACGAACA +ACTTGTTTATTTATACCAAGTGTGCAATTGTGTTGTACTCCCTTCAAGAGGGGAAGGTTTTGGACTTCCG +GCAGCTGAAGCAATGCTTTTTAAAAAACCTGTTATAGTTACGAATTACGGGGGGTTTAAGTACTTTTGCA +ATGATAACAATGCTTGGCTCATAGATTACAAGTTTGCAAAGGCAAAAACCCATATGAATTTACCTCTCTC +ATACTGGGTAGAACCGTCTAAAGAAGAATTAATGGAAAAACTAAAGGAGATTTATACAGCTCCAGAAGAA +GAAATAGCTCAGAAAACGGAGAGAGCTTATAAGGATATTATCGAAAATTTCACTTGGGATAAAACTGTTA +AAAGACTAATGAGCGCAATAGAAAAGACTAAAAAGTTACCAGTTTTCTTAAAAAATGATATTAAGGTTGG +AGTGATTAGTTCGTGGAATACCAGGTGTGGTATAGCTCAATATTCTGAGTTTCTCGTAGAAAACCTCTCA +AGAGATATAGAAGTAAGAATCGTAGCTCCAAAAGTGCCGGAAAAAGAAATAATAAATTCATCAAAAGAAA +GCAAAAATGTTAGAAGAGTTTGGAAAAGGGTGGATAATGATCGTGATATTTCAAATATAATTGAAGAATT +AAAGGATGTGGACGCCGTTGTGATACAACATCACTTTGCATACTTTGACACTAATTATTTAGGTAAACTT +ATAAAAGCTTTAAAGGAAAAAAGAAAGAAGGTGTTTATAACTTTTCACTCTCTTTCAGCCCCTCCTCATC +AGGATCTTAGAAATATAAAAGAAAATTTAGCAAAATTGGAAAGGATTTTTGTACATTCTATAAATGATTT +GAATAAATTAAAGGATAAAGGTTTAATCGAAAATGTTGCTCTTTTCCCTCACGGGGTAAATCAAGTGAAA +GTAGATCACGAAACTATAAGGAACTTAAAAAGAACATACGGACTAGAGGGAAAATTTATAATAGGAACTT +TTGGATACTTAAGAAAACACAAGGGTGTTAAAGAGTTAATAGAAGCATTTACTCTTTTAAGAAAAGAATT +TCCTGAAGTACACCTGCTCTTATTGACGTCCCTTTATCCCTCTCAGGATTCCGTTGAGTATTTTGAGGAG +TGTAAAGCTTACATAGTAAATAAAGGATTGGTTAATGACGTTACCTTTATTACGGAATATATACCTGAAG +AGGACATTTATTCTTACATAAGTCTTATGGATGTCGTAGTTTACCCTTATCAATTCACAGGAGAATCCTC +AAGTGCAGCGGTTAGATACGCAATAGCGACGAAAAAAACTATAATTTGCACACCTTTAAGTATATTCGAT +GATGTATCAGACGTTGTAATATTCACCGCTTCTACAGATCCCTACGGCATATATATGAAACTCAAAGAGT +TTATATCCTTCCCTGAAAAGTTTAAAGAATATGAAGAAAGAATGGAAAGGTATTTAAAGGCGGTAAACTG +GGAAAGCTTAGGCAAGCGTTTATCCAACATAATAAAATACTTTACCGTATTGAAACCTAATCTTTGATGA +AGCCTTCCTTTTTTAAAAATTCTAAAATTTTGAGTGCGCTCTCTTCAGGCGTTAGTTTTGTGGTATCCAC +GCGAACTTCTGGAGCTACCGGAGGTTCGTAGGGATCGTCAACACCCGTAAACCCTTTTATTAGTCCTTCT +TTAGCCTTTTTATACAAACCCTTTACATCTCTCTCTTCGCACACTTCAACTGGAGCGTCCACGAAAACTT +CTATAAACTTGCCTTCTTCCATCATATTTCTTACCTGATTTCTAGCGCTTCTGTAAGGGCTCACGAGTGC +ACATATAACAACTCCGTTGTGCTTTACTATCTCCGAAGCCACAAACCCTACACGGAGTATATTGGTAATC +CTGTCTTCCTTTGAAAAGCCAAGCCCTCTTGACAAGTGAGTCCTTACAACGTCTCCGTCCAGCAGAGTTA +CTTTCCTTCCCCTCGCTTGGAGCATGGTAGCTAAGATTTCTGCTATCGTGGACTTACCCGCACATGGTAG +ACCGGTAAGCCACACACAAAAACCCTGTTTATGTTTCGGAACGTAAGTTTCCGCCAGAATTTCTGCAACT +TCCGGCCTTGTGAACCATTCAGGTAATTTTCTTCCCTGTTTCAGGAAGTTTTCTCGAATTTCCGTTCCAG +AGATGTTTATATACTTTAAGTTTCTTTTTTTAGCTTCGTTTATTTCCACATATTGGTCGAGTTCAGGAAC +ATAAACCAACTCTTCAAAAGGTACCATCTTTATTCCTATTTCATCTTCATACTTTTTAAAGAGTTCTTGT +GCTTCATACGGATCGTAAAAGGGTTTTCCTTTAGAGTCTTTTCCGGGACTTGCGTGATCCCTTCCCACTA +TAAAATGAGTAGCTCCATAATTCCTCCTTATTATCCCGTGCCAGAGTGCTTCTCTTGGACCTGCCATTCT +CATGGCTAGAGGCAAAAAGGCAAGAATGGTTTTTTTCTTGTCGTAATACTTTTCGTAAAGAACTTTGTAG +ATACGCATACGCGTGTATACATCAACGTCGCCGGGCTTTGTCAAGCCTACAACTGGGTGTAGTAAAAGCC +CGCCTCCAACTTTTTCCATAGCCCTCTTGGTTAACTCCTCGTGAACCCTGTGCATGGGGTTCCTCGTTTG +GAAAGCTACAATCTTATCCAGTCCCAAGCTCTTTATTTCTTCTCTTACTTGCTTTGGGGTTTTCCTGTAC +TCGGGAAAATCGTAGTACTTTGGAAGCTGAATAACTTTAAGTTCTCCCGAAATGTAGTACTCACCCCACG +TATGCATTTCTGCAACGAGAGGGTGTCTGGGATCCGTTGTTCCGAGAACATTTTTAGCTTCATACTCTAA +ATTCCACTTATAAACCTCTTCCACTCTCATTATCGCTAAGGGAACGTTTTTGGGATCCCTGAGAACAATC +CATTCTCCCTCTTTTAGATCTTTTGCAATTTCTTTTTCCATAGGGAGAGTTATGGGTATGGGAAAAAGTG +TACCACTCTTTAGACGCATACTCTCAACTACGTTTCTGTAGTCTTCCTCTCCCATAAACCTGTCTAAAGG +GGTGAAAGCTCCCACTGCCAGAAGCTTTAAATCAAGAACAGAGCGTTGAGAAATCTGAATCGATTTTAAG +TATTTAATTTTTTCCAAAACTTCTTTTTTCTCCTCTTCATCGGATATAATTAAGCTAACTAGATCTTCCT +TTACCTCTATAAGAATTGAGTATACAATAGAAAATCATGTCTGGAAAGCGTGCTTTAATTACAGGAATCA +GGGGGCAGGATGGAGCTTACTTGGCTAAGCTCTTATTAGAAAAGGGATACGAGGTTTACGGAGCTGATAG +GAGAAGCGGAGAATTTGCGAGCTGGAGACTGAAAGAACTCGGGATAGAAAACGACGTAAAGATCATTCAC +ATGGATCTGCTTGAGTTTTCAAACATTATCAGAACCATAGAAAAGGTTCAACCCGATGAAGTTTACAACT +TAGCAGCTCAGAGCTTTGTGGGAGTTTCCTTTGAACAGCCCATACTTACCGCGGAAGTAGATGCCATAGG +AGTTCTGAGAATTCTTGAAGCTCTGAGAACAGTAAAACCTGACACCAAGTTTTATCAGGCTTCCACGAGC +GAGATGTTCGGTAAGGTGCAGGAAATTCCCCAAACGGAAAAAACGCCTTTTTACCCCAGAAGTCCTTATG +CGGTTGCCAAACTCTTCGGACACTGGATAACGGTAAATTACAGGGAAGCTTATAACATGTTCGCCTGCAG +TGGGATACTCTTTAACCACGAATCACCCCTAAGGGGTATTGAATTTGTGACGAGAAAGATAACATACAGC +TTGGCGAGGATAAAGTACGGACTTCAGGATAAGTTAGTTCTCGGAAACTTAAATGCCAAGAGGGACTGGG +GATACGCACCCGAATACGTGGAAGCTATGTGGCTTATGATGCAGCAGCCGGAACCAGATGACTACGTTAT +AGCGACTGGGGAAACCCATACCGTTCGGGAATTCGTAGAAAAAGCGGCGAAAATAGCGGGGTTCGACATA +GAGTGGGTCGGTGAAGGGATAAACGAGAAAGGAATAGACAGAAACACAGGTAAGGTGATAGTGGAAGTCT +CGGAAGAATTCTTCAGACCCGCGGAAGTGGACATACTTGTAGGAAATCCCGAAAAGGCTATGAAGAAGCT +CGGATGGAAACCGAGAACCACTTTTGACGAACTCGTTGAAATAATGATGGAAGCGGACCTTAAAAGAGTA +AGAGACAGAGAAGTTAGCGTTTAACCTTAAAGCTCTTCAAAGGATTCAGCTATATTTCTGAGCTGGTGCA +TCGTTGCCCTTTTTACCAATTTCTTTGCCTGAGTTTCGGGTTCCTTTTCAAGGAGTTCTAAAATCTTTAG +TAAAACTTGCGTGTTGTAGGATCTTATGCGTGACCAGACGTTTATTGCATCCTTTCTTCCTAGGTGTTTC +TCCCAGAGTTCCCTAAAGCTCCAGAACGGGCGTCTAGGCATGTTTATAGAACCAACCCACAGGTGGGAAA +TTATTACCTTGTTGCCTCTTACTTTATACTCGGGAATTCTTATCCAGTTTTGATTGCTCTTTACCTTTGC +CAGTTGCCTACCCACTACAAGTTGTGTTCCATCTGGGAGGTTCATCTGAAGCGCTACCGAGTAGGCAAAG +GGGTGGGAAGGAAGGAAGAAATAGGTGTTTAAGAAGGAAAATTCATCTCCTAAGTTGTAAATTGCAAAGA +CTTCTCACCTTTCGTCGGGTTTTGCCCTCACTACTATTGCATCTTCTCGGACATCGTAAGGAACTCCCTT +TTTAACGTCGTGGTTGATGAAATCTATAAACGGCATAAAAACAGCCTTTCCCTTAAAGTTTATAGTTCTT +GCCTGAAGGAACATGCGTTTTATATCTTTCCTTTCTTTTTTCCCGAAAAAGTTTTGTAAAAGTCCGGTTC +CGGACAGAATTCTCTTTAACTCCTCTGAAAAGGAGTTAAACTCTTCAACTAATTCCGCCAAGTACCTTAT +TCTTTTTTCCGAGAAAATGTAATCCAGATACTCGTTTATTGCCTGTTTTAAATCTTCGTACTTTAGTTCC +TCTACCCTGTGGTGTTCGTTCTCAATAACTAAGTTTTCAACGTACTGAAGTACGGGAAAGGGGACTTCTA +TGTAGGCTTCCTTTGCATGTCAAGGGCGTAAGCTCCAACAAACCCGTTTTCGTCTTCTATAAAGGTTATA +TTTTCAAACTTCGCTCCGTACTCCTGCGCTATTTGCATCCACTTTTCTACGTTAAACATTTATCTCTCCC +TAATTATTTTTAACCTGTTTAGATTAAAGGCTTTTCTTCCTTTAAAGAGTTTTTCCGCTGTTTTGTTGAT +ATCCTCTTCCTTAACCTCCCTTGCCTTTACAATATTTGTCCCCAGTTTTATAAATTCTTCCCGTGACTTT +AGGAACTTTACGGCTTCTTCTTTCGCCTTTGTTTTTCCTTTTTCTGAGGCAAACCAGAGGAGAATAACCT +CTAAAGTGTTTAAGTGTACCGCCGGACCCTTCGTAGCGTTTGATACTAAGTATGTATCTTCCAGATTTTC +AAAAGATACTTTAAGTATTTCGTCGTTCGGAGGAGTTAGTTCAAAACTTTCGGGAAGTTCGTCTTTTGCG +TCTTCTAAAAGATCATCGTTCACGCAGAGTATAAACTCTCCTGTGGAAAGAACCCTGTAAAAGGCTTTCC +AGGCAGTTTTTTTGCTTTTCTCATACAGAGGGTGCTCCGAGAGTCTTCTCGGTTCTTCCGAGTTTACAAA +GAAAAAGTCGTATACGGGCTCGCTTAAAGAAAGTTTGTGACCTCCCGGAAGTAAAACTTCCCGCCTTAAG +TTCTTTGGAGATTGTCTGGGGATTAGGAAAAATTTGTCCGCTACGCTTTCTATAGCCTTTTCCTGATCTA +CTTCCGGGAATTTTGCGTATATATCCCTTCTTTGTTTTGTGTCCAGGACAAAGTCAATTACCGCCTCTTT +GCAGAGGTTGTTCTTCCCGCACCTTGCGAGCGTGGCGAGGTGAGAGGGAAAGAGAACTATTTCGGGGTCG +TTCATTTCAAGGTTTGCCCTTCCTGCAAAGGAGAGCATACAATCTTTCAGGAGCTCGTGAACCTCGTCGT +GGGAGAAAATTCTGTAATTCTCGTTCGTTATTTCTCTCTTTACAAAATCATCGTTAAACCTCCTTGCCTT +TTCAAGGAAGTAGAGCCTCGTTTCGTTGTTCCTCGCCCAAAAGTAGGAAGGTCTTGAGAGTATAACTTCA +AGGTCAGTTTTCACCTGCTCACTCTCTACCTTCTTTAAAAAGAGTCTTATGAACCTTATGAACTCCTCCT +TCGGTGTGCTTCCAGGTTTTGAGTCGTATTCAATAAAAAGAACCCCTTTCTCCTTCAGGCTATTTCTTAT +AGAATTAGAGAGGCCCTTCCTTTCTTCTTCAAAGGCGTGGGAAAAGGGGATTTCTGAAATGATGAAGTCA +AAAGTCTCCTCCGTTTCTTTCTGCGGTTTTAGGAGTTTTACCTCCGCATTTAGAAAGAGTTTCTCCAGTA +CGTAGAAGTTCAGACTTTTCTTTTCGTTAAAGAAGGCCACCCTGAAATTTTGGTTTAAGTCGGGAGGAAC +TATCCCTGCGTTTACGAGGACGCAGGAAAACCCCGGAAGGCTCAAGTAAGGCTTTACCTGTGTAAACATA +GAAAAAGATTTTAACCTACGGTATAGCCGACCAGACCCTTAGGAATTACCTTGTCCTGATACTTTTCAAT +TTCGGGGTCCTCAAGCTTCTTAAATCCCTCCTGCAAGATTTCTATCACGGGCGTTAAATACTTCTCATAC +CTCCTCCACTTTTCCACCGAGGAGCGGTAAATTCCCTTCCTTACCTGCTTTATGCTTGCGGTTTTTACGG +GTCTCTTCGTCTTGTAGTATTCAAGAACTCGGTCCTCCCAAGGGAGTTCGCAAAATTCTAAAAGCTCCCT +TATTACCTCTTCGGGTTCTTCGGTGAGTCTCTGGTAATCAAGTTCGTAAATCTGTCCGGGGAATAGTTTG +TGCCAGTGTTCCATTATGGCCCTGTGGTCGTTGAGCATGTGTCCAATCCACCTAAGGTCAAAAGCAAAGC +CCATAGTCCCGTGCTTTGCGGCGAAGTTCTGCTGGTAATTAGAAACTGCAACGTCAAGGTCGTTCCTCTT +TAGGTGTATTACCTTAGCGTTGGGGAACATTAAAAGTATGAGTCCCACGTAGTCAAAGTTGTGGGGGAGC +TTGTCCACTATGCGAGGGTGCTCGGAGTCAAGTTTTGCTACCCTGTCAAGGTAATACTGAGCGGCGGATT +TCAGTAGCCTTTCGTCAAACTCCAGTATGGCTTCGGGCCACTCCTTGGGTTCTTTACCGACATACTGCAA +AGCCTTAGGGATTAGGTTTACTATCTTTGGAACAAAGGGAAGCTCTCCCGCGGGGTAGACCATTGAGTGG +CTTCCCAGAATTTGCTCGGTTAAAGTAGTTCCGGAGCGTGGCATTCCAAGAACGAATATGGGTCTCTTGG +AGGGGTGTCCCCTTCCTTTCAGTCTTTCCACCACTTCAGGAGTGAATACCTCTATCGTCCTCTGTATCAT +GAACCTGTGCTCTCTCCAGTCGTAATTGATTTCCTCTTTGACGAGCTCGTTTGCCTTTATTAGAACTTCA +AAAGCCTTGTCGTAATCTTTTCTCTTTTCCAAAACCTTGTGGAGAACAAATCCGGCGCTCGCTCTCGTTT +GCTTCGGAACAGCGGGGGAGTTCAGGAGGGTTTCAAGAACCTGAATTTGCTCATCTGTTGCCTTGTAGTC +TTCCATTTCCACCTGCTGGATAACAGCAGAGGGGTTTATAGCTACTATCTGAGACTGAATTTCCTTTGCC +TCCTCAAGCTCGCCTATGGAAGTGAGAACGTGAACGAGTTCCTGAAGGACTCCCAGATGTGCGGGGAACC +TCTCCTTTGCCTCCCTGAGGAGATCCGCAGCCTCAAGCCCTTTGTTTCTCTCCATTAAGATTTTAGATTT +CAATATGTAGTATTCGGGATAATCTTCCTTGTTTTCTACCTTTTCAAGGTCCTTCTCCGCGGTGTCAAGA +AAGCTTGCCTGAATTCTCAGTTCGTTTAACCTAAAACGCATCTGCATTAAAAACTCATCTTTGTTAGGTG +TTTTTTCCTCGTCAACCCAGGAGGTATCTTCAAGCCACTCCTTTAGCAAAGTGCCTGCCTGATAAGTTCT +TCCCTCCTCCTTTAAAACTTCAATGAGTCCCAACTTTAGCCTCGGGTCGTGTGGGAACTTTTCCGCGCCC +TCTTGGAATACCGCCCTTGCCTCCGCAAGCCTTCCCGCGGTGTAAAGGGTGTTTCCGAGCTTTATGTAAA +CCTCTTCATTCGGGTTTTTCTCAAGCTCCCTGTAGTACTCCTCAACCAGCTCGTCTATCCTGTTTAGAGA +AAGGAGTATAAGCGTTTTTTTCTCCTCGGCTTCGCGAAAATCGGGCTTTAACCTCAGGGCTCTCTCAAAG +AGGTCCAGAGCCTTCTCCAGTTCTCCCTTGTTTAGGTGCAAAACCCCCAAGTTGTATAGGATTTCCACCT +TATTCGGGTTTAAGGAAAGTGCCCTCTCCCAGTAGTGCTGAGCTTCCTCAAGCTTTCCCTGAGAGTAGTA +AAGAGCCCCGAGCCTCGCGTAAAGCGCGTCGTCAACGTCCGAAAACTTCAAAGCTTTTTTTAAAACTCTT +TCTGCGTCTTCTACCCTTCCGAGGAAAAAGTAAAGAAGTCCGAGGTCCGACAAACCTTGGGCGGAGTTCA +AAGAGTTTTCACTCACTTGGGAGAGGAGTTCCTCTGCTTTCTGAGGCTCTCCCGAAAGGAAGTGGTAAAT +ACCGAGGAGGATTTTCCCCTCTTCAGAAGACAAAAGGGTTTGGTAGTTTTCCTTACAGAGGTTTGAAAAG +TCATGCGTGTTTCTGGACTTGAAGAGTTTTCTCAGACGGGAAATTAAAGAACTCATAATAAAAGAAATTT +TATAAAGGAAGGGGAAAAAGGGGAAGGGAGTTAGTAAACGAAGATATCTCCGTCATTAAGGCCGTTAGGA +GCGGTTATGGTTGCTATCACCTTGGATGCTGAAAGTTTAACTGTGTCAAGAATAGTATCCCCATCTGCAC +CATCAGCAACTTTCACACCAAACAGCTTTAATTGTTTATCATCTGTGTCGTAGAAGAAGATTACACCCGT +TTTTGCAGCGTTATTTAGCCCTTTCTTTATAGTAATTGTTCCCCCTTTCGTATATATTTTAATTTGAGCA +TTAGCAGTATCTATTTCTATATTCTTACCAGTAAGGATTAAATCTTTACCTCCACTCGTTACTTTCACAG +CGGTACCTATAGCTTTATTAATAGAAAAGGATGCAGCAGTCACTTTAGAATTAGAGGCGGTTTTATATCC +TATAACTTTAATTTTTCCTGCACTTATATAACCCGACCCTAAAGAATTTACGTTTCCAAATGCACCTTTA +GTAAGGTTTGCTCCTGCTTTGAAATCTATTGCTATCTTTTCGTCTGTAGTATTGGTATCAAAGTCCGTAA +TTTTATCTATCGCTGCGAATGGAGCATCTAAACCAAACACATCTGCACCGTTTCCGCCGGTAAGTGTATC +CTGTCCTTTACCACCCGTTATTATATCGTTACCTGCACCACCTGTTAATGTGTCGTTACCTGCACCACCT +GCTATTGTATCGTTACCTGCACCACCTGCTATTGTGTTGTTACCTGCACCACCCGTTATTGTATCGTTAC +CTGCACTACCTACTATTTCAAATCCTTCTGTTTGGTTAGAAAGATTTATGGTTGCCCCATTAGATCCTGT +TGCAACAATCTTTTCCACATTCTTTAGATTATTGTCTGATGCAGGAGCATAAGTTACCGCTCCTCCTGTC +GTATCTACCTTAATGGTATCCGTTCCGTCACCGCCGTCTATAATATCGTTATTCGCTTCAATGTTAGTAT +CAACTATAACGGTATCGTCACCGCTTCCGAGTTTATAGGTTACATTTGCACCACCACCAACATCATCATC +TCCAACAGTTACACTTCCATTAAGCCCTGTAGCATCAAAAGTAAAACCTGCATCTTTAACATCAACCAAA +TAGAGGGAAAGGTAACTTACGTTTCCTCGGACACTCTGAAGGACGAAAGAAGAGGTTACGAGTACTACGA +AGGGCACGTTGTTCTCACGGAAAGGGGAAAGAAACAATTGAGGGAGTACGGTTTTGAGCTGGTTTCGGGT +ATGCCGGCGGTTGCCTTCATAAAAGTTGAAAAAGTCTCACCCCTTGAGTACGTCCTACAGCCGGTGATAT +TGATTATGAAGTCTGCCTTCAAATCAAACTGAGGTTGAAAAATGAAAAAGCTTATCTTCGGAGTACTCCT +GTTTTCTTTTTCCTTTTCATTTGACCTGGAAAAGATTGTAAAGGAAGCGGAAAGGAATAATCCGAGACTG +AACTACTACTTCCACAGGATAAAGTCAAAGGACTTTTACCTTGAACAAATTCTCTCAAAGTACAAGCCCA +GGCTTTCCGCTAGTGTTTACTACGGTTATCAGGAGTTTAAGCCGTACCTCGGAGAAAAGAAAAAGGCTAC +ACTCAAGTACTTTTACACCGCCCTTGAACAACCAATCTTTTACCCGGAAGTGTTGCAGGAGTACAGACAG +GGAAAAATTGAGAAGGAAGTAGAGAGACTCTACCTTGAAAAGTACCTTCAGGACTTCAGGTATGAACTCC +TCAGGCAGTTATTAACTTATTCATACCTCAAAACTAAAGAAAGATTATACAAAAAAGTCATAAAGGACAG +AAAGAAGATTATAAAAATCCTTGAAAAACTCCTGAAAAAGCGAATATCCACTGAGGTGGAGCTACTGGTT +GAGAAAAAGAAGTTAGAAATGGATGTGTCTGAGTACGAAAAATCAAAAGAGGAAAAGAAAAGGGTGGGGA +AAGTTTTAAGGTTTTATCTCCCTGAGGAAGAAATGGAAAAAATCCCTTCGCTTAACTTTCCTTTAGAATA +CTCGGTCTATGCGAATTTACTTAAGGAACTGAGCAAAAAAAGTGTTGAGAACGTTGATATTAAGATCGCC +CAGAAGCAGTACGAGAATGCAAGGTACGAAGTGAAAAAGAGGAAGTTTGAAAGGTGGCCAAAACTTTCGC +TTCAGCTCAGCTACCTGTACTCTTCAACTACCGCAGTAGCTACGGTATCGAGGGACAAGAGGGCGGCACT +TATCTTAAACGTTCCCATTTACAGTGGAGGATATTACAAGGCACGTGTAGCGGAAGCCCTTGAACTGGAG +AAGGCTTCCCTTTACTTCCTAAAGTCCGTTGAGAAGGAGGTAAAGGTAAGCTACGAGGAAGGTTTGAAGA +ATCTGGAAAAATCTTCTGAGGATATCAAAAGTTATTTAAAGTTACTCAGAGCGGAAAGGGAGTTACTGGA +AATGTACAGGGTTCTTTTCGAGAAGAGGGTAAAGAGTGAACGGGACGTTCTAAATCAGGAAATCTCATTC +CTATACAGAGAGGTTGAGTATTTAGAAAAGGTGTACGAGTTCTTGATCTACTACCTAGATACGCTCCACA +CCTTATCTCAAATAAAACCCGAGGAGATAAAAACCCTTAAGGAATTTTTCGGTAATTGAACTCAGTAGGG +AGGTAGCACACTCCCACGAACTGTTCCTTTTTAAAGCCGTTTACTTCAAAGTTGCATACGTTGTCAATCC +AGTGGTAACACTCCTGGGCATGATCCATGCCTTTGTGGAGTGCCACGGTCAGGGTATACTTTCCTGGAGC +AAGGTTCAAGGGCATTTTAAAGGTAAAAAGGTATTTGCCCTTTTTTAACTCAACTTTCTTTTCCATTAAG +TAGGTGTTGATACCGAATATGTCTTGTCCGAAGCGATCCCTTATGAGTATGCCTGCCACAACGTCCTGTA +AATCTTCTTTTGCCTCCACATCCAGTTCAATAAAAAGCGTATCTCCGCTTGGGAAGTTGTTCGTGTATCC +GTGTTCGCTTTTTAGCCTCACTTCTTTTATGACAGCTTTGAAGTTTCCGTAACCGTTTTGTAAAAAAGTT +ATACCTTCTTTGTTTTCAAGTGAAGCCATAAGTTTATAATAGGCTTGCGTTACCGTTTCAGGGCTCCCCT +CCTCAATTATTTCGCCTTTATGAAGCAAAATAGCCCTGTCGCATAGAATTTTTACAGCATTCATGTCGTG +GGAAACGAAGATTATGGATCCTCCCTTTTGTTTGTGTTCTTTTAGTTTTCTGAAACACTTCTGTTGAAAG +TGAGCATCGCCAACCGCAAGGGCTTCGTCTATTATGAAGCATTCGGGTTCTGTATGAATAGCAATTGAAA +AAGCGAGCCTCATTATCATTCCCGAAGAGTACGTTTTAAGTGGCTTGTTAATGAAGTCATCAAGTTCGGA +AAATTCTATTATACTCTCCAGTTTCTCGTCTATTTCTCTTCTGGAAAGACCAAGAAGGCTTGCGTTTACG +TATATATTTTCCAGTCCTGAGAGTTCGTAATTAAAGCCAGTTCCTAGTTCGAGAAGCCCTACTACCTTTC +CGGATCTTTCTACGAAACCCTTATCTGGTTCCGTTACTCCAGTTATTACTTTAAGTAGTGTTGATTTTCC +TGCACCGTTTGGACCTACTATTCCGAGAACCTCTCCCTTTTCAATCTCAAGGTTAATCCCCTTAAGAACC +CATAACTCTTCGTGAAAGGGTTTCCTGAAGATAATTTCCTTTAACCTGTCCTGAGGCTTTTTGTAGTACT +TGTACTTCTTCCATACATCAAATACCCTTATCATCACGCAAAGTCCTTTATATCCTTTTCAAGTTTTTTA +AAGAAGTAATAAGAAACAAAGAATACCAAAGGTGATGCAAGGAGAAAACCCAAAAGCGAGTACAGGTGTA +AATCAAGGTAATTTACAAATACTAGGTGATGAATACTCACAACGGGATACATAGGATTGTAGTAAATCAG +TTTTTTTACAAAAGGAGGAAGTATATCTAAAGTGTAAACAATAGGCGTAAACCAGAAAAAAATCTGGAGA +AATACACCGATTATTTCCTTTATATCCCGGAAAAATACGTTCAAAGTTCCCAGAACCATGCCTATGGAAA +AGGAGTAAACTATCATGAGATATAGAGCCACGGGAAACAGGTAAAAGTACTTAATACCTTCAAAACCAAG +TGTTATGAAACTGATTAGAGTAACTAGAGAAATGCCTATTAAGTAATTGATAAGTTCGGAAATAATTACC +ACTACGGGAAATACTTCAAGTCTTATTGGTATTTTAGTAAATAAAAACTTTTTTTCTGTAAATATTCCCG +TTATCCTTGAAAGGGAATTGGAAAAGAAAAACCATGGGAATATACCGGAAGACAGATAAATACTGTAGGC +ATAAACGGTATTTTCGTGTCCTAGTTTTGCCCCTATTAGGTGGGAAAAAATCAGAGTGTAAATGAGAACC +AACAATATGGGCCACAAAAAAGCCCACCAGATGCCTAAAACAGTATCCGCATACCTATTCTTTATTTCCT +GCCTTACGAGCTCTAATATAAGAGATAAATTCACTCTTCTAATTTACTCAGCACTTCCTTTAGTTTTTCA +GCATAGAAAATTCTTGCAGCCGTTAAGACTTTTTTCTGGTTTTCAAGTCTTTGAAGCTCAGTATCTACAA +ACACTATAGAGTTGATTAAATCCACAGCTTCTTTCGGAAGCTTTTCGGTGTCGTACTCCTTTCCGTCTAT +ATTTACCTTAGCCATGTTGATTTATTATAACTAAATTTCGGTTAAGTACTTTATTAAAAGCTTACAGTGA +TTTTCCCATGTATATTTATATTGTTTCAAGTTTGCAGGCTTAGGGTGAAGACCTTTTCTGTAAAGTTCAA +GCCACGTTTTTATCGCGTTTGCTATTACCTCCGGATTTTTGGTATTCTCAAAGAAGAAAGCGTTATCTCC +TGCAATTTCTCTGAACACCTTTATATCTCTCGCTATTACAGGAGTATTATTCCTGAAAGCTTCCACTATC +GGAAGTCCAAAACCCTCATCTTCAGAAGCTGCTATAAGAGCTAAGGCTCGTTTATAGAGCTCTTTCAACA +GTTCATCGGACACGTAACCAAACCAGAATAAATGTTTTCCTAAAAATCTATGTTTTTTAATATGTTTTAC +TAACTTTCTTACCTTCCATCCTTCTTTTCCGACGATAACTAAATTTACGTTTATTCCCTTTTTCCATAGA +ATTTCAAAGGCTTTTAACACCTGGAAGTGTCCCTTTCTGGGCTCTAATGTACTGACCATTAAAAAGAAGG +GCTCTTTAGATACTTTTTGAATAATTTCTTTTTCCTTTTCTGAAACTTTTGTTACATTTGGTGCTTTTTC +CGTTTCAGCCCCCAGAGGAAGAACTTTAATTTTTTCTTCAGGAAACGGCAGATTTTTTTTCTTAGAGAAT +TCTAGAATATCTTCTTTAACAGTATTTGATATAGTGAAAATCAAATCTGAAGTTTCTAAAACTATCTTAA +GCCAAATTTCGTGGATTTTATTAAATCTTTTAGGGAAGTATTCTGGAAACTTTATAGGAATCAAATCGTA +AACTAGAAATACTGTTTTTGTCTTCTTAAATTTCAAGTAATCAAAAAAACCGGATTTATAAGCTTCTAAA +GTTAAAAGTGGATAGTAATCGGGAAGGTAATATATATCTCCCTCCCTTATTAGTAATGGTACATCGCTCA +GAGTATTTGTTTGAATTTTTAGATAATTTTTGATAAATTCCCTTGCATACTTTACTGTTACTTTTCCATT +TTCTACAGTTATGTATGAGGGTTCTGCTCTGAACTTTGGGGTAAAATTTTCAAGAAAACAATTCAATTGT +GCTTTTACTACTCTATGTATTCCCGTACCACCTTCCTTTACTCTTAAAAGCGAAATGTCAAAAAAGAGTT +TTCTTTCGTATAAATTTGGATAAAAATTGCTGGCTACTAACTTTGATAATCTTTTAGCTTGAATATCTGT +AGAAATGAAGGATGAAAAAATTTTAATAACTTGCTCTAAAGCATCTTTTCTATATATTTCTTCTATTGCT +TCTACAATTGAATGTGTAAAAAAGTTATCCGAAAATTTAACCCTATTCCTATTAATAAGCCAATACTTCT +TTAGCTTTGTGAAATCTTTTGATAATATAGCACCCTTTGATTTGTTAATTAATAGCTTCAGTAGAGCCAA +CAGGTATAAATCTTTTCTTTCATCTTTTAACAATTTAAGTCCATTCCAACCAAAAGCGTAATAAATGAGT +TTTTCGTCTAACAGATCAAGATTTGCATTTTCCAAATTTTTAGGCAGGATTATCACAGGATGGATGTTGT +CTAAGTAGTCCAGCAAAACATTGTTAAAATTCTCAATCCAAACTACTATCCTGTCATAGGAATTTAATCT +AAACTTCTTGTACTTGGTTATATCTTCGCATATTAATTCGTAATTATTTCGTAGAGTATTACAGAAATAA +TCTAACTGTTTAGATAATTTAGTGTAAAATAGTAACAGCTTTTTCATTTTATGTTCTTAAGCTTTGAGTA +GATTATTTCTTCTTCTAAATCAAGATTACCTTCAAGATTCTTAATGGAAAAGCTTTTTTCTTTTCCTTTC +CAAGTTTTTACTAAATATATAAACACGTATTCTTTTAATTTATCCCTTAATAAGGGAATTTTATTTGCTG +TTGTTATAATTACCCTAAATATGCTTGAAAATTTAGCATTATAAACCAAAAAGAACAGCTTGCCCATAAT +TGAAAAATTATAGCTTAAAATAACCTAATTATGGCAACAAAAGAGAATACAGAAAACGTGCTGAGAAGTT +ATCTGGCAAAGTATAAGAAAACGCTTATAATTGTAGGGCTCTTCAGTTTATTTATCAATATCTTGTTTTT +ACTCCCGAGTATATACATGCTCGCGGTATACGATATTGTAGTTCCAAGTACTAGTGTGCCTACTTTGTTG +GTTATTACAGCCCTTGCAGTAGTTTTGTATTTTGCCCTAGGTTTACTTCAAAGTGTAAGGGCAAAAGTTA +TGCAAATAATAAGTTTAAAGTTAGATTCTGAACTGAATAAAGAAGTATTTACCTCAAGTTTTGAATACGC +AATACGAAATCCCTCAAAAGCGTCTGCACAGCCTATTAACGATTTATATCAACTGAAACAATTTCTTACC +TCACCTGTATTATTTGCAATATTTGATCTGCCCTGGGTTCCTATATACTTCGGTGTACTCTTTGTATTTC +ACGTTTACTACGGAGTGATGGCTATACTTTCCATGGCTGTTATCGTGGCTTTAGCTATTTTGAACGAGTA +CATAACAAAGAAAAAACTAAAAGAATCAAACGAACTACTCGTAAGGAGCACGAACTTTTTAAACAGAGCA +CTGCTTAACGCAGAAGTTGTTGAAGCTTTAGGTATGAGAAACAATTTGTACAAAAAGTGGATGAATTTTT +ACTCAAAACATCTTAGTGCCTTTGAAGAAGCTACAGACAGGAACAACTTCTTAAGTAATTTAACGAGAAT +TTTTCGTATTATGGCTCAATCTTTAATGCTGGGACTTGGTGGATATTTAGCTATAAAGCATGAAATTACA +ACAGGTATGATAGTTGCAGGGTCGATATTACTTGGTAGGATTCTTGGTCCTATAGACACAATAGTAAATG +GCTGGAGGCAAATAGGTAATACTAAAGTTGCATACACTAGGTTAAATGAATTTCTTAAGTTTCTTCGTTT +TAAAAGGGAGGTATCCGTTAAGCTTCCAGAACCGAAAGGAGAAATTGAATTATCAAATGTAGTTGTAGTG +CCTCCAGAAGGAAAAACTCCAGTACTGAGAAATATAAATATGCGCATACTTCCTGGAGAATTCGTGGCAA +TTATAGGACCAAGTGGTTCTGGAAAATCTTCGCTCGTGAGAACTATTCTTGGAATTTGGTTACCTGTTCA +CGGTACCGTGGAAATTGACGGAGCGGATTTGAAACAATGGGATAGAGATTATTTTGGCAAATTCGTAGGT +TATTTACCGCAAGATATAGAACTCTTTGAAGGTACGGTTGCAGAAAATATTGCCCGTTTTGGAGAATTGG +ATTCTGAAAAAATAATAGAAGCTGCAAAGCTTTCGGGTGCACACGATGTGATAATAAAACTTCCTGATGG +ATACGATACTTACATAGGTCCCGGAGGTATTACACTTTCAGGAGGGCAAAGACAGAGGATAGCATTAGCA +AGAGCTCTATATGGAAATCCCAGAATAGTTATTCTGGATGAACCAGATTCTAATTTGGATGAACAAGGAG +AACAGGCACTTTACAATGCGTTAATAGAACTAAAGAAAAGGAAAGTAACAACAATCATAGTGTCTCACAG +AATACGCCTTTTAAACCTCGTGGATAAGATAGCTATTATGCAAGATGGTACGCTAAAAGCTTTTGGAAAG +GCAGATATAATTATTCAGAAATTATTAAGAAAAAATGTAAATTAATACCTCAAAAGCACGGCTCCCCACG +TAAGACCGCCCCCCATGGCGGTCATGAGGATTAGATCTCCCCTCTTTACTTTTCCTTCTTTTATAGCTTC +ATGAAGGGCTATAGGAATGGATGCAGCGGAAGTGTTCCCGTACTTTTGTATGTTTACGAAGACCTTTTCC +TTCGGTATGTTTAATTTTTCGGCAAGGGCGTTTATTATCCTCACGTTTGCCTGATGGGGAATGACTAGGG +AAACTTCCTCAGGTTTTACGCCAGCCTTTTCTAAAACTTCCCTGCAGACCTCTTCCATGCTCCTTACGGC +GACCTTGAAAAGCTCCCTTCCCTTCATCCTTATGTATCCGCAGTTATCCGCGTGGAGGAGTTCCTCCAGA +GAGCCTTCGGCGTACATCCTCGTTGCGAGAATGTCGCTCTTGTCCTCTGACCTTGTTACCACTACCGCCC +CCGCTCCGTCTCCGAAGAGAACGCAGGTGGAGCGGTCCTCCCAGTCAACCGCCTCGGAGAGCTTTTCCGC +ACCTATTACGAGAACGTTTTTAGCCTTTCCCGACTTTATAAAGCTGTCTGCTATGTCCAGAGCGTATATA +AATCCGCTACAGGCTGCCGATATGTCAAAGGCGTAAACTCCCTTCGCCTTTAACTGTGCCTGAACCAAAC +AGGCGGTTGACGGAAACCTCTTTTGTGGTGTTAGGGTTGCGAGGATGATAAGGTCGAGCTCCTCTGGAGA +CAAGTTAGCTTCTCGGAGTGCCTCTTTTGCGGCTTGCGTTGCCATGTAGGTAATTGTTTCCTCTTTCGCT +ATCCTTCTTTCCTTTATACCTGTTCTCGTTGTTATCCACTCGTCTGATGTGTCCACTATTTTCTCAAGGT +CAAAGTTTGTAAGGACGTTTTTGGGCAGGTAAACGCCGGTTCCGATTATTTTAGTCCCCATTTACACCTT +CACTCCTTCGGGGATAAGGGTTTTTAGATTATACACGAGCTTCTTGTTGAAATCCGTATTTAAAAATTCT +CCCGCAACCCTTACGGCGTTTTTAATAGCCTTCGCGTTAGCCCTACCGTGGGTTATTATCACGGGCTTTT +TAGCTCCCAGAAGTGGTATTCCCCCGTACTCCGCAAAGTCCGCCTTCTTTTTAAACCTGTTCAGGGCAGG +CATCAAGAGCAAAGCTCCCAGTTTTGCGAGAATGCTTCTCTTGATCTCTTCCTTTATCATCTGCACTACT +GCAAGTCCCAAACTTTCACTCGCCTTTAGTATTACGTTTCCCACAAACCCGTCGCAAACTATTACGTCAA +AGGTGCCCGCGTATATGTCTCTTCCTTCCGCGTTTCCCTTGAAGTTGAGCTTTGTAGCCTTAAGGAGGGG +ATAGGTTTCCTTTACGAGTTCGTTTCCCTTTCCCTCTTCTTCTCCGATACTAAGTATCCCGACCCTTGGG +TTTTTTATCCCGAGAATCTCTTCCGCGTAAGTGTGTCCTATTACAGCGAACTGAACGAGGTGTTTTGGTT +TACAGTCTACGTTCGCTCCAACGTCTATTAAAACAGTCTTTCCTTTAGGATTGGGAAGTGCAACGCCTAT +TGAAGGTCTCTCTACCTCTTCTTCCGCTCCCACGATGAATTTTCCGACTGCGAGAACCGCCCCCGTGTTT +CCTGCAGAGACGAGACCGTCCGCTTCACCTTTCCTCACGAGCATTCCCGCCACGTAAAGGGAGGAGTTTT +TCTTCTTCAAAACGTTTGAAGGGGGTTCGTGCATTTCCACTTTATCAGGGGCATGAACTACCTCAAGGAG +AGAGTTGTTGTGTTCTTTTGCCTTTTCAAGTATCGGGATTATTTGTTCCTTGTCACCAACGAGGTATATC +TTGTAGCCGAGCTCTTTAGCCGCTAATATACAACCCCTTACTATTTCCAAGGGGGCGTAATCGCCCCCCA +TGCAGTCAACCGCTATCCTTAACATTATTCTGTTTCAATTACCTCTTTGCCCTTGTAATGTCCGCAGTAA +GGGCAGACCCTGTGGGGAATAATTCTCTCACCGCAGTTAGAGCATACAGACAGTGAAGGCAGGCTTCTCC +TGAATTTATTGAAGAAGTTCTGTGCTCTCCTCTGGTTTCTTCTCCACTTGGAAGTTTTCGCCTTCGGGAC +AGCCATCACTTACCTCCTTTCTGCGTTAACAAATTTTTTAGTATAGCAAAAGAACTCTCCTTTTTTGTTT +CCTTTTCTGGTTCTTCCAGTTCAACCGCGTAACCGGGAATTCCCCTGCACTGGGGACTGCAAAGGGGCTT +CATGGGTATGCTAAGAATAATCTCTTCCCTTACGAGGTCCGCTATGTTCACCTTATCAGGTTCTTCCATA +AAGGTAACCTCAAGGTCCTTGGGCTTTAGGTGGAAGGTTCCCTCCTCGTGGGGTATGTTCTGAAGGAGCT +TAGTCTTTTCCTGAGAAATGTCCTTCTCGTAAACTTCAAGGCACCTGCTGCACTCGAGTTCCACGTAACC +TTCCATGGAGAGTCTGAGCTTGTATCCGTTCTTGTCCTTCGTTATCTCCACGTTTACCTTCACGGGTTTT +TTTAACTCTCCTATGTCCGTGGGGAGCTTTACGTCCTTGGGCTGAAGGGTGTAAGAACCCTTAAACCTGT +CCGATATCTTGAAGATTTCCTTAAGGTCAAGAGTAAACATGGCTTTTACCTCTTTGTAGAGTTAAGTATT +AAATTTAATTTAACTGTGGAAACCACAATATTCCAGTTCCAGAAAACTTTTTTCACAAAACCTCCGAAGG +AGAGGGTCTTCGTCCTTCATGGAGAAGAGCAGTATCTCATAAGAACCTTTTTGTCTAAGCTGAAGGAAAA +GTACGGGGAGAATTACACGGTTCTGTGGGGGGATGAGATAAGCGAGGAGGAATTCTACACTGCCCTTTCC +GAGACCAGTATATTCGGCGGTTCAAAGGAAAAAGCGGTGGTCATTTACAACTTCGGGGATTTCCTGAAGA +AGCTCGGAAGGAAGAAAAAGGAAAAAGAAAGGCTTATAAAAGTCCTCAGAAACGTAAAGAGTAACTACGT +ATTTATAGTGTACGATGCGAAACTCCAGAAACAGGAACTTTCTTCGGAACCTCTGAAATCCGTAGCGTCT +TTCGGCGGTATAGTGGTAGCAAACAGGCTGAGCAAGGAGAGGATAAAACAGCTCGTCCTTAAGAAGTTCA +AAGAAAAAGGGATAAACGTAGAAAACGATGCCCTTGAATACCTTCTCCAGCTCACGGGTTACAACTTGAT +GGAGCTCAAACTTGAGGTTGAAAAACTGATAGATTACGCAAGTGAAAAGAAAATTTTAACACTCGATGAG +GTAAAGAGAGTAGCCTTCTCAGTCTCAGAAAACGTAAACGTATTTGAGTTCGTTGATTTACTCCTCTTAA +AAGATTACGAAAAGGCTCTTAAAGTTTTGGACTCCCTCATTTCCTTCGGAATACACCCCCTCCAGATTAT +GAAAATCCTGTCCTCCTATGCTCTAAAACTTTACACCCTCAAGAGGCTTGAAGAGAAGGGAGAGGACCTG +AATAAGGCGATGGAAAGCGTGGGAATAAAGAACAACTTTCTCAAGATGAAGTTCAAATCTTACTTAAAGG +CAAACTCTAAAGAGGACTTGAAGAACCTAATCCTCTCCCTCCAGAGGATAGACGCTTTTTCTAAACTTTA +CTTTCAGGACACAGTGCAGTTGCTGAGGGATTTCTTGACCTCAAGACTGGAGAGGGAAGTTGTGAAAAAT +ACTTCTCATGGTGGATAATCTTTTTTATGAAGTTTGCGGTTTGCGTTTTTCCCGGTTCTAACTGCGATTA +CGACACCTACTACGTTATAAGGGACATTCTTGAAAAGGACGTGGAATTCGTTTACTGGGAAGAAAAGAAC +CTTTCCAAGTACGACGTCGTTGTTCTGCCAGGAGGATTTTCCTTCGGGGATTACCTCAGACCCGGAGCTC +TGGCGGCAAGAACTCCCCTCGCTCAGGCCATTTACGATTTTGCCCAGAAGGGGAAGTACGTGATAGGCAT +ATGCAACGGCTTTCAAATCCTCACAGAACTCGGGCTGCTTCCGGGAGCTCTCCTTCCCAACTTGAACATG +AGGTTCGTGTGCAAGTGGGTAAACCTTAGGGTTGAAAATGAGCGCTCCGCCTTTACGAGGAAACTGGAAA +AGGGAGACGTTTTAAGAATTCCCATAGCCCACCACGACGGGAGGTATTACGTTCCCGAAGAAGAGCTCAG +GAAAATGGAAGAAAATGGACAGATACTCTTCAGGTACTGCGACGAGCAGGGAGAAGTGAAGGAGGAAGTA +AACCCTAACGGTTCGGTTTCAAATATAGCGGGAGTTATGAACAAGGAGGGGAACGTCTTTGGCATGATGC +CCCACCCTGAAAGGGCGTCAGAAGACATTCTGGGCTCTCACGACGGGCTGATGCTGTGGTATTCTTTATT +AAGTGATTAGTCCTGAGCTCGTAAAGGAAGCCTTAAAAAAGAAAAAAGTAAGGAGCGAAGAAGCCTTCGG +CCTTGAGTATCTGAGGTTTAACGACGACTACAAGGACATACCAAGGGGAACCGCTATATTCAAGGACTTT +ATAATCTGGGGCTACCCCCACATAGGAAGGATATTCTTATTGGAAACCGGATTAAGGGAACAATTTGAAG +CCCCTTTCTGGGTGGAGGAAAAGGTTGACGGCTACAACACGAGGATTTTCAAGTACGGAGACAATTACTA +CGCCCTCTCCAGGGGAGGATTTATATGCCCTTTTACAACCGACAGACTCCCGGACCTCATAGACTTAAGG +ATTTTGGACGAAAACCCCGATTTGGTGATTTGTGCGGAAGTAGCTGGACCAGAGAATCCTTACATAGAGG +AAAGTCCCCCTTACGTAAAGGAGGATGTCCAGCTCTTCGTGTTTGACTTCATGAAGAAAAACGAGCAGGG +ATTTCTGAGTCAAGAAGAGAAAATGGAGCTGATAGAGAAATACAACCTCCCCCACGTTGAAATACTCGGA +AGGTTCACGGCGAGCGAAGAAGGCATAAAGAAGATAAAGGAAATCCTGAAGAGGTTCAACGAAGAGGGAA +GGGAAGGAGTCGTTTTCAAAGAAGACAGCGAAAGGAATAAGAGGGCAAAGTACATAACGAGCTACGCCAA +CCTGATGGACATAAAAACGAATGCCAAGAACATGCTCCAGCTTCCGCCAGAATACTACACAAACAGAATT +CTCAGACTCGTTCTCTTTATGTACGAGGAAGGACTTAAAACAACTGAACACCTCTACGAAGAACTGGGCA +GGGCTTTCATAGATGGGCTTTTTCAAGCAATAGAACAGTTTGAAAAGGAACACAAGGTTTACAAGACCTT +CACGTGTAAGTTCAGGAAGAAAGAAAACGCCATAGCACTCCTTGAACTCCTCTCTAAAACTTCCAAACAC +ATTCAGGTAAAGGAAAGGAGACTGGAGAAAGAAGGGGATTACTGGAGGCTTGAGTTTGACAAAGTATTCC +TGAACATGACGGGATTACTCGGACATCTCCTGAGTGGCGGCATAGTTTATGATTAATTAATTCGTAAGAT +GGTGGAGATAAGGTACTTTTCCATTCTCAGGGAGAAGCTCGGTAAAGAAAAGGAAGAGTTTGAGTTTGAA +GGCACCGTATCTGAGCTCAGGAAACTACTACTGAGTAAGTATCCCGAGATAGAAAATATATTGAACTCCG +TTAAGTTTGCCGTTAACGAAGAGTACGTGGATGAGGACTATAAAATCTCCGACGGGGATAGGGTTGCTTT +AATACCTCCAGTTAGCGGTGGTTAAAACTTCTTGGAGGTGGAAGGATGGAAGACTTCTACGTTGAAGATT +ACCTTGTAAAGGGAGATCGCTACTACACAAAAGAGCACGAGTGGGTCAGGGTTAAAAACGGCTTTGCGGA +AGTTGGTATAACAGATTACGCCCAGAAACAACTGGGAGACATAGTTTACGTGGACCTTCCCGAGAAGGGA +AAGGAGGTGGATGCGGGAGACACCTTGGCTAACATAGAGTCCGTTAAAAACGTAGCTCCCGTTTACGCAC +CCGTTACGGGCACAGTTGTGGAGGTAAACGAGGACCTCAAAGACGAGCCGGGGATAATAAACGACGACCC +GTATGAGGCGGGCTGGATAGCTGTTATAGAGATGAAGGATCCCACGGAAGTGGAAGATTTGATGACAGCA +CAGGATTACGCAGAGTACCTCAAAGAAATTGTAGAAGAGGAAAAGGAAGAAGAAGTTGAAGTAAAAGAAG +AGGAATTAATAGAAACCGAGTCCATAGAAGAGTTGTCCGAAGAAGAACTCGGATACGAGGAGAATAAATG +AGTTACATTCCTCATTCGGAGGAAGAAACAAAAGAGATACTCTCAAAACTCGGTCTAGAAAGCTTAGAGG +ATCTCTTTTCCCACATACCAAAAGAGCTTTTTGCAAAGGATTTTTCCTTTCCCGAACCAAAATCCGAGGA +AGAACTCAGGAGAATTTTTGAAAGAGCCTGTGAAGACACGGAATTACCACTTTACTTTATAGGAGCGGGA +GCTTACGACAGAATAATCCCCTCTGTAATATGGCAGATACTCAGCAGAGGCGAGTTCCTGACTCCTTACA +CCCCCTATCAGGCGGAAGCCTCACAGGGAACACTTCAGGCTATTTTTGAGTACCAATCACTTATATGTGA +GCTCACGGGAATGGACGTGGCAAACGCCTCCATGTACGACGGGGCTTCAGCCCTTGCGGAAGCTGTTTTA +ATGGCAAGGGCAATAAAAGGTAAGGGGGACACTGTTGTCCTCTCTAAAGCCCTAAACCCCCTTTACAGGC +GAACCGTAAAAACTTACCTAAGAGGGTATGAGGACAAAATTGTTGAAGTTCCGTACACTGAAGAGGGAAC +AACTGACCTGAACAACCTGGAAGAGGTTCTAAAAGAAAGCGAAGTTCACGCCCTTGCGGTTCAGTATCCA +AACTTCTTCGGCTTTGTAGAACCACTAAAGGAAATAGGAGAACTTTGCAAGAAATACGAGGTTCCTTTCG +TAGTCTTTGTGGACCCAATAGCCCTTTCTATCCTGAAACCTCCCGCGGAGTTTGGAGCGGACATAGTTGT +GGGAGAAGGACAGCAGATGGGAATCCCGCTGTCTTTCGGCGGACCTTATGTGGGATTCTTTGCGACTAAG +AAGGAACACGTGAGAAAGATGCCCGGAAGACTCGTGGGAATGGGAGAGGATATTGAAGGAAAAAGAGCTT +TTACCTTGGTTCTCCAGACTAGGGAACAGCACATAAGGAGAGAAAGGGCAACCTCCAACATATGCACAAA +CCAGAACTTGATGGCTCTTGCAAACCTCCTTTACATGGTTCTCCTCGGAAAGGAAGGTATGAAAAAGGTA +GCAGTTCAGAGTCTCTCCAAGGCACTTTACTTCAAAAAAGAATTAATGAAAAAGGGATTTGAAGAAGTCT +TTACCGGTAAACACCTCTGGGAATTTCCCTTAAGACACGAAAGCCTAAAGGCTATATACAGGAAACTCTT +GAAAGAGAAAATAGTCCTCGGTCTTCCTCTGGATAGATTTTACGAAGACTTAAAAAACACTACATTAATA +GCAGTTACGGAAAAGAGAACGAAAGAGGAAATAGACTCCGTCTTAGCACTTCTTTAGGATTTCCCTTAAT +TTCTTCTCCATCCTTTCAAAGTGCGAACCCTTCCAGAAGACCGCTCCGCACTTGGGACAGAGCGTAAAGT +CCGTAGCCTCTTTATATACCCTTTCCGGAACACTTTCCTTTACCTCTTCCCTGCTCACAAAAAGCAAAGG +AGTGGAGCAGTAAGCGCAGAGATTTAACTTGAGCTCTGGTTTTAAATTGAGAGTTTTTATTACCGTGCAG +AGCTGAACTTCAAAGTCGTGCCTCGGAACTAAGACTGCACGAATTCCCAGTTTATTTAAACGCTCGTACC +ACCTCCTTGAGGTCGTTATAAAAACTCCATCGGGCTTTATCTTATTTAAGTCCACTTTTCCCTTTATAAC +ATGAGCCGGATAACCGAGGAATCTGAGCCATCTGGCGAGCTTTTCCAGGTTCTCCTCAAGGTAAAATTTC +GTAGTCATACTCTTGGGGTTCCTTTTCCTTTACCTTCACCCTGACCTTCGGACACATAACAGCCGAGATG +TCTACCTTTCCTATTTTTCCCACGGCAGGTGCTATAAGACAAAGGCCTAGATCCACTCCCTCTACTTCTG +CCCTTTTACCCGAGCAGGAGAGTAAAAGCAAAGTAAAAAAAGCTAAGATTAACCCTACCATCTAAGTTTT +ATAATATTTCCCGCATGCCAAAACTCTACGTCATCCCAACACCCATAGGGAACTTAAAAGACATAACACT +AAGAGCCTTGGAAGTGCTAAAGGAAGTAAATTACATAGCCTGTGAGGACACAAGGAGGACGATGATACTC +CTGAATCACTACGGTATAAAGGGAAAAAAGTTAATCTCCTATTACGAACCGAAGGAAGAAAAACAAATCC +CTAAGATTTTAAAGGTCCTTGAAAAGGAAGACGTGGCTCTCGTTACGGACGCCGGTATGCCTGCCATATC +GGACCCCGGCTACAGACTGATAAGAAAGTGTATAGAGAAAGGTATAGAGATAGAGGTCCTTCCGGGGCCA +AGTGCAGTTATTACCGCACTCGTGGGCTCGGGTCTTCCCCCAGACAGGTTTCTCTTCGTGGGTTTCCCTC +CCAAAAAGGGCACTAAGGGATTCTTTGAGGAATTGAAGAGCTGTGAGGACACTACCGTTATTCTCTTTGA +GAACCCGAACAGATTACTTAAAACCTTGAAGATTATTCACGAAGTTTTTGGTAACGTTCAGGCTTGCGTT +GCAAGGGAGCTCACAAAACTCCACGAAGAATACATAAGGGGAAACTTAGAGGAAATAATTCAGGAACTCG +AAAGCAGGGAAAAGATTAAAGGGGAGGTTGTAGTACTTTTCAGGATTTAAATTTTTGTATATGTTCAGAA +TTATCATTCTAATTTTTCTGATTTTTACCGTTTCGTGTGAGAAAAGAGAAGAGATAAATATAGCGGTTTT +CATTTCGGGTGATGGAAGGCTTGAAAAAGTAGGGGGATTTATAAAGGGTTTAAAAGATTTAGGTATTAAG +AATATAAAAATAGACTTATATAAAGGAAACAATTCGTTAAAATCTTTGGAAGATTTGGCACAGAACTTAA +ATTTGAAGACTAAAAGGTACAGACTGATCGCTGCGGGGGGAAGCCTTGAGGCGTACATATTGAAGAAGCA +CGGTGTAAATGAGAAAATTCCCGTAGTAATCCTGGGAGGCACTTCCATACTCAGCTGGGGATTGACTGAT +AGTTTTTCAAGACCCTCGGAAAACATAACGGGAGTTAATAACTTAAACGCTGAGCTGATGGAAAAAAGGA +TAGAGCTGTTCACTTACATGTTCCCCGACGTAAGGAAGGTAATAATATTCTGCTCTCCAAAGTTTGAAGC +TTCCAGAAAAGCTGCGAGGATTACCATCAAGACGGCAAAGAAGTTTAACCTGAAGGTGGTGCCCCTTTAC +GTTAAAGACGTAAAAGAACTTGAGTTCGTCATGAGTCACATGAAGGAAGACGGATACGGGGCTGTTATAA +TGACACCGTGTTATTACACAGAGAACTTTCTCACCCACTACATACTCCACTATGCGAACTTTTATAAAGT +GCCTGTGTTTTGTCATTCTCCGGAATTTGCGAAAGAAGGTTGTCCCGTAGCGTACGGCACCCCCGCCTTT +GAGCAGGGATACACCGCTGCCCACGTTGCTTACAAAATACTCAAAGGTATTCCCGTGGAAAACGTGCCCT +TCGTAAGGGCGTATTCTCCTAAGTTCATTCTCAATTTATCCGCCTTAAAGGAACTTTACGTTCAATACAA +CGAAAGAATCCTCGTATACGCAGACGAGGTAGTGAAATGACGTTAAAGACAAAGATCATCTTACTCGTGA +TTCTCCTGACCGCTTTACCTGCACTCCTTTCGCTCCTTCACTACTACTCCATGAAAAGGGAATTAATACA +GAAAGCTCTCGAACGAAACAGGGAAATCGTTGAAAAACTCGCGGACAGAGTGGATATGTACATATCAGAA +ACGCTTCATTCAATAGCTTCAAAGGTGAATCAGTACAAAGGTTACGGGCTTAACGAAAGGGAGATTATCT +GGAAGATAACGGGAGAAGTTTACGGCGTTTTTGAAGGAGCCTTTTACTCCCCCGAAGGAAAACTAATCAC +GAGTGCAAGCAGGGAAAAGGTAAATCCTAATTTTCCAGAAAGAATAAGCCCTGAGGGAAGGAGCAAACTC +CTTTACACCCCGTACCTTGAACCTTACGTTAGGGTACTTTACAAGGACGAAGAATTCGGAATTACGTTCG +GTTACTACATCTTTTCTTTAGACCTTTCTGCTTTCTGGAACAGGCTCGTGAACAGGTACAAAGGTCTGGA +GGCGTTTTTACTGGACGAAAACTCCAGACTTATAGCCTTTCCCGATACTAGATTTTACGACGGAAGGAAA +ATTCCCTTAAGGGAAGGGATTTACAGGTCGGATTTCTTGGGTACGGATGTTATCGGAACCTTTGCAAAGA +GTAAGGGAGGTAAGTGGATCGTTTACGCAGAGGAGCCGTTAATTTACGTACTCTCCCCTCTGGAAAACTA +CAGAAAGGAAGTAATACTCGCCGGATTGTTTACCTCCTTTTCGGGAGGAATACTCTGTCTTATCATCATC +ATCAGGATATTTAAGCCCCTTGAAAATTTCAAAGATTATGTAGTTTCCTGGGCAAAAGAAAACTTGAGTG +AAAACTTAAAACTAAAGGACGACGTTGAAATCTTCTTAAAAACTTTCAGGAGCCTGATTAAGAAAGTAGA +GGAGGAAAAGAAGATATACGAAGCCTTCTTTAAAAACTCCTTTGACGGTGTAGTTTTGTTCGACACATCC +CTGAAAGTTTCAAACGTGAACGAAAATTTCTGTGAAATATTTCAAGTGAAAAAAGACGAAGTCATAGGAA +AGAGTATGGAGGACCTGATAGGTGAAAGATTGCCTTTGAAGAACACCTTTATAAGGGAGGTAGAACTGAA +GTTAGGGAAAAAACACTACTGCAGTTTGAGGCAGGGTATACTCATCATAGAAGACGTGCCGTACGTAGTC +TGGTGGCTAAAGGATTTATCAAAGGAAAAAGAATTAAGGGGAATGCTAGAGAGAACCTCTAAGCTCGCTG +TTGCAGGTGAGATAGCCTGTTCCTTAGCCCACCAGCTAAACACTCCCCTTGCGTCGATTATGGGATATGC +GGAACTCCTGAACCTCTCGGAAAAAGACCAGAGGACTAAGGAAAAACTGGATCTGATTATTAAGCAAGCT +CACAGGTGTAAGGAGATTATAGGAAAGATGCTTTACTTGGGAAAGGTGGATTCCCGACCAGCGTACGTAA +ACTTAGAAGAATTAATCCTTGAAGTTCTGGAAATACTCGAACCTAAAGCGCGGAAAAAGGGCGTTAACGT +AAGGTTCGAGAATGGAGACGCGGGAAAGATTTTCGGTTTTCCATGGCAGATTGAGCAGATATTGATTAAC +ATTTTAGACAACGCAATAGACGCATTACCTGAGGGTGAAAGTATCTACATAAAGCTCAAAAAGGAAGAAG +AATACGTGGTTCTGGAAGTAAAGGACAAAGGAAAGGGATTTGAAGACCCGGAAAAGGCTTTTGAGCCCTT +TTACACTACAAAACAAAACGGAACGGGACTGGGACTTTCCATAGTAAAAACTTTTGTAGAAGGTATGAAC +GGAAAAATTGAAGTAAAAAACTGCAGCGGTGCTTTGGTTAAAGTGTATCTGCCGGAGGTAGCGGAAAGTG +AACGTTTTGGTAATTGAAGATGACAAGGTTTTCAGAGGTTTACTCGAGGAATACCTTTCCATGAAAGGTA +TAAAAGTTGAGAGTGCTGAGAGGGGAAAGGAAGCGTACAAACTCCTTTCGGAAAAACACTTCAACGTGGT +ACTCCTTGATCTCCTGCTTCCAGACGTGAACGGACTGGAAATACTCAAGTGGATTAAAGAAAGAAGCCCG +GAAACGGAAGTAATCGTAATTACGGGACACGGAACTATAAAAACTGCGGTAGAAGCTATGAAAATGGGAG +CGTACGACTTTTTAACAAAACCCTGCATGCTCGAAGAAATAGAACTCACTATAAATAAGGCGATAGAACA +CAGGAAATTGAGGAAAGAAAACGAATTACTGAGAAGGGAAAAGGACTTAAAGGAAGAGGAGTACGTATTC +GAAAGCCCCAAAATGAAGGAGATTCTGGAAAAAATTAAGAAGATTTCCTGTGCGGAATGTCCCGTCCTTA +TCACGGGAGAAAGCGGAGTTGGAAAGGAGGTTGTGGCACGGCTTATACACAAATTGAGCGACAGATCTAA +AGAGCCCTTTGTTGCATTAAATGTTGCTTCAATTCCCCGGGATATATTCGAAGCGGAACTCTTCGGGTAC +GAAAAGGGAGCCTTCACGGGAGCAGTATCTTCCAAGGAAGGTTTTTTTGAGCTTGCGGACGGAGGAACAC +TCTTTTTGGACGAGATAGGTGAGCTGAGTTTAGAGGCTCAGGCAAAACTGCTCAGGGTAATTGAGAGCGG +AAAGTTTTACAGACTCGGCGGAAGGAAGGAAATTGAAGTAAACGTAAGGATTCTGGCCGCAACTAATAGA +AACATTAAAGAACTTGTAAAGGAAGGAAAGTTCAGGGAAGACCTTTACTACAGACTCGGAGTTATCGAGA +TAGAAATACCACCTTTGAGGGAAAGGAAGGAAGACATAATCCCTCTCGCCAATCACTTTCTGAAAAAGTT +TAGCAGGAAGTACGCAAAAGAAGTGGAGGGATTCACAAAAAGTGCCCAAGAACTTCTACTAAGTTATCCC +TGGTACGGAAACGTGAGGGAACTCAAAAACGTAATTGAAAGGGCTGTACTCTTTTCCGAGGGAAAGTTTA +TAGACAGAGGGGAATTGTCCTGCTTGGTAAATTCAAAAGGGATAAAAAACAAACACAAAAGTATAAAGGA +AATTGAAAAGGAAGAAATAATAAAAGTCTTGAAAGAGGTAAATTTCAATAAAAAACTTGCTTCCGAGATC +CTTGGGATTCCCTTAAGAACTCTCTACAGGAGACTGAAGGAGTACGGAATAGAGTAATTGTCAGACTGGC +AAATTTTTGCCAAAATGGCAAAAATCCCTTCCTCTAACCCTTGATTTTCAAGCTCAAGAATTTGGCACAC +TACTTGCATTTATCCGTTCAGGAGGTGAGAGATATGAGGAGAAGAGACTTTTTAACCTTAGGTGCAGCTT +TTTTACTTACCGCTGCCGTACCATCATTTTCAATTGAAAGACTCTCTTTCAAAGATCTCAAGAAAAAAGC +GGAGATCGACGTGGTTTACCACGCGGACTTTCCTCAGGAAAAGCGTTTCAAGACTATGCTGAGGAACATA +ACAAACCACCTTTCCGTCTACAACTTCGATCCCTTTAAGGTTCACATCGTCGTTGTTGCACACGGAGCTG +GGGCAAAGTTCTTCCTGAAAGATCTTAAAGGTACAAGGTGGGAAAAGGAACCTATAGATCAGAAAGCTAT +AAAGGCTAAGCTTGAAGAGCTACAGCAGTACGGTGTAGAGTTCTACGTTTGCGGGATAACGGTAAAGAGG +CTAAAACTAAAGGACAAGCTCTACGACTTCGTAAAGATAGTTCCCTCGGGTGTTGGTGCCGTTGCACATC +TTCAAAAAATCGGTTACGCCTACATAAAGGTTCAGTAAAGGAGGAGGGGCTATGAAGAAGTACATCGTAC +CTCTCGGAATTTCCCTTCTCGCTCTTTCTACACCCTCTCACGCCATAAGGATATGGAGTCCTTCAGAAAA +CCAGTTCTTAGATATATATAAACTTCCTTATACAAACTTGGCTGAGATACCAGGAGATAAGCGATAAAAA +CAGACCTAACTTCATCAAAGGAGACAACAGGACCGATTTTTCTTTCAGGAGAATAAGGGTAAGGTTCGGA +GGAAGTTTAAACAAATGGTTCAAGTTTAATTTGGTAATAAGGCTGAACAACGTGGGAAGGGACGCATACC +TCGCACCCTTCGGAGGTCAACCTGCGGGGTACAAAAGACAGGGTGAACTTTTGGGAGGCAGGAACTTCGC +GCTCCACGAACTAGATCTGAAGTTTGCACTTCACGAACTCCTAGAAACGAGAGGTTGGATCTGGGATCTA +CACTTGGGTTTTCCTAGAGTTCCGCTTGGAAGAGAACAGTACGGAAGAACAGGATTCGACAACTTGGAAA +GTGACAGAACATTGGCAACTCTCAGGTGGACTCACTTCACCGTTGCAAACGTTACGGGGCGTTCTTACGG +TGCGTACTTACACGTGAGGAAAGGAAATAAGGCTAAAGGTTTTAAGAGGATTACTTGGGATGGTTTTCTC +GGAATCTTTGACGGATTTAAAGGAACTGATCAACCTTGGGATGAAACGGTGAGGGGAACGGATGCAAGCC +AGTACGGTTGTAACGCAGCATGCCTATCCCAACTAAGGATGTAATTCCAAAGACTCCTTCCTGTACACTT +TCAGAACGACTCTAATGTTTGGAAAACCGGAAGGGAAACCTAAAGGACTTAACTGGCTTTACAGGGACAC +TTACATAGGAAAGAGGAAGGGAATAACCCTTGGTTTTTCCTTTGCTATGCAAAACGACATAGATCAGGAA +CTCATATCAGACACACAGGGTCCGGCTCCAGGGATAAACGGACAAGGAAAACCTTCTCCAGGTGCGGGAA +GTGTACAAGTAAGGGTGCCGTATATGATACTCCCGAATCCCATTACCACTCCCGAAGTGAGAAATCATCC +GGTAGATATGAGGATGTACGGTGCGGACTTAGCAATCCACTACGGTCCCTTATCTTTCATACTCGAAGCT +GGACAACACCAGTTTAAAAACGTTTTCTTAGACGCACAAAAACTTAGTGAAGACTTTAAAAACAATTGGT +TCATAATAAAAGGAGCTTACGCCTTAAATCCCAAGAGCACTACAGTCTTTGAGCCTTACGTCAGTTATTA +CATATGGGATCCGGATATAAAGGAAGATTCAAAGGGTAGGGCTTACGGTGATGCGGCTAACTTTATCAAA +GGAAACAAAGCCGGCAAGGAAAAGGCAACATTAGGAAAAATATCCGTGACATCTTTAGGAGTAAACATCT +GGTATACAAAAGCGAAGCTCATGAGCTTAACCTTTGAGTATCAAATAATAAACGAAGAGAGAAACGAAAT +AACGCCTTTACCGTTCAATTCCGCTTTGTCTTTTAGCCGGCACCTTCCTTTAATCTTTCTTCGTTTCTGT +TCCCAGAGCTTTCCTAACTCCAGTCCATACCTTAAATATTGCCCCTTCTAAAATCTACGTAAATGGCGTA +TAGTGCGGGCACTATTATAAGCACTATTACTATTGTCGAGAGTATACCTCCTACCATAGGTGCAGCAATT +CTGGACATAACCTCGCTTCCCGTGCCGTGTCCAAGCATTATGGGAAGGAGACCTATGAGAATAGCCCCGA +AAGTCATAAACTTGGGTCTTATCCTCTTGACAGCTCCCTTGTATATAGCTTCAAAGGCATCTTTTTTACT +CCTTATTTCGCTCTCTTTCAGGGCGTTTTGTATGTAAACCACCATAACTATTCCCATTTCTGCCGCTATT +CCGAGGAGTGCCAAAAATCCAGCTATCGAGGCTATTGAGATGTTGTAGTTGAGAAGGTACATGAGCAGGA +CTCCGCCGAAAGTGGCTATCGGAAGGGTTATGAGAACGAGGAAAGTCTCAAAGAGTTTGTTGAAGGTAAA +CCACACGAGAAGGATTATCAGGAGTATTACAGAAGGGACTATGACTTTCAGGTTTTCCAGAGCTTTTTTC +CAGTACTCGAACTGACCGCTCCACTCGTAGTAGTAACCTTTTGGAAGTTTTAAATTCTCTTTAAGAACCT +TTTCAGCCCTTTCAATTACGGTTCCCATATCCACTTCCGGGTCGGGTGTTACGAAGACGTAGCTAACGAG +AAGACCGTTTTCAGACTTTATACTGGAAGGACTTTCCTTTACGACCACGTCCGCCACTGCGGAAAGGGGA +ACGAATTTATCCTTCATAGGAATCGTAAGCGTTTCCAACTCGTACCTGTAGTCCAGAGGAATACCTAAGG +TTACTGAGTACCTTTCCCTTCCCAAGATCACAGTACTGATTTTCTTATTTGCAAAGAGTGTTAAAATGGC +TTCGTTCACGTCTCCCACTGTAAGACCGTACCTATCTAATTCTTCCCTCTTCGGAATTATCTCAACGTAC +AGGGCGTTTGCGGAACGCTCTCCGAAAACGCTCATAATCCCAGGAACGTCCTTCAGTAGTTTTTCTATTT +CCTGAGCTACTTCGTTTAACTTATTCACATCATCTCCGTAAACTTTTATACCGAGCGGTGTCTGTATGCC +CGTGGTAATCATATCTATCCTTCCCTTTATGGGCATGGTCCACATGTTGGAAAGCCCGGGCAGGGATATA +GCCTTATCCATTTCCCTAATTAGCTCTGCATAAGTTAAAGGTCTTTCCTCAGGGAATACTTTCCTCAGGA +TATCCTTTATAAATTCGGGGATTTCCCAGTCGGAATAAAATCTCTCAACTTTTACCTTCCTCCACTCTTC +CTGAGGCTTCAGGGTTATGAAAGTCTCTATCATGGACATGGGAGCGGGATCGGTGGGTGTGTTTGCCCTT +CCCGCCTTTCCGAGAACGGACTCCACTTCCGGAAACTCCTTCAGTATTCTGTCCTGAATGTTCAGTATTC +TGAGCATCTCCTGTCTCGATACGCTGGGCACCGTCGTTGGCATGTACATAAGGGTTCCTTCGTTGAGGGG +AGGCATGAATTCTCTGCCAAGTTTCTCGTAAAGGTAAAAGGTTGCAACGCCCATAAAGATGAAGAGGATT +AAGAGAAGGTACCTCAGTTTTATGGAAATGTGAAACACGGGGTCGTATACCTTTATAAGTAATTTAACGA +GGGGATTTTTCTCCTCTCCGGGGATGCGTCCCCTTATAAAGTAGTAGGCTAATACAGGTACAACGATAAC +CGATATTATGGAGGCGATGAGCATTGAGAGGGTCTTTGTTGCAACGAGGGGTTCAAAAAGCCTTCCAGCC +TGTCCTTCCAGAGCAAAAAGCGGAACGAAGGAAACGGTAACTATCAAAAGGGCGAAAAATATGGGTTTCC +CCACGTCTTTGGCGGAATGAACGATGGCGTCCCAGAGTTTTTCCCCCTCTTCAAGTCTCCTGTGTATGTT +TTCTACGAGAACAATCGCGGCATCAACCATAGTCCCAATCGCAATCGCTATACCGCCGAGGGACATTATG +TTCGAAGTAATGCCGAGATGGTTCATAACGGCAAAGGTGGTGAGAATGGAAAGTACGAGGAATATTATGA +TTACGAGCGCACTCCTTACGTGAAAGAGGAATATCCCCACTATCAGAAGGACGACTACAGACTCCTCTAT +GAGCTTCCTCTTCAGGTTTTCTATTGCACTTTCTATAAGCGTTGAGCGGTCGTAAGCGGTTAAAACCTGC +ACGTCCTCCGGAAGCCCCTTCTTAACTTCTTCCAGTTTTTCTTTTACCCTTTGTATAACTTTGTACGCGT +CCGCCCCGAAGCGCATAACGACTATTCCCGCAACCGTATCCCCCATACCGTTGAAGTCCGCAACTCCCAT +CCTGAAGGCGGGAACCTCTACGACCTTTGCCACATCTTCAAGCCTTATGGGTACTCCGTCCCTTTCCGCT +ACTACCGTTTTCTCTATTTCTTCCCTATTCTTTACGTATCCAACTGCTCTTATAAGGTACTCCTTCTCGT +TTATCTCCACGTACTTTCCGCCGGTTTCAACGTTGGTCCTCTTTATAGCCCTGTAGAGTTCTCCCAGAGA +TATTCCGTACTGGTAGAGCTTTTCAGGCTTTACGAGAATTCTGTACTCTTTTTCAAAACCCCCTACGGAC +GCAACTTCCGCAACGTCCGGAATAGAGAGGAGTGCGTACTTGATATAGAAGTTCTGGAGTGCCCAGAGTT +CTTCTAAGGTTCTCTTTTTGGAGACTAAAACGTACTTGTAAACCCATCCGACACCCGTCGCGTCCGGACC +AAGTTCAATCCTCGCATCTTGTGGCAATTGACTTCTTATTGAAGAGAGCTTTTCCAGAACTCTGCTCCTT +GCCCAGTAGAGATCCGTTCCGTCTTCAAATATCACGAAAACTAAGGAAAAGTTCGGAAAGGAGTATCCCC +TCACGGTCTTTACCTTGGGGACTCCCATCATGTTAGTCACGAGGGGATAGGTGAGCTGGTCCTCTATAAC +TTGCGGTATCTGCCCAATCCACTCGGAGTATATAATCACCTGAACGTCTGAAAGATCAGGTATTGCGTCT +ATGGGGGTCTTCTTAAGGGAATAATACCCGTAAAACAGGAGAAAGATGGATATAAAGAGAATAGGAAGCC +TGTTTCTCAGGAGTATTTCGGTAAACCTTTCCATGGGTTATCACCTCAGTTCTTTTTTCATAAGCATAGA +GTTCAGGGCTACGATTACGGTGCTTGCACTCATGAATATCGCTCCAACCGCAGGTTTGAGAACAAATCCC +CACGGATAACCGAGTCCCGTGGCGAGGGGCAAAGTAATTACGTTGTAGCCGACAGCCCAAAAGAGGTTCT +GGAGCATCTTGCTCACGGTTACTTGAGAAAGCTTTATTACCTTCACCACGTCTCTCGGATCGCTCTTTAC +GAGAATTACGTCCGCACTCTCTATGGCTATATCCGTTCCCGAACCTATTGCTATACCCACGTCCGCCTGA +ATTAAAGCGGGAGCGTCGTTCACACCGTCTCCAACCATAGCCACGCTGTAACCCCTATCCTGAAGCTCCT +TAATCTTTTGAGCCTTTTCGTGGGGAAGAACCCTAGCAAAATACTCGTCCATTTCCAGCTCTTTTGCCAC +GTACTTTGCAACCTCTTCGGAATCACCTGTTATCATGACTACCTTCTTACCGAGTTCCTTTAAACTTCTT +ACCGCTTCGTAAGATTCCTCTTTTATCCTGTCTGCCAAGGCTATTATCCCTGCTAGTTTCCCGTCCATTG +AGGCGAAAACCACGGTTTTACCTTCCGACTGCAAACTCCTTGCCCTTTCTACGAGTTCCTCATCGAGCTT +TACGTTAATTTCCTTTAAAAACTCAAGCGTTCCCACGCAAACGTTTCTGCCCGACACTTCTCCGCACACA +CCTTTTCCGGGAAAAGCTTTGAAGTTTTTTACTTCTTCTTTTTCCTTTGCGTAAGAGACTATAGCTCTCG +CTATTACGTGTTCCGAATGGTTCTCAACACTCGCAACGAATTTTAAAAATTCTCCTTCTTCAATATCCTT +CGTAATTACTTCCGTAACACCTAACTTACCTTCTGTCAGGGTACCTGTTTTGTCAAAAACTACCACGTCA +ATGTCTTTCGCCTTTTCCAAGGCAAGCCTGTTTCTCACGAGTATTCCGTTTCTCGCTGAATAGGAAGTGG +ATATGGATACGACCAAAGGTATGGCGAGTCCCAGAGCGTGGGGGCATGCGGTTACCATGACCGTTACAGC +CCTCTCAACGGCAAAGTTTAAATCTCCCAGGTAATACCACCAGAAGAGGAGTGAAATGGAGCCCAGACTT +ACGGCTATAACGGTAAGGTAAAAGGCTGCACGATCCGCAAGGCTCTGGAGTTTCGTCTTTGATTCCTGAG +CCTCTTTAACGAGCTTTATCACCTGTTTTAAGTAAGTTTCCTCTCCGGTCTTCTCTACGCGAACTTTAAT +GGAACCTTCCAAGTTTACGGAACCACCTATTACTTTATCCCCTGGCTTTTTGGGTACGGGTCTTGACTCT +CCAGTTAACATGGATTCGTCCACGTGCGTATTCCCTTCCACTACGGTTCCGTCCGTCGGTATCTTTTCAC +CAGGTCTGACAAGAACTAAATCTCCCTTTTTTAATTTCTCCACGGGAACGTCAATCAAGCCCTTTTGTGT +AACGAGATGTGCCTTTGAGGGGATTAGCTTTACAAGTTCTTCTAAAGCCCTCCCCGCTCCGAGTACTGAC +TTCATTTCCACGTAGTGACCCCAGAGCATTACCACGATCAGGGTCGTAAGTTCCCAGAAAAACTCCTTTC +CTCCGAAAAAGAAAGTGTAAACGCTGTAGATGTAAGCCACACTTATCGCAAGACCCACAAGGGTCATCAT +TCCCGGATTTTTCTTTTTTAATTCTTCTAACATTCCTTTCAGGAAGAAAGTACCGCCGTATATAAACACC +GCTGTGGAAAGTAGTAGAATTACCCAGTTAGAGTAAGGGAAGGATACTTTTATTCCAATCAATTCCTGTA +TACTGGGAGAAAGGACAACTACGGGAACGGTTAAAATCGTGGTTATTAAAGCCTTTCTCTTAATAATTTC +CGCGTGATGTGCATGTTCATGTTTTTCACTTTTTCTTTTTAATTCGTGTTTGTGTTTATCGTGATGTTCG +TGCATACTACTCCTCCAAAAATAAAGGGAAAAAGGAAGAGAAAATTACTTTTTCGTTCTCTTCTGGAGTT +TTTCCATAAGTTCCTTCATACACTTTTGCCTGTGTTCTATTACAATCTTCATGGTTTCCGGATCCATCAT +CTGCATGTTCATCATTCCCATCATGGGGTTCATACCCATGTAGGGCATACCCATCATCGGCATCATGTAC +ATCATCGGCATCATAGGCATCATGTAAGGGTAGTAGTACATGGGCGGAGACATCTGCCTTTCTTTCGTCA +TTCCTCCCATCATTCCTCCACCCATCATGTCCATATGAGCGAAGGAAATGGAAAGTCCGAGTCCTGCAGC +AACTAAAAACTTCTTCATGACACACCTCCTTTATTCAATCAGTTCGTAAACTTGCTCTTCCTTTCCCCAC +CCGCTGAGAACACCGTGCGGGGAGTAAACACCTCTCGCTTTTTCACTCTTCAAAAGTTCCCTTATGCCCT +CTGCGGGCACGTGTCCCTCCACAAACTTTCCGTTTATCACCATCGTGTGACACGAACGTTTGTCTATGGG +AACCCCAAGTTCATCCTTCTTTCTCAAAACCTCCCTCGGTTTTAGGGCAACTCTCTTTACTTTGAAACCT +TTACTCTCGAGTATCTGGAAGTATTTGTGACAACAACCGCAGTTTGGATTGTAAAAGGCCGTGAGTTCAA +ATGAAAAGCCAAAAGAGAAGAGAAGTAAAAGACTTAAAACTCTCAACATATTGCACCTCCTTTCAGGCGT +TTACCCTGTAATTGACCATCATCCCCTCGTCGTGGTGTTCGAGAATGTGGCAGTGAAGAAGGTATATCTG +GTGCTCGTTATAGGGATGGCTCATGTCCACCGCTATTCTTACCGTTTCCATGGGAGCTACTATTACCGTA +TCCTTCCAGCCGAGGTCCGTAGCCCTCAAAGGTCCCAAGCTCCTTTCTAGAACTTGAAACTGAAAGCCGT +GTATGTGCATGGGGTGGTACATACCCGTGTTGTTTACGTACTCTATAATCACCACGTCGCCGTTGTTCTG +TTCAAAGAGAACCTTCGGATTGTTTATGTCCTGCGGATTTGCGTAGCCGTCTTCCCACGTTTCTCCGTTA +ATCGTGAAAACCATTCTCCTCATGCCTAGAGTTATCCTTTGAACTTGTGCACCGTCTGTATTTATAGGTG +TTACTTCTGAAAGACGTTGAGGAATACTTTTGTCGTAAGCAGAATCCTTTGTAACCCTGAACTCCATAAC +TTCAAACTCTGAGTTATCTGCCATACCCATATCCATATTCATTCCATTTCCCATACCCATACCTCTTTCC +ATTCCCATTCCCATTCTCATTCCAATCATTCCCATTCCTATTAAGTTGTGAGGGAAGTTGTAAAGCTTTA +TTACGTCATTTACGCTTGCGTCCCTGAAATCTACGAGGATGTCTATTCTCTCTCCCGGAGCTACTAAGAT +TTCATTAACCTCCTTCGGAGTGTCCAGCAGTCCTCCCTCCACGCCGATTACCCAGAACCTCATCCTTTGG +TTTCCTCTGAGGAGTGCAAGCCTGTAGGGCCGTGCATTAGAACCGTTCAAAATTCTGAACCTGTAAATCT +TTCTCTCTACGTCCATATAAGGGTTTGGCGTTAAGTTCACGAGAATAGTGTCTCCCCAGAAGCCCATGTG +TCCCATCGGGTTGTAAACGAGCTGTCCACTGGAGTCAAAGGTCTTGTCCTGAATTATGAGCGGAATGTCT +ATAACTCCGTATTCGAGATCGAGAGCCTGTTTTAAGTTATCCTCATCCTCGTCCTCGATTATTATCATTC +CCGCAAGACCGTAGTAAACCTGATAACCCGTCCTTCCGTGGGGGTGGGGGTGGTAAAAGTAAGTCCCGGA +GCGGTCTATAATCGTAAAGTCGGGGTAGGAGTAAGTTTCTCCGTCTTTTACGGCGTAATAGGGATGTCCG +TCGGACTTCCAGGGAGCTCTAAAGCCGTGCCAGTGTATTATTGAGTCTTCTCCGGAGTTATTCACAAAGT +CAGCACTGAAAGTTTGCCCCTTTCTGAGAAATATGACGGGGTTGTACTCATTATCAATCTCGTAAACGAG +CATATCCGTCGACTTTCCGGGGATTACCTCAAGGGTTGTCCACTTTGCGGTTATACTTACTCGCTGTCCA +TCGGGAAAAAGGAAGTATCCGGGGATATTGAGGGATTGTTTACTCAAAGTTCCGCTGCCCTGACCCGAGG +AACTTCCGGTTGTACCACCCCCTCCGCAGGAAAGGAGGGAAAGTCCCCCAACCGAAAAGCCAAGGGCGGA +AAAGAGAGAAGTTTTTATAAATTTACGCCTGTCCATAACTTACCTCCTTTAGTGGTGGTGATGCATTTGC +ATTTGTTTGCCGTAAAGCCCTTTGATTTGTGCTTCCGCATCGAGCAGGAATGTGCCCTTTACCACAACTC +TCTGTCCTTCTTTCAGTCCGTGAATTACCTCGTAGTAGCCCTCTCCTCTTCTTCCGAGCTTTACCTGAAC +GGGCATGTACATTCCCTTTTCCATCTCTACAAAGACGAACCGCCTCCTTCCCGTATCCACTACAGCACTT +TCCGGAACTGCAATAACCTCGCCTATCGGCACTTCAAAGGAAACGTTTACGAGTGCGTTAGGCTTAAAGG +TGAGGTTTTCGTTCTTGAGTTTGAGCCTGACCTTCAAGGTTCTGGAGAGTTTATTCACCTCAGGGAATAT +GTAGTCCACTGTAGCCTGAAACTGGGTGCTGTCTCCTTCCGGACTTACAAATGCCTTAAGGCCTTTTCTT +ATGTAGCTTGAAAAATGAAGGGGAACTTCCGCAACTATCCATGCGGTGGAAAGATCTGCAATCCTGTAAG +CGGTTTGACCTTCCTTCAGGTACCCTCCCTCGTAAACTTGTTTTTGGAGAATTACACCGTCAACGGGAGA +ACGTACTACACTTCCTGCCTTTAAATACCTCAACTTCCTTAAAGCTTCCTTTATGAGTTTTTCGTCGCCT +ATTTTTTTTGCAAGTTTATACTCCCTTTTGGCTATCTCTATATCGGGGCTAAGCACCTTCATTAGCGGTG +TTCCCTTCTTGACGTACTCTCCTTCAAACCTGCCGTAAGTTTTCTCAACCCAAGCGTCGGCCCTTACGGT +TATGTCGTAAACCTTTTCCCTGTTGTAGTCCACGTAACCCACGGTGTAAAAGCGTCTGACCAGAAACCTT +TTCTTCACGGGTTCGGTTATAACGCCGAGAAGTTGAAGTTTTTCCGGAGGAATCATTATGTGTCCCGAGT +GTTCCATAGGCTTCGTTTCCTTTGCGGTTTCTTTTGACAGGGGAATGAAAACGTTTCTCGTTATCTTCGT +TCCGTCTGCAAACATTATCCTTATCTCCCACGGACCGTCCATACTTATGTTCACAAAACCCTCGTAAACT +CCCTCACCCTTTTTCTCCAGTTTTGCGACGTCCCTCATCTCGTTCATACCGGGCATCGGAGGCATGTAAA +AGTAGAACTCCTTTATCTCCTTTGGGGGCTTTACCTCAACCCTTATTTCATTCCCTCCCGACTTTATCTT +TCCATCTTTTGAGTAGATAACAACCTCCACTTCCTTTTGCTTTAGTCTTATTACTTCCTTATAATCTCCA +CCCAAAAAGGCAAAAACTACGTTAATGAAAATAAGAAAGCTTAAAATTCTCATATTAGCGCCTCCGCCTC +AGCAGAAATTTCGTTAAGTTTTTTCAAGGTAAAAGCCCTCTGGATTTTTAACTTCCAGAGATCCCTGTAA +GCCCGGATAATTTCTCTAACATCAACTTTTTCGTACCCATAGGCTAAGAATAGAGCTTCTATTTCTTGTT +CTTTCTTCTTTATTTCCTCTTCCAGAGTTTTTAACGCCTTAAGTGTTATGTTATACGACCTCTTTAATCC +AAGAAACCTCTCTTTTACGAAGTTTTTTGTAAAGTTAAGCTCCTTCATTTTAGCCTTTATCCTTTCCTTT +GCTTCAAGGACCAAAAACCTTTCCCTTTTCTCGTACCAAACAGGAAGGGAAACTCCAATTCCCAGAGAAA +AAAGGTCCGGATTTCCCGTTCTTACAACGTACTCCGCGAGCAAGTTCAAATCTGGATAGTGTTCAACTTT +TGCCCTTTCCAGTTCTTTCCTTAGAGTGTTTAATTCCTCAAAGAGGAGTCTAACGTAAACGCTTTCATCT +TCGGAAAAATTCTGGGGAAACTTAAATAAACTCAATCTTCCAGGTCTTAAATCAAATTTACCGCCGATTA +GAGAGTATATTTCACCCTTTATCTTTTCCCTTAACGCCTCGTTGTTTTTAAGTTCTTCCTCCACTTTTAT +TATTTCCGTTTTGACCATTAGAATATCCGAAAGCAGGGCTTTATTTTGAGCGTACTTTTCCTTCAAATTT +TCAAGGAGAATGTAAAGGTCTTCTTTTATTTCCTTGAGTATTCTTTCCTTTTCGTAAGTGTAGAGAAAAT +CGTAGTAAAGTATCTTTACGTTTTTTATTAGCTCTCTTTCGTATATTTCTCTTTTTACCTTTACCTCTTT +TGCCCTGTTCTTAAAAATTTCGGAACTCTTTTCCCTTTTTACCGGAAGTGTGTACCTCTGCATAAAGGTT +ATTGCGTAACCGCTCATGGGATTTTCCTCTCTTACCATTGGAACTTCCGTATCAAAATTCCTGAACGTGA +ACCTGATTTCGGGATTTGGTAAAGATTTCATAAAAAGACTTCTGAAAGTATTAGCTTTTTCCAAATAAAC +GAAACTTTTTAACTTTGTATTGTTCTTTAAAGCAAAGTTTATTAATTCTTCTAACTGGGAAGAAAAAACA +AAGTTCAAGGAAATTAACACAAAAATCAGAAAATGCATACGTAAATATGTAAAGTTCTCCTTGTGTTAAT +TCAAGATTTAAATTCAATTTAAGAAAATGTTAAAATTCAGAGAAAAATAACCATATTATCTCTGTGGATT +ACTTCGTCTTTTGTTGTGTTTAATAGTTTTCTAACTTCACTCGTTTTTAGACCTTTTATCTTTTCTATTT +CCTCCGAAGAAAAATTCACCTTTCCCTTTCCTATTATCAGTCCTTCTTCGTTCTGAATGCTTACCACATC +TCCCCTTTTAAAGTTTCCCTGAACGGAAACCACACCCGCGGGAAGCAGGCTCTTTCCTGCTTTCAGGGCT +TCTTGAGCTCCCCTGTCCACCACGATTATACCTTTCGGTTCTTCCAAGGTAGCTATAACCTTGAGGGCGT +TCCTGAGTTTTCTCTTGGATGGCTTAAAAAGCGTTCCCTTAGTTTTCAAATTCCTCAAGTCCAAAATGTT +TTCTTCCTTGCTCGTTATTATCACGGGAATGTTCAGAGTTGTTGCGAGTCTTGTGGCCTCAAGCTTGCTC +CTCATTCCGCCCGTTCCGAAGCTCGTACCCGTTCCCCTCACGTACTTGAAAACCTTTTCTATGTCCTCAA +CCACGGGAATTATCCTGTCTTTGTCGTCCTTCAGTCCACCAGCACTTGAGAATATCACTAGAAGGTCAGC +GTTTACCATGAAAGAGACGTAAACCGCGAGGAAGTCGTTGTCCCCGAACACGAGTTCCTCCACTGCAACG +GCGTCGTTCTCGTTTATTACGGGAACTACGCCCAGTTCTAGGAGCTTTTCAAGGGTGCTCTTTGCGTTTT +TAAACCTCTCTTCCTTTTCCTTTGAAAAAACGTCTTTCGTGAGGAGAACCTGACCTACCTTCAATCCGTA +GTTTGAGAATATCGTGTCGTAAAGGTGCATGAGGTAGCTCTGTCCCACGGAGGCGAGGGCCTGTTTTAAA +GTCAGATCTTTTGGCTTTTCCTTAATTCCTAGCTTCTTCGCTCCCGAGAGAACCGCACCCGAAGAGACTA +TTAAAACTTTATCACCAAAGGAGTGGAGTTTTTTTATGCCTTCCGCCAGCTTGGATAAAAAGCTGAGGTC +TATATCTCCCTCGTCGGTCTCAAGGAGGTTAGAACCTATCTTGAAAACTATTCTCATGTGAGTTTTATAT +ATTAAATCATTAATTTATGGGAGTTCTCGAGGCGTGGGAGAGGCATCTGGAAAAGACAAAGAGCCAGAAA +ACAAAAGAAACGTACCTTATGCTAGTCAAGGAATTTTTCAAGTTCCACAAAGTTGACGAAAAGGAAATAA +TTGAAAATCTGAAACCTTCCATGGTTTACAGATTCGTAGACGAGAGCGATCTAAACCCGAGTTCTCTTCT +CACGACCCTTTCCGCCCTCAGGTACTTCTTAAAGTTCTTAACGAGGAGGGAGTACATAGAAAAGAGTATG +TACGAAAGCCTTAAGGCCGCTATAGAGGAGGCGAGGGAAGAACTCAACGCAAAGAAAACACCACGCTATC +CGAGGGCTCTTACCAGAGAAGAAATAGAGGCGATATTTGAAAAGGTAAAAGGTAAGAAGTACGAAAAGAT +TTACACGCTCTTTCTCTACAGCGGTATAAGACTCGGGGAGTACGAGAAACTCTCCGAAGAAAACTTCTTC +ATGGACAAGAGTGGTATACTCTGGATCAAGTTAACACCTGAAATGACCAAGAGAAACAAAGGGAGGCTCG +TTCCTATACTCTCTCCCGACAAGGACGAAACACTCAAGGTTACTGAGAAACTTAGCAGGTGGATAGAAGA +CTTTGAAGGGAACTTCCGCGTAAAGAGGGGGGTGCTTCAGGTTTACACGGACAGGCTCTCCAAGAGGTTA +AACATAGACTTCAGTATCCACAGCTTCAGGCACACCTATATCACGAACCTCATAAATTCCGGCTTCCCCA +TTGAGGTGGTAAAGGAGTTTGCGGGGCACTCGAGCATAAAGACTACCGTGGAGACTTATTACAAGTTCAG +TCAAAAGAGGGCACAGGAACTCGTAAGGAACTTCCTCTTTTCGCAGTAAAATCGTATTTATGAAGATAGC +TATCGGTTCGGATCACGCGGGATTTCCTCTAAAGGAAAAGATAAAGGAATTTTTAAAGGGAGAAGGGCAC +AAGGTTATAGACGTAGGAACTCACGCTCAGGAGTCCACCCACTACCCTATATACGCAAAAGAGGTCGTAA +GGGCTATAAGGAGCGGAAAAGCTGAAAGGGGAATACTCATATGCGGAACAGGAATAGGCATGTCCATTAC +AGCAAACAAGTTCAGGGGCATAAGGGCGGCACTTTGCACGAACGAGTACATGGCACGCATGAGCAGACTA +CACAACGATGCAAACGTCTTGTGCTTGGGAGAGAGAGTTCTCGGAGTTGAACTCGCCCTTTCCATAGTAA +AAGTTTGGCTGGAAACACCTTTCGAAGGGGGAAGGCACTTAAAGAGACTCGAGATAATATCAGAGATAGA +AGATGAAATTTGCGGAGAAAATATACCCCGATAAAGTTATCCTTACGCTCCTGTTCGTGTTCTTTCTCCT +CTCCCAAACCTTTGTGTTTATAAAAAACGTTGTTCCCCTTCTCGTTCAGTACAACCCCTACGCTGTGCTA +AAGTACGAGGAGAGAAAAAATAGGTGGAGGTTGTTTACTCATGAAAACTTGAGGTACTTTTACGACTTGA +AGACCAAAAAACTCTACCCGCTTCCACTTCTTAAAAACGAACCCTACAGGTTCAAACCCGCTTTAAAGGG +AGAGTACTTGGTCAACTTTGAAGGAGTTAAATACAGGATAAAGCCCTTTAAGGAATTGTTTCCCAAAAAA +CTCTTTATTGCCTCCTTTAAAAACGTAAAGTTACTCCTTTTCTGGGTTTTCGGTTTTTTGATTATGTATC +TCTTTACTAGGATAAACTACAAGGCTTTTAGGAATAAGAAGTTTGTTTACGTTCTAGTATCAGTATCTTT +ACTTCTTTTAGTGCTCGTTCTGGTAAAGAAGTTTTTAAATCCAAATTCGCATATGCCCACGAGGTGGCTC +TTCGGGACGAGCTTTCAACCCTCCGAGTTTTCAAAAATCGTACTTATCCTTTTTCTCGCTTACTACATAG +GCGTTAAAGGGGAAATAGAAAAGATAAGCAACTTCTTCTTTGCCCTCGGTGTCCTAGTCATACACGCAAG +TTTGGTGGCTCTCCAAACGGACCTAGGTATGGCTATATTCTACATAGTCCTCGGTTCTTCCTTGATGTTC +GTGGGCGGAACTCCCTGGAGGATACTCATTCCAAGTTCTTTTATCCTCGGTCTTGCGGGAGTGTTCTTCA +TTTCCGCAAACATGGAAACGGTAAAGAAGCGTTTTTCCGGCTGGCTTGATCCCTTTGCCGATCCCTACGA +CAGGGGATACCAGATAATTAAGTCTCTGGAAGCGGTTATAAACGGAGGTTTCTTAGGGCAGGGACTGGGA +AAGGGGCTTTACGCGGCTGTCTACATAAGGGAATCCGACACGGACTACGTAATAAGCTTAATCGTGGAGA +ACTTAGGAGTAATAGGCTTTTTCTTTATCCTCTCCCTTCAGTTTCTCTTTGCCCTGAGGCTTTTCAAGTA +CGCTGTGAGGATTTACGGGATGTACGAAAAGATAATAATCCTCGGCGTTGCCCTGAATTTCCTATATTCA +GTATTCGTCAATTACGCAATGGCTTTAAACATACTGCCGCCTAAAGGTATAGCCCTGCCCTTTATAAGCT +ACGGAGTCAGTAATTTGCTTTCCAATATGATAATGCTGGGAATAGTTGGTTCTATATACAGGAGAAACAG +CGATGTATTAAACTTATGAATTATGAAGAAAAAGAGGGTAATTCTCGCATACTCGGGCGGACTCGACACA +TCCATAATAGTGAGATGGCTCACGGAAAAAGGGTACGAGGTAATAACATACACCGCGGACGTGGGACAGG +GAGAAGAACTCTCTGAAATTCCCGAAAAGGCAAGGAGAGCGGGAGCGATTGAAGCCATAGTAGAGGATTT +AAAAGAAACCTTTGCGGAAAATTACTGCCTTCCAACTTTGAGGGCATTAGCCCTTTACGAAGGGAAGTAC +CCCCTCACCGCAGCCCTCTCAAGACCTCTCATAGCAGAGAGGCTCGTTTACTATGCCGAAAAGTTCAACG +CGGACTACGTAGCACACGGCTCAACTGGGAAGGGAAACGATCAGGTGAGGTTTGAACTCTCAGTCTGGGC +CCTAAACCCCGATATAGAGGTTCTCGCTCCCGTGAGAGAATGGGAGTTCAAATCAAGGGAAGAACAAGTT +GAGTACGCTCAGAGGTTCAACATCCCCGTTAAAGCTACGAAAGAAAAGCCATACTCCATAGACAGGAACC +TCTGGGGCGTTTCCATAGAGTGCGGACCCTTAGAAGACCCGTGGCAAGAACCACCGCAAGACGCTTACCA +GATCACCCAATCCCCTGAAGAGGCTCCGGATGAACCAGAATACGTTACCGTGGGTTTTGAAAAAGGAAAA +CCCGTTTACCTGAACGGTGAGCGCTACGAAGAGCAGTGGAAATTGATAGCCAACCTAAATGAAATAGCGG +GAAGACACGGTGTGGGAAGGATAGACATGGTTGAAAACAGACTCGTAGGGATAAAGAGCAGGGAGATATA +CGAAGCTCCCGGAGCCATGGTTCTCTACGAAGCATACAGGGATTTACTCTCTTTAGTTCTTGACAGGTTT +ACCTTCCACTACTTCCTCACCCATATTCCCCACGAGTACGCAAAGCTCGTTTACGAAGGTCTCTGGTTCA +CCCCCTTGAGGGAAGCGCTTGACGCCTTTACGAATAAAATCGCCGAGTTCGCAACGGGAGAAGTAAGATT +AAAACTCTACAAAGGAAGTGTAAGCGTTGTTGGGAGACGTTCACCCAACTCCCTTTACGTTGAAGAGCTC +GCAACTTACTCGGAAAAGGACCAATTTGACCAAATAGCAGGTAAGCACTTCACAAAGGTATGGGGACTTC +CACTGAAGGTTCTGGGAAGGGTGAGAAAAGGTAAATAGAAATTTAACAATTAAAGACTTAACTTAATAGT +ATGAACGTAGGAATATTTAGTAGATGGAACGCAACGTGCGGGGTTTCCCTGCACGCGGAAATGATAGGGA +GGGAACTCCTCAGGAGGGGTTATCCTATTACCGTTTTTGCCCCATACCTTGAGAGTGCCAGCAGATGGTG +GCACCACAAACTCATAAGACCCGATGAGGAGTACGTTGTCCGTTGTTACGAAGAGCTTTCCCCTGACGGA +AAAGAGGGAAAGATAGACATTGAAAAAGTACTTGAAAGGGAAATAGACTTCCTGATAGTGGAAAGCTACG +AAAAACTACCTTACAAAGACGTAGAAAAACTTGTAAAAATACTGAAAGATAAAGGCATTCCTTCAATAGC +GATTATCCACGAGGGAGACTACGAAGATATTCGCTACACCGATATGAACATCTTTGAAAAGGTTTGCGTT +TTTGACGAGAGGTATGTAAAAGAGGTCCTGAAAGACAGGGTCAGTGAAGAAAAAGTAGAGATCATCCCAT +ACCCGTGCTACCCCGTAAGGGAGGGAAGTAGGGAGTTTGCCGAAGATGGTGTTATAAAGTTCTTCTCCTT +CGGAAGACAGCCAAAGGAGGAGTACTGTCCTTATATAGAAGGTCTTAAGGTTTTCAAAAGGGATTTCCCG +AACGTAAAGTACAGGATAGTGAGGGCTATGGAACCCTTAAAAATTTTTGAAGACTTTGTAGAGCAGGAGG +AAAGGATTTTAGATTATGAGGAAATAGTAAAGGAACTTCACTCTGCGGACTTTCACCTGCTTCCCAAAGG +AAATACAAAAAGAGTGGTGGTTTCCTCTACACTCTATCAGGTTCTCGGGACGCTTACCCTTACCGTAGTA +CCGGACAATAGGTTCTTTGAAACACTCCCCCATGGAGAAGAAGCCCCGGTAATATTCTACAGGGACGTTC +TGGAACTCGTTAAAGAACTGAAGAAGGCTTCAGCAGATGAAGAATACAGAAAGAAAATAAGGGAGAACGC +GAGTAAGTTTGTGGAAGAAAACAGCGTGGAGAGGATAACGGACCGATTTGAGAATTTAATCAATTCTATT +CTCGTAAAGAATGTTCATTAATTCTTCGAGGTCTATCTCCCCTATAACCACTACCGTGTCTGCTCCACCG +TATGAAATGAGGAGTTTGTTCTCTAATCTCTGTATTCCGCATGGGAAGACTACAAAGGGTCTGTCACCGT +AAACTTCGTAGATTTTTTTCGGTTCTAGGATGTAGAAAGGCGTTACAGCGGTGAAGTACCCTTCCTTGTT +CATGAGCACTGCAAAGACCCTGTAAGCGGTAAGTTCTTTGTCTACACCGTGTATTAGAACGAGGTTCTCT +TCTCCAACTTTCACTGGAGGAGTCGCCCATCCTATCTTTGTTTCAAAGGGAGCTTCTTCCATAATGGTTA +TGTTCTCCCCTATTTCTATTTCTTTGAACTCGTTTGTATAGAGAACCTCTTCGGGAACGTTGCAAACCGC +GAGGTAAAACTTTTCGTTAAGCATGTGTAGTCTGTGATACAGCATTAATTTATCCGTTTTTACGAGAAAG +GCGTTTTTGTCGCTCACTACAAAACTCCTGATGTCTTCAGGCATTCTGAACACGGCAATCTTCTTCCATT +GGCCGTTTTCGTATCTCGCGGTCACGGGAAGAGTTCTTTCCGTTCTAATATCCGTTCTAAAGTAATTAAC +CGTCCTTCCCGTGTAGGTCATGAAGAGTTTTCCGTCTATCTCGTAAACCCTCGGATCCTCAACACCCCAA +AGGTCATACTTTATGTTCGGTAAAACGGTCAGGTTGGCTTCGTAGGTTTTCCTTTCGGGATTGTAGAGTT +CTTCTAAATCTATATCAAACTCTGCTATAGCGCTTGTGTAGGTGTAGTATCCCATGACTACCCTTGCGTA +AATCCTCAGCCTGTTCTCAAACACGTGTATTGAGGGGTTGAAGGCTACACGTGGAGTTTCCACTGGATAA +TTCTGTATGTGGATGTCGTGTCCTGTAATCACTTTAAGTCTCTTTACTAAATCTTTGGTCTCAAACCTTC +TCTTTTCCAGAATTTTACGTGAAATATCCGCCCAGTTATTTCTCAGCGCTACCATAGCACAAAAATTTTA +TACTTGTTAATTAAAAGGAGGAAAGGATGTTTCAAGGCTCAATAGTTGCTCTGATTACTCCCTTCAAGGA +AGGAGAAGTGGACTACGAAGCCCTCGGAAACCTAATTGAGTTTCACGTGGACAATGGTACAGACGCAATT +TTGGTTTGCGGAACTACGGGAGAATCCCCGACCCTTACCTTTGAAGAGCACGAAAAGGTTATAGAGTTTG +CCGTAAAAAGGGCGGCGGGAAGGATTAAGGTAATCGCAGGAACGGGCGGGAACGCAACCCACGAAGCGGT +TCACCTGACAGCCCATGCGAAAGAAGTAGGAGCGGACGGAGCCTTAGTGGTCGTTCCATACTACAACAAG +CCCACACAAAGAGGTCTCTACGAGCACTTTAAAACGGTTGCTCAGGAAGTGGACATTCCCATAATCATTT +ACAACATACCCTCAAGAACCTGCGTGGAAATTTCCGTGGACACCATGTTCAAGCTCGCGAGCGAGTGCGA +AAACATAGTCGCTTCAAAGGAATCCACTCCCAACATGGATCGCATTTCGGAAATAGTAAAGAGGCTGGGA +GAAAGTTTCAGCGTCCTTTCGGGAGATGACAGCCTGACTCTTCCCATGATGGCCCTCGGTGCTAAGGGAG +TTATATCGGTTGCGAACAACGTAATGCCAAGAGAAGTAAAAGAACTCATACGGGCCGCTTTGGAAGGAGA +CTTTAGAAGGGCGAGGGAAATCCATTACTACCTTCACGACCTATTTAAGGTTCTCTTTATAGAAACGAAT +CCCATTCCCGTCAAAACCGCCTGCTGGATGCTGGGTATGTGTGAAAAGGAATTCAGACTTCCCTTAACGG +AAATGTCTCCAGAGAATGAAAACAAGCTGAGAGAAGTCCTAAAGAAGTACAACCTACCTCTGAAAAACTA +AGCTTCCAGCCCTCTTGAAAGCCTCAACTTTGAGATGCATCTCCTCCGTTTCCCTTTCCTCTACCGAGTC +CCACACTATACCGCATCCTGCGTAGTAATAAAGCCTGTCGCCTCGTCCTATTGCCGTTCTTATGAGAACT +GAAAGTGTAAAGTCCTCTTCAGAAAAAACTAAACCTCCCGAACCGCAGTAGTAGGACCTTGAAAAGGGTT +CCAGCTCGTCTATTATCTCAACCGCCCTTCTTTTTGGAGCACCCGTCACGGAAGCGGGCGGAAAGGTGCT +TGAAAGTATCTCACTTAAGCTCTTATCCGTTATTCCTTTCACGGTTGAGTGCATGTGGTAGAGCGTTCTG +TATTTTTCCACTTTAAAGAGTTCTTCCACTTCAACACTCCCTGTTCTTGCTATTCTTCCTATGTCGTTCC +TCATCATGTCCGTAATCATCAGGTTTTCTGCCCTCTCTTTTTCACTCAGAAGCAGTGTTTTTTCTTCTTT +TGCCGTTCCCTTTATGGGTTTGCTCCTTATAACATTTCCCTTCTTTTCTAAAAATAGCTCCATAGAACCG +CTGATAACGTAAAAATCTTCAAGCTCTAGGTAAAAGGCAAAAGGAACTGGCTGGGCTTCATAGAAATTGA +AAAATAGTTCTTCGGAAGAGCCCTTCAGTTCAAACTCAAACCTGTTTGTTAAATTTATCTGGTAAACGTC +CCCTTTTTCTATGTACTTTTTAATCTTTTTTATCCTCTCTTTATACTCTTCGTCGCTCAGAATTGCTCCT +TTTAATTTTAATTCTACACCACTACTCTTCTTTGGATTGTAAGGTTTGAATCCTACGAGCTCTGCGAGAA +TTATCTTCTCTCCTTCGTTCTTAATTTCAAGCTCAAGGGTTTGGGTGGATAAAGTGTAGGGAACTAAGAG +AAAGAAGGGTGGAGTAAACTTTTTTATATCCTGTATAGAAGAAAGAAAGTGCATACTTTTTAAAATCCCT +TCAAAAAAGCCCCCTTTTCCCAGCCACGTGCCCGCAAGGATTAACTTCATAATCTTCCTTCGTAAGCCCT +TTCGTAGAGTTCCTCTACTTCTTCCATACCTACTTCTACAGGGTTAACGGCAAAGGAGTGCCTTGCGCAC +ATGTAAACGTCTTCGGCAAGTCTCGGGAGTTTTTCCTTTTCTACTCCAAGCTCCTTCAGGGTTTTTGGGA +GAGAAAACCTTTCTATGAACTTAACGAGAGCGTCCACCGCTTTGTGAGGTTTTTCTTCTTCTCCCATCAG +TCTTGCAAAGAGGGCGTACTTCTCAGGGTTTCCTCTGTAATTAAAGGCGGTTATGTAAGGAGCGAGCGCC +GAAAGTCCTTCCGCATGTGCCACCTCGGGGTAGTGTCCCGAAACGGGGTGTTCCATTGCGTGTATGAGGG +CAACTCCGAGGTGGTCTATAGCTATCCCCGCAAGCATAGCTGCGTAACTCATGTACCGCCTTGCTTCTTT +ATTTTCTGGCTCTTCAAAGGCTACGGGAAGCCACTTCCTTATAAGCTCTATCGCCTTTACCGAGTACTCT +TCAGCTATGAAGTTTTCTCTTTTATTCGTCAAACTCTCAAGGGCGTGCATCAGGGCATCAAAGCCTGTGA +GGGCGGTGAGTCTAGGAGGCATACTATAAGTTAGCTCCGGGTCCACGAGTGCAACCTTCGGGTAGTTCAG +GCTGTGGGAAATTACCATTTTTTCTTTTGTCATCGGGTTTGTGAGTACGGAATACCTGTTTACCTCGCTT +CCCGTTCCCGCCGTTGTCGGTATCGTTATCACGGGTCTGTTCAGAAAGGGAATCAGCCTGCTCCCTTCCG +GATACCTTACGTAATCCCAGGCGTAACCTTCGTTGGAAGATACTATGGAAATTGCTTTCGCGGCGTCCAA +GACACTTCCTCCTCCGATACCTACGATAAAGTCCACTTTTTCGTTTACGGCTATCTCTGCACCTTTGTTT +ACCTGTTTGTCCGTCGGGTTGGGAGTTATCTCGTCAAATACCACGTACTCTATTTGATTTTGTTTTAAGG +AGTTTATCAATTTATCCAGTGCACCGCTTTCCTTTGTGCTTTTTCTTCCAGTAACTATCAGGGCTTTGAA +GCCAAAGCGTCTCCCTACTTCTCCCGCTTTTTTTACCGCTCCTTCGCCGAAGAAAACTTCAACGGGTCTG +TACTCATTTACAACAGTCATAAGGAATAAATATAAAAGGAGAAGGTTAAAAGGAGGAAAGCTTTATGTCC +GTTATAAAGGCGTAATCTCCTCCGTCAATATCTCCAGCGTACAGTTTTATGTAAACATATCTCTTCAGAC +GTTTGAAGGTTATCGGTGAAAATTCCCTTTCACCCAGTAACTTTCCATCCATAAAAACGGATACTGTATT +TCCCTTCTTCACTACGTGAACCGTGTGTACCTTACCCTCCATATCCTTATCCTTTAACCTTTGACCTCCC +AAGTAGGTTTCATTCCTGACGTGTTTTACGTTTACTGCGGAGGTTTCCCGACCGATGGAAACTTCAACGG +CTACCGCATACATTCCTTTCCCCTGTTTTTTATAGAACGTGTACTCAAGAGTCCAGTCCTTCTCGGGATT +GAAGTTATTGACGTACTTGCGAAGAACTGCCCCACCTCCTACGTCGGCTACCCACTTCTTGCCGTTCATT +TCCACGCATTCAACACTTCCCTTAAGGATTTTGAGAGAGGTAGGTTTTACCCTGCACGTGCTGAAGTCTT +CTTCCCACAGGATTTTATCCCCGTGAACAGGAGTTCTGGAAGGTCTCTTAATTATCCCGGCTGTCTGTTC +TTGTTTTGCTTCTGTTTTTTCCTCACTTACGCTCCCCTTCTCGGGAGGGAGGTCCCTCACCTGAGCGACT +ATTAACTTAACTGCATGGTATATGAGGTCTCTCGTTGCTTCTTCCATAGGTGTATTTTTAAAAGCTTCAA +ACCATCCGCCCGCTATAGTTGTACCGAATATTCCACCGCCTCCTACTCCGAACTTCCACCTATCGGACTT +ACCTTCTACCGTCTCGGCGAGTAAAACTTCCGCATCTCTTACGCGTACAAGTCTAAGGTCTAGGGCTATG +TGAGCACTGCTCTTGCCAGCCTTTACACCTACTCCGCCTAAGAACGGCAACGGTACAACAACACCTCCCC +CGCCCATTCCTGAGGCTTTCATCTCCAGAGCAGTTATAGAACCTGTGAGCAGGAAGTCTGCACCTTTTAA +TGCCTTTTTAGGCTGTACACCCAGCATTTCGAGTTCTTCCTTTATTTCCTGCAGGGTCTCTCTCTCAAGA +ACCCTGAAACACCCTGTTTTCACGAGGGCGGTAACCAGCATATCAGAGAGACCATCACCAAGAACTTTCG +GAGAAACTTCAACGGTGTAGTTCGGACCAAAAACTATCCTATCTCCCGCACACTGTGCCGCTTTACACTT +AAAGCCTCTTGCGACTATCGTACCTATCGGTCTGTCACACTTCGGGAGTTCTGGTTCCCTTTGCCTGATG +TCTTTTGCGTATTCGCCCTGCGTGGTTTGAGTGGAAGCCTGTTGAGCTACTGGTCCGCAACTGAAAATTA +AAAAAATCACTGAAATGACTAGAAGAGGGAACATAATTCACCTCCCCTATGTTTGTTATCTTTTAAAAAT +ACTTAAAAGAGTGAAAAAAACAATGAGGGTTAAGCGGAGACCTGAGCCTCTAAGTTATCCAATATTTCTA +CAACTTTTCTTGCTGCATTTTTGAGTTCTTCGGGGTTTGAAAACTCCCTGAACTCCCTAACCATAATCGC +GAGGTTGCTAAAGAGTTCTTCCTTCAAAGGTCCGTTTCCAAACTTTATCCTGTAAGTTGCGTTTCTTATT +GGTTCTTTAATTTCTTCCACTAGCTCCATGAGCTCAGTTTCGTTCTGAGCGTTAGCCATGGACTCTATCT +GTTCCTTGAACTTCTTAAGTAGTTCATAACCTATTTTGAAGTCCGCGTCCATTTGCATTCACCGACCTCC +TGAGGATTTTGTAATTATTTTAACCCGTTGAACTTCCTGAAGAACTCCTCGAATTCCTCAGGAGGCAATG +GAGGAGAGTAGTAATACCCCTGTGCGTAATCGCAACTGAGTTCCATGAGCATCTTCTCGTGAATTTCCTT +TTCCACACCCTCGGCAACTGTCTTCAGTCCCAAGGAGTGGGCGAGGTTTATAACTCCCTTTACTATCTCG +TAATCCCTTTCGTTCACGTCCATGTCTTTAACAAACTCAACATCTATCTTCAGGGCTGAAACGGGTAGCT +GTTTTAAGTGGAGTATAGATGAGTAACCCGTCCCGAAATCATCTATGTAAACCCTTATACCCAGTTCTGA +TAGGGATTTTAAAAATAGCGTTGCAACCGAAACGTTTTCCACCAGAGCTGTTTCCGTAACTTCCACACCC +AAGTAGTAAAGGAGTTCTGTGTAACCCTCAAGATCCTTCAAGAAACTCTGTAAGAACTCACCGGAGCGAA +ATTGCGCCGGGGATATGTTTATGGCTATTTCAATCTCTATTCCCTTTTTATGCCATTCTTTTAACTGCCT +GCAGGCTTTTTCAAGAACGATTAGCCCCACCTCGTTCATGAGTCCTGTTTCTTCCAGCAGTGGTATGAAT +TCGTAAGGAGGTACGAGTTTATCTCCCTTTTTCCAGCGAATGAGTGCCTCGCATCCCACTATTTTTTTCT +CTTTTAAATCTATTTTGGGCTGGTAAAACAGGATAAATTCATCTTTTTTAATGGCTTCGAGTAGTTCCTT +TTTCTTCGTAATGATTTCTTCTATTTTCGGAAATTCTTTACTGCTGTAGTAAACGACTCTATTACCTCCG +AGTTTTTTGGCTTCAAACATAGCCTGAAGAGCATAACCGAGGAGTTTTTCGGCTTCGTTCCCGTCGTCCG +GAAATACGGAAATACCTATGGAAAAAGTCACCTGGATTTCCTTGCCGTTTACTATGACGGGTTTACTGAA +AAGTTTATTCAGCCTTGCGAGAAAGCTGTTTACCGCAACGGGAACATCTGCACACGTCAGGGCAACTCCG +AAGGTATCTGCTCCAAGTCTTGCGAGTATGTCGCCTATCCGAACGCTGTCCCTTAGGCTGTCCGCAACCT +CTATGAGGACTTTATCCCCGACCTCCGTGCCGTAGAGCGTATTTATGGCTGTAAAGTTGTCTATATCCAG +AACTACTACAACGACCTTTTTCCTCTCCTGAGCGGCTATACTTAGCCTGTCCGAAAGGGCTTTGACGAAG +AAGATACGAGTGGGCAACCTCGTGAGTTTGTCAAAGAACTCTATTTTTTCAAGTTTTTCGTGAGCGGTAA +TGGCGTCTATTGCGGTACTTAATTCCTCAAGGAAGTTTATAATTAACTGAACTTCTGCGGGATAAAATTC +CTCTTCCTTTGAAAGGGTTAAGTAGTATTTTTCCTTGCTTTTCAGCTTAAAGCAAACTGAATACTCTCCC +ATCTTCCCTTTCTTGATTATTGTGTGCCCGTCTAAGGTTATTTCCGCGTAAGTGAAGTTCTCTTCATCCA +CGAGAAAGTCTGCTATCTTTCTAAATATTTCTTCCTTTTCCGTTTCCTCAAAGATTATTTTTATAAGATG +TGTAAATAGCGAGTAAAGTCTGCTTATCCTCTGCCTTTCTCTTTCTTTTTTAACTTCTTCCGAAACATCC +CTCAGGTCTATTATGAAAAAGGTTTCCCCGTTTACGCTCAGCGTCTGGTAGGAGACTTCAAAGGGTTTTA +GTATCGCCAGCTTTGGATTTCCCAAGTAAACGACTTCGGGAAGTGTTCCGCTTCCTTTCATTTTACACAG +TTCACACAGGAGTCTGTAAACTCCCCTGTAACGTTCGGGAAGGAGTTCAGTGAAAGGCTTTCCTACGACC +TCTTCCCTTTTGAATTTTAGTTTTTCCTCCCCGGTTTTGTTTATAAAGTTTATCTTGAAATTACTGTCAA +GAACGACAACTACATCGGGAAGGTTATCGAGGAGTAGTCTTAACGTTTCCGTTCCCTTCTTTCTCATTTG +ATCTATAAGCAGGGATATGTGTATTAAGGTGATTTTGGCTAAAGATAGGCATATCTCGTTTAACTGCTCT +GGGGAAAATTTATCTTTCAGTTTTTCCCTTATGAGTTCAAAGAGTTTCCCGTGTTCAGCCACGACTTCTT +CTGGAGTTACGTTAAATTTTGAAATAAAATTTGCGAGTTCTTCCCTTTCTTTTAGTCCTTCTTTTAAGTC +TATTAATCCCCTTAAGTGTTTATAAACTACTTCCTCTACTTCTTTCTCTTTTCCCTTAAAATCTCTGTAA +CTTTTTAAGTACTCCGCAAACCGCCGGGCAACTTCTTTTAATTCCTCGTCTTTTAAAACTTGTCTTATAA +GCTCTACGTGTTCTACATCTTTCTCAATAAAGTCCGCAAGCTTTCTTAAAGAATTTAAGTCGTAGTTTCT +CCCCTCCACATCTTTAATTCTAAACTCTGTATTCGTAATTTTCCGTATAAGTTTCTACTACTCTTTATTT +TTCCCGTTTATAGTTTCAAATTCCTCCATTTCCTCTATGAACTCCTCATGGAGTGCCCTCACGGCGAGCT +CCGCGTACTTTTCGTCTATGAGACAGGATATCTTTATTTCGGATGTGGATATAGCCTTTATGTTTATACC +GTTTCTGGCGAGTATGTCGAACATCCTTCCCGCCACGCCGTAAGCGCTCTTCATCCCTATGCCAACTATA +GAGATTTTCGCTACTTTGTCGTCCCTTACAACTTCCTTTGCCCCTATCTTCTGGGCTATCTTCTTGACTA +TCTCTTCTGCCTTGTCCGCGTCCGTTTTGTTAACCGTGAAGGACATATCCGTGTAACCTTCGTGGGACAC +GTTCTGGACAATCATGTCAACCACTATGTGGGCATCTCCGAGAGCTTTGAAAATTTCGGCGGCTATTCCC +GGCTTGTCGGGAACCCTTACAACGGTAAACCTCGTTTCTTTTGTGTCAACGGTAATTCCCCTTACAGCTA +CCTTTTCCATGACTTCATCCTCCGGAACTATCCAAGTCCCCTCCTCCTCCGAGAAGGTACTCCTCACGTG +TATCCTGACGTTGTACTTCGCAGCAAACTCAACGCTCCTTATCTGCATAACCTTAGCACCAAGGGATGCG +AGCTCCAGCATTTCTTCATAAGAAATTTTCTTTATCTTCTTTGCGTTCGGGACTATCCTCGGGTCTGCGG +TAAATACGCCAGGAACGTCCGTGTTTATCTCACAGTCCGCTTTAAGGGCTGCGGCGAGGGCTACCGCTGT +CGTGTCGGAACCACCTCTCCCTAAGGTCGTTATTTCCCAGTCTTCCGTCACTCCCTGAAATCCGGCAACG +ACGGGAATGTATCCTTCCTCTATTAAGCTGAGAAGTCTGCTTATACCTATCTTTCTGATTCTTGCCTTTG +TGTGAACGTTGTCCGTTATTATGGGAACCTGCCAGCCGCACAGGCTAACCGCGGGGTATCCGAGTTTATT +TAAAGTCATAGCAAAGAGGGCTATAGCCTTTTGTTCTCCCACTGCAAGGAGTGTGTCCATCTCCCTTTCC +GGGGGTCTTGGGTGTACTTTTTTGGCGAGTTCTATTAAAGAGTCAGTCTCTCCAGCCATTGCGGAAGAAA +CAACAACGGGTTTGTAGCCCTTTTCAAGGGCTTTTATTACTCTCTTTGCACAAAGTTCTATCCTCTCTAG +GGTTCCCACGGAGGTTCCGCCGAACTTCTGAACGAGTATTTTCATCGGAAAGTAATATTTTACCTTAAAA +TTTATTAATTATGTACAACCTCAGAATGGCTGAATCCGTAACGGAAGGCCACCCGGACAAAATAGCGGAT +CAACTCGCTGATGCACTCCTTGACGAGTTCATAAAGAAGGATCCTTACAGCAAAGTCTCCTTAGAGATTA +TGGTAACCACAGGACTCGTTATGGTAGGAGGGGAGCTCACCACGGAAAGCTACGTGGACATCCCAAGAGT +TGTGAGAAGCGTTATTAAGGATATCGGATACACGAGACCCGAACTCGGTTTTGATGCGGACACCTGCGCT +GTAGTTCAGTCCATAGACGAGCAGAGTCCCGAAATTGCTTTAGGTATTTCCTCGGAGGGTGCGGGAGACA +CCGCGATAGTTGTGGGCTACGCCACGAAGGAAGCTCCTAACCTCATGCCCTGGCCCATAACAATAGCCCA +CAAGATCACAAAGAGGATATCCGAGTACAGGAAGATAGGAAAGTTTCCCTTCCTGAGGCCAGACGGAAAG +GTTCTCGTGGCTATGATTTACGAGGACGGGAAGCCCTCTTACGTTCAGAGCATAGTTGCCTACGTCCACC +ACGACCCCGACGTTTCCATAAATCACCTGAGGGAACTAATAATTGAAGAAATTATTAAAAAGGAAATTCC +TGAGGAGTTCTTGACGGAAAAAACGAGCATAAAGGTAAACCCCACAGGCAGGTTCGTAATTGGTGGACCC +GTTGCGGACACGGGACTCACAGGAAGGAAGATAGTTTCCGACGCATACGGAGATATAGGACTCTCCGGCG +GTAGTGCCTTTTCAGGCAAGGACCCGACGAAGACAGATCGTTCAGGTTCTTACCTTGCGAGGATGATAGC +GAAACACGTTGTTGCCGGTGGATGGGCAGAGAGGTGTTTGGTTCAGATAGGGTACGCCTTCGGACTTACC +GAACCCGTTGCTTTTGACATAGAAACCTTCGGAACGGAGAAGATAAGCAAAGAAATACTGGAAGACGCTG +TAAAGAAGGTATTTCCATTAAGACCAGCGGAAATAATAGAGTTCCTTGACCTCAGGAAACCCATATACAG +GCAAACATCCGTTTACGGACACTTCGGAAAGGAAAACCTCCCATGGGAAAAGTTAACGAAGCTTGAGGAG +CTGAAGGAGTTACTCGATTAAATCAAGAAATTCTCTTATTTTCATTACCACGTAATCCTTCGGAGTTGTG +TAAACCTTAACTATTTCATCTTCCACGAGGAGTACTTCCTTAAAACCCTTATCAAAGGCGTAAATCAGGG +AATGCTCCAGTCCCCTTTCCTTTACTATTTCCATTCCTACTTTTTTTCCCTTTTCCCTTAGGACATCCGC +AAGCTTCAGCCCTAGACGCTTTTTCGTTTTGTCTATCACGAAGTAATCCTTCTTTTCCACGTTTTTGGGA +AGTATGTCAAGGAGTCTCTCCAAGTAAACAGCTCCGCCGGTTGCCGGGTATTCCTTTCCGTAAATCTTTG +ATAGGTTATCGTACCTTCCTCCTCCCGCTAACGCCTTTCCGCTCTTCAGTTCGTAAATTTCAAAGATAAC +TCCCGTGTAGTAAGGGAAGTTCCTTACCTCTCCGAGGTCGTAGGCGTAATCTATGCCGAACTCCTCAAGC +AGTTTCCCGAGCTCTAGGAGTTCTTCTTTTTCTTTTTCAAGATCGTACTTTTCCAGAAAGTTTAGAACCT +CTGGATTTTTAGAAACTTCCACGAAGAACTTTATGTCGTTTCCGAGAACTTCCTTTAAAGCTTCCAAGTT +CCTTTCTGAAAAGGCCCTCAGGAGTTCTTCCCTTTCATCGGCTACCTTTCTCACTATTCCCGCGTGGCTG +AGTATCACTTTTAAGTCTTTAAGTCCCAAAGATTTCAAGAACTCGGTGAGTACCTGAATTACCTCAAAAT +CCGCGAGTATACTTTTTTCACCAATAAGCTCAACGCCGGTCTGGAGCTTCTCAAACCCCCTCCTGTCCAA +GGAAAAAACTTTGCCGAAGTAGTAAACTCTCTCGGGGAGTTTTACGTTCCTGAGGTGGGATATAGTCCTC +ACCACCTGTGTGGTAAAGTCGAGCCTGAGACCGAAACTTTCCTTCGTGTAGCTGTCCTTGAAGGTTATCG +CTTCCTTTGAACCTTCCCCAAAAGTGAGTTCCTGAAATTCGTAAGGTTCAAAGTGAGAAAGGTTTATGTA +ATCGTATCCGAAAGCTTCAAAAATTTTTACTGCTTTTTTGAATATCTCTTTCACGAGGTTGGATTCCTCT +AAGCTGTAAAATCTTTCTCCGGAAATCAGGGATGTTTTCATAGAGAAAATTTTAGCCTCCTGTGGATTGC +CAGATACGGGGGCGTCCTGAAGTGGGGTTTCCTCCTGACGAAGTAGTAGCGCGCTATGTGATAACTCGTG +TCAAAGCCGTAAAAGTTGAGTTTCATCTTTTCGAGTTCGTGCTCCCTGCACTTTTGTATTTCCTCGAGCC +ACTCCCCGGAAGTCCTTTCCTTTTTCTTTTTCTCTATAAATTCATAAAAATCCTTTGAGTTTATGAAATT +CTTTATTCTTTCCTTCAGCCTTTGTCTGAATTCCTTCGGAGTTTTCCCGAAAACGCCGTCTATTAAACCT +ATCTCAAAGGCCTTTTTAGAGCTTATGGGCATCCTGTTTTCCATAACCTCTTTTCCCTTTTCCCAGCCGA +CTCTTTTGGGTAGGGTATACGTCCAGAATTCAGAACCATAAAGGTTTCCTATGTTTTTGTAGTGAGGGTT +CAGAACCACACCTTCCCGAGCAAACACAAGGTCACAGGTAAGGGCTAAGAACACTCCTCCCGCACCTGCG +TTTCCCTGCATTCCCGCAACGGTTAATTTGTCGGGAGTTTTCAGTATTTCCTCACAGACGTCGTCTATGG +CGTTTATGTTCCTCCAGGACTCGTCCGCGGGACTTTCTGCGTTTTCTATGGTGTTTAAGTTCATGCCGTT +GGAGAAAAAGTCTTCACTTCCAAGCAGAACTATAGCTTTAACGGGTCTCTTCTTAGCGTACTTTATCGTT +TCTAATAGTCTGTAACACTGCTCCGTGGACATCGCTCCGTTGTAGAAGTTAAAGTGGATAAAACCTATGC +CGTCCTCTTCCTCGTAAAGGATTTCCCTGTAAGTTTTAAAGTCCACTTTTTCCCACGGCTTTATAGGGTC +TTCCTTAACTCCTTTTAGGAATTCTCCGAGAACTCTGGCGGAGGGGAGTTTTATACTTTCCTTTTTTCTC +TCCCTCATGTGGGTAATCCAAACGGCTCCGTCTCTTGTTCCTATGCACACAGCCTCGTCGCGAAGGGCGA +GCACTTCACCGGGCTTTCCTTTCAATTCCTCTTCAGGATACGCGTTGAAAAGGAGAACCTCCTTCCCCAG +AACTTTTGAAGACGCTCCGGGTTGAGAATCCGAAGCGTAAACTTTTCTGAGAACTGTTTTCGTATCGTCC +TGTTCCCAGTCCACTCTCCTTAATTCCTGCTCCATTTTGGGATTCCACCAGTGTTCCTTTTGTGGCGTTG +GTTTAAAATCTCCCCTTTCAAAGTTCTCCAGCGCTTCTAACACGCACTCGACCACTCCTTCCGTCACTTC +GTTTCTGTATATACTTGCCTTTCTTGCAAAGCGCATGGGAAAGGTTCTGTAAGCCCAAACATCTCCGGCG +TCGTACTCTTCAGAGGCTTCCAGAAGCGTAACTCCCCATATCCTTTCTCCTTTCATAATAGCCCAGTCAA +GGGCGTTGGGCCCCCTGTCTCCGGGAGGTCCGGGGTGGATTATGAGAGTTTTGTACTTCTTCCAGACTTC +TTGAGGTATTTTTCTCTTTAAGAACGGGGCTATTATCAGGTCTGGTTTGTAAAGTTCTGCAGCCTCTACG +GTGAGATCGGGATGAACGTCTAGTTCAACGGAAACCTCGTGTTCCCTTTCCGTAAGTTCGCAGTAAAGTC +TTTGGGAAAGGGAGTTAAACCTGTAGGAGAGAAAGAGTATTCTCATTCCGATAACCTCTTACTGAACTAA +AGCCCTTCTGTACTTGTAGTAAGCCGCACAGGCTCCTTCCGAAGAAACCATACAGGAACCGAGCGGGTTT +GAAGGCGTGCATACTGTTCCGAAGAGCTTGCAGTCCGTAGGTCTCGCAACGCCCCTTATTACCTTTCCGC +ATATACAGGCGGGGTGTTCCTTTGGCTCTGGAAGTTCAACCTCAAAGACCTTTTCCGCGTCAAACTCTTC +GTACTCTTTCCTTATCTTCAGGGCGCTGTAAGGTATTGTGCCGAGTCCTCTCCACTCAAATTCCTTCCTC +AGTTCAAATAATTCCGCAACGAGGTTTTGAGCCTTCAAGTTCCCCTTGTAAGTAACGAACCTTGTGTAAT +TGTTTTTAACCTCAGCCCTCCCCTTGTAAATTTGTTTCAGTATTAGGTAAACGGCCTTCAGGACGTTTAA +TGGTTCAAACCCCGCTATCACCACCGGTTTCTGGAATTCCTCGGCAAAGTAGTGGTAAGGTTTCGTCCCT +ATTATCACGCTCACGTGCCCCGGTCCTATGAAGGCGTCTATCTCCACTTTTCCTATCTCCCTGATTTCCG +GGGCGTTAAGTATGTGCTGGATCGCAGCGGGCGTTATAACGTGGTTGGAAACCACGAAGAGGTTTTTAAT +CCCTTCTTCCTTTGCCTTCTTTATAAGAACGGCGGTTTGGGGAGTAGTGGTTTCAAAACCTATGGCAAAG +AAGATAACCTTTTTATCAGGATTTTCTTTTGCTATTTTTAGCGTATCTAAGCACGAGTAAACCATCCTGA +CGTCCGCACCTTCCGCCCGGACGTTGAGTAGGCTCTTCCTTTTCGAGCCCGGAACCCTCAGGAGGTCTCC +GTAGGAGCACATAATGACGTCTTTCCTTTTTGCAAGCTCTATGGCGAGGTCTATCCTCTGCATGGGCATA +ACGCAAACAGGACACCCCGGCCCGTGGATAAAACGCACGACACCTTTTAGGAGCTGGTCTATGCCGTACT +TCATTATGGCGTGGGTGTGCCCTCCGCAAAACTCCATTATGTTTACCGTTCTTCCTATCTTTTCAGAAAG +TTTTTTTATCTTTTCGGAGAGTTTTAAAACCCTTTCTTTATCTTTATAGGCCTCAAAGATGGAAATTTCT +TCAACCCTCATACATACCTTCCTCTTTTTCCATTTCTTCTATTATTTCTTCGAAAAGCTCAAGACTCTTG +AGGGCTTCCTCTTCATCCAGCTTTTGTATGGCAAACCCAACGTGTACAAGTACGTAGTCACCTACGTTTA +CAGGTTCTGGCATGAGTTCGAGGGAAATTTTCCTTTTGACTCCGAGGGTATCCACAAGGGCTGTTCCGTC +CTCGTAAACTTCCACAACTTTAGAAGGTATAGCCAAGCACATGTCTACTTTAATAATTATATTCCTTCGG +TGAATGGTTGTTCATAAAAAAGAAAAGCAAAAGGTTTCCATCTAAAAGTTATCCTATTATTATGGCGTTA +GAACTAATAGAAAGAGGATGTCCTAACTGCGGAGGGGTTATAAGTTCGGACAGGCTCGAAAAAGGCTTGC +CCTGTTCAAAGTGCCTTCCAAAACCAACGGAAGAAAAAGTGTGCGATGCCCTTGAAGAACTGAAAACGCT +AAAGTACTTAAAACCTTTCTGCGATACGGATAAAAGTCTTGAAAGATTTATAAATTTCTTCGAAAAGGCT +GTAGGTGCAAAGCCCTGGAGCCTCCAGAGGGTTTGGGCAAAGCGCGTTTTTATGAACCAGTCCTTTGCGA +TAGTAGCTCCAACTGGAGTCGGTAAAACCACCTTCGGACTCGTTATGTCTCTGTTCTTAAAGGGAAGAGT +TTTGGCAATCTTCCCCACAAGGCTCCTCGCCCAGCAGGCGGGAGACAGACTCTCGGAGCTCGCCCAGAAG +GTTGGAGTTAACAAAAAAATTCTCATTTACCAATCAAAGAAAAACATAAGGGAACAATTCCTTAACGGTG +ATTGGGACATACTCCTCGGGACAAATATGTTCCTCCACAAGAACTTTGAAAACTTAATTAACTTTAAGTT +CAAATTAATCTTCATAGACGACATAGACAGCTTTCTCAAGAGAGGTAAAAACGTAGATTACCTCTTTAAA +CTTCTCGGCTTTTCCGGCGAGGAGATAAAGCTCGCCCTCAAGGAAAACAAGACCCAGAGGGATTATGACA +GGCTTGCAAGGATAAGAAAGAGAAAGAGGGATACGGTTCTCATCGTTTCTTCCGCCACCCTCAAACCTAG +GGGAAAGAGGGCATACCTCTTCCGAAATTTACTCGGTTTTGACGTCCAGAAAGCTATAACAACGTTAAGG +AACATAGTGGACGTTGCGGAGCCCGTAAAGGATCTCGAGGAAGCTCTGGAAAAATCCGTGGAACTTATAA +AGAAACTCGGGAAAGGGGGACTCGTTTACCTTTCTGTCTTTTACGGAAAAGACAAAGTTCAAGAAGTAAA +AGAGTTTTATAGAAAGCACGGTATAAACGCTGTATCTTACTTGGACTACAAACCCGAGGAGCTTTATCAG +ATCCTCGAAAAGGGCGAGTTTGACGTTGCGGTAGGAATTTCCCACATAACGAACCCCTTAGTTCGTGGAA +TAGACCTTCCCCACATAATAAGGTACGCGGTCTTTTTAGACCCCCCGAAGCACGTATTCCCGACGGAACT +TACTTTAAGCCCCCCACTCCTCCACGGACTGCTTCTTACGCTTCTCAACCTCTTTGAAGGAGACGACAGA +TTAAAGGCCATACAGTACGTTATGTACTTGAAAAGGTACCTCACCCTCAGAGAAGAACAACTCGACAACT +ACCCGAGGATAAAGGAAAGAGTGGAGGAGATAAAGAACTTCCTTGAGAATTACTTAAAAGACGAGAACTT +CCTTAAGAAGATAAAAGAGAGTGAAGACATCTCCCTAGTTCCTAAGGAGGGAAAGCTTTATATAGTCGTG +GGAGACGCAAACTCCTACATTCAGGCGAGCGGAAGAACCTCAAGGTTTATAGCAGGAGGAATGACGAAAG +GACTTTCCGTGGTTTACTACTCCGACCCGAAGGCCTTTTACTCTCTCAAAAAACGCCTTGCCCTTTATTA +CATGACACAGGAAATAGAGTTCAAACGATTAAGCGAAGTAGACCTAAATAAATTAATAAAGGAAATAGAC +GAGGACAGAAAGAGGGCAAGGGAAATCCTTCAAGGAAAAGGTGTAGCTCAGATAAAGGACCTCTTCAAAA +CCACCCTCGTTATCGTTGAAAGCCCAAACAAGGCGAGAACGATAGCGGGCTTTTTCGGAAAACCCCAGAT +GAGACTCGTGGAAGACTCCGTCGCCTACGAAGTTCCCTTGGGAGACAGACTCCTCGTCATAACCGCCTCC +CTCGGACACGTTCTTGACCTCGTAACCGATAAAGGATTTTTCGGTGTCCTTGACGACACGTACCCCTACC +TTCCCGTGTACGACACTATAAAGATATGCAGGGAAACACACGAACAGCACACTGAATACGAGTACCTAAA +GAAACGCTGTAAGGGAAAAATAGAGGACAAGCTGGAAATAATAAAGGGAGTTAGGGAAGTTTCTTACGAA +GTAGATGAAGTCTTTATAGCAACGGACCCTGACGCGGAAGGGGAAAAGATAGGTTACGACCTGTACCTCC +TCTCAAAGCCCTTTAACTTCAACATAAAGAGGGCGGAATTCCACGAAGTCACGCCGAAGGCCTTTAGAGA +AGCCATACAAAACCCCAGAGAAGTTGACCTGAACCTCGTAAAAGCACAGCTCGTGAGGAGAATTCTCGAC +AGGTGGGTGGGCTTTACGCTTTCCCACATCCTCTGGGACGCCTTCGGTAAAAAGTGGCTCTCCGCGGGAA +GAGTCCAGACACCGGTTCTCGGCTGGGTAATAAAACGCTACGAAGAGTCAAAGGAAAAGAAGGGAGAAAT +CCTCCTTCACGTAAACGACTTCCCTTTAAAGATAGAAATTGAGGACCTGATGTTCGCAAAAGAAATTTTC +AAGGACCTTGAACTGGCGGATATATCCCTCTCAAACCCTCAGGAAGAGGAAAAAAGACCGCTTCCTCCTT +ATACGACAGACACGGTTCTGGAAGACGCAAACGAGAAACTCCACCTTTCCGCTCACAAAACGATGAAAAT +ACTTCAGGAACTCTTTGAAGCGGGCTACATAACCTACCACAGAACGGACTCCACCCGCGTATCGGATGCG +GGAAAGTATTTAGTTGCAAAACCTTACATAACGAAGATGTTCGGAGAAGAGTACTTCTACCCGAGGAGTT +GGGGAGAGGGCGGTGCTCACGAGTGTATAAGACCCACAAGACCCTTAGAACCGAAAGACCTTGAGTTCAT +GATAACCGCGGGAATAGCGGAATTCGAGGATCCGGAAAATGCTCTGAAGGTTTATGAACTAATATTCAAG +AGGTTTATGGCATCCCAGATGAGACCTGCAAAAGTAATAACGGAAGAAATCATTTTAAAACTCCCCTACT +TTGAGTGGAAGGAAAGGGTTGTAACTGAGGTAAAGGAACACGGTTTTGACCTCATGTATCCGACCTTCAA +AGTCTTTCCCAAAAAAGAAAAACTAGAAATTACACATAAAGAGTTCAGGGAAGTTCCGAAAGTCTACCCC +TACACGCAGGGAACGTTAATTCAGGAGATGAAAAGAAGAGGACTCGGAAGACCTTCAACTTACGCCCAGA +TAGTCCAGACGCTTCTTGAAAGGCACTACGTTGTGGAAGAAAAGGGATTTTTAATTCCCACGGATCTAGG +AAGGGAAGTTTACGAATACCTGACCAAGCACTTCCCCGAGTGGACAAGTGAAGAACTCACGAGAAAACTT +GAAGAGGCGATGGACAAAATAGAGAGAGGAGAACTCGATTACATGGAAGTTCTAAAGGAGGTTCACAGGA +TAAAGGTACTCCTGAAGGAAGAAAAGGCTTTTAAAAAATAAAACAATTTTTTGATTTGAATTTCTATAAT +ATTCATTATGTGGGCCAGAGTACTTAAATTAATCTGCGAAGAGTTAGGAGACAGAGAGCTGTTCCTCTTG +GAAGCTGACAAGGATCTTAAGTGGTTTGGAGCACCTGTAAAGGAAGTGTGTGAAAAGGTAAACTTTGACG +CGAGGAACTCCGAAATAGCCCAGACCGTAAAGGCAAGCCTTCAGGAAGTTCAGGGAGAAGGATGGATAGT +TTACGTAGATCCCTTTAATAACTTTGCGGATATATACGAGGCGAATAAACCCAGATACAGAAATAGGTGG +AATCAGGAAAGACCTTACGACATAAGCGAAACACGTTTCCGCGTAGGATTTTTCCCTTCAAGGGAAGAGG +CTTACGATTCTTCTTCAAGATTTCAAAGAGAATAAGGGATCTTTACGACCTTAAATTGGACGTTATATAC +ACTTAAACCGTTGTTTTAATTTTGAGCTTCCTCATAAACTTTTTAAGCTTAAATTATATCTTTAGGTAAC +AAATTCTTTTGTGGAGGTTGTACATGGCTAAGAAAAATCCTATCCAGCCCGGACCAGAAGGATACATACC +AACCCCTGCCGCATTCCAAGGATGTGACCTTCCTCCACCAGGAAAAGCACTCCTGTACGGAGAAATAGTA +GACGAAGAAGTAGCAATGAGGGAAGCCGCAAAGGCACTCCTGACAAGAAGAAATCCCACTATATTCCCCG +GTCCTCTGGTCCTGTGGGGATGGAACGCGGACGCAATGGAAAAAGCAAAAGCAGTTCTGGAACTCGCCAT +GGAAATTCCCAACTGCAGAATTATCCCCATGCCCGACTACAGACCCAAGTACCCCAAAATTGACCCAGAA +GCGGAAATAAACCCGAACCACCCCAACTTAACGATACTTCACAACAAAATAGAGGCTTGTATCTTTGTAG +GCGTTCACTGTCACTACGCAAACTTATCTTTAAGGATGATAAGGGCGGGAACGAACTGCTTTACCATAGC +TCTATGTGCTGAAATGGGACACGAAGACGCAATGGTTTCCCTAAGAGACGTTCACGCGGATGAAATAAGG +AAGTTCAGGGACGTTGTAGTAGAAGTCAGAAAGGAACTCGGAATAGAGTGGGAACCCAAACTACCCCCGG +AAAATCCATCACTTCCAAAAGAAGACTGGGTCAAGATATCACCCCTGGACTTCGGAGAGTATGCGTATCT +GCTTATCCCCAGAAGGGGTGAAATAGTAGAAGAAAGTGAATAACAATTGAGGAGGTGTTGTAATGCCTGA +GCAAAGAGTTGTTGAGCCTGACTACCTTCTTTTAGAGGCTCCAAGGGAGAAAAAATTTATTACCGGATCT +CAGGCTTTTGCAGAAGCTGTAAAGAGGGCTAACGTAGACGTCGCTATAGCTTACCCCATAACTCCCCAAT +CCGAAACCATGCACCTAGTCGGTGACCTTTACGCACAAGGATACGTTAAGGATTACTATAGAGCGGAAGA +AGAGTACGGTGCTATGTCCGCAATAGCGGGAGCGGTGAGAGGAGGAGCAAGAGCCTTTACCGCAACATCG +GGTCCAGGACTTCTGAGAGGTCTTGAGGCTATAGTTTCATGGCCTGGACACAGAATTCCCGCAGTTCTCG +GTGTAATGACCAGAGTCGTAAACGCACCCCTCTCCATACAGCCCGACAACGTTGAAATATCCTACTTACT +TAACTCAGGACTCGTAGTTCTCCACGCTGAAAACCAGCAGGACGTTTTTGACTTTACACTGGCAGGTTTC +GTGATCTCCGAAAAAGTAGACGTTTACCTGCCGGTCGTAGTTGCAACGGAAGGTTTCTTCGTAACTCACG +CAAAAGGTTACGTAGAACTCCCACCTGAAGATATGAAACTCCCACCGAGAGATCCTTACAAAGCACCGGT +ACCGCCCACCGACTGTGAAATACCTCCTGCGAGAATACAGAGAGACGCTCCGGTTCAGAAGTCAAACTTC +ATGAGCTACCTTATACACGCTGTATGGCAGCAGGAAGTTTGGTCCGCAAACAGGAGAGCTGCAAAGTGGA +TTAAGCACTACCTCGGTGGACTCATAGAAGTTGTAAACCCAGACGCGGAAGTGTTCGTAGTAGCTTCCGG +ATGTGCAGCCGCACAGGGTAGGGAAGCTCAAAGGTACGCTACTATGGAAGGCCTAAACGTAGGTCTAATA +AAGGTAAAATCCCTCAGACCGTTCCCCGTGGACGAAATAAGGGAAGCTCTCAAGAACGCAAAAGCCGTAA +TAGTTCCCGAGCACAACATAGTTGGATGGCTCGCAAAAGAAGTAAAAGCTGCTATACCCAACAGCGGAAT +AGTTGTTGACGGTCCGAGAGTTTACGGAGGAATGACCCTACCCGTTGAACTTATAATGGAAGAAATTTAC +AAAGCCTTCGGTATTAAGAAGGAAAAGAAGGTTGTTGTTTAAAAAAACTTTAAGGAGGTGTTGATATGGG +TCTGGAATACGTAAGAATTTCTCCAGGATTTGAAAAATACATGCCCAGAGACTACGTGGATCTCGTTAAG +TACGGGCCCTTCGGAAGAAAAGTAGACGTAATGGATATGGGCCAATTCAAGGAACTCGTTGAAGAACACC +CCATGTGCGCTGGATGCTACATGGCTTACTTCATAAGGGTGTTCTACACGGCACTCCCCAATCCCGAGGA +CACAATAGTAATCGGAACGGCGGGATGTGCAAGGCTCGCACTCTCACAAGCTGCAGTTCCCTTCATCTAC +GGTAACTACGGTGACACGAACGCAGTTGCATCTGGTCTAAAGAGGGCACTTTCTATAAGGTTCCCCGACA +AACACAAGGACGTTGTAGTTATAGCAGGTGACGGTGGTCTCATAGACATCGGTTTTGGTATGACGATGCA +CTCCTGGTTCAGAAGGGAAAAGTTCACTACCATAATGGTTGACAACGAAGTTTACGGAAACACTGGCGGA +CAGGAAAGCGGAATGTCTCCCAAAGGCGTTCAACTCAAGATGGCTCCTTTAGGAAAGAAGTTCGATAAGA +TAAACGCCGTTGAACTTGCAAAGACTGCTGGATGTGTTTACGTTGCAAGAATTTCTCCCACAAACCCCAA +GAGAATAGCTAAGACCATAAGAAGGGCGATACTTGCCGCAAGACACTTTGGTCCTACCTTCATCCACGCG +TACACCTCCTGTAACATAGAGTACTCCATACCCACGAGAGAAGTTCTCGCAGACGCAAGGAAGAGGGAAA +AGCAGGACTTCAAGTTCTACGAATGGATGACGGACGAAGTTAAGGAATTCCTTGAAGAAGTTGAAAGGAA +GGAAAAGCAGGAGGTTAAGAAATGAAAAGGTACAACATAAGAATAGCCGGTGTTGGTGGGCAGGGGGTCG +TTACCTCTGCCCACATTATTGGAAACGCTATGGCAGCCGCCGGAAAGTACGCCTCCCTGGTACCCTTCTT +CGGTTCTGAAAAGAGAATGGCTCCCGTTGAAGCTTACGTCAGGGCTTCAGATCAGCCCATTTACGAAGTC +GGTGAAGTTGTTTACCCCAACGTTATCATGATTTACCACCCTCAGGTTATAACTCACGGTAAGTCCTACA +CAATGCCCTTCTACTCCGGACTAAAAGAGAATGGAATGATAATAATTAACTCGGACGTAGACATAATTCC +CGATGAAGACAAGAAAATACTCGAAGAACTAAACGCAAAGATTTACTACATTCCAGCTACCCAGATAGCG +AGGGACATAGCCGGAACGGAACTCGCCACGAACATGGCTATGGTGGGAACTTTCTTCGGTATCACGAGAC +TCGTTACTCTCGAACACATAGAAAAGGCTTTAATTGAAAGGTTCCTAGGAGGAACTTTCGTAGCATCAGG +TGGTACCACGGCACTTGACTCCGCAATTGAAAAGAAATTCAAGAAGAAACAAGAACTCCTTGCAAAGAAC +ATGGAGGTTATTAAGTACACGATGAAGATGGCTGAAGAAAACGGCTGGGTAGAGGAGGAAGAAGAGCAGG +TAAAAGCCCAGTAGGAGGTATAGATAGATGTACTTTGTGGCTGATGTAAAAGAAAAAGAATGTGCTCAGT +ACAACTGCAAACAGTGCGTTCTCTTCTGCCCTGAGCCAAACTGCTTGAACTTTAAGGCTTCTACGAACAG +CGCTTGGGTATGGTACGACAGGTGTAAGGGATGCGAAATCTGCGTTTACGTGTGTTCTGACCTCTTAAAG +AGACACTGCATTGAAATGGTAATGGTAACGCCCAAGGCTACGGCAAAATCTTAAGCCTTTTCCCTTTCTC +TGTTATACTTTTCTTTAAGGGAGGTGAAGTGTGACCATAAACGAAAAAGAAATTGAAAAATTAAAGAAGC +TTGCGAAGGAACTGGAAGACTTACCGGTCGGTGTAGATATTGACTTGGAAGTTTGTTTTGACGATGTTGT +GAAGGAAGAAGGCTGTGAAGTTGACTTAACACCCGGTTACAAACCTCAGTATCCGTACGTGAAGATCGTT +TACAAAACTGGAGACGGAGACCTTTTTGAGAAGAAGATAGAAATACCACCCGAAATACTCAAAAAAGACA +TTAAAGAAATAAAGGAATTTGTAACCTTTGCAATAGAACAATTTATGGAAGAAATAGACAGCGTGGAGTA +CGGAGGAGAATAAGTATAATCTTTCTTAATGTCTAAAAAGGTTGTAATACTCGGAAGCGGACCCAACAGA +ATAGGACAAGGTATAGAGTTCGATTACGCCTGTGTTCACGCCGTTTTTTCTCTTCAAGAAGAAGGTTATT +ACGCCGTAATGGTTAACTGCAATCCCGAAACCGTTTCTACCGACTACGACACAGCCGATAAACTCTACTT +TGAGCCTATTGTCTTTGAACACGTAATGGACATAATAGAGCGAGAAAAACCCGAAGGCGTTATACTCCAG +TTTGGCGGACAAACCCCTCTGAAGCTAGCACTCCCGCTTCAAAAAAACGGAGTAAAAATCTTAGGAACTA +AACCCGAAAGCATAGACAAAGCTGAGGACAGGGAACTTTTCAGGGAATTAATAATAGAGCTGGGGCTCAA +GCAACCACCAAGCGGTACTGCAAGAACAAAAGAAGAAGCCCTAAAAATAGCAAAGGAAATAGGCTTCCCC +GTTCTTGTGAGACCCTCTTACGTACTCGGCGGAAGGGCTATGCGGATAGTCTACGACGAGGAAGAATTGA +AGGAATACCTCGAAGAGGCTGTAAGCGTAAGTCATGAGAGACCCGTATTAATAGACAAATTCCTTGACAA +CAGTATAGAACTGGACGTTGACGCGGTATCTGACGGAAAAGACGTTTTAATCGGAGCGGTTATGGAGCAC +ATAGAAGAGGCGGGAGTTCACTCCGGAGACAGCGCTACTTCAATACCCCCCTACTCCCTTTCCAAGGAAA +TTGTAGAAGAAGTAAAGGAACAGACGAGAAAACTCGCCGTAGCCCTTGAGGTAAAGGGACTCATAAACGT +TCAGTACGCGGTTCAAAACAACGAGGTTTACGTCCTTGAGGTAAACCCGCGGGCTTCTAGAACGGTTCCC +TTCGTCAGCAAAAGTATAGGTTATCCCCTTGCAAAAATAGCAACTAAAGTTGCAATTGGGAAAAGCTTGA +GGGAAATACTACCGGAAGTCTTTGAAAGACTTGAGAAAGGAGAGGCACACTTTGCCTCGGATTTCCTCCC +TAAAGAAAAAAAGATATTCTCTGTAAAGGAAGTCGTATTTCCCTGGAAACGTTTTCCGGAAGTTGACCCG +ATTTTAGGGCCGGAAATGAAGAGTACGGGGGAGGTTATGGGGATAGATAAAGAGTTCGGACTCGCCTACT +ACAAGGCTCAGCTTTCAGCTGGCTACAGACTTCCAGAAAAGGGAAACTTATTTATAAGCGTTGCGGACAG +GGACAAACCCAAAATCCTTGAACTTGCAAAAGAATTTGAGAAACTCGGTTTTGGTATATATGCAACTTCC +GGTACTTACAAATTTCTAAAGGAGCACGGTGTAAACGCCAAAAGGGTTTTGAAGGTTTCAGAAGGCAGAC +CTAACGTTGTTGACATGATAATAAACGGAGAAATTCATCTGGTAATAAATACTCCCTCCGGAAAGCGTGA +AAAGAGCGACGCTTATTACATAAGGAGGGCATGCGTTCAGTTTAACGTTCCTTACTACACTACGATGCGT +GCGGGATACGCAGTTCTTGAAGCAATAAAAAGCATAAAGAAATTAAAAGAAGAAGGAAAAGGCTTAAGTG +TTCATTCCCTTCAAGAGATTTATAATATTTAGTTAGTAAATCCTAACAGGAGGTGGAAGGATGGGCGACG +TAATGATAGCTGTTATAACTATCGTAGTTTTACTCGCGTTAATACCCGTATTCTCAAAGCTTCTTCCCGC +TTAAGCCATGTTTTGGGTTTTTCTCGTAAGGCACGGTGAGGCTTATCCCGAAGAGGTAGACCCTCAAAGA +CCTTTAACCGAAAAGGGAAGGAAAGATACAGAAAAGATCGCGAAAGCCCTGAAAAATTTCGGTGTAAAAC +CTGAACTGATATACACTTCTCCTAAGCTGAGGGCAAAACAAACCGCAAAAATAATTGCGAACATTTTAGG +TGTTGAAAAAATCAGGGAAACGGAACTCCTCCTTCCGAATACCGATCCAAAAGAAACTTCAAAGCTGATT +GACGGAAAAAACGTAGTCCTTTGCGGACACCTTCCCAATCTCGCCCGCTTGTTTTCCTTACTTTATCTGT +CTGAAGACAACGAAAGAAGGGTTAATTTATCCACATCTGGAGCTTTAGTTCTCAAATGGAAAGATTTCTG +GGTTTTAGAACTCCTCTTGGAGCCCTCGGTGTTGTAATACTCTTAACACTCATTCTTTCCAGCTGTAGTG +TAAAAACCTCATACAAAGAAAAGGGTAGAGTTTACAACGGCAAATGTCCAGAATATGCAAAAGTATGGGT +TCATTACTGCCCAACGAAATACGCTTACACGGACAGGTATCAGCACCTCAGTAAGGTAAAAATCGTAAAT +CCCAGAAACGGAAAAAGTGTAAAAATATCACTCAGACTTAACAAAAAGGTTAGGGGTATATGCCTACCTA +AGAGGCTGAAGAAGTACTTAGGAAAGCCCTTTCTGGGAAAGGTTTATCTTCTAAGATGCGGAGAAAACGG +CGTAAAGAAGTGTCCGAAGTACATAAGGGGATACGCCTCGTGGTACGGAGGAAAGTTCCACGGGAGGAAA +ACTGCTTCGGGAATAAGGTTCAATCAACACGAGTATTACGCAGCTCACAGGTACTTGCCATTCGGAACAC +TCCTTGAAGTTAAAAATTTAAAAAACGGCAGAAAGGTGATTGTTAAAGTCGTGGACAGGGGACCCTACGT +CAGGGGAAGGCACCTTGACCTTTCTTACGCAGCAGCTAAAAAGCTGGGTATGATAAGGGACGGTGTAATT +CCCTTTGAGGCGAAAGTGCTCAGGTGTGGTTACTGAAAAAGGTGTATATTTAAACTTGTTAAGATGTGCG +GAGTTGCAGGAGTCTTTAATTCCCCTTACGCAGCGGAATATGCCCTTTTAATGATTTACTCACTCCAGCA +CAGGGGACAGGAAAGTGTAGGGATAAGTTCCTCTGATGAAAAGGAAATTTACACCGTTAAAAAACCCGGA +AGGGTTTTAGAAGCGATAAAAAAAGAAGACCTTGAAAAATTAAAAGGAAGTATAGCGATAGCACACGTCA +GGTACTCAACAGCGGGAAACGCAGGAGGCTTTAACGCCCAGCCTCTTGTGAGGGAAACACCTCTCGGAAA +AGTTGCGGTAGTACACAACGGAAACCTCGTAAACTTCCTAACTTTGAGAAAGGAGCTTGAAGATAAAGGT +ATAAAGTTCAATTACAACTCTGACAGCGAACTCTTTTTAGCACTTCTTGAGGAAGGAAGGACCTATATAC +CTGAAGGTGTAACGCTTCATCCGGAGGACAAGGATTTCCTTCCCTACATCTTTTACGCCCTTTCTAGAGT +TAAAGGTGCCTACAGTTTGATATACCTCTTTAGGGACAAGCTCGTAGTTGCGAGGGATCCATACGGTTTC +AGACCCTTAGCCTTGGGAAGGAAGAAAAACACCATTCTGGTAGCTTCGGAGAGCTGTGCCTTTGACATAC +TTGAAGCTGAATTCTGGAGAGAAGTAAAACCGGGTGAAGTTCTCGTAATAGACAAAAAAGGAAAGAGGAG +CTACAGGATATTCAGTTCACCCAGAAAAGCTATGTGCATATTTGAGTTTGTGTACTTCTCAAGACCGGAC +AGCTACATATTCGGCGACTGGGTATACAACGTGAGAAAAGAAATGGGAAGACAGCTTGCGAGAGAAGATA +ACATAGAAGCGGACGTTGTCATTCCCGTTCCCGATTCTGGAGTCGTTCCGGCACTCGGATACGCGGAGGA +AAAGGGACTGCCTTTTGAGTACGGGCTTATAAGAAACCACTACGTGGGAAGGAGCTTTATAGAACCAACA +CCCGAACTCAGAAACTTAAGAGTTTTAATGAAGCTCTCTCCCAACAGAGCCGTTCTGCAAGGGAAGAGAG +TTATAGTTATAGATGACTCCCTCGTGAGAGGAACTACCTCAAAGAGGATAGTCAGCATGCTCAGGAGGGC +AGGTGCTAAGGAAATACACATGAGGATAGCCTCTCCGCCCGTCGTGGGACCCTGTTACTACGGCATAGAC +ACGCCCACAAAAGAGGAGTTAATAGCAAACAAAATGCCGATAGAGGATATAGCCAAGTTCATAGGTGTAG +ATTCCCTGAAGTACCTTTCTTTAGAAGGCTTGAGAAAGTGTGTTGATAAGCCTGAAGATTTCTGCGACGC +ATGCTTTAGCCTGAATTATCCCGTAGAAGTTGAAGATAATGTCCCCTCAAAGATACGCTAAAAATTTGAC +AAATCTAAACTAAAGAAATATCATAAAAATTGTTAAAACTCACAGGGAGGTGGAAAGATGGCTACAAAAG +CTATACCAAAAGAACAGTGGGAAAAGTACTTTGATAACCTTTCTAAAAACCTGCCCGCTGTTGAAGTTCA +GCTGGAAGTAGTAGACAAGGAAATTGGAGACCAGGTGGAAGTTGAGTACTCCCCCCTTTTGGGACTCTCT +TACGATCCCAAAGATGACGTATTTGAGATTCAGTTCAGAGAAACCCACGATCACCTCATTTACCATCCCA +AAGAAATATACGTAGAAGAAGAGGACGGGAAAATAACCACAATAGAAGTGGTGGACAAGGAAGGAACTCG +CTACATCCTAAGAATAAAACCTGCAATTCCTTTACCCGAGTAATTCTTCGTACATCCTCTCCTCTGCCCC +TTCTGCGAAAAATTTTTTAATATTTTCTGAATACCTTTCCAAGTTTTTAACAATTTCCTTTAAGGCGGAT +AAAACTTTATCAGGTTTAGCTTCTTCCTGTCTTAAAACCAAACCTCCTCCCAGTTTTTCTATTTCTTTAG +CGTTGTAAAATTGGTGGTCGTCAACCGCATAAGGGTATGGAACAAACACAGAAGGTACACCAAAGTGCGA +AAGCTCGTTTATCGTGCCAGCTCCCGCCCGTGAAATCGCGACATCTGAAGCTGAATAAATTAGTCCCATA +TCAAGAGAAAAGGGCATTACGCGAAATTTTTCCCCTTCCAGATTTTTAAACTTTTCGTAGTGAATTTTTC +CGGTAAGGAGAATTACCTGAAATTCCTTCGGAAGAACACTCTTTAAATCTCTTGCGAGCTCGTTTAAAAA +GAGTGCTCCCTGAGAACCACCGAATATGAGAACAGTTATTTTGTCAGGTTCTAAACCAAATCTCTTCTTT +ACTTCTTTCTTCGGAAGTTTTTTCTTTAGTTCTTTTCTTATGGGTAGTCCCACCCTTACGCCTTCTGGGA +AAAACCTTTTAGTGTAATTAAAAGTGATTAAAACTTTTTTTGCTTTTTTTGATAGGATTTTGTTAGTTTT +ACTCGGAATCGAGTTTTGCTCGTGAATAAAGAGCTCTTTCCTTCTCAAAACTGTATTTATTCCTAAGGGA +AGGGATGCGTATCCTCCGAAGATCAAAGCCCTGTAATCCTCTTTTAAAAATTCGTTTATCTCTTCCTGAG +CTTTTAAGAACTTCCAAATAGCCTTTAACTTTTGGTAAAAATTTCTTTCCCTTAATGGTTCTACATCAAG +GAACAGCTTTTCTGTCTTTATTAAATCTTTTAACTCGTATTCTATTCCCCTTTTACTCCCGATGAACTTC +ACTTTTTCCTTTTTTAAGACATAATTTGTAAAAGCTAGAGCGGGAAAAAAGTGTCCGCCCGTTCCTCCTC +CTGATACAGCGATCATCTTGATATTTTAAACTTTTCTTTTATGAAACCACTCGTTGGCGTAATAATGGGA +AGTATTTCCGACTGGGAGTATATGAAAAAGGCTGTTGAAGTTTTAAAGGAATTCGGAGTTCCTCACGAGG +TTAAAGTGGTCTCCGCACACAGAACGCCCGAACTCATGTATGAATACGCAAAAACCGCAAGGGAGAGGGG +AATAGAGGTGATAATAGCGGGAGCGGGAGGCTCCGCCCATCTTCCGGGAATGACCGCCTCTATGACTACA +CTTCCCGTTATAGGCGTTCCCATACCCACTAAAAACCTCGGAGGAGTGGACTCGTTGTACTCGATAGTCC +AGATGCCAGCGGGTATTCCCGTGGCTACGGTGGCTATAGGAAACGCAACAAATGCCGGGCTCTTAGCGGT +AAGAATTCTCTCAATAAAGTACCCCGAGTATGCTAAGAAATTGGACGAGTACACGGAAAAACTGAAGGAG +AAAGTGGCTAAAATGAACGAAGAACTGCAAAAGGAGGTGGAAAATGGAATTTGACGTGAAGGATTTGTCC +TTAGCGGAAGAGGGATTGAAGAGGATTGAGTGGGCTGAAATGGACATGCCCGTCCTCAGGCAGATAAGGG +AAAGATTTTCAAAGGAAAAACCCCTGAAAGGTAAGAAGATTTCCGCATGCCTTCACGTAACTACGGAGAC +CGCTAACCTTATGAGAACTTTGAAGGAAGGAGGAGCGGAAGTTTACCTAACGGCTTCAAATCCACTATCC +ACGCAGGACGACGTTGCGGCGGCACTCGTAAAGTACTTTGAAATTCCCGTTTTTGCAATCAGAGGAGAGG +ACAGGGAAACTTATTACAAGCATCTGAGGGCTGTGATAGAAAAGGAACCGGACGTTGTTATTGACGACGG +TGCGGATTTAATTTCAACGCTTCACAAAGAATACCCCGGGCTTGCGGAAAAGGTTCTCGGCGGTATGGAG +GAAACCACAACGGGAGTTATAAGACTGAGGGCTATGGCAGAACAAGGAGTTTTAAAGTTTCCCATAATAG +CGGTAAACGACGCATACACAAAACACATGTTTGACAACAGGTACGGAACGGGTCAGTCTACGATAGACGG +TATTTTGAGGGCTACTAACAGACTTCTGGCGGGTTCATACTTCGTAGTTGCGGGTTACGGGTGGTGTGGA +AAAGGAGTTGCTCAAAGGGCAAGGGGAATGGGAGCGATAGTGATAGTTACGGAAGTTGATCCGATAAAGG +CTCTGGAAGCCAGAATGGACGGATTTCTGGTAATGCCTATGGAAGAGGCGGCAAAGCTCGGTGACTTTTT +CGTGACCGTCACGGGAAACATACACGTCATTAGAAGAGAACACTTTGAAGTAATGAAGGATGGTGCCATA +GTTGCAAACAGCGGACACTTTAACGTGGAAATAGACATTCCGGCACTTGAAGAAATGGCGGTAGAAAAAA +GGGAAATAAGGAAAGAAGTTACGGAGTACAAATTAAAGGACGGAAGGAGGATATACCTCCTTGCGGAAGG +GAGGCTCGTGAACTTAGCTGCCGCGGAAGGTCACCCAGCATCTGTTATGGACATGTCCTTCTCAAACCAG +GCTCTGAGTGCTGAATACATAGTAAAACACCACAAAGAACTCGAAAAAAAGGTTTACAGAGTTCCGAGGG +AAATAGACGAGGCTGTTGCAAGGTTAAAGTTAAACGCCTTGGGAATAAAGATAGACGAACTCACGGAAGA +GCAGAAGAAATACCTGAGTTCCTGGGAAATGGGCACCTGAGGGCTCAGCCCTCTTTTAACCACTTTTTCA +GTACCATAGCCACTTTTTCGGGTTCCTGCTTTGCGATTTCCAGCAATTCTTCGTAAGGTGTCTTCTTTCT +GACTTCTTCTACCGTTGGCGGTACTCCGGGAACAGCTGGAGCGGGCGTTGGAGCGGGAGGTCTTCTTCTT +AGCAGTTTCACAAGTCCAAAAGCTACAAGTCCCAGTATAACAAGGCTTACAAGTGCTACGGCTACGTAAA +CGTAGGTAGGAACTTTGGGCTTTTCCGCCACGACCGTGGGCTTTACAAAAGGAACGCTAACGATAGACAC +CTGATCTCCACGTTTTGGATCTAATCCCGCGGAAGCTATTATTAAGTTCTTAAGTTCTTCCGTGTTTACC +TTAACATCTTTGTCTATAACCAAACCTACGCTGATTCTCTTTACCTTTATCGTTTTGTCCTCAAAGTATA +TTTCCCTCTTACTCACCTCGTAATTGGTTATGCTCTCTTTTCTCTCGGTGATTAACTCCCCTCCTCCCTG +TCTTCCCGTAGCGGGCGGGATGTTTGCTTGAGTTCCCGGAATACCCTGAGCCCTTGTGCTCGTGGTTCTT +TCCTTCTTCTTCTGCTCACTCACAACTGCCGTGAGGTCAGGGTCGTAAAGCTCTTCCCTCTTCTTCATGG +AAGAAAAGTCAAGCTCCGCAGAAACGTTTACCTTTACCTTTCCGTAGCCGAAAACCTCCTCTAGGGTTTT +CTGGAGTTTCCTTTCTAAGCTCTTCTCAAATTCCCTTTTTACTTTTAATTGAGAGGCGTTAGTTTTAAAT +TCCTCGTCCAAATAGGCGGTCAAATCCCTCCCCTTGTCGTCTACCACTACCACCTGCGAAGGTTTTAAGT +TCTCAACGCTCCCAGACACGAGATTTCTTATAGCCTTTACCTGCTCGGGAGTGAGTTCACATCCCGGTTT +TAACTTTAAAAAAACGGAGGCCTTTGCCTCCTCCTCTTCCCTTATAAATAAACTTTTTTCGGGAAGAACT +ATATGAACCCTTGCAAACTCCACGCAGTCCAAGCTCATTATCGTCTTCGCAAGTTCTCCCTCTATAGCCC +TTTTGAAGTTAACGAGTTGTTGAAAGCGGGAAAGAACTATGCCGCTTTTGTCAAAAAGCTCGTAACCTAC +TATACCTTTTCTTGGCACACCCTTGGCGGCAAGCTTTAGCCTTAGTTCCCTTGCCACGTTTTCCGGGACG +TAAATCGTTCTTCCATCCGGAGAGATCTTGTACTTTACCCCTTCCTTGTCGAGTTCCGTCACTACAGCGT +TCAGGTCATCCGGAGAAAGGCCTGTGTAGAGAACTGTGTAATTTTCCTGAGAGAGATAAATAAGGGCTAC +AGCTCCCAAGGATAAGAGCAAAAGAGGAATGCCTACCGCGAGTGCCTTCTGTACAGGTGTCAGGGCGTTA +AATCTTTCCTTCAGAAGGTTTAAGTATTCCCTTAACTTGTCCATACTAAACTTGCATCTTCATAAGTTCG +TTGTAAGCTTCTAATAGTTTATTCCTTACCTCTATGAGAAGGTTCAGGGCTACCTTTGCCTTTTCCGCTT +CTATAACTATCTCGTGAAGAGGAACGTCTCTTCCCTCCAATACCGCCTCTTTTAGCTTCTTTGACTTTAA +CTGCTTTTCGTTCACCCACTCCACGAAATTTACGAAGTTCTCAACTATATCCTCTCCCTTCACGTTTTGT +TGGACTTCAAATAATTTTGGTATAAAACCGAGTTTTCCTACTTCCATGCTTCAAAGGTCCTCTCAAAGAT +TTCCTTAGTTAATGAGAAGGCTTTTAAGTTAGCCTCATAACTCCTTACGGCGGTTATCATATCCACCATC +TCTTTTACAGGTTCTATGTTGGGAAGTCTCACGTATCCCCTCTCGTCAGCGTTGGGATTTTCAGGATCGT +AAATTAGCTTAAAACCGGGAACTTCTCTTATTTCCCTTACGTTTACGTAGACTTCCGAAGGGTCTTCAAG +ATTTTCAACTGCTTCAAATACGGGAACTAGTCTGTTAAACGGTGTTCCGTCACTCTTGAAGGACTCGTAA +TTGGCGAGGTTAGAAGCGACGGTGTTCATCCTTATCCTCTGTGCATACATCCCGGAGGCACTTATATCAA +GCGCGTTGAAGATATCCATCATTCAGCCCTCCCTTTTATAACGCGATTTAATGTGTTTAAACTGCCCATT +GCAAACTTTAGGTAGGTTTCGTAAGCAAGTTTGTTTTTTACTATCTCGGAAAGTTCTCTCTCTATACTCA +CGTTGTTCCTGTCGTTCCCTTGAAGTCCGTTTTTAAATACTACGAGTCTTTCCTCAAATTTCCTGAAGTT +TTTCACGTGCTTATTGTGTGTAGTCTTTAAGGGAATGGTAGGAGGTTCTAAGAAAAAGATTAAATCCCTC +CTTTTGTAGTTGGGGGTATCCGCATTTGCGAGGTTTCCCAAGAGAACTTTGTGCCTCTTCCACGTGAAGT +TTATGTACTTTTTGTAGAGATTTACACCCCTAAATAAGTCCATTTACCCACCACCCCATAAACTTAATAT +AGCCCTTCCCACCGTATCTTTAAAGCTTTTTGCCTCTTTCAAAACAAATTCTAAGGTTTCCCTGTCCTTT +TGCCTTTCTGCGCAACTGCCCAGTTTAACGAGCGTGAGTTTGTAAAGCTCGTCCTTCGTTTTGTATTCCT +TTAAAAATCTCTTGTACATATCCTTTGCTTCACTGCACATTTCCTTTTCAAAGTAAATGTCCCCTGCAAT +CCTGTAAGCGTGCGGAAAGTATCCCCTCATAGGCTCATACTCCTCAGAGAGATAAAGAACCTCGTTTATG +TAAGGACTCTTTGAGAGGTAGTAGTAGAGCAAGTAAGCTTCCAGTTTGTCTAATCCCTCAAGTTCGTGCA +TGGACTCCTTAAGTAGCCTCTGAGACACTTCCCTACTTCCTTTAACGAACCAGTACTTAGCCTCCAGAAA +CTTTCTTACAGGACTTTTGGGAAGGAGTTTTACCACTTTTATGAACTCGTCATCCCCTTTGTAAAGTAAT +GCTCTCGCAAGGAGCTCCACAGACTCAGGATTTTTGAAGACACTTAAGAAGTTATACCTGTTCGTTTTGT +ATAAAGAAACTATCAAGTCTGCATCCTTGTAATCTTTTAACTTCAGGAATTCCTCGTTTAAAAGTCTTAT +TTGCTCACCGTATGAAAATATCTCCTTGTTTAAGACAAATTCTCCTTCCTTGAACTTAAAAATTTTTAAA +AAATCTCTTGCTTTTTCTATAGGATTTTGTTTATTTATTAGTCCGTCGTAGAGGGCAAATAGGGCATAAT +TTCCTACTCTGCTATCTGAATTCAGCCACCCGAGCTGCAGGACAATGTCGTAATAAAACTTAAAATCCTT +AAATCTCTTCAGGAATTCCTTATTTGTCCAGTAATTCAGGTAAATTATCTGGTATATCGGATTGTAGAAG +AGTTCTTTTTTTATATCTTTGTATATCTCGTAAGCTCCTGAAAAGTCGTTAAAGGTGAGGTAAACCTTCG +TCAAGTAGTAATTGGTCATCGTGGTGTAGAACCTGAACCTGTCCAGTTCCCGTGTCCTGATGAAGTACAG +AAGACTCTTTCTTATCTCCCCATTTTTGAAGAGGGAAACACCCGCGTAGTAATTGAAGTGAACGTCAAAC +TTCAGAAAGGGATTGAGCGAAAAAGCCTTATTCAGGTAGTTTAAAGCCTTTTCGTAATGCCCGAAGTCCG +TTTCGTAAATCCCTAAGGTCAGGTAGTACAGGTATTCGTACTCCTCGGGAATGTTTTTTAAGTTTTTAAT +ATAGTTGTAGCCCGTGTAATCACCGTAGACCGCCGCAGTGAAGGAGTACTTAAGGAGGTATCTCGGATCT +TTTTTAGAACCGTAAAGGCTTGAATACAGATTCATAGCGTTCTCGTACCAGCCTATGAGAAAGTAACTGT +CCCCCAAAAACTCCTGCTTTAGGTCAAAGAACCTCGGCTCTTTGTAGTAGAAGGTATATAGATTCAGGTA +TCCTATGGCGGAAAACACCCCTTCTTTACTCCCCACGTGGTAAGAGTACAGGGCGTATGTGAGCCCGTAG +TACAGGTAAGAAAGCTCCCCATACTCGCTTTCCGGTGCTACGCTCCTTGCTTTTGAAAAGTAAATAAGTG +CGTCTACGTAATCGTTTACGGAAAGGGCTTTTAAACCTTCCTCGTAGTAAATTTTTGCTATTTCTTCGTT +ACTTCTCGTTTGTGGATTAAAGGAGAATACTGATATTACTGTCAGAACGAGAAGAATTAATACCCTCTCC +CATAAGTTCATTTACTTTTATATTAACCCTTTCCTTCTCCCTGTTTCTGTATACTTCACTTCCGTTTACG +TTAACACTCTCGAGCCTAAAACCGTAGGAACTAAGAATTTGCGAAACCTTCAAGGCATCGTAAGGAGTGA +ATATGAAGTTCTGGAGCATTTCGTTGAGATTAATCTTCAGATTTGCACTATCTCTTATAAAAGAAATTTG +AATTCCGAGCCCTTCCAGTTTAACGTTTACATTTTTCCTTTCACTTCCTTCAAAAATTCTTATATCTTTT +ATGGAAAAAACCTTTTCACTTCCCTGAACTTTCGGAATGTCTTTCCCTTTCCACTCCTTTAATTCCACAA +CCACACCGGGAGAATGACTGAATTCCTTACTCTTTTTGGTTTTAGACGTTTCTCCTTTAGAGACTTCTTT +AAAGATTTTTTCTTGAACCGCTTGAAGTTCGCTTAAATTGTTGAGTTTATTGGGTTGTTTTACGTGTGCT +GTACCTTTTCCATCTTGAGGTAGGGATACTTCCTGAACATTCACTGTACTAATCTGTAATTTATCCTTTT +TGGAAATTTCAAAGAATTTAAATTCTTTTACATTCCCCTCTTCGGTTGAAAAAAGCTTCAAGGGTTTATC +TATTTTCTCTTTATTTCCCTCATTAAATTGTATTTCTTCAAAAGCTTCTAAAGCTTTTTTTAGATTTTGC +AGGTTTTTCGTGAATAAAATGTTTAAATTTCCTTTTTCAGAATCAGAAGTAGTTTGAGTAGTAGTTCTAG +TATTTTGTATATTGGTTTTCTTAATAAAATTTACCTCTCTATTCTGGAAAATTTTCAGGAATTGATTTAG +GAAAGTTAAAATTTCAGGCAAAGGATTATTAAGCCTTTTAAAGCTCTCCTTTTTAGCTCCTTCAATAAAA +ACTTTGTTGTTGCTAAAGGTATCATTTAATTTCTCGTTAGACTCTAATATTTTTTCCAATTCAGGGACAA +AATTTACGTTAAAGTTTTGTGCGAATTCCTTTGCATTTTTCCCTGCAAAAAGGTTGCCATCTTTAGCGTT +GAATATTTCTTCAAATATTTGAAGGAATACTGCTAAGAAATCACCACTACTTTTTGTATTTATATTCGTA +CTCTGTCCAAAGGCATTGAGTAAGCTTTCAACCCTCAAACTCCCCACCTCTATTTAAGAAGTTATTCCTT +ACACCTCCTGAAGTCTATACTTTCGAACCCCAGTCTGTCCGCAAAAAAGAGCTGTGTTCCCTCGTAAACT +TCCCTTATTTCCTCGTCGTTCTCTGGATGCTGTATCCTTACTATCAAGTGTTTTTTTTCTTTTCCTTTGA +CTTCGACGTTGCATACCGGGAGCTTATTGCGCTTTGCGTCCATCATGACGAATTTCGGGAATATGCTCCT +TTTCACAAAGAAGTAGTGTTTGTAAAGTTTCTTAGAATACGCGTAAAGCTTTAGGTCTATTTCGCTTCTT +TCCTTCGTGTACTTGTACTTCGAGTAAATCTGATATATGGGATAACCCAAAGCGTTCAATTTGTCTATAA +CTTTCGAGTTTATTTGCCCCTTCTTTAAGGTTTCTTCCACCTTAAGAAGCTCTCTGTAAATATTAACTAA +CTTGGCTTTATCTTCTTCATAACCGTTCGGAAGGACAAAACCGAATAAGACAAGTAACTGAGTTATCAAC +TTCATACTTTTTAAATATACAATTCACGTCAAGATAACGTAGTATAAAAAATTATGACTTTCCTTTTCTT +AATACTCGTATTTATCATAGAAATCCTTCAACTTTCCGTATTTCCCCCAATTTTTGGAAACGCGTACATT +GTACCTTCACTGGCTTTTCTCTTAGTTTTATTTTCTTCTTACAAAATAAAGGAAAAAGCCCTCTTGTTAG +CTTTTCTGAGCGGTTTGTTCTACGACGCCGTGGTCAATTTCCTCGGTTTTATATCCCTACTTAATGTAGT +ATTTACTTACCTTTATCTGGTTTTGAATAACATACTCTTCGTAAAAAACCCAAAAGTTGAAGTATTTTTG +ATAATGCCTTTAATACTTTTACTCAGGAAGTTGACAATTTTTTTAGTTGTAAACACAAAGTTTCCCTTAA +ATATCGGCTTAAAAGATTTCGGTGTTGTTCTATTAATAGATCTCATATTTCTGATACTCCTCTACAAGGT +GTTTAATAAATACGTATATGAAAAGGCGTAGTTTTATCCTGATGCTTTTGTCCGCGATAGGGAGTTTTAT +CGGAGTTGTTGGGAATCTTTTCAGGATCCAAGTTCTTGAGGGAAAGAAGTACAGGGAGCTTTCCGAGAGG +AATTACGAGAGGGAAAGGTACCTTTACCCGCCGAGGGGGGATATATACGACAGGAACGGGGTCAAACTCG +CTTACGACGTTCCTAAATACGTCCTCGTTCTTGACGCTTACAGACTCGGAAAAGAAGAACTCAAAAAGAC +CTTGGAAAACTTAAAGGAATTATTCGGAATTGAGATTGATAAAAGGAAAGTTCTCAAGGGGGGATTTGAA +CCGCAAGTGGTAAAGGAGGAGTTAACTCCCAAGGAGCTGGAAATATATTACGAAAACAAGGAAATACTTC +CGGGAGTCTTTATAGAAGTTATACCCAAAAGGGTTTACCCGTACGGGGAGCTTGCGTCTCATATTTTGGG +ATACGTGGGGTATCCCAACGAAAGGGACTTTAAAAGGATAAAGAAAGAAATAGGGAGTAAAAGTTTTGTC +GGGAAGATGGGAATAGAACGGGTGTTTGACGAAAAGCTACTCGGGGAACTCGGAAAGGAAAGGGTTATGG +TAAACGCAATTGGGGGAATAGTAAAAGTTCTCGAAAGGAGAGAACCGAAGAAAGGAAACTCCGTAAAGCT +CACGATCGATTACAGATTTCAAAAAATAGTGGAGGAGGTTTTTAAGGAAAGCGGACACCCAGCGGGAGCC +GTAATCCTTTTGAAAGCTTCCACAGGAGAAGTTCTCGCCCTTGCGAGTTTTCCCAACTTCAACCCGAACA +AGGTTTACGAAGAGTGGAAAAGTCTCGTAAAAAATCCCTTGAAACCTCTCTTTAACAGGGCTATTAGGGG +ACTGTATCCGCCCGCTTCTGTCTTTAAAGTCCCTATGGCTTTTGCTACACTGAGTGCAAAGATAAGGAGT +CCTTGGGAAAAGGTTTTTTGTCCCGGATACTACGAACTAGGGGACAGGAAATTTTACTGCTGGAGGAGGT +GGGGACACGGTAAGGTGGATCTTATTAAAAGTCTTTCGGAATCATGCGACGTTTACTACTACACCGCAGG +TTACAAACTTGGCCCTACTAAGATACGCTACTACGCCAAAAGGTTTTCTTACGGTGAACGTATTCCCTTT +GAACTTCCCGTAAGGAAAGGTTTCATACCGACACCGAGGTGGAAACTCAGGCGCTTTAAAGAACCGTGGT +ACGATGGGGATACCGTTAACATGAGTATAGGGCAGGGATTTGTGCTGAGTAACTTAATGGAACAGACCTT +AATGATGATGGGTATAGCGAATAACGGAGTTATATACAAACCGACGCTTTTGAAGGAAATACTCGACGAT +AAAGGAAACGTGATATTCAGAAATAAAAGGGAAGTCTGGAAAGCGGTTTACGGCAGTCTTGAGCATTTTG +CTTTGATAAAGAGAGGATTGAGAGACGCGGTGAGAAAGGGAACCGCAAAACTCGCATTCTCCAGAATAGT +GGACATAGCGGGAAAAACGGGAACCGCGGAAGTTTTCTTCAAAAATAAGAGAAAGATTAAAAAGAAGTAC +AAGAAAATGAGAAAGAAACTTCCCTGGAAGTACAGAAACCACGCGTGGTTTGTGGGATTTGCACCCTACA +GGGACCCTAAATTCGTCATCGGAGTTTTTGTTGAGCACGGAGAGAGCGGAGGAAAAACAGCAGCCCCCAT +AGCAAGAAAGATTCTGGAGAGGATATACATAGAAAAACTCCATAAAGAACTTTAAAGTTTTTTGTAGTAA +GCCCCTTCCTGTACAACTTTTCCTTGAATTATTAAAGAACTAAGAATTTTGAAAACTTCTTTCCTTTCCC +TTTTCAGGAAGCTAATCACCTCGTCGAAAGTTCTCGGAACACTCAGGAACTCTAAGAGTTTGTCTTTTTC +ACTACTAAAGTCCAGTCTTTTTGCCTTCCCTTCTTCAATTAGCTTTAAGCAACCCTTCCACCTCTCCGAA +TGCTCGTCTCCCACATAGGCGTAAATCTCTCTTCCGTACCTGTGGGCGTAATCCGCGGTAATTAGAGCTC +CACTCTTTGAACCTGCTTCCATAACAAACAACTTTTTTGAAAGACCCGCTATAATCCTGTTTCTCTTCGG +AAAGGTCCATTTACTCCCTTCGGTCCAAGGAAGGAACTCGCTGACGAGCGATGCTCCCATACCCTTTAGT +TTTTTAATCCTTGATTCAATTTTTAAAATTCCTGTACCCAGAATTACGAAATTTTTAAAACCATGTTTTA +AACTTTCAAAATGAGCTTTGAAGTCTATCCCGACCGCACCGCCCGAAATTATCGGTCCCTCAATACTTTC +AAGGAGCTTTTCAACGGCGTTTAAAGACAACTTTGAAGGTCTCCTCGTCCCGACAATTCCGTATCCTCCC +TCAGGAGGCTCACCCTGATAAAAGAGGTAGGGAGGCGGTTCGTCTATCCCTTTCAAGATTTCTGGATACT +CTTTATCCTCATAAAGAATAAATTTTATATCATTTTTATCAATAATATTTATTAACTTTTCCTCAAAATT +CCTTTCAGTTTCTAAACTGAGTACTACTCTCTCCGCCCTTTTCGTACCGAGAAGGCGTTCCAGTTCTTTT +TCGTTTAAGTTCCTTATGCTTTTGAAGTGGTAAAGTATCTTTTTTACACTCTTTAAACCTACGCCGTTAG +TGTCCGCTAATCTAACGTAGAGTACTAAATCCTCCAGTTTTCTAAGATTCGTCATAAAATAGACCCTTGT +AAAATTATTAAGGAATTTTTATATTTTAATTCACAAACTCTTTTCTGGAGGAAGAGGTAATGTACTACGT +TGCTCAAGTCATTAAAGATGAATGTTCAAAATACAACTGTAAGCAGTGTACCCTCTTTTGTCCCGAGCCT +AATACTTTGATGTACACAGATGAAGGTCACCACGCTTACGTTAATACCTTGAGGTGCAAAGGTTGTGCCC +TTTGCGTTTACGTGTGTTCTGAGCTCTTGAAGCGTGATTCCATTGAGATGGTTTACGCGGAAAACAGAGA +CGTTGCAGGTGTAAGGTAAGGAGGTATTAGAATGGCAAAGTTAGGACCTGCAGGATATTCTCCCTATCCT +GTGGCGGTTACGGAAGGTGTTTTAACCCCTCCTCCCGGAAAAGCTCTTATGTTCAACGAGATAGTGGACG +AAGAAATCGCAATGAGGGAAGCCGCTAAGGCAATGCTCACAAGGGATAACCCCACCATATTCCCTGGACC +TCAGGTACTATACGCCTGGAACGAGGAGGCGAAGGAAAAGGCTAAACTCGTAAGGAAGATGGCGGAAGTC +CTCGGTGCAAAGATAATTCCCATGTACGACTACAGACCCAAGTATCCCAAAATTGACCCCGAAAAGGAAA +TAAATCCAAACCATCCTAACCTCACCATATGGCACAACAAGATTAAGGCGTGCATATTCATAGGTGTTCA +CTGTCACTACGCAAACGTGGCTCTCAAGATAATAAGGGCAGAAACGGACTGCTTCACTATAGCCATGTGC +AGTATGGCGGGACACGAGGACGCCATGATCACCTTGAGGGACCAGCACGTGGAGGACCTAGAGAAGTTTA +TAAAGATTGCCGAAGAAGTTAAGAAGGAACTCGGCAAGTAATGACTACAACTTTAAAGAAGTGGACCTAC +AAGGATTACTTAAAGCTTCCCGATGACAAGAGATACGAGATAATAAACGGAGAACTTTTAGAAGTGCCGG +CTCCTACAACAACTCATCAAAGAATAGTAGGAAAATTATTCAGGATTTTAAGTGATTTTGTAGAAAGTAA +AGAACTCGGTGAAGTTTTCGTTTCCCCCGTTGACGTAATTCTTTCCGAGGATAACGTGTTTCAACCGGAC +ATTGTTTTCGTTTCCAAAGACAGGAAGGAAATAATAAAGGAAAGAGGGATTTTCGGAGCTCCCGACCTTG +TGATAGAAGTGATTTCCCCCTCTACACTGAAGAGGGATACCGAAGACAAGAAAAAGGTTTACGAGAAGGC +TTGCGTAAAGGAATTGTGGCTCGTATTTCCGGGAGAAAAGGCGGTAGAGGTCTTCTTCAAGAAGGACAAG +AATTACAAAGTTTGTTCCTTTGGTTATGAGAATTTAAGCATCCGATCATGTTTTTTAAAGGGCTTTGAAC +TAAATTTAAAGGAAATCTTTTAAGGAGGTGTGTTATGGCACAACAAGTAAAGACTGAAAAAGTCAGATAC +AATAGAATGGGCCAAAGAATTGTCTCACCCGATTACCTTCTCTTTGAAGCCCCCAGAACCAAACACTTCA +TAACCGGTTCAGAAGCGGTTAAGGAAGCGGCAAAGAGGGCAAGCGTAGACGCTTCTATATCTTACCCCAT +CACTCCCCAGTCCGAAGCTGCACACATGCTCGGTGAGCTCTGGAGGGAAGGTTACATAGGCGTTTACTTC +AGAGGGGAGTCCGAGTTCGGTGTTATGTCCGAAGTGGCCGGATGTGCAATGGCGGGAGCCAGAACCATAA +CCACCACTTCCGGACCCGGAACTATGAGGGCTATGGAAGTATTTCCCATGTGGGCAGGATCAAGACTTCC +CATACAACTCGTTCTCATGGCAAGAGGTATAAACTCTCCACTCTCCATACAGCCCGATAACTTGGAAATA +TCCTTCCTTCTGGACACGGGATGTATGGTATGGCACGCGGAAACCGCTCAGGAACTATTTGACATGATTA +TCGCAGGATTTGTGGTAGCCGAACAACCTGACGTCCACGTTCCCATAATAACCGCGATAGACGGATTCTT +TATATCTCACACAAGGGAAGCTGTCTACCTACCACCAGAAGATATAGCATTACCTCCGTACAACCCCTAT +AAGGCACCCATGCCCCCGATAGACATGGAAATGCCTCCCGGAAGGTTCATGAGAGACCCCTTCGTAATGA +AGTCCAATTACATTTCTTACGCAACGCACGCAAGCTGGCAGTTTGAGGTAAGGGCCGCAATAGAAAGGTC +AAGACCTTATGCAAAGCACTACCTCAGAGGACTCGTAGAACACTTCGGAGACCCCGAGGGTGAAGTTCTC +TTTATCGCAAGCGGAACCGCTGCGGCTCAGGCAAAAGAGGCAACCCAGATACTCATCCACGAGGAAGGAA +TAAAGGCAAGAGTTCTCAGACTAAAGACCCTAAGACCTTTCCCCACGGAAGAAGTGAGAGAAGCCGTAAA +AGGTGCCAAGTATATATTCATACCCGAGTTCAACGTAGTGGGTTGGCTCGAAAGGGAAGTCAAGAGAGCT +CTTTATGGTTACACTGATATACCCATATTTGGAACCCCCAGAGTTGGTGGTGGTATGACGATGCCTCCTG +AATTCATCGTTCAAGAGGTTTTAAGACTTATAGGAAAGGAGGTGAAACATGTCGGTTAAGATATTTAAAA +TCAACGAAGATTTAAAGGAATTTATGCCTCAAGAAATTGTTGACCTTGAGGAAAAGGCTACTTGGGGCAA +TCCAAAAAGGGGAGTTATGGACCTCCCCTACGCGAAGGAGCTTATAGAAGAACACTCCCTTTGTGCGGGA +TGCCCAGAGTCCGCAGCTTTCAGGTACATCCTTGCATCCCTTCCCAGTCCGGAAGACACCGTAATAGTTA +ACTCTACGGGATGTACCTCTCTCGTTTTTCCGCATATCGCACTCCACACGGTACACCCTCTGTTCGGAAA +CCAGAATGCTGTTGCTTCGGGTATTAAGAGGGTTCTCGAGTGGAGATTCCCTGACAAGCCTAAGGACGTT +GTTGTAATTGCCGGTGACGGTGCTACCATAGACATCGGACTTGACTGTACACTCCAGTCTTTCTTCAGAC +AGGAAAAGATAACGACCATATGTTTTGACAATGAAGTTTACGCTAACACCGGTGGACAGGATAGCGGTGC +AACACCGAGGGGAATGGAATTCAAGATGGCTCCGGGTGGAAAGCAGTGGGATAAAGTTCCCATGTGGCAA +CTCGCTATAGACTCCGGATGCCACTACGTTGCAAGGCTTACCGTTTCTTCACCTAAGAAGGTAGAACAAG +TAGTAAAGAAAGCTATATACGTCGCAAGAGAAGTAGGACCCACCTACATACACCTCTACACACCGTGCAT +ACTTGAAATCGGGCTCAACTCAGACCAGGGTCTTTGGGAAATGAGACAAAGGGACAAAGAAAGGTTCAAG +TTCTTTGAATATATGACAGATGAGGCTAAGGAAGTTATTAAGAAGAAGAAAGAGGAGGGTCTGTTATGAC +ACAACCCGTTAGAAGAAGGATTAACGTTAGAATGCCCGCTATCGGTGGGCAGGGTGCGGTTTCCGCCGCC +CACATTATGGCTACCGCTGCGGACCACGCAGGGTATTACGCAGTCTCCAACCCCTTCTACGGTGCAGAAA +AGAGAATGGCACCCTCTGAAAGTTACGTGAGGATAGGGATAGAACCTATATACGACAGGGGAGAAGTCGT +TTATCCCGACGTTATAATGGTCTTCCACTCTCAGGTTATAACCATGGGTAAATCCTACACAATGCCCTTC +TACTCAGGTATAAAGAAGAACGGACTCATCATAATAAACGCAGAAGAGGATCTTCTTTCTGACGAAGACA +AGGCTTTCCTTGAAGAGAGAAACGTAAAGATATTTAACTTCTCCGCCACGAAGTTTGCAGTTGAGATCGC +GGGAACGGAACTCGCCACAAACATGGCTATGATAGGAGCATTCTTCGGAATTACTCAAATAGTTGGAATG +GAGTCCATTGAAGAAGGTATTAAGGCTAGGTTCCTTAAAAAATTCGTTGCGTCCGGTGGTACTGCATCTC +TGGACTCGGCTATTGAGAGAAAGTTCAAGAAAAAGTTAGAACTCATAGAAAAGAACATAGCTACCGCAAG +AGCGGCTTACGAGTTTGCCAATCAGTGGGCAAAAGAACAAGGAATAGAACCCTGGCTTCCCAAGCCTGAA +GCTGTTCTCCAGAGGGCTTAATATTCTTTTTCCTTTCCTTTTAAAAATTTTTTATTTTTCTAGATGAATT +ACTGCAATTTTATGGTGCCGGTGGCGGGAGTCGAACCCGCACGCCCGTGAAGGGCAGGGGATTTTGAATC +CCCCGCGTCTGCCAGTTCCGCCACACCGGCTATTTATTTATTATACTGACTCAAGATAAACTTAGCTATT +CCTATCCCTCCCGTAGAAGCGAGCTTTTCGCTAACGCCTTCTAAAAAGGCGTCGTAATACATCCTTGCGG +TAAAGCTCTTTCCTTCAGTCATAGGTTTAAAGGCTTCCTTTAATATCTCCTTTATAAAAATAGCTTCAAA +CTCCTTTGCAACTTCTTCTGGTTGTTTCTTCGTTAGAGTTCTATAGTCCATAGGCGGAGGCGAAAAAATA +ATCTTATTCAACAGCTATCCTCCTAGATTTAGGCTTTCTTTCGGTTTCCTTTACCCTTTCTTCAAGTACT +TTAATCTCGTAATCCAGTATAGTCCTGAAGGCTTTCAAGATTGAAAGGGGTATGTTGTAAAGATTTTTCA +TAACCTCATCTCTAACTTCCTTGGGAGGGATGCAGAACTCCATGAATTTAAAGAACTCTCTCCTGAGCTC +TTCCAGTTCCTTTTCCATACTCGGAACTTTTAATTCTTCAGCGGTTTGAGTAGTGCTTTCCCTCCTTTCC +TCAGAGATCTTTTTTTCTGCCATACAATATAATTTATCCCTTATGGAAGAGGTAAGACTCAAAAAGCTCC +AGGAACTCAGGGAAAAAGGAATAAACCCCTACCCCTACAGGTTTGAAGTTACGGACTTTATAGGAAACAT +AAGGAAACAGTACGAGGAAGAGCCTCCTGAGAACTACAAAGTTCGGGTTAAAGGTGTGGCTAAAAGGGTT +TCCAGAACGGAAAACGGCTACATGGTAAGGCTTGCAGACGAGAAGGGGATAGAGATACTTGTCTTCACGA +AGGAGGAAGGGTTAAAACCAAAGGAAAGTTATACTTTTGAAGGGATTTTAAAAAGGGTTGAAGGAAAACT +CAGCCTGGTGGAAGCCGTTCTCACTGAGGAAGAAGGGGAAGAAGTTTACAAGATAAAGGAACAGTTTGAT +TACGACCCAAACTTCAGACCCGTTTCCTTGGCGGGAAGACTCGTTTCTATGAGAAGTATGGGGAAGGCTA +TATTCGGACACATTCAGGATCTCACGGGAAAGATACAGATATACCTCAAAAAAGACGTAATAGGCGAGGA +AAAGCTGAAGTTCTTTAACGATTACATAGACGTAGGGGATATTGTAGGAGTAAGGGGGAAGCTCTTTAGA +ACGAACACGGGAGAGCTCACCGTTGAAGTTGAAGAGTACCAACTCCTCGCAAAGTCCCTGCACCCACTTC +CGGAAAAGTGGCACGGGCTCAAGGACGTGGAAGTTCGCTACAGGCAAAGGTACCTTGACCTTATCGCTAA +CCCCGAGGCGAGAAGGATATTCATGCTGAGGACCAAACTCATAACGGAAATGCGGAAGTTCTTTGAGATG +CACGGATTTATAGAGGTGGAAACTCCCATACTCCAGCCAATAGCGAGCGGTGCAAACGCAAGACCCTTCG +TGACTTATCACAACTTCCTTGAAACAGAGCTTTACCTCAGGATAGCCCCGGAACTCTACCTCAAGAGATT +AATCGTAGGAGGCTTTCCGAGGGTTTACGAGATAGGAAAGAACTTCAGGAACGAGAGCGTGGACAGGACA +CACAACCCAGAATTTACTATGGTTGAGTTTTACGCCGCTTACTGGGATTACCACGACCTTATAAAGTTTA +CAGAGGATATGTTCGTTTATCTCCTTGAAAAAACCTTAGGAACTCTGAAGGTAAAGTACGGAGAGTGGGA +GCTTGATTTTTCACCGCCTTTTAAGAAGGTTCGCTACTTTGACCTCTTAAAAGAGAAGACCGGAAAGGAT +AAGGACTTTTTCCTGAAAGACCTTGAAGGCTTGAGGAAGCTAGCCAAGGAACTTGAAATTCCCGATGTAG +AGAGGATGACTCACGCAAAGCTCCTTGACAAAGTTTTTGAAAAGGTTGCGGAGGAAGATTTAATCCAACC +TACATTCGTAATAGACTTTCCGAAAATCCTCTCACCTCTTGCGAAAACCCACAGGGAGGACCCCGACCTC +GTTGAGAGATTTGAGCTTATCATCGCACGTTACGAGGTGGCGAACGCATACACCGAGCTGAACGATCCCT +TTGACCAAAAGGAAAGATTTTTAGAGCAGCTCAAAGAAAAGCAAATGGGTGACGAAGAGGCTATGGATAT +GGATGAGGACTTTATAAGGGCACTTGAATACGGAATGCCTCCTACCGCAGGTGAAGGTATAGGAATAGAC +AGACTAGTTATGATATTGGCAAATACGGACTCTATCAGAGAGGTTATTCTCTTCCCTCAATTAAAGCCGG +AAAAAAAGAAGAAGGAAGCCCCTTAAGGGGCTACCCAGTTCCCGTTTTCTATTAATTCTTCAGGAGAAAC +TTTTTCCTGAACCTTCTGGGATATCTTGTAAGAGCAGAACTCCGGTCCGCACATAGAACAGAATTTAGCG +GTTTTGTATCCTTCCTGAGGCAGTGTCTCGTCGTGGTACGCCCTCGCGGTTTCTGGGTCCATAGCGAGTT +CAAACTGTTTGTTCCAGTCAAAGTTATACCTTGCTATGGACATGGCGAGATCCCAGTCTCTTGCTCCGGG +CCAGTGCTTTGCTATGTCCGCGGCGTGTGCGGCAATCTTGTAAGCTATAACGCCCTGTTTTACGTCTTCA +ACGTTTGGTAGCCCGAGGTGTTCCTTAGGAGTTATGTAACAGAGCATTGCAGCTCCTGCCCATCCTGCAA +GTGCTCCGCCTATAGCACTACCTATGTGGTCGTATCCGGGTGCTACGTCGAGAACTAATGGTCCAAGTAC +GTAGAAGGGGGCTTCGTGACACCACTCCTGCTGTATCTTCATGTTGAACTCTACCTGATGAAGGGGGACG +TGTCCGGGTCCTTCCACCATAGCCTGGACGTCGTGCTTCCAGGCCTTTTCTACGAGCTCACCGAGAACCT +TTAGCTCTGCGAGTTGTGCGTCGTCCGTTGCGTCTTCTATACAACCGGGTCTCAGTGCGTCTCCCAAGGA +GAAGGAGACGTCGTACTTCTTAAATATTTCACATATCTTGTCAAAGTGCTCGTATAAGGGGTTTTGTTTG +CCGTGCTCTGCCATCCACTGGGCTAAGATAGCTCCTCCCCTTGAGACTATTCCCATAACTCTGTGCTGAA +CAAGAGGGAGGTGTTCCCTCAAAATACCCGCGTGTATTGTCATGTAAGAAACACCCTGTCTTGCCTGTTC +CTCTATTACGTCCAGTATGAGGTCAACGGTGAGTTCCTTTACGTTTCCCTTTGCTATCTTCCAAGCCTCG +TATATGGGAACTGTTCCCACTGGAACGGTGCTGACGTTTATTATGGCTTCCCTCGTTTCCTTTATAGCTT +CTCCCGTGGAGAGGTCCATTATCGTGTCTGCACCGTACTTTATAGCAACTTTTGCCTTTTCAACTTCCGT +GGGTATGTCCGAAGCAAGTCCGGAATTTCCTATGTTTGCGTTTACCTTAACTTTAGAGTTTATACCTATA +CACATAGGTTCAAGGTGAAGGTGATTTATGTTTGCAGGGATTATCATCCTTCCCCTTGCGACTTCCTGCC +TTACGAATTCAGGGTGAAGTCCTTCTCTCTTTGCGACGTATTCCATTTCTTCGGTGATTATTCCCTGACG +GGCTAAGTGCATCTGTGTTTTATTTTTGAACCTCTTCCTCTTCTCTACCCACTCAGCTCTTAGCATACGC +TAACCTCCTAAAAAGAAGTTTTATTCTTAAACTTAATACCGTAGGTTTTTTATTCAACATGATATTATTC +AAAGTTATGCACCTAGAGTTCGAAAAAGAGCTCTTAGAAATAAAGGAAAAGATAGACAGACTCCTGGGTC +TTTACAGACTCGGAAAGGAGGAGGTTCTATCCGAACTGGACGAACTCAGGAAGAAGTTCAAGGAAAAGGC +CAGGAAAATTTACAGGGACCTCTCCCCTTGGGAAAGGGTTCAGGTGGCAAGACATCCCAAGCGTCCTCAC +ACCTCAGACTACATAAAGTACTTAATAAAGGATTTTGAAGAGGTTCACGGAGACACCTGCTACGGCGACG +ACAAGGCGGTAATTGCGGGTTTTGGATACTTCAGGGGAAAGCCCGTGGCAGTCGTGGGGCACGAGAAGGG +AAAGGACACGAAAGAAAAACTGGAGAGAAACTTCGGTATGCCCCACCCTGAGGGCTACAGAAAAGCCATA +AAGGTTTTCAAACTGGCAGAAAGGTACAATATTCCCGTCATAACTTTTATAGACACACCGGGAGCTTTTC +CAGGAATAGGAGCGGAAGAGAGAGGGCAGTCCAGAGCTATAGCGGAAAGTATGCTTACCATGGCGTTTTT +AAAAGTTCCCTCCGTTGCGGTTGTAATAGGCGAGGGCGGAAGCGGCGGAGCGCTCGCCTTCGGTGTGGCA +AACAGGGTTTGTATCCTTGAGAACGCCTACTACTCCGTCATTTCTCCCGAGGGTTGTGCCGCTATACTTT +GGAAGGATCAGAGCAAGGTAAAGGAGGCGGCAAAGGCCCTAAGGCTCACCGCAAAAGACCTTAAGGAACT +TGGGGTGGTGGACTGCGTAATTCCTGAACCCTACGGTGCAGCTCACTGGAGTCCAAGGGGAACGGCTATG +ATGGTTGGAATGACATTAAAGAAGTGTTTAGACGAACTCTCAAAATTGACGGAAGAGGGTGTGGTGAGGA +GCAGACTGGAGAAGTTTAAAAATATGGGAGCTTTTAAGATTGCATCTTAGCCCTGCAGTCTGGGCAAATT +CCGTATACGTTCACCGAGTAACTTTCCGTTTTGTAGCCGTAGAACTCTTCGGGTATGTTTAGTTTTTGAT +CCAGTTTTATGTCTTCAATTTTTCCACACTTTTCGCATATGAGGTGGTGGTGTTCTTCCAGGTTTGCGTC +GTACCTCGCAGAGTTACCCCAGAAGCATACTTTTTTCACTAAACCTATGTTTTCCAGAGTCTCAAGGGTT +CTGTATACGGTAGCCAGAGAGACGTAAGGGTACAGTTTTTTCACTTCCTCGTATATTTCCTCAACGGTCG +GGTGGTTATCAGACTTTAAAAGAACTTCGTAAACTGCCATTCTCTGAGGTGTTATCTTTAGTCCCGTCTC +TTTACACCTCTTTACAAAGAACTCAAGCCTCTCATCCGCTTTAAGCATGACATAAAAAAATAAATTGAGA +AGGAAAACTTTTCAAGAACATTTATCAGATATCAAGAGAAGGTTCTACGATGTAATCGTAATTTTCCCTC +TTTCTTATTAACTTAACGCTACCATTTTCAACAAGCACTTCAGCTGCTCTCGGTCTCATGTTGTAGTGAG +AAGACATAGCAAACCCGTAAGCTCCTGCAGACAGAACCGCAAGGTACTCGCCCCTCTGGACCTCTTCAAT +CTCCCTGTCAAGTGCCAGGAAGTCTCCCGTTTCGCATATAGGCCCTACTATATCCGCAACTACCTTTTTC +CTTTCCTTCGTTTCTACGGGAATTATGTGGTGGTACGCGTTGTATATGGAAGGTCTTATAAGGTCGTTCA +TTCCAGCATCCACGATTATAAAGTGCTTACTTCCCTTGTCCTTGAGAAACTGAACCTGAGTTATCAAAAT +TCCAGCATTCCCCATTATTGAACGTCCGGGTTCGAGTATAATTTTCGCCTTCACGTTTTCAAGGAGGTCC +TTGAGGAGATCTGCAAGATCCTGAGGAGCGGGTTCTTTGTCCTCGGGTTTGTACTTTATGCCCAGACCTC +CGCCTATGTCCAGGTACTTTATATCAAAGCCTTTTTGAGTTAAGCTTTCGTAAAGGCTTACAACTTTTTC +GACCGCTTCCCTGTAGGGGGATATGTCGAGTATTTGAGAGCCTATATGGCAGTGTATCCCTACTATTTCC +AGATTTTCGAGTTTTGAGGCGTACTCGTACTCCTTTTGGGCTTCTCTTATATCAACTCCGAACTTACTCT +TTTGCATTCCCGTGGCTATGTAGGGGTGAGTTTTGGGGTCAACGTCCGGGTTTACCCTTATGGCTATCCT +CGCCTTCTTTCCCAGTTTGCCCGCTATTTCGTTCAGCACGTCCAGTTCCTGTCTGCTCTCAACGTTGAAC +ATCAAGATTTCGGAGTCCACAGCGTCTGTGAGTTCTTTTTCCGTCTTTCCCACGCCCGCGTAAACTATCC +TCTCGGGGGGAATTCCCGCTTTCTTGGCGAGGTATAACTCTCCGCCCGAAACTATGTCCGCTCCTGCTCC +GAGCTCTCCGAGAAGCTTAACAAGGTGTGGGTTGAAATTCGCCTTCACGGCGTAGCAGATGAGTGCGTCG +GGGAAAGCCTTCCTGTAAGCCTCGAAACGCTCCTTTATAAAGTTTGAACTGTAAACGTATAGGGGTGTTC +CGAAGGTCTGTGCCAGTTCTTTCAGGGAAACACCCTCTATGAAAAGCTCACCATCTCTGTACTCAAGGTA +AGGGTTGTACTCTTTGAGCAGTTCCATAAAATTGAGATTTTACAAAATTCACTTAAAAGCTTTCCTGAAA +ATTTCCCTTATGCCCAGGTATGCGAGGATAGAGCTTCCAGAAATTCCAGAGAAGAGAAGTGTGTAGAGAA +TTACTATCTGGAATAGGATAGCCTTTAGAGGACTCACCCCTGCAACAAGCAGTCCCACAGCAACACCCGG +AATGTGGACAAGTCCCGCGGACTTTAGCCAGTTGAGCTTCGGGATAAGAGCCATTCTTATGCTGTCCCTT +ATCACGTCCTCACAAGCCTGAAGTAGCGTAGCCCCGAGGGCTACCTTTGCCTCTATCTCCTCCTTTCTGT +TTTTTATCTCTCCCTTAATCCTGTCGTAGAACAAGGAAAGGGAGTTTAGGGTATTCCCTATTATCAACCC +GCCGAAGGGTATAACCTCGTGGGGTTCAGGTTTTAAAACTTTCAGAAAAATCAAAAGGAGAATGGGAAAA +GCGTAGGAAAAGGTTATTGAAAGGTAAACTACGGGAAAAAGTTTTAAGCTTTTTGACCTCTCCGTAAAAA +TTACCGAAGCTATTAAAGTCATTATCGTAAAAACTAAAAACTGTGATGTTAAACTTTCTAGCTTAAGTAT +GTAGTGGAGTAAGTAAGCGAGTAAAAGCAACTGAACAAGTGTTCTGAGGGAAGAGAGGAATATCTCCTTT +TCAATACCGAGCCCTTCCCTGTGGGATATGGCAAGCGTCATGAGGACGAAAAGGTAGGAGTAAAGGTAAA +TCAAGTTTTCCATAGGCAAGAAATTATAAGGGGCTTAAAATAATCCTTGTATGGAACTTTTGAGGGAGTT +TTTAAGGAATTACGGGGAAAGGTTTAAAGAAGAGCTCGAGAACTTAGTAAAGAAGTACGTTCAGGGCGAA +GAGGACGTCGTTCTTTTAAAAATGGATGAACGTTGTTTAATACTACCGTTTTTGAATGTAGGCGACTTTT +TTTACATGAAAGCGAGAGAACTTACCGAGCCAGTGAAGTTGGAGGTTCTGCAAAAAAGAGACAGTGAAGT +ACTCGCAAGGGCAATATCTTACGAAGAGACCTATATAGAAAAGAGGCAGCACGTAAGAGTTCAGCCTGAC +AAACCCATACCCGTTTACATAAAGGAAAAGGACACCGTGGGAAGTATACTCGACATTTCCGTAGGCGGAA +TTGGTGTCTTTCTTAAAGAAAAGGTCGTAGAACCGGAAGAGGTGGTGACTCTCGAGTTTGAACTGGAAGG +GGAGGAGATAAAAACAAAAGGGGAGTGCAGGTACACAATCCCCTACAGAGCGGGATACAGGGCTGGTTTT +AAGTTCGTGGATCTCAGCACGAGGTACGAGAACATTATCGGAAGGTACGTTATGAAGAGACAGATGGAAA +TCCTCAAGGAGCTTAAAGAGAGTATGATATGAGGGGAAAAGAGTTCTGGATAATACTCGCGGTAGTATTA +ATCCTCTCCGCGATAATAATCCCTATACCCGCCCTTCTTCTGGATTTACTCCTCACCCTTTCAATAACCT +TTTCCTTAACGGTTCTCCTTTTGACTTTTTTCATTAAAAACCCTCTTGAGTTCTCTTCATTTCCCTCAGT +TTTGCTCCTCGGAACACTCTTGAGGCTTTCTCTCAACATAGCGGCGGCGAGGAGGATACTCCTTCACGGA +CACGAAGGAACGCATGCAGCTGGTAAAGTAATAGAAGCCTTCGGGAAACTCGTGGCTGGAGGGGACGTGG +TAGTAGGTTTAATAGTCTTCCTGATATTCATAGTAATTAACTTCATAGTCATTACGAAGGGTGCGGAAAG +GATTTCGGAAGTGGCGGCTAGGTTTACTCTGGACGCCCTTCCCGGAAAGCAGATGTCCATAGACGCGGAT +CTGAACGCAGGTCTCATAACGGAAGAGGAGGCAAAAAGAAGAAGGCAGGAACTCGAAAAGGAAGCCAACT +TCTACGCAGCGATGGACGGTGCGAGCAAGTTCATAAGAGGAGACGCAATAGCGGCCCTGATAATCCTCTT +CCTGAGTTTAGTGGGAGGACTGTTGATAGGGATAGGTATAAGGGGAATGGATCTGGCGAGTGCGGTAAAG +ACTTACACCATACTTTCCATAGGTGAAGGTCTGGCTTCTCAGGTTCCGGCCCTGCTCCTTTCAACAGCGG +CAGGTGTTCTAACCACAAAGATGTCCTCAAGGGAAAACCTCGGAGAGGCTATCAGTGAGGAACTAACGAA +GCAGCCAAGGGCACTTCTCTTTTCCGCAGGCGTTCTCGGTTTTATAGGTCTCATTCCCGGGCTTCCTACC +CTTCCTTTCCTCGCTATGTCAGCAATCCTTGCCGGAGCTTACTACCTCGTTCAACAATCCCTGAAGGAAA +GGGAGTTAAAGGAACTGGAAAAATTGGCACAGGAGAAGACTAAGGAAAAGGAAGAGGAAGGGGAAGAGTT +GATTCCTCAGCCCGAGCCCATAACCCTTGAGATAGGCTACGCCCTCATCCCGCTCGTTGACGAGTCTCAG +GGCGGACAGATACCGAAGAAGATAAAGAACTTGAGGAAGCAAATAGCGAAAGAGTACGGAGTGATCGTTC +CCCTCATTCACATAAGGGATAACCTTAGGCTAAAACCAAACGAGTACAGGATACTGATAAAAGGTATTGA +GATAGACAGGTACGAACTTATGCCCGGGCACTACCTCGCGGTGAACCTTGGAAACGCAAAAGGTCCAATA +GAAGGAATAGAGACTTACGACCCCGCCTTTAAGATAAAGGCTTACTGGATTACGGAAGACAAAAAGGAAG +AAGCTCAGAAGCTCGGTTACATGGTAGTGGACGCGGAAACGGTTTTAATCACGCACCTCTCGGAAGTGAT +AAAGAGGAACCTTCACGAACTCCTTACCAGAAACGAAGTAATGGAACTTATAGAAATGCTTTCTAAGAAG +TATCCGAAAGTCGTAAAGGAAATAGTCCCGGAACAGGTTCCCATATCCATAATACACAGGGTTCTCCAGA +ATTTACTGAGGGAGGGCATACCCGTAAACGACCTGCTCACCATACTCGAAACACTTGCGGACTACATAGA +ACAGACCAAAGACCCGGACCTCTTAACGGAGTATGTAAGGCAGGCACTCTCTAAACGCATAACAAGGATG +TACCTTACCAACGGAACTCTTTACGCAATAGCCCTGTCTCCGAAAGTAGAGGCTAAACTCGTGAAATTTT +TAAAAGAGAACAGGGAAGACGAGTTCATAGACTACGTTCTGAATACACTCCTTCCGAAGATAAAGAACGA +GATTGTCAAGTTTGCCCAGTACGGAGCTGTTCCGGTTTTGTTAACTTCCGGGGAAGTGAGGCGGTTTGTG +AGAAAAACGATAGAGCCCTACCTTTCCGAACTTGCGGTTCTATCTTACAACGAACTAGAAAAGCAAGTTA +ATATAAAAATTATAGGTATAGTGGATGAAGATTGAGAAAATAGAGGTAAACTCCTTACAGGAAGCTATAG +AGATAGTGGAGAGGAGGTTTGGAGAAAACGCGGTAATACTTTCCTCAAGAGTTATTAGGAAAAACAGGTT +TGGCTTTTTACCCATATTCAGGAAGAAGATACTGGAAGTAACAGTTGGTATTCGAGAAGAAGAGGACTTT +AGAAAGGAATTTGAAAGGGAGAGGGAACTTATAAAAGAAATAGAAAACCTGAAAAAGATTGTAAACGAAC +TCATAAACAACGGAGAGGTCAAAGGGGAAAAAATCGTAGAAAAGGGTTCCGACACTTACGCGCCGAGAGT +AAAAAGGTATTTGGAAAAGCTCGTTATAAAGAACATAAGTAAGAACATAGCGGAGAAGATAATTCAGGAC +GCATGCGGTTACGATATAGACAACAAGATTTACGACTTCAAGGATGAACCTTACACTTCGTTGAGAGAAA +GCATAGAGAAAAACATAAAACTGAATGAGGAGTTTATTCAAAACCCGCCGAAAGTTGTCGCTTTGGTTGG +ACCAACTGGTGTGGGGAAAACCACTACTCTTGCAAAGCTTGCCCACCTCTTCAAGAAGAACAAGAAGAAG +GTAGGTATTATTTCCCTTGATTGTTTCAGAGTTGGGGCTTTTGAGCAGTTAAAAGCTTTTGCGGAAGTAC +TGGAAGTTCCCTTCAAACTTGCGGACTCGCCGAGAGCCTTTAACATTCAACTCCTCGAAATGGACGACAG +GGATGTAATACTCGTAGATACCGCGGGAAGGAGTCATTACGATGTCATAAGACTCAAGGAACTTGAAACG +TATTTTAAAGTCTCCGACATAAGCGTATACCTCACACTTGCGGCGAACCTTTCCGAACTCGTCATGTACG +AAGCCATAATGCAGTTTGGAATGTTCTCTATAAGCGGGCTTATATTCACAAAGCTCGACGAGACACCTTA +TCCAGGGAGTATGGTAAACGTAGCCTACAGAACCCAGTATCCGGTTGTGTGCTTCACGATGGGGCAATCC +ATACCTGAAGACATTGTGGTTGCAAATTACGATTACTTAGTCCGATTAATCTTAGAGGATGAAGATGAAG +TTAGACCAGCAACTCAACTTGCTTAAACATATGCTCGGAAAGAGCAAGGGCACGCGTTACATATCCGTGT +CCAGCGGGAAAGGAGGTGTAGGGAAAACACTCGTCTCCATAAACATAGGCGAGATATTATCGGAAAGGGG +AAAGAGAGTTCTCATATTCGACGGAGACCTCGGGCTTAGTAACGTCCACTTGATGTACGGTATAGCTCCA +ACCAAAGACCTGAGCGACCTAATAAAAGGCTTTGCTACAATAGAGGAACTTCCCGTAAAAGTAAACGAAC +ACCTCTACTTCATATCAGGAGGTAGCGGCTTTCAGGAACTCGCAGACCTTCCGAAGGAGAGGTTAACGAC +GATAGTCCAAAAACTCTACGAGTACGCGGAAGACAACTTTGATTACGTCGTGATAGACACACCTCCGGGG +ATACATAGAACTACAGTTATGCTCACTTCCTGCGCGGACATACCTATAATACTTACCACCCCTGAGCCCA +CAGCGCTCATGGACGCCTATGCACTCATAAAGGTGATAAACAGAGAAGAGGGAGTGGAGAACTTTTACGT +GATAATAAACAAGGCGGACAGCTACGCGGAGGCAAAAGCTGTAGCGGAGAGCTTATCCTTAATGGTTATG +AAGTACACAAACGCAAGAGTAAACTTCATCGGATTTATGCACTACAGGAAGAATTTAATAAGGAATGTGG +TGGATCAGAAACCAGTAGATAAGAACTTCAAGGAGGAGCTGAGGGAAGCGCTTATAAACCTCGACCTTGA +AGTGAACGGAAAAGAAGGATTCTGGAGTAAAATACTCAAGAAGCTGGGCGTATGAAAAACCCTTACAGCA +ACCAAATAGAAAGAGAAGAATTAATACTGAAGTACCTGCCCTTAGTAAAGGCGATAGCGACAAACATAAA +AAAACATCTGCCCGAAGACGTGGACATAAGGGATCTCATCAGTTATGGCGTTATAGGACTAATAAAAGCC +GTAGACAATTTAAGCACGGAGAATCCTAAAAGAGCGGAGGCTTACATAAAACTGAGGATAAAGGGAGCCA +TATACGATTACCTCAGGAGCCTGGATTTTGGAAGCAGACAGGTAAGGGAAAAAGAAAGAAGGATTAAGGA +AGTTGTGGAAAAACTGAAGGAAAAACTCGGAAGAGAGCCCACGGACGAAGAAGTAGCAAAGGAGCTCGGC +ATTTCCACAGAAGAGCTTTTTAAGACCCTTGATAAGATCAACTTTTCTTACATCTTGAGCCTTGAAGAAG +TCTTCAGAGACTTTGCAAGGGATTACTCGGAACTCATACCGAGTTCAACGAACGTAGAAGAAGAAGTTAT +TAAGAGGGAACTCACGGAAAAGGTAAAAGAAGCGGTTTCAAAACTTCCCGAAAGAGAAAAACTCGTCATT +CAATTGATTTTTTACGAAGAACTTCCCGCAAAGGAAGTTGCAAAAATTCTCGAAACCTCCGTTTCCCGTG +TCTCTCAACTGAAGGCAAAAGCCCTAGAACGCTTAAGGGAAATGCTCTCTAATCCTCTATAAATTCTTCG +AGCTTTTCTTTGTGATTTTCGAACCACTTTTCCAAGGACTCCGTGTCGTACCCTCCGTTCTTTCCGAAGG +TAAGCTCAAACTCTTCAAATCCCATGCCTTCAAGAATAGCTAGGATGTAGTACCTAACTCCTACGGGATC +TTCAGGGTCCAGTTTATAGAGCATTTTGAGGACTTCAAGAGCCCTGTCTACGTCTCCCACTTCCCAGAAC +ATTATCCCAGCTTCCAAAATCGCCTTTATTATGTGTCTGTTCGTTTCGTACTTCCACTCGAGCCTGTCGG +GAAGGTTTCCATCTTCATCTTTAATGAGTTCCATAGCTTTGTTGAGGGCGTCTATTAGTATTTCTTCCGC +CTCTTTTATGTGCCCTTCGTTTTCAAGGATTTCCGCAAGGTAGACGTAAGACTCAAGGTAGTAAGGGTCT +TCCTGCATGAGCTTTTTAAGACTTGAGATTAACTTGGGTATGTCGTGCCTCTCTTCCTCTAAAACCCTCT +GTAGTTTTTCCTGAGCTTCCCTCTTCTTGTCCACAAACACTCTCATAACTACACTTAAATAATTTATACA +AATTCATTGTAGCTTTACTTGATGACGCAGAGCAAAAACTCTTCAAACCTCTTTTTTCTCTTTATATCAA +GCATGAACTTGAAAAAACGGGACTCGGAACTCGTGTATAGCTCCCACTTTCTCACGGGCTCACAATCGAA +GCTTCCCTTCCTCGCAAGGACTATTGCAGGCTTTTTCACTTCCTTGGTTCTCCTTATTATTACCCTGTCC +GCGTAAAAGGGCAGGTTGTGATGGAAAAAGCCAAGTTCGTAAGTACGCAGTTCATTTTTTGGATCAAGCT +TTCTTATCTCCTTTCCCACTTCCCTGTAGGGTCTGAACTGCTCAACGTAAGGGAGTATCACAGACGACAG +GTAAAACAAGAAGGCAAAGGCCCCAAATGCGGGAAGGAGTTCGTACTTTTTAAGGAAGAACGGAAGGAGC +AATAAGGGTATCAAAGGAAAGAGAGTTGCTGAAAACTTAAAGTAAAGGGAAAGTGCCAAAGTTGCAAGAA +CGAGAACGGTCCATAGGAAGATAAGGGAAAGGTTTTTTACTTTCTTTAAGCTTTGGGAGTTTAAAAAGTC +CGCTGTAATTATAGCCATGGCCGGGTAGGCGGGCATGATGTAGACAGGTATCTTCATCTTTACGATACTG +AAAATCAGGAATATAAAGGAAAACCAGACGAGGGGAAAAGAGAGTTCCCTTCTTTTTTCTTTCAGAGCCC +AGAAGAGGGCAAAGAAGAACAAAAAGGAATATGGCAGAAAAGAGACGTTTATATCAAGGGCGTAGAAGTA +AAAGGGATCCCTCTGGAGTGCATAAATCCTCTTTACGTTTTCCTTTATAAAGACTTCTAGGAACTCCTCC +CTGTGTACGAGGTACTGGTATAAAAACCACCAGCCGCTTAGAAGGAATACCATAAGAGTTCCGGCGTAGT +ACTTAATCTTTAAAAGTTCCTTCGGAGCTCTCAGGAGCAGGTAAAAGAATACCACTCCTGCCGGAAGGAC +AAATCCGGCTGGACCTTTCGTCAGAACAGCCAAGGAAGAAGCAATTAAGGCAAGCCAAAAAAGAAATTCT +TTCTTTCTCGTGAAGTACTCGTACCAGAGGTAAAGGGAAAGGGTTATGAAGAAGGTGAAGGGGACTTCCG +GGGAGGCATAACGAGCGTTTGCGATAAAGATAAAGGAAAGAGATAGAATTAAAAAGGAAAGGAGAGCGGT +GTTCTTACTTCCCGTAATCCTTCTGGCGAGGAGGTACGTGAGGACTCCAGTGAAAACTCCTAGAAGGGCA +TGGAAGAACCTGAGTCCGAGCTCGTTTACACCGAAAATCTTGTAACCTAAGGAAACTATCCAATAGGTCA +TAGGGGGTTTGTTCAGTCTGATCTCTCCGTTGTAAACTGGGGTCAAAAACTCCCCGCTCTTTAGCATGTT +CTTTGCACTGTCCGCGTAAAAGGACTCGTTGGGCATCCACACCGCGTTATAACCGAGGTTGTAAAAGTAA +AGGATAAGGACAGGAATTAAAACTAAGAGGAATTTTTTCATCACTCGGTGAATATTTGCCCTTCTATGGG +TTGAACCTCCACTCCCTGTTTTTGTATAAAATCTATAGCCCTTTCTATTTCTTCCGCTTCACCGTCAATT +TCAACAAGGAGAATTCCCGTGTCCTGTGAAACCTGTGCCCTCCTTATGTTTACTACAACGTCAAAGTTTT +TACAAACCATACAAAGTACAGGCTCCTTGACCTTTTCTTCAGGGTATATTAATTGAAGCCTTACCATGTT +CATGATAAGTTTTATTGTAATTCAAAGGTTAAAATAAACTCTCATGAGTAAAGTGAAAACGAGGTTCGCA +CCCAGTCCAACCGGATACCTACACCTCGGAAACGCAAGAACAGCCATATTCAGTTATCTGTTTGCAAGGC +ACAACAACGGAGGTTTTGTACTTCGTATAGAGGACACCGATCCAGAGCGTTCAAAGAAAGAGTATGAAGA +AATGCTGATAGAGGATTTAAAGTGGCTCGGTATAGATTGGGACGAATTCTACAGACAGTCCGAGAGGTTT +GACATATACAGGGAGTACGTGAACAAGCTCCTTGAGAGCGGTCACGCTTACCCGTGTTTTTGCACGCCGG +AAGAACTTGAAAAAGAAAGAGAAGAGGCTAGAAAGAAGGGAATTCCTTACAGGTATTCTGGAAAGTGCAG +ACACCTGACACCAGAAGAGGTGGAGAAGTTCAAGAAGGAGGGAAAACCCTTCGCCATAAGGTTTAAAGTT +CCCGAAAACAGAACCGTGGTGTTTGAAGACCTAATAAAGGGTCACATAGCCATTAACACGGATGACTTCG +GGGACTTTGTAATTGTCAGGAGCGATGGCTCACCCACTTACAACTTCGTCGTTGTTGTTGACGACGCCCT +TATGGGAATTACCCACGTGATAAGAGGAGAGGACCACATACCCAACACTCCCAAGCAAATACTCATATAC +GAAGCTCTCGGGTTTCCCGTTCCCAAGTTCGCACACCTTCCCGTTATACTGGGAGAGGACAGGAGTAAAC +TCTCAAAGAGGCACGGAGCTGTTTCGGTAAGGGCTTACAGGGAAGAAGGCTATATGCCGGAAGCCCTCTT +CAATTACCTCTGTCTCTTAGGGTGGTCCCCTCCAGAAGAGGGAAGGGAGATATTCTCAAAGGAAGAACTG +ATAAAGATTTTTGACCTCAAAGACGTAAACGACTCCCCGGCGGTCTTCAACAAGGAAAAACTAAAGTGGA +TGAACGGAGTGTACATAAGGGAGGTGCTTCCCTTAGACGTTCTCCTTGAAAGGGCTATTCCCTTCTTGGA +AAAAGCGGGCTACGACACGAGCGACAGGGAGTATATAAAGAAAGTTCTCGAATACACGCGCGACTCCTTT +GATACATTGAGCGAAATGGTAGACAGGCTCAGACCCTTCTTCGTGGACGAGTTTGAAATACCAGAAGAGC +TCTGGAGCTTCCTAGACGACGAAAAGGCTTATCAGGTTCTCTCAGCTTTCTTGGAAAAAATCAGGGAGAA +AAAACCCGAAACTCCCCAGGAAGTAAAGAAGCTCGCAAAGGAAATACAAAAAGCCCTGAAAGTAAAACCA +CCGCAGGTATGGAAACCCCTCAGGATAGCCCTCACGGGTGAACTCGAAGGTGTGGGCATAGACATACTCA +TAGCCGTTCTTCCTAAGGAAAAAATAGAAAAGAGGATACTGAGGGTTCTGGAAAAGCTCTCGTGATTTTC +CTCTCCTTTAAAAAATCTTTTAAGAACATAACTATTGAAGGAAAGTTTACCTTTGAGAAGGGATTTAACG +TAATTTTAGGGCCTTCGGGAGCAGGAAAGAGTACCGTGATTAAGGTAATGTGCGGTATAGAAAAGCCCGA +TGAGGGCTTTATGAAGTGTTGCGATGAGGTTTTCTTTGATACGAAAAAGGGAGTATTTCTACCTCCTCAA +AAAAGAAGGCTCGGTGTTGTTTTCCAGAGTCATAACCTCTTCCCCCACATGACCGTAAGGGAGAACATAG +AGTTTGCCTTAAAGAAGGCAAAAGAACCTCAGTTTACAGTTGAAGAACTCCTTGAAAAGTTCAACTTAAA +AGGACACGAAAATAAATACCCCGGCGAGCTTTCAGGTGGACAGAGGCAGAGAGTAGCCGTAATAAGGGCA +ATAGTTTTCAATCCGAGAGCCGTTTTAATGGATGAGCCCTTTTCTTCGCTTGATTTTAAAACAAAACTGA +GCATTATGGAATTTATAAAGAGCGTTCACATAGAAAAGCCTGTAATTATAGTGACCCACGACCTATTTGA +GGCTCTATACCTCGGACAGAAATTCTTTTTAATGGATAACGGAAAAAAGGTAAAGGAAGGCGGAAAGGAA +GTATTAAAGGAGTACGTGGATTTAGAAAAAATAAAGAAGTTTTTAAGTTAGAGCTTGTAGTAAACGAACC +TGCCACAGGAGGGACACTGCTCTATGGAATCCTCCTTTATCATCTTTGAGAGTAATACACTCGGTATCTT +TATCCCGCAACCCGCACAGGCTTCATCTTCCGTTGGGACTATAACCAAGCCCTCAAAGTGTTTTTTGTTC +TCCTCGTAGAATTTAAGAAGGTGCTCTGGAATTTCCCTTTTCACTTCTTCCCTTTTTTGAACGTACTCGT +GTATTTTTCTGTGGGCTATGCTCTCTTCCAATTCCAAATCTTTTAGTTCTTCTTCAATTTCCTTTACTTG +TCTCTCTATTCTCGGGACTTTTTCCTCTATTTCTTTCGTAATCTTTTCCAGTTCTTCTTCTATTTGGTCT +ATCTCGTAGGATTTTTTTAGTATCTTGTCTTCAAGTTTTGATTTTTCCCTGAGGAGTGCCTTATACTCCA +CGTCCCTAGTAACCTTCATTAATTTTTCTTCGGTTACTTTTAATTTTTCTTCCGCTTCTTTTACTTCTTC +CTGAAGTTGTTTTTTTAAATTCTCCAGTTCTTCCTTTCTCTTGAGTAGCGTTTCTTTTTCCTTTAATAGG +GCTTCTAGCTCCTCTTTTAATTTCTTTACTTCTTCTTCTATCTTTTTAAGTCTGTGGTTGACCCTTTCGG +TTTCTAAGTCTATTTCTTGAATTTTTACGAGGAGTTTTGCTTCTTCTTTTGTCATGGTTTTGTGGTGGGC +GCGGGAGGACTCGAACCCCCAACCGGGCGGTTATGAGCCGCCCGCTCTGCCAATTGAGCTACGCGCCCAA +GCTAAATAAATATTATACTTCCTGAACTGGAAAAGTGCAAGATATTACTTAAATTAATTCCTTTGGAATG +AGAGTAGCGGTGGGAATGAGCGGTGGCGTTGACAGCAGCGTCACCGCACTCCTTCTTAAAGAACAGGGAC +ACGACGTAATACGAGTTACTTTGCGCTTTCACACGGTGGAAGCCTGCGAGGTGAACGAAACGCACAACGT +CTGTTGCTCTCCAAAGGACGTTCAGGATGCAAGCAGGGTGGCAAAAAGACTCGGTATTCCACACCTTGTA +TTTTCATGGGAGGAAATATTTAAAAGTAAAGTAATAGATTACTTCGTTGAGGAGTACAAAAGAGGAAGAA +CGCCAAACCCCTGTGCCCTTTGCAACAGAGAGGTAAAAACGGGTTTCTTTGCACGGTACCTAAAACAAGT +TGCGGATATAGACAAACTCGCAACAGGACACTACGCAAAAATAGAGGAAGATAAGAAGTACGGCCTTGTG +ATAAAAAGGCCAAAGGACAGGAAAAGGGATCAAACTTACTTTTTGTCTCTCGTCAGAAGGGAGGACTTGG +AACTCCTCACTTTTCCCCTCGGTGCGTACACAAAAGAGGAAGTAAGGGAGATAGCGAAAAGGTACGGACT +CGAAGTAGCTCAAAAGAGGGATTCTCAGGAAGTGTGCTTCTTGATGGGAAAGAGTCCGGGAGAGTACCTT +GAAGGGATTTTGGGAAAACAGAGGGGACTTATTAAGCACGTTTCGGGAAAAGTTCTCGGTGAGCATGAGG +GCGTTTACCGCTACACGATAGGACAGAGAAGGGGACTCGGCATATCTTACGGAAAACCTGTTTACGTGAT +AGACATAGACGCGAAAACTAATACGCTGATAGTAGGAGAAGAAGAATACCTTTACAACGACAAACTCCTC +GTTAAGGAGATAAACTTCCACGTTCCCTTGGAAAAGTGGGAAAACGTATCCGCTCAAATCAGGTACAGAC +ATAAACCTGTTCCCGTGGAGAGGATAGAAAAAACTGAAGAAGGGTTCCTCGTTAAGTTCAAGGAGGATGT +TCGAGGAATTACACCGGGACAGGTGGTAGCCTTTTACGACGGAGACGTGCTTTTGGGCGGAGGGATAATT +GAAGAAAGCGTAAAGTGAGGTTATACTATTTAGCTTGAATCCTTTGAGGAGGTAAGGGATTGAAAAACAT +AGTAGTTACCCCCATGACCTTTGAACCCGTTTACGAGCAAGATGCGGAAATTGTTGAAAGAAAAGGCATA +GGTCACCCGGACACCATATGCGACTATCTGGCGGAAGAGCTCTCCGTTGCGCTTTCAAAACTTTACATAG +AGAGATTCGGGGCTATTATGCACCACAACGTGGATAAAGCCCTTCTGGTAGGTGGTGAGGCGAATCCCGT +TTTCGGCGGAGGAGAGGTAATATCCCCCATAGAGATATACCTCGTAGGAAGAGCTCTCAAGGAGTACAAG +GGGGTAACGATTCCCGCAGAAGAGCTCGCGATAGAAGTGGCAAGGGAGTGGCTGAAAGATAACATAAGGA +ACCTTGATCCTGACACACACGTGATAATAAAGCCAAGGATTAAGCCCGGAAGCAAGGACCTGGTGGACCT +TTTTCTGAGATTTCAACAAAAGGGAGAGGTTCCCCTAGCCAACGATACCTCCTTTGGAGTAGGCTTTGCA +CCCCTTGACGACCTAGAGAGAATAGTCTTCGAAACGGAACAGCTCCTTAACTCTCCTTCCTTTAAAGAAA +ATCACCCTTACGTCGGAGAAGACATAAAGGTAATGGGAGTGAGGATAAAGGATAAGGTCAGGATTACGAT +AGCTTGTGCCTTCGTTAGCAAGTACGTTGAAAACATTCAGGATTACCTGGAAAAGAAAGAGCACGTAAGA +AGAATAGTTGAGGAAATGGCACAGGGTTTGACGCAGAGACAGGTAGAAGTTTTCATAAACACCGCGGACG +ATCCTGAAAGGGAAAGCGTCTACATAACCGTTACCGGAACCTCTGCGGAACAGGGAGACGACGGACAGGT +GGGAAGGGGAAACAGAGTAAACGGACTCATTACTCCTTACAGACCCATGAGCCTGGAAGCCGCGGCGGGT +AAGAACCCCGTTTCCCATATAGGGAAGATTTACAACGTCGTTGCCAATGTGATAGCGGACAGGGTAGTGA +GTGAAATAGAAGAGGTTGAAGAAGCGTACTGCTACCTTGTTTCCCAGATAGGAAAACCTATAAACGAACC +GCAGGTGTGTGACGTAAAGGTTAGAACGAAGAAAGATTTAAAGAGCCTTGAAGAGGAAATAAAGAGGATC +GCTCAGGAAGAACTCGAAAAGATGCCCGAAACTTGGAAGAAGTTCCTCAACAGGGAGTATGCGGTAGCCT +AAGGTAAGGTTAATACTATCTAACGTGTAAAATATTCTTTATGCTTACTAAGGAAGAAAAAAAGGTAGTT +AGCGGAATAACCTTCGTCGTAGTTGCCCGCTTTCTCGGGCTCTTTTTACTGCTACCCGTTCTCGCACCTT +ACGTTAAGAACCTTCCCGGAAGCACTCCACTCCTGACAGGTCTGGCGGTGGGCATATACGGTCTGACTCA +GGCTCTCCTTCAGATTCCCTTCGGATACCTCTCGGACAAGTACTCAAGGAAAGGAGTTATATCCTTCGGA +CTCCTTGTGTACGCTCTCGGGAGTTTTCTCGGAGGGATAGCTCAAAACATATGGATGATGCTCTTTGCCC +GTTTCTTACAGGGGGCAGGAGCTATATCTTCCGCTGCGATAGCTCTGGCTGCAGATCTCATAAGGGAAGA +AGTAAGAACCGTAACCTTTGCTCATATAGGTGCAGCCATAGGTATGTCCTTTGCCTTCAGTATCGTGGCG +GCTCCTTTCCTGGCGGGACACTTCGGAGTTCCCTTCATCTTCTTCCTGACGGGAGGACTTTCACTATTAG +CTTTACTTTACCTCTGGATCTTCATAAAAGAACCCCAACGGCACGAGAAGGAAATTGAGCCCTTCTTAAA +GCTTCTTCCCCAAATACTCAGAGATAAAAATCAAATGGCTGTGGACCTATCAATAGGGATTTTGCACCTC +TTTCTTGTGTCCATATTCACAGTAATTCCCGTAGAACTCATAGAAAGGTTTAACTTTCCGAAGCCCGAGC +ACTGGAAGATATACCTTCCCGTGATAATTATCTCCCTCGCCATAATGGTTCCCGCGATAATAGCTGCGGA +GAGAAAAGGAAAAATGAAGCCTGTATTTCTGGCGGGTATCGCCTTTGTAGCCCTCGGATTTGCATCTCAC +CTGATCCTCCAGGACTTCTGGGGAGCTGTGCTTTTACTTCTCTTTTTCTTCATAGGGTTTCACCTGATGG +AACCTATCCTTCCCTCTATGCTTACCAAGTTTGCGGGACCTGAGAGGAGAGGGATAGCTGTAGGTGTTTA +CAACACCGTGCAGTTCAGCGGAGCGTTTATAGGGGGATTTCTCGGAGGACTTTTCTTAAAACTCGGAGCT +GTTTACATGCTCTTAACTAACCTGTTACTTTCCCTTGTATGGCTTCTCGGTATAGGAATCTGGATTAAAA +ACGTTGAAATAAAAAAGAGAAGCACTTGAACCCCGAGCCCCCTCTCCCTCACAAGTTTTTAAACGTGTGC +CAGTGCGTGTGCCTCAAACTTTACCTTTTTGATGTTCATACCAGGTTTAAAGAAGAGTATCGCAACCTCC +TCGTTTTTCTTTATTGCTTCTTTTATCGCTTCCGGATCTTTTTCCGTTTTCAGGAGTGTCCTCCAGGCGA +AGAAGTGCTTTATGTGATGGAAGTCCGAATTAGCCACGAACCTGCATCCCTTAAGTCCTACGGTGTTTTG +TAGGTCGTACTGGTTCGCTATTTCCCAAGCGTCAAAAAGCTCCTTGTAGTAATCCATATTCTCGTAAAGG +TGCTTCGATAAGTGCTCCCTGTCCGTGTTCTTCTTCTCGGGATGGGCAGCTATACTTATTCCGTCGTTTT +CCCTTACAATCTTCAGTATCTCTTCTACGCTTAAGGAAGGATCTATGTACTCGTAAACGTCTAAAACTAC +TATGTGGTACAGATCCGTGTTGTTCGTGACTTCAAAACCCGGAATTAGGAGCATCCTGTACTCGTTCCAT +GCCCTTTTTTGTTCTTCCTTTAAGACTTTCATATAATCCTTAAAGTTTTCCTCTGTAACCGAAGGTACTT +TTGTTCCCCTTTCACGGAGCTTGCTAAGATATGTAGGATCAAAGACGTGATCCGTTATCGCTATTACGTC +AAATCCGTGGCTTCCGTAAAGATCCACAACGTCTCTTAAAGACAAGCTTCCATCGCTCATTTCGGTGTGT +ATGTGAAAGTCACAAAGGAGCCACTCTTCCATGACATCTCCCTCCGAACTTTGCTACTTTTTTATTTACC +CCTCCCCTGTTAAGAAAGAGTTAAGAACATTAACCTTCCATTTCGTTTACAGTGGCTCCGTCTATTAAGC +CGTGTTCTATTGCCACTTGAATTTGAGCAAGTTCCTCATCAGATGGTCTCTCGCCTTTGAGAACCTGTCT +GATAAACTCCTCGGTAACCTGCTCCACGACTTCTTCGTTTATTTCATCTACATGAAGTTCGTCCCTTTCA +GCAACAAACCTGCCGAAATTTACAGCCAACGTATGTATATCCTGCACGATAAACCTCCGTAAAGTTTTTA +GAAGAATTATCGGGAAGGAAAGGAGGGAAGAAAAGGAGGAATATCAGTAAATGGAGATTCTCGTTTCTTT +TCTTTCCATGTAACCCTTTCTGAGCTTGTAGCCCTCTTCGGGGTAAAGACCGTAGAAGAGGTTCTGGACG +TGGTTCCCTTCAACGAAGAAGCACCACCTTTCAATGGCACTTCCCGCAAGGATAGATAGGTATATCAGAA +CCAGAAGTGGCAGGTTAACTACGTCCGTAACGTAGATGTATATGAGGAGGAAGAGCGGAATTACGAAGGT +AAAGAGATAAGCCAGAGGTATGAACGTGGGAAGCATTTGCTTTCCTTTTGCGTAATAAAACTCGGTGGTA +CAGTAGTTGTCTGTGGTGGAGCTCTTGTCTATAACCCTTATGGATCTGTTGTGGGGAAGGTTGAGTGCTT +CGTTGAGGGTGGGTCTCTTTATGTAAAACTGCCTTACGTTAAAGGCTATCCTGAACCCGAGTCCGAGGAG +TACGAACAGGAACGTCAGGAATAAGAAAGTTCCTGTGTAGGGAAGGTTGTAGAAGTAAGAGATTATCGTA +AAGGCTGAAGAGCCCAGCATTAAGTACATGAGGAGGTAGTAAATGACCGTTATTCCCGTGTTCCACTCAA +GGACAAACTTGTTGGAAGCGTAAATCATAGCTGTGGAAAAACCGCTCAAGATACCTAAAATCCACGTAAT +TATCCCGAAGGTGTGTTCGAGGAAGGGGGAAACTTCAAAGTATTTGAGTACCAAGTAAATGAGGAGAGTA +AATCCGTAAGCTCCGCTAAATACCGCTTCTCTGGAAAGCCAAGAGGTGTTGAAACGCTTTATTGCCTTCC +AGGCTCTCAGTTTGTGTCCAAGGTGGAAGGAGGCTCCTATCGCTCCCGCACCTATGAGGATTAAGCTAAT +CACTCCAGAAACTAAAACTACTTCTTTGGGAAGTCCCTGCCCTTTTCCGAAGAGGGTTAAAAACTCAATG +AAGTAAGTGAAAATGAAAAGACCTATTGAAGTTCCGGCCGTGAGGAAAAAGAATATCAAGGAAATCGGCG +GGTGCATTTCTTTACCTCCTTTTTATGGTAATTCTTCAGAATGTGTTACTTCCTCTTGAGGTGTTTCCTG +TGCTTGAGCCTTTGAAGAGGTGTGGTGTCTCCTCATAACTTCCAGGAAGAGCGGGTTGTCGGGCTTTAGT +ATGTGCTTTTCAAACTCTTCAAGGTTTATCCTCGTTTCCTGTCTCGGGAGGTAGTGGTTTGCCGGGTTCG +TTCCCATATCGGGGAAGAGGACAAATCCGTTTCTTTCCTTAATGAGTTTGTAAACCTCGCTGTTTGGGTC +TTCTATGTCTCCGAAGAACCTCGCCCTCGCGGGACAAGTGAGAACGCACGCGGGCTGTCTGTGTTCGGGA +GGAAGTGTCTCGTCGTAAATCCTGTCTATACAGAGGGTACACTTCTTCATTACCTTGTCCGCCTCGTCAA +ACTCCCTGCAACCGTAAGGACATGCCCAGGAACATAGCTTACAACCTATACAGTCGTCGTAGTTCACGAG +AACTATTCCGTCCTGTTCCCTTTTGTAGCTTGCTCCCGTAGGGCAAACGGGAACGCAGGGAGCGTCCTGA +CAGTGGAGACATGATTTTGGAAGGTGAAAGACCTGCGTTTCGGGGAACTCTCCCGTTTCGTAAGTGAATA +TCCTGTTGTACCAGACTCCTGAAGCTTCCCTTCCGTAGGGGTCGTAATCGGATAAGGGCCCGAAAGCCGC +CTGAGTGTTCCACTCTTTGCAATTCGTCGCACAGGCGTGACAACCAACACAGGTGTTCAAATCTATAACG +AGCGCGTACTGAGGCATTTTTACACCTCCTTAAGGTTTATACCTGAGAACGTCAACCCACCTCTCCTTTA +TGTAAGGCAGAGGCTCTACTTTAAACTCGGGATAAGTTTCGGGTGTTTGATCTTCTGCTTTGTAAACTCT +GACTTTCGTGTCAAACCAGGCAAGGTGTCCGGTTATCGGGTCTCCGTAGTAGAACTCTTTTCCGTTCATC +TTTATGGAGTGGGGAATTACGTGGTTTAGAAGGAATCCCTGATGTCCTTCTTCCGCTTCGGGTTTTAATC +CCCAGGCTCCTATCATCTTACCTATGGCGTTCCAGGTCCATACGGAATTGGGCTCCGTGCACTCGGTAAG +GAATACCTGACACTTAACCCTTCCTATTCTCGACTCTACCCATACCCAGTCAAGGTGCTTTATTCCGAGC +TTTTTAGCGGTTTTTGGATTCATGTAAAGATAGTTTCTCGTTGATATCTGCCTGAGCCATGCGTTTTGAG +AGTCCCAGGAGTGATACATCCACTGGGGTCTCTTTGTAAAGGCGTAGAGGGGATAATCTTTTCCGCTGAC +TTCTTCTTCAAAGGGCGGGTACCAGAAGGGTAGCGGGTCAAAGTACCTTACGAGCCTCTCCCTGATTGCC +GGGTCGTTGGGAGGTTGATTTTCCCCTTCCCAGAGCCCCTGACCCGCGAGTCTAAACTTTTGTAGTGTTT +CCACGTAGAAGTTCATTATTATCGGGTCCGTTCTCTTTACGAACTTCACGCTCTTTGCCCACTCAAGATA +ATCCTTGTTAACGTGCCTGTAATACCTCATGTGTTCGGGAAGTGGGTAGTAGAAGAATCCTTTATTCTTT +GCGTACATCTCAAGCTGGTTGGGATTGGGTTCACCTACGAAGTGTTTATCGCCATTCTTTCCTCTCCATC +CCGCAAGTGCTCCCACTCCGGGTTGAGGTTGCCAGTTTATGAGGAAGTCTTTCCAATCTTTGTACTTAGG +TGTTCCGTCCTCATTTAAGAATCCCGGAAGTCCCAGCTTCGTTCCCAGTCTTACCATTACCTCTCCCCAC +GGGAGCACGTCCAGTTTTTCACCTTTGAGGTCCTGCGGTTCCACTATGGGTTGTCTTATGGCGTCAACGG +GTCCCGATGCCACGGAAGGCGGTCTGTCCAGAAGTGAGAGTGCGAACCACTGTTCTAAGTAGGTGGCGTC +GGGTAGAACTAAATCGGAGTATGCAACCATTTCACTGTAGAAAGCGTCTATCGTGATTATCTTTGGGATT +ATGTAGTTTCCGCTGGCATCTTTTGCGGTAAGGGCCTCCAGTATGTAGGGAATGTTCTGGGAGGAGTTCC +AAGCCATGTTAGCCATGTAAATCATAAGAACTTCTATGTCGTAGGGATCCTTCTGGTATGCCGCGGGGAT +TACGTTCTGTATGCAACCGTGAGCCGCTATCGGAAACTCCCAGCTGTAAGCCCTGTCTATTCTTAAGGGA +TTTCCTTTCTCGTCCACGAGGAGGTCGTCAGGGCTTTGTGGTATTCCGAGGTGAGGTCCGTAAGGTTTTC +CAAATTCAAGTTCATCAAGGGATTTTATCTTCTTGGGTTTGGGTAGGTCTTCTATGTGTTTGGGATAGGG +TGGTTTTGCGAGGTGTCCGCCGGGTCTGTCTATGCAACCTAGGAGCATCATAAGGACAAATACAGCCCTT +GCGGTCTGGTATCCGTTTGTGTGGGAAGCTATTCCCCTCATTATGTGGAAGGAAACTGGTCTTCCCACCA +TCTTCTTGTGCTTTCTGCCCCAGACGTCTGTCCACTCTATCGGGAGTTCTATGGGGTTGTAAAGAGCCGT +AACACCGAGTTCCTTTGCTATTCTCTCTATCGTTTCCGCAGGAATTCCTGTAATCTTTTCAACTTTTTCG +GGCGTATAGTCCTTAACAATTCTTTCTGCGAAGATATCAAAGGCGGGTCTTACCTTGTATCCTTCTGGCG +TTTCAAATTCTCCTATAAACGCGGGATCAAGGTCCTCGGGAACTATCCTGTCTGCGGGTTTGAAGGAGTT +GGACTTTTTGTCAAATACCATGGGCTTTCCTTCTTCATTCCTGTAGAAGAGTCCGTCCTTGGGTGTTCCA +GGTGCTTGAATTACGAGCCAGGGGGCGTTCGTGAACTCTTTCAAGAATTCCCAATCTATCAGGTTGTACT +TAAATAGAACGTGTGCGAGGCCTAAGATAAAGGCTCCGTCCGTTCCGGGCTTTATGGGAACCCACTCGTC +TGCTATCGCCCCGTAACTCCACCTTACAGGATTTACGAATACGAACTTTCCGCCTCTTCTCTTTAATTCC +TGAATTCCGAGCTTAAAGGGATTAGAAGCATGGTCTTCCGCAACACCAATCATCATGAAGTACTTGGTGT +GCTCAAAGTCCGGGTCCCCGAACTCCCAGAAGGAGTATCCTACTGACATCAGTCCTGCTGCTGCAACGTT +TACAGAACAAAATCCTCCGTGAGCTGCCCAGTTCAGCGTTCCTATCTGTCCTGCAAACCAGCCGTTTATG +GCCTGCATCTGGTCCCTTCCGGTGAAGAAAGCGACCTTTGAGGGGTTTTTCTGAGCCGCTTCCTTAATCC +ACTTTGCTGCAATCTCTAAAGCTTCGTCCCACTCTATTTCTTTAAACTGTCCTGAACCTCTCGGTCCTAC +TCTTAAGAGGGGTTTTCTCAATCTTGCGGGGGAGTATTCCTTCATTATTCCGGAAGAACCCTTAGCACAG +AGAACTCCTTTGTTAAGCGGGTGGTCGTCGTTTCCTTTTATGTATGTAACTTTTCCGTTTCTGACGTAAA +CTTCTATACCGCACCTGCACGCACACATATAACAGGTGCTGTAATACTTCCTTTCGTAAAAACTACCGCC +TATTTCCATTTTTAACCCTCCTGTACTTCCATTTAGAATAAGTCTTAAACTTTTCCATTTACAGTCACAC +TTTCTTAAGGGATTATAAGCGAAACTTATGGGTCTTATAAGCAAAAAGACGGGCTACCATATTCCTTATG +TTTTACATACTCATAATTCTTCTGGCTACTTTCTCGATGATACCGAACATAAATGAGTTTGCTTTCAGGT +TTGAAGAAACCACCCGTGCGGTTGTAGCCTTTGAAATGTACCATTCAGGGAATTACTTTCAGCCCACAAT +TCTCGGAGATCCATACTACAACAAACCTCCTCTCTTTAACTGGTTTATTATTATTTCCTCCAAATTTTTC +GGGTGGGACATTGTAACTGCAAGGGCAGTGAGTGTTTTCTTCACCCTTGCAAATGCCTTTCTTATTTACT +TTTTTTCTTCGAAAGTCCTGAAAAATAAGGAAAAGGCTCTACTTTCTTCAGTGTTTTTTATTACCTTTGC +TGACGTTTTATTCTGGTACGGGTGGCTTGCGGAAATAGACGTGACTTTGAGTTTCTTCGTCACTTTGTTG +TTTATCCAGATTTACAAACTCTGGGAAGAAGGGAAACCCATTTATTACTACACTTCCGCGCTTTTGACAG +GTTTGATTTTCATGATAAAGGGCTTTCCCGCATTTGCATTTTACGGACTGAGTTTAATTTCCCTGAGTAT +TTTTAAAAGGGACTTTAAGGTTCTGCTGAACTTCCACGCTTTTGCTTCCTACTTCCTCGCTTTAATTGCT +TCCTTCTGGTGGCTTCCCTTTTCGGAAAATCCTGAATTTTACTTTAGGAGACTCTGGGAGGAGAGCTTTA +GCAGAGTAGAGAGCTCTAAAGATCTGGAAAAGTTTTTAATTCACTTAATCACTTATCCTCTTTTGAACGT +AAAACAACTCCTCCCCGCTTCTTTGTTTGTGATACCTTTAATCTTTACAAAGAGAATTTCACTTCCAAGG +GAGCTTAAGTTCTTGCTCTTTCTCGTAATTTTTAACTACATTCCATATATTATTTCTGCAACAAGTAGGG +GAAGGTATGTTCTTCCGCTCTTTCCTATCTTAGCGGTAATTTTTGCCCACTTAATTCACGAATACTTGAG +TAAGAACTGGAAAAAAGTTCTTTTATTCTCCTTAATTTTTGTAATAATTTTAAGATTTATTTACGGGATT +TTCTTCCTTCCTTACGTAAACCACAGGAAGGGAGAGCCGAAACTTCAGGCGAAGGTAGCCTACGAGCTCA +CGAAAACTGGAAAAGTTGCCTGTGACTGTCCCAAGATAAAGGACTTCTGTCTTTACATCGGCTTTCTAAG +GGGAGAACCTCTCCTGAGACCTAAGTACACGAAAGCCTGGGATTACTTGGTGGATTGTAAAGAGAGGAAA +GATTTAAGCTTAATAAAGAAGTTTTACGTAAACAAGAAGGAGGTATACCTGTATGGTAGGTTTGCTTCTG +GTTTTGCTATTAATACCTTTAATCGTTCTAGGGGTTCCAAGGTATTTGAAGGCATGTCTGGAGCTCGCCG +TTGACGCTAAAGTGGCTCTGGAAAACGCGGAGGAGTTCACGGGAAAGGTTTACAAGCTTTACCTCACGAA +GAGGCGCTCTGGAGATTGCCTTTATAAGATTAAGGGTGAGAAGGGAAAGGCGATTGTGGACGCACTCACG +GGAAAAGTTGTAAAATTCTTCAAGAGTGAGTAGTTATTTCCCAGTTTACCTGGATTTAAAGGACAAGGAA +GTTCTCGTTATTGGGGGCGGCAGGGTAGCCACGAGAAAGGTAAAGACGCTTCTTGAATTTACAAAAAATA +TCACGATAGTCTCACCGAAGGTTACTGAAGAATTGAAAAATTTAATAAAAGAAAAGAAAATTAAGTGGAT +TGATAGAAAGTTCAAACCTTCGGATTTAAAGGACAAATTCCTCGTAGTGGTAGCGGTGGACGATATTAAA +CTTCAGAAAAGGGTTTTCAATCTGTGTGAAAAGAGAGGGATACTGTGCAATTCCGTTGACTCTCCTAAGT +ACTGCAACTTTATATTCCCATCAATAATAAAAAGGGGGGATTTAGTGATAAGTATTTCAACGTCGGGAAA +GGTTCCAGCTCTGTCGCGGGCACTCAGGGAGAAAATTGAGGAATGTTTACCAGAAAATATAGAGGAAATT +ATGAAAGAACTAGAAATTATAAGGAAATCGGAAGAGAAAGGTGAGGAAAGACAGAAAAAGCTTTTAAGAC +TTGCCAGAGAGCTTCTAAAGAATTTTTGAAATTTTTACCGCTCTTTTTCCGTTCTTTTCGCCTAAAATTC +CCAAAAACTTTAACCTTCCCTGAACTAAAACTTCCACTTCCTCTTGAGGCGTTTTTCCGGTAAGGATCAC +GAAACCCTTTCCCATGTTTACAACTTTGTTTAATTTGTCTTTCCTTTTAAAGAGTAAAACTTCTAAGTTC +ACGGGCACTTTGAGAAGTGCGCTCAGGAGTTCTTCCCTTTCCTTCGGATCGGGTTTTCTCATAGATAGTT +CTTCCTTTATTTCCTTTAAAAGGTAGAGTGGGAAAGCTAAGAAAAGACTTCTCTTTAAGGTTTCGTTCTC +CACGCCGAGTTCCGCAACGTAGTGGTCGTCGTCCAGATCAAGTTCGTAAACGTTTTCAGAAAGTTCGCAA +TCTGTTACGTCTCTTGTAAAAAATTCGTTCCAGACTTCCCTGAAGGTACTGCAAAAGCTTTCACTCAGTT +TGGTGAGCATACTCATTTCCAGTCTGGAGAAGGGCTTTCCTTCAAGTTCGTACGGTTCTCCACCGAGCAT +CATGCTTATAAAGGCGTAAGAGAGTTTTGCGTCTAGCAGTGTGTAAAATCTCCGACTTCCTCGAGGTGTT +GTCTTATAAAAACTACGGGAGGGGACAGGTTGGGAAGTATTTTTGAAAGGGGTTTTACGTCCTTTTCCTT +TACCTTAACCTTCAGGTTTGAGAGAGTGATTTTCTTTAGTTCCTCCGAGAGCCTTTCCGTAAAAGTGCTC +AGGAACTGCTCAAGTCTGGGGTAACGTTCCGAGGATATTTTTTCCAAGCTGTCAAAGTCAAAGGGCTGTA +AACCTTGCGGGATTTTTTCTACCTTTTTCTTCTCTAGGGTTTCCATTAAGAACTCTATCTCTTCCTGAGA +AAGGAGTTCCTCGCTCATCAGTAAACTCCGTACCTTAAAATGTACTCCTCGTACTCGGGAAAGTCTCGGA +CGTCCACAAAGGAGCCCGACTCTACACTCTCCAGTTTCGGAAGAATGGAAAATATAAACTCCGCAGTCTT +TTCAGGTGTGAGTTTAGGAGCGTTCTTTATCCTCTTTATGGACGGGTACTTTTCCTCATTCTGCGACATT +ACCTCTTTCAGCATAGGTGTGAGCACAAGTCCTGGAGCCAAGGAAATTACTTTAGTTTCGGGGAGTTCCC +AGGAGTAGAGTTTTAAGAGGCAGTTTAGCCCCGCCTTTGAAAGGGAGTAGGCGTTCCAACCCCTGTTGCA +GTTCCTCGCAGCCCCCGAAGAAATACCTATTAAAGTTTTTACCTTTATTCCGAGTTCCATAAGCGTGTCT +ATTATTACCTTGTTGGACCACAGGTTTACCTTCATCACTTCGTCTATTTCGTGTAGGCTTATGTCCTTCA +TATCGGAAAACTTTCCGAGGATTCCCGCGTTCAGGATTGCAAGTTCCAGTTCTTTTACACCACTAAGGAG +TTTAAAAAGACAGCCTTGAACTTCTTCTACCTTTAAAAGGTCGCACTTTACAAAGTGTATCTTCTCCTTG +AATTCCTCGGGCAGGTGTCTGCTTAAAGCGTAAACCTCGTAGCCCCTCTTTATTCCTTCCTCTACGAGTG +CCTTTCCCAGCCCTGAGCCTATTCCCGTTATGAACAACTTCATTTTTCTTTCTCCTCAAAGACTTGGTTT +ATAAGAATTTTAACGTCCTCGTCGCCGGCTTGAGCCTGAGCAAAGCCGTACAGGTCTCCCCTTTTAAAAC +CGGCGGTAGGCTCTTTTGATATTCTCGCGGTTAGCATAAGTTTTCCTTCTATAAAGTCCTCGGGGACGAT +TTTGTGTTTTCCGGTTATCTTAAACCTGTAAGGGAAATCTGGATTTTTAACTCTCAAAACCGCTACAGGT +CTGGAACTTCCCTCCTTCATAACCGCTATTATTAGGTACCTTTCTCCTTTAGGAATTTTCTCCTTTAGTT +TATCGTCCAGTATTACGACTCCCTTTACGTACTGCTTTTTGTACTTTTCAAGTATCTTTTTACCTTCAGG +CGTCTGGTATTTCTTGGGCAGTTCCTGACAGGAGTAAATCAGTAGGGAAAGCAGTAAAAAAATCCACTTC +ATGTTTCTTCTCCGTACTCTAAGTATACTACCGTGACGCCCGAACCCCCTTCCTTGGGATAGGCGTCCCT +GAAGAACTTAACCTTTTCGTTTTTTGAAAGGGCTTCCCTTACAGCACTCTTTAACTTTCCGCTTCCTATG +CCGTGTATTACTTTAACGACTTTGTACCCAGCACTGTAAGCTTCTTCTATGAACTTTTCCAGTTCCCTTA +CCGCGGTTTCCACGTCTTTGCCGATTAAGTTTAGCGTGTCCCTTTTTTCCATTACCGGAGTTTGAACGGT +CACTTTCGTTTCCTTTTGCGGCTCTGCCTTTCCCACCTTCTGTAGCTCTCTTGTATCAAGCCACATCCTG +AGGTGATCCACGAGAACTAAAGCTTTATTACCTTTTACTTCCAGAACTTTACCTTTCTTTCCCATGAACT +CTACGAGGTCTCCTACTTCCAGTTTCTGGGGTTTTTGGGGTGCTAAATTCTCTATTTCCTCCCTCTTTTT +GGAAACGAACTCTTTTATCTCCTTCTTTTCCTTTGCTTTTTTAAAGATTTCTTCAGACTCCTGCACGAGC +TTTCTGAGGTATTCCCTCGCCTCTTTGTAGGCCTCCTTCCAGCCCTTTCTCTTTGCCTCCTCGTACTCCT +TCCTGAGCTTTTCTACTTCTTCTTTCTCCTTCTGTAGTTCCTTTCTGAGCTCTTCTAGTTTCCTGAACTC +CTCCTCGTACTTCTTCACGTAGTCCGAGAGTTTTTCCATAGCCTTTATGTACTGCTCTCCGAATTCTCCC +ACGTGTCTTTTTGCGATTTCTATAACTTCGCTCGGGATTCCGTACTTCTGGGCTATGTAAAAGGCCATAC +TCTCTCCAACCGTGTTGTAGGCAATTTTATAAAGAGGTTTTAAGGTTTCCCTATCAAAGAGGACGCTTGC +GGGTGTGTAGTAATCGGAGTTTGTTGAGTAGAGCTTTATAGGCGTGTGGTGCGTTGTGACGAATACCCAA +GCCTTTTTCTTCTTTAAGTACTCCAGTATACCTATACCCAGTGCGGAACCCTCTATCGGGTCCGTTCCCG +CCCCCAGCTCGTCTATGAGAACTAAAGTATTTTCATCGCTCTTTGGTAAGAACTCCGCCATGTTTTTCAC +GTGTGCCGAAAAGGTGGAAAGGTTTTGTTCTATACTCTGCTCGTCCCCGATATCAGTAAAGACTTTTTCA +AACAACGGAAGTTTGCTATTTGGACTTGCAGGAACGGGAATAGCACTCTGGAACATCAAGACGCTGAGAC +CGAGGGTTTTTAAAGCCACAGTCTTTCCACCCGTATTTGGACCCGTCAGTATTAATCCCTTCTTTTCTTT +GAGGAGTATACCAACTGGAACAACGTCTTCCTTTACTAATACTAAAACGGGGTGTCTAGCCTCGTAGAGT +TCTACCCATTCTCCAAAGTCGGGAAAGCTTCCTTCTACAAGTTTTGAAAACCTGTACTTACATTGCTGGA +AATCAACCTCTACACAGGCTTCAAAGCTCTCAAGAAGTTCTTTTGCGTAATCCCCTATGTATTCGGTTAT +CCTCTGGAGAACCTTTCTTACTTCTTCTTCCTCTTTTTGTTTTAATTCCGTGAGCTTGTTGTTCAGGTGT +ATTACGAACTGGGGCTCAACGTAAGTGGTGTAGCCAGAGGATGACGTTCCGTGAACTATTCCGAATATCT +TTTTTACGTGGGAAGTCTTTACAGGAATTACGTACCTTCCGTTCCTTATCGTGACTATCCTGTCGGATAA +AAACTTGGCAGAATCTGGTCTGTTTATTAGGTTATCTAGCCTCTTTTTAATTTCCTCTTCTACCGCCCTT +ATGCTCTTCCTTACCCTGAGGAGTTCCTCGCTCGCCTCGTCTTTTACAAAACCCCTCGGGTCTATGCTAC +CGATGATTAAGTTTTCCAAGGGAGAGAAAGTGTAGAGTTTTTTGTAAACCTTCCTTAAAGGTTCTAACCT +CTGAACGTGGGAACTGAGAACCCTCCTTATTTCCTTCGTCAGGTTTATGACGTTGAGGATCTTAAGTATG +TCCTCTACGCCGAGAATTGCCCCTTGGAGCTTTGCCTTCTTTAAGAGTTCCCTTATGTCTTCGAACTCAA +AGAGTCTTACGTTTTCCGCTATATCAAAAAAAGCCTTGGAGAGTTCTATTTCTTCCTTTACTTTTTCTTT +GTTCGTATATGGCTTTAGGTTCTGTATTTTTTCCTTTGTAGCCGGCGAGTGGGCGTAAGAGGCGAGAACT +TCTTTTACTTTGTCAAACTCCAGTTTAATTAAATCCTTTTCCCTCATTCCTGACTATTCGTACTCTTTAC +CGTACTTCTTATAGAGGTAAATAATCCTCATCAAAAGAGATGCAAGTGTTAAAAGTGCAACGAGTTTTAT +ACCAAAGCCAAGTCCTACCGGTATCGGACTTCTTTCTAAGATTGAAAAGAGTATTATCGTGATGTGGGTT +TCAGGTCTCCCGAAAAATCCAACTCCTTCTAATGGATCAACGATTTTCCCCTTCTTTCTTTCCGTATAAC +CGATTTCCGCGTAAGCTACAGGTTTTATAAAGGAGTGGAGCATGGAAAGGGTTATAGCTACTATCGCAAC +GAAGGGAGAGGCGTATGCAAAGCCTATAGCTCCCAGAACGAGTCCGTCCACCCACTTGTCCGCTATCCAG +TCAAACACAGCCCCGAACTTAGTAGTTTTTCCCGTAGTTCTGGCAACTACGCCATCAAGCAGGTCAAAGA +GTCCGGAGAGTGCGAGTAAAAAAGCACCAGAAAGAGTTTTATGGTGAAAGTAAAAGTAAGCGGAAATACT +TCCTAAGAAGAGGGATATTAAGGTTATAAAGTTGGGGGGAAAGCCCGTTCTCGCCAGGCTCTCCCCGAGA +GGATAGTAAAGCTTTTTTAAGCTCTCTCTCTTGCTTGTTAAGTTCATTTAAGCTCCTTCTTTCCGAGCCA +GGGCATCATCTTTCTGAGCTCTTCCCCTACTTTCTCCACGAGGTGTTCTCTGTCCCTCTCCAGGAGTGCG +TAGTACACGGGTCTTCCGGCTTTGTTTTCCAGTATCCATTCCCTCGCAAACTCACCTTTCTGTATCTCTT +CTAAGGTCTTCTCCATTACGGGTTTTACCACTTTGTAAATCCTTTCACCTCTTGTAACGTCCCCGTACTT +GGCTGTGTCTGAAATGGAGTACCTCATTCCGGAAATGCCGTGTTCGTATATTAAATCCACTATAAGTTTA +AGTTCGTGCAAACACTCAAAGTACGCAACCTCCGGCTGGTATCCCGCATTTACCAAAGTCTCAAATCCTG +CCTTTATAAGTGCTGTCACTCCACCGCAGAGAACCATCTGTTCACCGAAGAGGTCCGTTTCCGTCTCTTC +TTTGAATGTGGTCTCTATAACTCCCGCCCTCGTTGCACCTATCCCTTTAGCGTAGGCGAGGGCTTTGTCC +TTGCACGTTCCAGAAGCGTCCTGATGTATGGCCACGAGTGCCGGAACTCCCTTGCCTTCGGTGTACATCC +ACCTCACAAGGTGTCCGGGGCCTTTAGGAGCTACCATGAAAACGTCAACATCCTTGGGAGGAACTATCTG +TCTGAAGTGTATGTTAAAGCCGTGTGCAAATGCAAGAGTCTTTGAGGAGTTGAGTTCGGGCTCCACCTCG +TTTTTGTAAACTTCGGGCTGAACTGTATCGGGAATGAGGAACATTATGATATCAGCTCTCTTTGCCGCTT +CTCTTGGAGTGTAGACTTCAAAGCCGTCCGCTTTAGCCTTTTCCCTTGAACGGCTTCCTTCGTGCAGTCC +TATTATTACGTTAAGTCCGCTGTCTCTTAGATTAAGAGCGTGAGCGTGTCCCTGACTGCCGTAACCGAGA +ATTGCTATTACCTTGTCTTTTAGTATGTCAAGACTTGCGTCTTCGTCGTAGTATATCTTTGCCATGCGTG +ACCTCCTGAAGGATTTATTATAAAGAACAAATTGTAAGATAATAATGTCGGGAGGTAGGTTATGAAAAAA +TACTCAATACTTCTCTTACCCTTCATACTCGCTTCCTGTGCACCTGTATCCGAGAGCCAATTCACGGAAC +AAAGACTCAGCGAACTTGAAATCAAAGTGGCAAAACTCGAGGAAAGACAGGAAAAGATAGAGGAACAACT +CGAGGAAATAAACAAAAGACTCGACTACATAACGAAGAGTATCGCAAAAAGGGAAATAAAGAGTTACAAA +GAGCCGGAGGAGGAAAAACCACCTTTTGAAGAAGTAAAATCCACCGAGGATGAAAAAGCCGAGTACGAAA +ATGCTCTAGAACTCTATAAAATGAAGCAACTGAACGAAGCAAGGGACGCATTTGTGGAGTTCATAAAAAA +GTATCCAAATTCAAAGTACACGGATAACGCGTATTTTTGGCTCGGGAAAACATTCTACGAACTGGGAAAT +ACCGAGAGGGCTAAACAAATCTTTAACGTTTTAATTAAGAAGTGCAAGTCTGGAGAACTTCCCGACTGTA +ATAAACTTCCCGACACTTACTTTATGCTCGTAAAAATTTCTCTCGACGAGGGGAACATAGAAGAGGCAAA +CAGGTACTTATCCATACTTGAGGAAAAGTTTCCCGATGCAGAGGCAACCCAAAGGGCAAAGGAGTTAATA +TATAAAACTCCATGAGCTTAAAACTTCCAGAGCACGTTGCGATAATAATGGACGGAAACGGGCGGTGGGC +AAGACAGAGGGGTCTACCCAGAGTTGCGGGACATTACAGAGGTGCAGAGGTAGCCGAAGACATAATAGAG +TACTGTATAGAGCTGGGAATAAAACACCTGACTTTGTTTGCCTTCTCTACGGAAAACTGGAACAGACCTA +AAGAAGAAGTTAAAGCCCTGTTTGAGCTTATGGAAAACTACATAAGGAGTAAGAGGGAAAAACTTTACTC +CTTAGGTGTAAGGGTAAGGTTAATAGGAAGGAGGGACAGACTCAGTAGAGGCTTAGTAAACTTAATGGAA +GAACTGGAAAGTGATTCAAAGGATTTCAAAAATCTCTTTTTAAACGTTGCCATAGACTACGGCGGAAGGG +ATGACATACTGAGGGCTGTGAAAAAAATAATGGAAGTTCAACCGAGCAAACTTGATGAGGAGACTTTTTC +TCAGTTTCTGGATCTCTCCTGCTCTCCTGACCCTGACCTTCTAATAAGAACCGCGGGAGAGAAGAGGATT +TCCAACTTCCTCCTATGGAACCTGGCGTACACGGAGCTTTACTTTACTGATACACTCTGGCCCGATTTCA +CGAGAGAAGAATTTATGAAAGCCCTTGAGGATTACTCAAGGAGAAAGAGAAAGTTCGGGAGAGTTCTTGA +TGAGTAGAGAATTTTACGGCGTGCTTATAGGCGTAACGACACTTCTTGTTATCTTCTTACCGAAATCTTT +ATTCCTTTTAGTGATTTTGTTCTTGTGTTTTGCCATATCTAGAGAAGTATCGGTAGCTTTGGGAGAAAAT +GAGGTATTTTATTTCTCACCTTTAGTTTTATTGACTTATTACTTTGCCGATCCACTTGTCTTTCCGTTAA +TAGGTTTACTGTCTCTTTATTTTGCCTACAAAAGGTGGGAACTAAATTCTTTTTTTAAATCAACTTTTTT +GCTTTTTTATCCCGCCCTTTTTCTTGTTTACCTGATAAAAATAAAGGAAATCTCAACTTATTACTTGCTA +ATTTTTATTTTCGGAATTTGGATAAACGACGTTTTTGCTTACTATATAGGGAAAAACTTCGGGAAAACTC +CTCTCTTTCCAAAAATTTCTCCGAAGAAAACTGTGGAAGGATTCCTCGGTGGAGTATTATTCGGGAGTTT +ATTCTTTGCCCTCACTTTGCCCTATGGAATTTTAAACTCTTTCCTTTTAGGTACTTTTGTACTTACGGTA +GGTGTAGCGGGGGACTACTTTAAGTCCTTCATAAAGAGGCAGGTTGGGATTAAGGACTTTTCAAACGTTT +TTGGTGAACACGGCGGCTTTACGGACCGCTTTGACGCCCTTGTTTTTTCCGCTCCCGTGTTTTACCTTAT +AATGTGTGCTGGGGAGCTTAATTGTAAACTTTAAACTCTTCTCAGCGGGAGGGGCAATTATGGAAGTATT +CAGCCGTTCCTTTAAGAACGGAGAAGAAATTCCAAAAGTTTACACATGTGACGGTAAAGACATATCACCT +CATATAGGCTGGGAGGATGTTCCCGAAGGAACGAAAAGCTTCGTCCTGATAATGGATGACCCTGACGCTC +CTATCGGAACTTTTACCCATTGGGTTGTTTACGACATACCTTCCCAAACCAGAGAGTTACTTGAAGACTT +TCCGAAAGTTCCGGAGGTGAGCGGGATAAAGCAGGGAATTAACGACTTTGGGAGAGTAGGCTATGGAGGG +CCATGTCCTCCCAGAGGTCACGGCTATCACAGGTACTTCTTCAAAGTCTTTGCCCTGAGCGTGGAGAGCT +TAGGACTTCCTCCGGGAGCAAGCAGAAAAGATGTTGAGTTAAAAATGAACGGGAAAATCCTCGCACAGGC +TCACATAATAGGGCTCTACAAAAGAGATTAATTCCTTTAAAGGAAACCTCGGATATTCTTTTACAAGTTC +TCCTTCTTCGTTGAATATCATAGTGCTCGGCAAAAAGACGAGTTTTACGAGTTCCGTTATGTTTCCTTTA +GGGTCTACAAGCACTTTAAACTTAGGCTTAATTCCGTAATCTTTTAAAACTTTCAATACGTCCTGAGGTG +TCATAAAAACCGCCAAAGAAACGACTTCGTATTTTTGAGAAAGTTTTTCGTAATTTTCGTTTATTACCTT +CATATCGTCGGTGTGCCCCGTGCAGGTGCCCGTCCAGACGTACAGGAGGAGTTTCTTGTTTACTGGTTTT +TCCATCCTTGCAGGATTTCCTTTAAGGTCAACGAAGTTTATGTTGTAAATTGTCCTCTCCGCCTGACAGG +AAATTATAAAGAGAAGAAGGAAAACGAGGAACCTCATCAATGGTGCATGTGGTGCTTCATGCGGTGCTTT +TTCACAACTGGAGCTTCAACGGTTATCTTCCCGCTCTTTTCAAAGATGAGTTCTACCTTCACTTTGTCCC +CTTCCTTAATCCTCTTCTTTAAACCTATTATCATCACGTGGTACCCGTGGTGTTTGAACTCTACCTTTCC +TTTAGGAGGGATTTCTATCCTCTCTTGAGGAACCATTTTGGCGACGTCGTTTTCTATTACAGTTTTGTGG +AGTTCCACCCTTTGGGCTATATCCGTTTTTGCACCGATCAGGTAATCGGGTTCATCGCCTTCGTTCACAA +TAATCATCCCCATCATCGTAGTGTTAGGACCGGGAGGCGGTTCCATAACCCACGGGTGTTTAACGACTAT +CTTGGGAGCTCCGAAGCTGAGAGCTACAAACACTACTATCAAAGTGAGTAACTTCCTCATAATATTAAGC +ATTCTAATATAATTAATTGCTTAGCTAAAAAGGAGGTAAAGAGATGGAACAACAGAGTCCTGTGGGAGCA +CTCCTCTTTCAGATAATCTTCTTAGTCGCCATATTCCTTATGTTCTACTTTCTCATAATAAGACCGCAGA +AAAAGGAAAGGGAAAGGCACAGAAAGTTTTTAGAAAGTTTAAAGAAGGGAGACAAGGTTATAACTTCTTC +GGGTATATGGGGAACGGTTGTGGAGATTGGAGACAGGACAATTACCCTGAAAGTTGATGCAAACACCAAG +ATAACCTTCTCAAAGGAAGCCATAGTGGCTTACCAGCCGGGATATGAGAAGAAAGAAGAGAAGAAAGATT +AAGATAGGAGTTTGTAGGAAATCGTTCCTATTATCCATGCAAGTACAAAGCTGTAAACGAGGAAGGCCGT +TGCCTTCCCGTACCCTATTTCTCTGCCCATCGTTGCATAAGTCCCGAGACAAGATGTGTATATCAGTATG +AATACCATAAAGGCAAAGGCGGAAGCAGGAGTAAAGCTGTTTCTTATTAAATCTCTTAGTTGTCCCGTTT +CCTCTTCTTCCACTTCAAGGGCTTGAATCTTTAGGCTGAAAACGGATTTAACTGCGGTTTTTGTAGCCTC +CAGAAGTCCCGACAACTGGTTCTTAAGTTCTTCTGAAAAACTGAACTTTTCTTTTTCCTGAACCACCTCT +GTGGCCGTGTATATAACACCCATGGAGCTGAGGACTATCTCCCTTGCCAAAAATGCTGGAATCAAAGATG +TGGTAGCTCTCCAGTCGGAAATTCCCATAGGCTCAAAAACGGGAACCAAAACTCTACCTATGTCCGCCGC +CAGGCTATCTTTCGGATTTTTGACATTCGGAGGGAGATTTAAAAGTATCCATATGAAAATAGACGCTGCA +AATATTAGCGTTCCTGCCCTGTATAAGAAATCTTTTACGTGTATCCAGGAGATATTTAAAACCGTTTTTA +AAGAAGGCATACGGTAAGGTGGAAGTTCTATCACGAAGTGAGAGGAGGCTCCTCTTGCTATACTTTTTCT +CATTAAAAAGGCTGTAAGCAGTGCAACTGCTACACCCAGAAGGTACAGACCCGTTATCACGAGTGCGGCA +TTATTGGGAAAGAACGTAATTGCAAAGAAGGAAAATACCACAAGTCTTGCGGGACAACTGATAAAAGGTA +TCATGGCGATAACGATTAACTTTTCCCTCGTGGTTTCAAGGGTTCTCGTGGCAACTATTGCTGGAACATT +ACAACCGAGGGCGAGGATTAAAGGAATTACGCTCTTTCCGTGGAGTCCCATTCTGTGCAGGAACTTGTCC +ATTAAAAAGGCAACCCTCGGAACGTATCCCGACATCTCAAGGAAGGTTATAAGAAAGTAAAGAGTAAAAA +TAAGAGGAACAAAGGTAAGAACAAATCCCACGCCTCCGATAACAGCTTCGGAGAAAAACCGCGAGATAAA +TTCAGGTGCACCTAAGGAAGCCAAAAATTCCTTTACCGCAGGGTTTAAGAAGTCCGTGAAGAAACCATCA +ACCCAGTCAACAAACGGACTTGAGAAGTCAAAGGTAACCTTGAAAAGGAGGAACATTATAACGACGAAGA +ACACGAAACCGAGAACCGGATGGAGGAGGAGGTTGTCAAGGAAATCCGTTAATGTTCTTACGTCTATACC +CTTTTGTTTTACGACTTCTTCGTAAATCCCGTGGGCAAAGGCGTAACGTTCATCTTCTAAGTACTTTTTA +AACTCTTTTCCGTACTTCTCTTTAAACTTTTTTTGAAGTTCTTTATCTCGGAGGGCAAACTCTATGAGCT +CGTGTTTAGTAAAAGGCTGAGCTTTAAGGGATTTGTACTTCTGTGCTACTTCAGATAAAAACTCTTCAAG +TTCTTCAGAATACTTTAACCTGGGTACGTGTTTTTCTTCGTAAGCTTCCACTATTAATGGAAGTATCTTC +TCAACACCAGTTCCCTTTTTTCCTACAGTTTTTACCGCCTTTACTCCCAAGAGTTCGTAAAAAGCCTTTT +CGTCTATTTCTATCCCGAGTTTTTGAGCCTCGTCGTAGAGGTTTAAAACTAGAACTGTGGGTTTTTCAAA +CTCAAAGAGCTGAACAGTGAGGTATAAACTCCTTTCTAAGTTCGTTGAGTCAAGAACGGTTAAAATTACG +TCAACGTTTCCCTTTTCTAAAAACTCAACCGCTATCTTCTCGTCTTCCGATATTGGTTCAAGGGTGTATA +TACCGGGAAGGTCCACAAAGTGTATCTCGTAATCCTTGTACCTTACGGTAGCTTCCTTCTTCTCAACGGT +GACACCAGGCCAGTTTCCGACCTTTAGAGCTGTTCCGGCTATAGCGTTCAGTATCGTAGTCTTTCCCACG +TTCGGATTTCCCGCAACTGCAACCGTTATTTTCTTCATGTCTCTACCTCAGTACTCAAAGTTCAGCCGAA +AACCTAAAACGTATGTGTTCCTAACATCGTCTATTAATTGATAATCAAAGGTAATGTGAAGATAACTTGA +AAGTACGTGTTTAAAATAGATTTCCAACACGTTTACGTCTTTTAGCTTGTTTCCCTTCCTGAAGGCGTAA +CCAAAACCGATTTCTTCCTTTCCTAAATTCAATACGCTACCACCGCTTACAAAGTATTTGTAATCCTCAA +GGTTATTCTTCCCGAACCTGAAGAAAAATCCCAAGTTTTCAAAGGTGTAGTCGGAGGAAATACCTAAACT +TTTTACTTCTTCAAAAGGTGAGTGGGTGTAGTAAAAGTAAACGTGGTAATCTTCTGAAGAAAAGCCGAAC +TGCATCAGATAAACGCTTTCCGTGTCAGGGTCTCCTTGGGCCCAGCCAAACTGGAGTGAAAAATTATGAC +TTAAATTAAGATTTAATATCAATCCGGGATTGTACGAAGGTAAAACCGCTAAAGGGTTGTTTACGAGATC +CGTATTTAAAAATTGATTTTGCTCGTCGTTTGCATACTCATTTGTATCAAAAAAGGAAGTCGTGTCGAGA +ATTCCAGCGTAAACCCCTGCACGTTTTACTTTTAAACCTGCGTAAGCTTCCAGTAAGTACTTTCTGCCAG +TTTCGTTTACATCTTTGGTGTCCTTCTCCAGATCGTCTGCGGAAGGAAGAGAGTTAAATCCAAGCTCTTC +AAAGGTTTTATTGAGCTCGTTTCCGAAAGAAACTGAGGCGTTTACAAGGATTTCAAATTTTCCGATTTTC +GGGTTGAAAATCAAGTGTGAGGTGGTATAAGCACCGCCTTTATACCTTGAACTTTGATAAACGGTAGTGT +TCATAAAGTGAATTCTGTGTTGAATATGCTTCTCAACGTGCTTCAATACGGGAGTGGAAAAGTCCAATCA +GTGAGCCTCCTTCTTAAGGAGATCAAATAAATTTTTGTCTATAACTATTCTTGTATTGTCAACTTTCAGA +AGGTAAACCCTTCCGTTCTTCATAAGTATTTTTGCCCTTTTCCCCTCCTTCAGTCCCATGGACCTGAGCT +TTTGAATTACAGGATTTTCTTCGTTTTCGTATCCGAGAATAAGAAATTCTTTTCCTTCTTTTAAGCCCTC +TACCATTTTCTACCTCCTTTCGTGAAATAAAGATACAATCTCAAAATCTTTGTGTCAAGTCCAAAGAGCA +TTATTGTAAAATGACACTTATGAAGAAGTTCTACGTAACAACTCCCATATACTACGTGAACGACGTTCCG +CACCTGGGACACGCTTACACAACGATAGCCGCGGACACGATAGCGCGCTACTACAGACTGAGGGATTACG +ACGTTTTCTTTTTGACGGGTACAGATGAGCACGGTTTAAAAATCCAGAAAAAGGCGGAAGAACTCGGTAT +ATCTCCAAAGGAACTCGTTGACAGGAACGCAGAGCGTTTTAAGAAACTCTGGGAGTTTTTAAAAATTGAA +TACACGAAGTTTATAAGAACGACGGACCCATACCACGTTAAGTTCGTTCAAAAGGTCTTTGAAGAGTGCT +ACAAAAGGGGAGATATATACCTCGGGGAGTACGAGGGCTGGTACTGCGTGGGATGTGAGGAATTCAAGAG +CGAGGCGGAACTCGCCGAGGACCATACCTGTCCCATACACCAGAAAAAGTGCGAGTACATTAAAGAGCCC +TCCTACTTCTTCAGACTTTCAAAGTATCAGGACAAGTTGCTGGAACTCTACGAGAAAAACCCAGAGTTTA +TCCAGCCGGATTACAGGAGAAACGAGATTATATCTTTTGTAAAACAAGGGCTTAAGGACCTCTCGGTTAC +AAGGCCCAGAAGCAGGGTGAAGTGGGGAATACCCGTTCCCTTTGACCCCGAACATACCATTTACGTGTGG +TTTGACGCCCTATTTAATTACATCTCCGCTTTGGAAGACAAGGTTGAAATTTACTGGCCCGCGGACCTCC +ACCTTGTGGGCAAGGATATTCTGAGGTTTCACACCGTTTACTGGCCCGCCTTCCTGATGTCCCTTGGCTA +CGAGCTTCCCAAAAAGGTCTTTGCCCACGGCTGGTGGACCGTAGAAGGTAAAAAGATGTCAAAAACGCTC +GGGAACGTGGTGGACCCTTACGAGGTGGTTCAGGAGTACGGACTGGACGAGGTGAGGTATTTCCTCCTCA +GGGAAGTTCCCTTCGGACAGGACGGAGATTTCTCAAAGAAGGCAATTCTTAACAGGATTAACGGAGAGCT +CGCAAACGAAATAGGAAACCTCTACAGCAGAGTAGTTAACATGGCTCACAAGTTCCTCGGCGGGGAAGTG +AGCGGAGCAAGGGACGAAGAGTACGCAAAAATCGCACAAGAAAGCATAAAAAACTACGAAAACTACATGG +AAAAGGTAAACTTCTACAAGGCTATTGAGGAAATACTAAAGTTCACGAGTTATCTAAACAAGTACGTTGA +TGAGAAACAACCATGGGCACTGAACAAGGAAAGGAAAAAGGAAGAACTCCAGAAGGTTCTCTACGCCTTA +GTCGACGGACTCTTTGTTCTCACACACCTTTTATACCCTATAACTCCTAACAAGATGAAGGAAGCCCTAC +AGATGCTCGGGGAAAAGGAATTCCTGAAAGAGTTAAAACCTTACTCTAAGAACACTTACAAACTCGGCGA +AAGAAAAATACTATTTCCCAAAAGGGAAGGTTGATACTAATACTCCTTTTCCTCCTCATAAACTTCCTCT +TTGCGGAAAGAGTTTTTTACCTTATGGGAACTTATCTGATTCTGGACGAACTCCGCGGAAAAGAAGTAGC +AGTTTACAAATACATGAAAAAGCTGGAAGAGAAGCTCTCTCACTTTATACCGGACTCTGAAATTTCCCGA +ATAAACGAGAACGCTGGAATAAAACCCGTAAAAGTTTCCAAAGAAACTTATGAAATTCTGAAAATATCTA +AGGAAATAGCAGAAAAAACTTACGGATACTTTGACCCAACCGTAGGAAGTTACACGGTAAACTTTAAAAT +GAAAAAATTAATTTCCGAGAAAAAAGCGAAATCCTTAATAAATTTCAAAGATTTAATACTCTTTCCTGAA +GAAAGAAAAGTTTTTTTAAGGAAAAAGTATATGGCTCTTGACCTCGGCGGTATAGGTAAAGGTTTTGCAG +TTCAGAAGGCTTACGAATACATAAAAACGGAGAAGGGATTTATAGCCCTTGCGGGCGATATGAAAGTTTG +GGGACACAAAAGAAAACTCGCGGTTTACAATCCGATAAACGGAAAAATCCTCGCGGAAGGTGTAAACAAA +AAAGATTTGTGTCTCTCTACCTCTGGAAATTACTTCAGGAAACACATCTTGGGAAAAAGTAAAAGAGTAT +TACAGATTACGGTGGCTCACGAGAACTGCACCGTAGCGGACGCTCTCGCAACCGCCCTCTTCGCCTCTCC +AGAAAAGGAAAGAGAGAAAATTCTGAAAAACTTTCCAGAAGCCGCTGTTCTCATTCTCTACACAGACGGA +AGCCTGTTTGTGAATGGAAAATTTAGGGACTTCTTCGAGTACTTAATCCTGTACTGAAATGACTTCAGTC +ATAGAAGTAAGTTTTTTTCTTTTGTTAATATACTGAAATCAAATTTCAATTTTAAGGAGGTGTGTGATGA +AAAGATTTGTGGCGCTCTCAATGGCCATCTTCAGTCTTTCTTTTGCCCAAGACGTGGATGAGAAAATCAA +GGCTTTGGAAGAACAAATTGAGAGCCTCCAAAAGGAGCTCCAGGAACTGAAGAAAGCAAAGGAAGAGACG +GAAGTTTTAAAAGAAGAGTTCAGGAAATTGAGACTGGAAATCGTTATGCCTGAAGCTTACAAACCTTACG +CAGGTCTTGGACCTGCAGCCTCAAAGGTTTATCAAGTAAAGAAAGGTGTTTCCATAGGCGGATACGGAGA +ACTCCACTACATAAACAATCCGGATAATGATCCAAGTTCCATAATAGATCTCAAGAGGTTAATCCTGTAC +TTCGGTTACTCTTTCACTGAAAATTTAAAATTTAATTCTGAGATTGAGATTGAGCACGCATTTGTAGAAG +GTGGAGAGGAAAGCGGTGAACTTGCAGTAGAATTCGCTTATCTGGATTACAACTTTTCTCCTAAGTTCGG +ACTTAGAGGCGGTATGCTCCTTATACCAGTAGGAATTGTAAACGAACTCCACGAGCCACCTACATTTCCT +ACCGTTGATAGACCATATCTTGAGAGAAACATAATCCCTACAACATGGAGTGAAAATGGTATTGGTATTT +ACGGAGACACGGACCTTATATCTTACAGGGCTTACATAGTAAACGGTATGAAGGCGGAAGAGGGAGAGTT +TAAAGCATCTGCTCCATTGAAAAAACTCAGACAAAATGGTGGGGAGGCAGTTTCCGACTCTCTCGCTTTT +ACAGGAAGAATAGACTTTAAGCTTCCCAATAACTTAACTGTAGGAGCTTCTACCTTCATATCGGGCGTTC +AGAATGAAGACGGTAAAAACTTAGGGAATATTTACCTGTTTTCTCCGCACCTCTGGTGGCAGTATGCGGG +ATGGGATGTAAGGTTCGTAGGAGCTTACGCCACGGTAAGTGATGCGGAAAAGATTACCCTTGAACTTTCT +TCCGCAACTTGTGACAAAAGCACGTGTAACGTCTTTCCAAAGAGAATGCAGGGCTTTTACCTGCAAGTCG +CTTACAACATCCTGAGACACTTTGATACAGAGCAAGAGCTCTACGTATTCGGAGTGTATGAAAATTACGA +CACGCACGCGTCTGTGCCCTCGGGATATGAAAAACCAAAGGGCTCCGAGGTTCAGATATTCAACTTCGGT +ATTTCTTACAAACCTCACCCTCTTGTGGCTCTAAAGGCGGATTATGTCAGGGAAGATTACAAAGATAAAA +AGGACAACGATATTTACAGAGCGGCTATAACTTGGATGTTCTAAAAACCCCTGCGAGGAGGAGCGTGGGG +AGGTGGGGCTTCCTTTAGTCTTTTTAGAGAGGTACAAGGATGAGGAGAATTGGAGCCATAACAGCACTCT +CCCTGCCGGTTCTTTTATCACTTTTGTACTCATGCGGAACAGGAGGAAGTGCAAGTAAAGAAGAAATCTT +ATCTAAAAAGGAACACAACCCCGAGCCCAACATACCTCTTGAATGTTATACGGACACAGGAGTGGTAAAA +CTCGGAAAGGCGATAGCCAATCCCTGTTATGTGTGCCATACAAAAGCTCTAACTCCCTACGAAAACGAAG +TTGACGACTTTGACCTGCAACTCGTTTACGATTTTCCGGAAGAAATAAAAGAAATGGGAAATCCATGGCT +CAATGCCATTAAACCAGAGCTAACCATAGGAAGTGTACCTATGCCTTCCGACGAAGAAATTAAAACGTGG +ATAAGACAGGACAACTGGAGTAAAGCCTATGCAGAAAAAGGAAAAGGAGAACTCGTTTACTTTCCCGATA +TACCACCCATATACAAATACGAAAACGGTTCTTACGAACTTATAAACGTTGATAAAGAAGGCTTTGTAAG +GGACCCCGAAACGGGTGAGTATACTGGATGGCGTGTGTTTAAGTGGAAACCTTTTCCCGGATTTTTCCCC +ACAAACGGGAGGATAGACTCAACCTTTATAAGGCTTCCTGAAAAGTTCAGAAAGAAGAACGGAGAGTTTG +ATTTAAACCTTTACAAAAAGAACCTCGCAATTCTTGAGTGTGCGATGAAAGGCGTAGCTCCCGGAGAAAC +CTGCTCGGGAACTGAAGTAGGAGACTTTATCATGCCTTTCCGCTACGAAGGTGATGCCTCAGACGTAGAA +GTCGTAGTGTACCAGTATCCTCCCGGAACGGAATTTGCACATCCCCTTTACTACCTAGATCCCGAAAACA +CGCTTTCCTTTAAATCATTGAGGATTAAGGAAATGAGGTATATGAAGAAGCTTGCTTACGCGGATACGAG +AACGGGCACGGGAGAAGAAGAGGAGGAAGAGGGCACATTCTTCTGGGATAAGGGCAGATTTTTTAACGAC +AGCGGATACTGGGAAATGAGGGCATTTATAGAAGATAAAAATGGATACCTCAGACCCCAGTCTCCCGAAG +AGAGCAAGTTCTGCATAGCCTGCCACGGAGGTATAGGCGGAACCGTTGACGGCACATTTACCCTCTGGAG +GAAGATTCCCGGAGAGGAAGGCTGGAAGGAACAGGATTACAAAAACATAAAGGATTACAGGTATAAAGCT +ATTACATGTGAAAATCTGGATAGCCTTGAAATGGGAGAGGAAGTGAAGAAAGCCCTTGAGGCTTACTGTT +CCAAAGTGGGCGAATCACCGGGAGAATACACCGTGTACTTTGCACTCACTGCGGGTGGGGACCACTTCAG +GAGCAACTATGAAATACTCCAAGATATAAGTGTGGACGGAAAAGTGGATCTGGAACTCCTCTATAATCCC +GAGAAGATAAAATTCATTGATAACAGTGGATTTATAAAACCTGAACTCTTCTTCCCTGAGCCAGAAAGAG +CCTACGGTATAGACAAGCAGTACTACAGGATAGTTAAAGCACAGGCATTCATTTACGGAAGGGATGTATT +TGAGAAGGCGTTTGGCATATCAAGCGGTGGAAATTCCCTGGAAGAATTGGATAATTTAGAAAGTACAGGT +GTTAAGGAGTCGGGAATATGGAACTTCGTGAAAAACTTCCTCTCTTCAGAATGAGCACACTTTTAGCCAT +TCTTTTCCTCCTCCCTTTTTACACATTTTCTCTGAATAAAAAACCCGAAGAAGTTTTAAAGGGACTCTAC +CCTTCCGCGGAAATTGAAGTGGAGGACATTATCCTCACCGAAGAACAAGTAAAGGAAGTGGAAAAGCTCT +CCGGAACGAAATTAAATACGCGCTTCGTAACCTTTTACATAGTTAAGAAAGATGGGAAGGTACTGGCTTA +CGGATACGTGGATATACACAGGGTCAGGACAAAACCCGAAGCTGTGCTTTATGTAATATCTCCCAAAGGA +AAAATTGAATTAATTGAGGTCCTTGCCTTTCACGAACCCCTTGAGTACCTTCCTCCCAAAAACTGGCTGA +AACTCTTCGAAGGAAAGGACATAAACGCACCACTAAGAGTAAAGAAGGACATCCCGAACGTCACGGGTGC +AACGCTAACCGCCCGAGCAATAACAAAGAATGCCAAAAAGGTTCTCGCCCTCTGGCAAGTTCTATTCGGA +GGAAAAGAATGAGGTTCTTAATAAGCGGTAGTATAAAGAAGAATAAACCCCTCCTTTACATAGTTTCTTT +TTTACTTTTATTTGAACTCTTATTCTGGTTTTTCAACTGGTTTTATTACGACGCGGTTTTTGGACTATCT +CCTGAAAAACTGAGGGAGTTCTTCTTCGGTCCCCCTGACTATCCAGAAAAGATAGAAATTTCCTCCTTGC +TTCAAGAGGTTCATATATTTTTCTTCATTAACTTTTTTGCTTACTTTGTGCTATCATCACTCCTTAATCT +GTTTCCCGTTAAATTCAAGAATTCAGTAATAATTCTCGGATTTTCCTTCTTAACCCTTGAAGTTCTATCA +AACTTTCTTATTTATTTCACGGAAAACTTTATAACACTCAAGCTCATTTTATTTCTACTGTTTCAGGTAA +TTTTCTTTACCACTTTAATTTTTAGCGTTTACGGATTAATTTACGAGAAGGAAAAAACGGACTACGACTT +TTTAAAGACTCTAATAGTTATATTCGCAATTTTCAGCATACTATTTACTTTTCTAAATTTTTTTCTCTTT +AAGGAGAAGTTAGGTCTTTTCTATTCAGATATAAGGGATTACTACCTCGGAAATCCAGAAAAATTTGCAA +GACCCAAAACCTTTGAAGGTTTAATTAAAGTCTTTCATCCTCACTTAATCAGCATTACAGCCTTTTACTT +TGCCTTAGCCCATTTTTTGCTTTTTATACCTCTTAAATACAAAGCCCTTTTAATGGTTTTATTGATTTTA +ATTCCTTTAACTGAAACTTCCGCGGGATTTTTTATACGCTACTTTGGTGAAAGCTTTGTTTACTTAAAAC +TCCTTTCTTTTTACTTAATGATTTTTATAACATTTCTCAGTGCATTTTTACTGATAAAGGAAGGGATTAA +AAAGCGGGAGCACGCCTGACAGCCCTGAAGGACTCAAAGATTATAAACATTTCAAGGAGCAGTATTATAA +AGCTAACGGAAAAGAGGAGTAAGTCTCCCTTCATTAAGTTGTTCCAAGCGTTCATAGCCATGGCGAGGGA +AGTTATAAAGAGAACGAAAATCATGGGAATCAGGATAGGGAGAGTAGGCCTGTTTACCCTTTTTAGGTAA +AGGTATCCTATCAGGAGAGCGAGCCCAGCGAGAAGCTGGTTTGCAGCACCGAAAACGGGCCAGAAAACCA +TACCACCCTTCCCGCCTTCTTTGGAAAGAACAAGAGCCATGGACGTCAGTACCGCAACTCCGGAAGCTAC +CCAAGGGTTCGTAAGCAAACGCACCCCGTATATCTCTCCGAGCTCTCCGAGGATATACCTCTGTATCCTC +ACGCTCGTGTCCATAGTAGTTGCTGCAAAGAGAACAACAAGAGTGGCAATTACAGTTTTCCCGAAGTCTA +CGGGAATGCCGACGGCACCGAGCAGATTAGCCCCGCCGTCAACTACTGCAACGAGACTTGAGGACTTTAT +GGAGGACCACGAAGAGTAGAGTTCCTGGAACTTTTCAGCGGAAAACATGGCTATTCCCGCAGTGGTTGCG +ATTATAACCGCAAGGGCGAGGGAGCTTTCACCCATAAATCCGAGATACCCGACCGCCCTCGCGTCGCTCT +CCTTTTCAAGCTGTTTTGATGAAGTTCCCGAAGACACCAAAGCGTGAAAACCACTCAGCGCCCCGCAGGC +TATCGTTATAAACAGAAACGGGAATATAGGCGGTGCTCCCTCCGGATTTAAATTAACCGCAGGGGCTACT +ATCTTAGGATTTGCAATTACCGCACCGATGTAGAGTAAAATAAGAAGGATAAGGAGTTGCAAACCGTTTA +AGAAGTCCCTCGGCTGGAGCAAAACCCAAACGGGCAGAGATGAGGCAAAAAAGGCGTAAGTAAAGAGAAC +GATTATCCACAACATTATGGGAGAAAGTCCCAGAGACTCTGCTAAAGGCTTTACATCTATCGGGGATACA +CTCCCGAGGTAAATACCAAAATACAGGATACTCAGAAAAATTACCGTAAGGATTAAGAAGTTCACCCTTA +GCCTGTAAACGCTAAAACCGAAAATCACGGCGAGTGGAATTACAAGCCACGCGGGAAGCACACTTGAGGG +ATACTTTACAAAGAGAAGGGAAATCACGTAAGCGAAAACCGCGTTAACGAGTATCGCAAGGGCAAGCAGG +AGGAGTAAAAATAAGACCCTCGCCTTTTCTCCTGCGTATTCACCGAGGATAGTCCCGATGGACTTTCCTT +TATGTCTTATAGACGTTACAAGAGCGGTAAAGTCGTGAACTCCACCGATGAATACAGCTCCCAGAACCAC +CCACAAAAAGGCAGGAAGCCATCCCCATATAACAGCTATTGCAGGTCCCACAATAGGTCCCGCTCCCGTT +ATAGAAGTAAAGTGGTGTCCGAGAAGTATCCACTTGTTCGTAGGAACGTAATCAACCCCGTCGTTTATTT +CCTTTGCAGGAGTAGGTCTTGAATCGTCAAGCTGAAAAATCTTTTCTGCCAGATACTTTGAGTAAACGAA +GTAACCGAAAGCGTAAAGAAGGAAAGCAATCCCTATTAACGGAAGGGCATGCATACCTAAATATTGTATA +TTGATTATTTAATGGAACTTCAGATACTGCTCATTCTTATAATAGCTTTTATATTTCTCGGACCCGAAGG +TATGCTCAACGTTGCCACAAAACTCGGCGAACTCGCCCGTCAGGCGAGGGAATTAATAGACCAGCTCAGA +ATGGAAGCTTATATGGAAGAATTTAATAAAAAAATCCTTGAAGAAGAAAAAAGAATGAAAGAGGAAGAAG +CACCTCCCGAGGACATAGCCGAGGAATTAAAGGAGGAGCTAGAAGACGTTTTAGAAGAAGAAAAGGAGGA +GAAGAAGGAAGATGAGTCAGGAAAAACTCCCGGAAATGCCTCTAACGGAACATCTGAGAGAGCTTAGGTA +TCGTTTAATAATATCTATAATTGCCTTCCTTATAGGCTCCGGGATAGCCTTTTACTTTGCAAAGTACGTG +TTTGAAATTTTAAAAGAACCCATCCTGAAGTCCTACCCCGAAGTGGAATTAATAACTCTATCTCCCACAG +AACCTCTCTTTATACTCATAAAGATATCTTTAGCGGTTGGATTTATAATCGCCTCTCCCGTAATACTTTA +CCAGTTCTGGCGTTTTATAGAGCCAGCCCTTTACTCCCATGAAAAAAGAGCTTTTATCCCGCTGCTTCTT +GGTTCAATACTTCTCTTTATGCTTGGTGCATTGTTTGCCTACTTTATTGTCCTGCCTTTAGCCCTTAAGT +TCTTGCTCGGCCTTGGATTTACTCAGCTCCTTGCAACTCCTTACCTTTCAGTTGATATGTACATAAGCTT +TGTCCTTAAACTTGTTGTGGCCTTCGGCATAGCTTTTGAGATGCCCATAGTCCTTTACGTTCTACAAAAA +GCAGGAGTAATCACCCCCGAGCAGTTAGCGAGTTTCAGAAAGTACTTCATAGTTATAGCCTTCGTGATAG +GTGCGATAATCGCTCCGGATGTTTCCACACAGGTTTTGATGGCTATTCCTCTTCTTCTCCTGTACGAGAT +ATCCATCTTCCTTGGAAAACTGGCTACGAGGAAGAAGAAGGAAATTCAAAAGGCATAAGCTTTTTTTAAT +ATTCTTATTAAATAAGGTTATATATAACAGAGCTCATAATAGGTTTTAATAAATATGTCATGAAAAGAGC +CGAGGAGGTACCCGGAATTACCGTGAGTTTCAGCATCAAATTTCCCTTTTTAATGTGGTTTAAAAACTAC +TCAAAGGAAGGTTTCATAAGGGATTTAATAGCAGGTATCACTGTAGCGGCGGTTTACGTTCCCCAGTCAA +TGGCTTACGCAATGCTCGCGGGAATGCCGCCCATCCACGGTCTTTACGTCGCCTTCATAGCAACGATAGT +CGCAGCGATCTTCGGAAGTTCGCGGTACCTTAACACAGGTCCCGTTGCAATGACATGCCTTCTTTCGGCG +TCCGTTCTGTACGGAATAGGCTTTGAACCTCAGACACCCGAATGGATAAAGTACATGGCACTCCTCGCCC +TTATGGTGGGACTCATAAGGTTAACGGTAGGGCTTTTTAAGCTGGGTTTTATCGTGGATCTCATATCAAA +CAGCGTAGTCGTGGGTTTTACCGCAGCGGGTGCTCTCGTTATAGCCCTTTCCCAGTTCAAACACTTCTTC +GGATACGAAGTAAAGAGTTCCACACACATATTCGAGGTTGTTATGGATCTTGTAAGCAAAATAGAGATGA +CCAACCCCTACACCCTTGCTATCGGAGTCCTCGCCTACTTCCTCATCTGGGGTTCTAGGAGAATAAGCGT +ATACCTTCCCGGTGCTTTAATAGCTGTTGTAGTTACTTCCTTACTCGTTTACTGGTACAAGCTTTACGAT +AAAGGTGTTGCGATAGTGGGAGAAGTTCCACAGGGTCTTCCTTCTCCAGAACCGCCACCCCTTGACTTTG +CCATGATGAGCAAGATGTGGGGTGGAGCTTTCGTCGTTGCGTTTTTTGGATTAATTGAAGCTGTGGCAAT +AGCAAAAACCCTCGCCATAAGGGTTGGTGACAAGTGGGATCCCAATCAGGAACTTATTGGTCAGGGTCTT +GCAAACGTAGCTGTTTCCTTCTTTAAAGGCTTTCCAGCCGGTGGTTCTTTCTCCCGTTCCTCCCTTAACT +TTGCACTTGGTGCTGTTTCCCCGCTTGCAAGTGTGATATCTGGTGCACTTGTTGGACTAACGCTATTTTT +ATTTGCTCCTGCCTTCTACTATCTTCCTAAAGCTACTCTCGCTGCAATAGTCCTTTCCGCAGTTGTTAAC +CTAATAAGACCTCAGGATATTCTAAAACTTTACAGGATAAACAAAATAGACGGTGTGGTTGCAGGACTCA +CCTTTTTATCCGTATTCTTTATGGATCTTTGGGTGGCTATCACCTTGGGAGTTCTCCTGTCCTTGGGAAG +CTTTGTTTACAAGACTATGTACCCGCGTATAGTAACCTTAACAAGGGATCCCGTTACGAGAACCTTTGTA +AATGCTGAGAAGAGAGGTCTGCCTGAGTGTCCCCAGATAATGTTCATAAGACCTAACATGTCCATATACT +TCGGAAACGCCCAGTACGTCTACGACTACATAATGAACAAGGTGGAAGATGCCCTGTTTAATGGAAGACC +CCTTAAGTTCGTCCTAATAGACATGGAAGCCGTTAACTACGTTGACGCTACAGGTGCGGAAACAATAGTG +AGGCTTGTGAAAGACATAAAACAGAAGGGAGTAGAAGTCGCTTTTGCAAACATAGGTTGTGACGTTTACC +CAATCCTCGAAAACGCGGGATTCGACGAAGTAGTTAATCAGGATCTTGTATTCAACGCAAAAGGAGAAGC +CATCGGAAAACTCTTTGAAAAGCTCGATCACGATTACTGCCGAGAAAAGTGTCCTTACGCTGTATTTGAC +GAGTGTCTTGAGGTGAAACCGCCCGAAAAAGTTCAGGAGTTAAAGAAAGCGTCTTGATTGGTGCGGGTGG +CGGGAGTCGAACCCGCACGCCCTTGCGGGCACCGGATCCTGAGTCCGGCGCGTCTGCCAGTTCCGCCACA +CCCGCTACTTATATAAAATTTTATACCGTGAACCCCTTTGACGCCTACTACAAAAAGTACGATGAGTGGT +ACGAAAAGCCCTTTGGAAAGAGTGCCTACGAATTGGAGGTAAAGTGCCTCTCCTCAATGGAGAAAAACTT +AGGGAAATCTTTAGAAGTGGGAGGGGGACAGGCAGATTTGCAAAAGCTTTAGGTATTGAGTACGGAGTGG +ATACTTCCTTCAACATGCTCAAAGTCGCAAAAGAAAGGGGGATTAAGGTCGCACTGGCAAAGGGAGAAAA +TCTTCCCTTTAAATCCGAAACTTTTGACAGCGTTTTCCTCGTGGTTACCATTTGCTTTGTAGAAAATCCC +AAACAAGTCCTCAAAGAAGCTCACAGAGTTCTAAAAAGGGACGGAAAACTTTACCTCGGGTTGATACTAA +AAGAAAGCAAGTGGGCAAAGTTTTACGAGGAGAAGGCAAAAAATGGGCATCCTTTCTACAAACACGCGAG +GTTTTACTCGTTCTTTGAGCTGAAAGAAATGGTAAAAGATATTTTTTCCTTCGAGGAGATGAAAAGTACT +CTCCTTGAAGAACCGCAGGACTCAGAACCTGTAAAGAATAAGGAGATAAAGCCCGGATTTTACGAAAATT +CCGGTTTTACGTGTATAAGGCTTTCTAAAAAGCTTTAAACTATAAAATCATGGCAAAAACGATACTCTCC +AAAGCTTGGCACTACTTTTCAAACCTCCTAATATTCTACGGATACTACCTCCTCTTCTTGTTTTTCTACG +ACACCTTTCTCAGGGTGGTAAAACCGTTAGCTTTGCCTCTCGCACTCATAATCACCTTGTCCATAGCTGG +AATTCACTTAGTATTTATTTTGAGAAGGAAGAAGAAAAATGATTAAGTTCTTAATTCTGGGGGTTATCTT +GATGGTTCAGGTTCTGACAGCTCAAGAGCTTTACATAAGAGACCTTCCAAACGGTGCAAAACTCATAGTA +AAGCCAAGGGACGACACCGAAGCGGTTGCCCTTCATGTCTGGTTCAGGGTGGGATCGGTTTACGAGAAGT +ACGACGAGAAGGGAATGGCTCACTTTCTGGAGCACATGCTCTTTAACGGAACTGAGAAGTACAAGTACGG +GGAGATAGACAGGATAATAGAGAGTTTAGGGGGAAACATAAACGCCGGAACTTCAAAGGATTACACCTAC +TACCACGTGGAAATAGCCCACCCTTACTGGAAACAGGCTTTAGAGGTCCTCTACCAGCTCACCATGAAGG +CGACGCTGGACGAGGAGATGATAGAAAAGGAAAAACCTATAGTAATTGAGGAGCTAAGGCGGGGTAAGGA +CAACCCTACGACAGTTCTGTGGGAAGAATTCGAGAAGCTCGTTTACAAAGTATCCCCCTACAGGTTTCCG +ATTATAGGCTTTGAGGAGACTATAAGGAAGTTCACGAGGGAAAAACTCCTGAAGTTTTACAAATCCTTCT +ACCAGCCTAGAAACATGGCTGTAGTCATAGTGGGAAAGGTTAATCCCAAGGAAGTGGAAGAAGAAGTTAT +GAAAACCTTTGGAAAGGAAGAAGGAAGACCAGTTCCCAAAGTTCAGATACCCACAGAACCCGAACAGATA +GGTATAAGGTTTAAAAAACTCAAAGACCCCAGAATTGAAAAGGCTTACTGGATTATAGGCTGGAGGGTTC +CAGCTATTGGAAAGACTGATTACAAAGGGCTTCTGGTTTTCAGTGAAATCCTCTGTGGAGGAAGGATTTC +TGTATTCTACAGGGAGCTGAGGGAAAAGGGACTCGTTTACTCGTACTCCTGCGGAGACATGGGTAGACCT +AGGGATAATATCTTCATTATAACGGCTACTTTCCCTCCCGAAAACTATGAAAAAGTCAAGAAGAGGGTGT +TTGAACTTCTTAAGGAAACTTACGAGAACTTAACCGATGAGCAGGTGGAAGAGGCAAAGAGCAGGATAAT +AAACTCAAGGCTCTTTGAAGAGGAGAGAGTTGAAAACGATGCCTTTGATATAGGCTACTCCTACACTGTC +GTGAGGGATCTGGACTTTTACAGGTTCTTTGATAAGAACCTGAGCAGGGTAAGAAGAGTGGACGTTATGA +GGATATTCGAAAGGTACATAAAGGAGGATAAGTACTCGGAAATCCTTATGGTGCCTGAAGATGGAAATAA +AGCCGAGTGATGTAAAGGCTCAAACTTCCATCTTCTTTGCGTCCGCCCATATCCACTCAAGTCCATAGTA +CTCCCTAGTTTCGGGCGTGAATATGTGGACTATCGTGTCTATCAAGTCTATTAATATCCAGTGCCCATAA +TCCTTTCCTTCTATGTGGTCTATTTCTATGCCTCTCTTTTCGAGTTCTTCTTCGAGGTAATCCGCTAAAG +CCCTTGCGTGAGTTGTGGAGTTTGCGGTGGCTATAACGAAATAATCCGCGAGGTTGGTGAGCTTGGAAAC +GTCAAGTATTACTATGTCTTCCGCTTTTTTGTTCTCAAGAAGTTCCTTTATTAACTTTAGCTTTTCCATT +TTTTCATTAATTTTAGCAGTTCCTTGTAGTAGGCGTTTTCTCCGTAAACTTCCCTGTAACGCTGGAGTGC +CCTTTCTGCCTCCTTAAAGGCCTCCTCTTTAATCTTTTCCCAGCGTTTTACCTCTCCTTCGAGGAACTTT +ATCCTGTTTTCAATAGCTTTCTTCTCTTCAGGACTTTTAACCTCTTCAAGTTTTTCTTTAGCCTCCTCTA +TGAAATCTTCCAGCTTTTCCCTTTCCCTTTTTACCTGCTTTGGCGTGAGGAGGAGATTTTTTATGTACTT +GTAGGCGAGCCTCTCTTCGGAAAAGTACTCGGGGAAGTTTATGAGAACTTCCCTGTACCTAATTGCTGCG +TTGTAAGGGTATCCGTACTCCTCGTAAAACTTCGCTATGTAGTACTCGTGGTAGGCAAGTTTTTTGTTCG +CCTCTTCAATTACTTCTTCTACCTTTCTCGTGAACCTGCTGTCAGGATACTTTGCGAGGAATTCCTTGGC +CTTCCTTATAGCTTCAACCGTGTACGTTTGATCCCTGTAAGGGTCTGGGGCTACTTTTACTAGACTGTCA +ACGAGTATGTAAAATACTTCTTCCGCTTCCTTACTTCCCGGGTAATTCGCCAGAAAATCTTCCGCGTAAA +CTACCGCATCTACGTAATCCTTGTCCTTGTATGCTGATTTCACGAGGAGGTACTTCACCTTTTTGATCTG +TTCAGGTGTCAGGTGTTCCAGGTAGTTAAGGGCTTTTTCAAAGTTACTCTTGGCGTCTCCGTAATCTCCC +TTCCTATACTCACTCAGTCCCTTTTCGTAGAATTCTTTTGCGTATCCCGCCCTCCTTGCTTCCGATTTTG +GGGCACAGGCGTTTATCAGTAGTAGTCCGAGTAGGAGAGCTGAAAGTAGTCGGAACGTTCTTCCCATACC +TCTTTTATGGTAATCCAATCCTTCAAATTTTTCTCGTTAATAAATTCTTCTACGGTTTTAGCTACGCTCG +GGTGTACTTTAAGAACTATCTTTTTGCCTCTGGTCTTCTCAAGAGCCTTTTCCAAGGTGTGGAGTATGAA +CTCTTTACTCTTCACAAAGCCTTTGCCCTGACAGTGGGGACACGTTTCCCCTATGACTTCGTATATGCTT +TCGGATTCCCACTTCTTCGTCATCTCAAGAAGTCCCAGCTTCGTTATTCCGTATATCTTTATCCTGAGAC +CTTCTCCCTCAAAGATCTTCTTAACTTCAGAAAGCAAAGATTCCTTTGTCTTTTCCTTTTTCATATCTAT +GAGATCCACTATTATTATCCCCGAGAGATTTCTGAACTTAATCTGCTTTGCCACCTCCTTTAAGGCTTCC +AAATTCACGTTGTAAGCCGTTTCCTCAAGGGACTTACCGCAGGTCTCCCCGCTGTTTACGTCTATAGACG +TTAAGGCTTCTGTCTGTTCTATCACTATAAAACCGCCGTTCTTGAGCCAAACGGTTTTCGAAGTGAGTTT +ATCTATCAATTGATTTAACGTTATTCCTCCAGGAAGCGTGTCTATCGTGTTCACGTACCTGAGTTTGTGC +TTTATGGAGTCTCCGAAAAACTCTACTATCTCTCCCCATACGTCTCCGTTGTCCACGTAAATGTTCTTTA +TAAATCCCCAGTAATCGAGAATAGTTTTTATAAACTGGGGCTGACCCTCTTCCAGAATTCCCTTGTTGAC +TTTCTTAGCCTTTTCCTTCAAGCTTTCCCACTTGTTTCTGAGTTCCTGAAGTTCCTTTAAGATTTGTTCC +TTCGTTGCGCTTATAGCTGAAGCCCTGATTATTACGCCTTCTCTGTCATTGAGTTCTTCTTTCAGGATTT +TTTTTAAATCCTCCGTGAAGGCAAAGCCTTTGAGTTTCTTTGAAAAGTTGAGTTTCTTCGTCTCGGGGAA +GTAAACGATGTACTTTCCGGGGATTGATACCTTACAGGTTACCTTTGCACCTTTTAGATCCCTTTCCTTC +CTCTTTAACTGCACGATCACGCTGTCTCCTATTCTCAAATTCTTGCAGTTCTTCTTTTCCTGAAGGAGGG +CTTCTTTTGTAAGTCCAACGTCAAGGAAGAAACCGTCAAGGGCGGGACATTCCTTCTTCACAAGTCCCTT +TAAAAAAGCCCCCGTCCTGTACTTTTCCTTTCGCCTCTCTACCTTGAAGTCCTTTAGCTCCGTTCCAAGA +AAGACGAGCGTAAAGGCAAAGAAGCTGCTAGCGGATATAAAGATTTCTACGTCGCCCAGCACGCTAAATT +ATTTTAAACTTTTTAAATCGGTGAAAGAGAAAATAGGACTTATAGCTGGAAAGGGAAAACTTCCCTTAGA +GTTCAAAAAGAGTGCTGTTCAAAAAGGTTATGAAGTCATTACGATAGGTGTTGAGGGGATAACGGACTTC +GAGTGCGATTACAAAGTTTCCTTCGGAAAGGTTGGAAAGCTGATAAAACTCCTTGAAAAGGAAGAGGCGT +ATTCCCTCGTTATGCTGGGCAAGTTCGAACACAAACTCGCACTGACGGACCTTTTTCACTTTGACTTAAC +GGGAATTCAGATACTCTCAAGAGCAAAAGACAAAAGACCTGAAACCTTGATAAAGACCTTTATGGATTAC +ATGGAAAAGAGGGGATTTAAATTTATAGACCCGAAGCCTTTCTTGGAAGGTATATTGGCAGAAAAAGGAC +CTATGACTAAAAAAGAACCGGACAATAAAACCCTTGAGGAGGCCCTGTGGGCTTTTGAGATTGCAAAGAC +AATAGCCTCCCTGGACGTGGGGCAAACGATTGTTGTGAAGGATAAGGCTGTCGTGGCCGTAGAGGCCATG +GAGGGAACTCAGGAAACCATAAGGAGGGGAGGAAAAATAGCTGGAAAGGGATGCACGGTTATAAAAGTTG +CAAGAAGGAATCAGGACTACAGAATAGACGTCCCAACGGTGGGGGAGGATACCCTGAGGGTTATGAAGGA +AGTAGGGGCAAAAGCCCTCTTTTTGGAGGAGGGAAAGGTGTTTATAGTGGATAAAGAGAACTTTTTAAAG +GAAGCGGACAGACTGGGTATATGCGTTTACGGAATTCAGAGTAAGGAGTAGAACTCCCTCACAAAGGCTT +CCTCTGCGTCCTCTATCGCTTTTAGTTTTATAAAGTCCGGTTTTGGTAGCTTCTCGGATTTGTAGCCCTT +TTCGTCACAGTAACGCTTGTAAAATCCACCTTTGTAAACTTTAGCGAAGAGAACTTCTTTACTTTTTGCG +TTCATGACGTTAAAGAGTACGTCAGCGGTTGCTTGCCTCTCAACGCAGAAGTACGTAATGTCCATATCCT +CTTCTTTCGTTTTGTATCTTTTCTCTTCGTACCTTAATTTCTTGAGTTCCATACTTATTACTAAATCGGC +GTTACTCCCTTCCGTAAGTTGTAACTTTCCCTCCTTTTTCATTACCTTGAGTTTTAGCTTTACGTCGGGA +GGCGGATTGAGAAGTTTGTCTTTTAGATTTCTAAGTGCCACCTTCTGGATTGCGAGGTTGTGGGAGGGAT +TTCTTACAAGTTCTACCCTTGCCCTTACGGTATCTTTACCTAAAATTTCTCTAAAGGTAGCCTTCTGGGC +ACAGGAGAGTGTGAGGAGAATTATTAAAATTGATAATACCCTTAACATATCCAATATTTTATCAGAGAGG +AATATAATTAACCTTGATGGGCGAAATATTCGTGGCGGGTGTAAACTTCAAGGTAGCACCCGTAGAGGTA +AGGGAAAAACTCGCTTGCTCTCTGGAAGAAACTAAAAAGGTCTTACCGATTTTAAAGAGGGAAACTCCAT +TAGAAGAAGTCATGCTCCTCTCAACGTGCAACAGGGTTGAGGTTTACGCCTATAATTTCGTGGAAAACTC +CGAAGATCTAATAAATAAACTTTTAGAGATAAAAAGGTTAAATCCAAGCTTTAAAAGGTACTTTTTTGTA +AAAAGGGGAGAAGAAGCGGTTTACCACATCTTCAAAGTGGCCTCAAGCCTAGACTCCATGGTTATCGGAG +AGCCTCAAATAGTCGCCCAGTTTAAGGAAGCGTACAGAGTTGCAAAGGAAGCTGGAACCGTCGGAAAGAT +TTTAAACAGGGTTTACGAGAAAGCTTTAAGGGCTTCCAAAAGGGTTAGGACGGAAACGGGAATAAGCAGG +AGTGCGGTATCCGTAAGTTACGCGGCTGTAGAACTCGCAAAGAAAATTTTCGGAGACTTGAAGGAGGCAA +AGGTTCTTTTAATCGGTGCAGGCGAGATGGGGGAACTCGCTGCAAACTACCTCAGACGCTTTGGAGCAAA +ACTCCACATAACAAACAGAACCTACGAAAGGGCTCTTAAACTCGTCAAGGAACTCAGCGGTAATGTTCTG +AGATTTGAAGAACTAAAGGAGTACCTTCCCCTGATGGACATCGTTATCGTCTCAACGGGGGCAAAAGATT +ACATACTCAAAAGAGAGGATTTTGAACGCTCCGTAAGGGAAAGGCATTACGAACCTCAGTTCGTTATAGA +CATAGCCGTCCCGAGAAACGTTGATCCTGAAGCGGGAAATGTGGAAGGTGTATTCCTTTACGACATAGAC +GACCTCAAACAGGTAGTGGAAGAAAACTTAAAGGAGAGGATAAAGGAAGCCCAGAGGGGTGAGATAATCC +TCTGGGACGAAGTTAAGAAGTTCATGAACTGGTACGAGTCTTTAAAGGCCGAACCCTACATTCTGGAACT +AAAAGCAAGTGTTGAAGGGAAAGAGGTAAGTCCTTACATTAAAAAATTGGTGCACAGGGCTATTAAGGAA +ATCAAAAGAAATCCCGAAGTTGCGGATATAATCTTAAGGATATTCAAGGAGGTAGAGAAGAATGAACCCA +GAAGAAAGGAATTATCCAATGTCTATAACGGAACTCATGGAGCTTGAGTCAGAGTATGCTATAAGGGCGT +ACATACTAATAAAAGCTGATCCGAGGGAAATTCCCTCAATAATGCTTGCCCTTTCCACTTTTGAGGGCGT +AAAGACCGCGGACGTGGTGACAGGACCCTACGACATAATCGTTTTCGTGGAAGTTCCAAATCAGGACGAA +CTAGGAAGGCTCGTTATAAACAAGATCCACTCCTTGGAAGGTGTTAAAGAAGCTATAACCTGCGTAGTTG +TAAGGATATGAACTTTCCCTACGTTGAGGAAAAAGAAGACAAAATTATAGTTGTTTATTCAAACGAAAAG +ATAGCCTACGTGGAGGAAGATGACGGAGTGCAGATTTTCTACTCCAAAAATTACGACGTTGTTAAGATAA +TTATCCCGAAGGATGAAGAACACCACATTATATACTTACCGTGATTACTTCGTTATAAGGGGAGGAAAGC +CCCTTACCGGGAAGGTAAAAATTTCGGGGGCAAAGAACGCTGCCCTCCCCATTATGTTTGCAACGATCCT +TACGGAAGAACCCTGCACCATTACAAACGTTCCGGATCTCCTTGATGTAAGAAATACTCTACTTTTGCTT +CGGGAACTTGGAGCAGAGCTTGAGTTTTTAAACAACACCGTTTTTATAAATCCATCTATTAACTCCTTTA +TTACAAATCAGGAAATCATAAGGCGCATGCGTGCTTCCGTTTTGAGCCTTGGTCCCCTTCTCGGGAGATT +TGGAAGGGCGGTCGTTGGACTTCCCGGCGGTTGTTCTATAGGAGCGAGACCAATAGACCAGCACCTGAAG +TTTTTCAAAGAAGCTGGTGCAGATGTAGAGGTCAGGGAGGGGTACGTATACGTAAACTTGAAGGAAAAGA +GGAGAGTTCACTTTAAATTTGACCTCGTTACCGTCACGGGAACTGAAAACGCACTACTTTATCTGGCAAG +CGTTCCCGAAGAGAGCATCCTTGAAAATATTGCCTTAGAACCCGAAGTAATGGATTTAATAGAAGTCTTG +AAGAAAATGGGAGCACATGTAAAAGTTGAAGGGAGGAGTGCTTACGTAAAAGGTTCTGAAAACTTGAAAG +GGTTTACTCACTCGGTTATTCCCGACAGGATAGAGGCTGGCACTTTTATGGTCGGGGCTGTGCTAACGGA +CGGAGAAATCCTTCTGGAAAACGCGAGAATAAATCACCTCAGAGCGGTTGTAGAGAAGTTAAAACTTATC +GGAGGAGAGGTTGTGGAAGAAAACGGGAACTTGAGGGTATTCAGGAAGGAAAGTTTAAGGGCTTGTGATA +TAGAAACTCAGGTTTACCCGGGATTTCCCACGGATATGCAGGCCCAGTTCATGGCACTCCTTTCGGTAGC +AAAGGGGAAATCAAGGATAAAGGAAAACATCTTTGAACACAGGTTTCACCACGCTCAGGAACTGAACAGG +CTCGGGGCAAACATAACCGTGAGGGGAAACACAGCCTACGTTGAGGGGGTAGAAAGGCTCTACGGAAGTG +AGGTTTACTCAACAGACCTCAGGGCTTCCGCATCTCTCGTGCTCGCGGGTTTGGTCGCCCAAGGGGAAAC +CGTGGTGAGGGACGTTTACCACCTTGACAGGGGTTATGAAAAACTTGAAGAAAAGTTAAAGAAACTCGGA +GCCGACATAGAAAGGGTAAGTGAATTATGAACTTAACTTCTTAGGGGCAGAAAATAAAAGTGGAGATAAA +AGAAAGGGATTAGGCAAGTTTTATCTTCTTTTCCTTTTCTACGTGAACCTTGGGTATCCTTATTTCAAGG +ACTCCATTTTCGTACTTAGCCTCTGCCTTTTCGGGGTCAACTTCTACGGGCAGGGGTATTACTCTTTCTA +TAACTCCGTAGAACCTTTCAGCCCTTATAATGTTCTCAGTCTTTTCTTCCTTTTCCTCTTTCCTTTCGGC +CCTTACGTGTACTGCGTTTTCCTTTACGGTTATTTCTATGTCTTCCTTCTTAACGCCGGGAAGATCCATC +TTAATAACTACTTCCTTGTCCGTTTCGTATACTTCAACGGGAGGAACTAAGGTTTCCTGTTCAGCCCTTC +TCGGTACAAATTCTTCCAAGAGTCTTTCAAAATCCCTTCTGAGTCTTTCTACTTCTTCAAAAGGTCTCCA +AACTATCATGCTTCTCCTGTCCATGGTTCCCACCTCCTTTAACAATTTTTCTTACATTAAACTTAAGTCT +ATCTTTATAAAATGTCAAGACTTAAATCCCATACTGATTTCCGTAAGGGGCAGTATTACGCTGAAGGCTA +TTATCCCGACGGTTATACCTATCACTAGTATTGCTAGAGGTTCAACTAATCTGAGCCAGAAGCTTATCAG +CCTATCCGACTGCTTTTCGTAAACCTGAGCGAGCAAGTTTAAAGTTTTTTCAAGCTCACCGCTCACCTCC +CCCGTCTCTACAAGATTCACAAAGAGTTCCGGAAGGACGTTTTCCCTTGAGAGGAGTGCGGAAAAACTCT +TTCCTTTTTCTACCTCGCTCACCAAACTTTCCAGCTTCTTCCTCAAGTACACGTTGCTTACACTCTTTAC +CGCTATGGAAAGGGCGGTGCTCAGGGGAACGGAAGCCTCAAGGAGCATGGAAAGAGTTCTCGAAAAACGT +GAAAGGTTAAAGTATAAATTCAATTTTCCGATAACCGGGATTTTCAGCGTTAAGTAATCGAGCCTTTCCC +TTGAGAATATCTTTTCCCTGAACTGGAAAATTAAGAGAATTAATGGAAGGAGTAATAAGAAAAGAGTCAA +CACGTCCGAAAAAAGTATCACGAGTTTGGTTATCAGGGGAAGTTCCTTTCCGAAGCCTTCGAGGACTTTT +GCGATCCTAGGGACTACGAACTTGACCGCTACGAAGAGGGAAAGGAAACTGAAAGTAATGACGAAGGCGG +GGTACGTTATAGAGGTTATTACCTTGTTCTTGAACTCCGCTACTTTTTGAAGGTACTCGCCTGCCACCTG +AAAGACGTACTCTAAGTTCTCACCTCTCTGGACGCCCGTGAGCATCTCCGTTAAGAACTCCGGAAAGACT +CCTGTTCTCTTGAAGGCTTCCGCGAGGCTGTAGCCTTTTTCTACGTACTCCTTTACCTGGAAAAAAGCGT +TCTTGAGGTTTTCGTTCTCGGTCTGTGAGGACACGAGCTCGAGGGCACGGGTGAGGGGGATGCCCGATGA +GAGGAGCAGGGAAAGTTGAATGAGGGAAAAGCCGAGTTCTTCTTCACCGACCCTTTTCTTGAAAAACTTA +AAACTTAACTTTTTCTTCTCCTCGTGTATGGATATTGGCTTTACTCCTTCGGAAATAAGTTTTTTAAAGG +CTTCGACCTCGTCCCTTGCCCTTACCTTACCGCTTAACTTCCTGCCTTCTTTGTATCCCTCGTAAACGAA +CTCCTTCATCTCAATTCCTTAAAGAGTATCTTATTACCGTCCCGGTCGTAAACTACGGTAAGGAAAGTCT +TAACTCCATGACTTTCCATGCTCATCTCTATCCTGAATACAGAACTCTTCACGTTCGCAAAGTTCTGAAT +TCTGTAAAGAATGTCCAGAGTCATCCCTTCCACCATCAAAAGGTCTTTCAATTGTTTGAAAGGTTTTTCC +TTTCTGTAATCCGCAATCCTCTTTGCTAGTTCCATGTCTATATCCCTGTCCAGAGAGTAAAGAACGAGAA +GGGGGGCGGTGTTGATATTTACCTTTCCCTTTGAAAAGACAGTCAGAAACTCAAAGAGTCCTTCTCTGTC +CTCTGCACCGTAAAGATCCTCCTTCTTTTCCCAGAAGAGTTCTATCTCGTAAGTTGAGTCTAAAGGCTTT +CCCTTAGGCAGGTAATCCGTGTTGAGGCTTCCCTCCTCCTGACCCGTCCAGATTAGAATTCGATCGAGGA +GTTCCCTGTCCACTTCTAAGTAAGTGATGAGTTTTTCAAAGACCTCGCTCAATCCCTTGTATTTTGTTAT +ATAGTTCGGGTTCAAGTACCTGTCTTCGTCCACTATCGTTATGGAAACACTTCCTAAGGGTGTCTCAAAG +GTGTAGGGTTTTGCCCAGAGGTCAGAAAGGGCGTCGTAAGAGGTGTCTTCCCTTTTGAGGAGCTCCGTTA +TCTTCGGAACCAAGGAGTCGAGGATGAGGTACTGCTTTTCTTTGAGATAAACCTTGTTTACGATTTCCTT +TGCACTCTGGACGCTTTCACCGAGATCAGCAGCGTAAAAACTGAGCGTTAAGATAATTCCGAGAACCAGA +ACTAGAATCATTTCATATAAACTCTGAGGTTGTTCAGGGTTCCTTGAACCTTTATCCTCACACCGTTTCC +TTTAAACTCTCCGTCCACTTTGCTCATTAAGAAGTTTTTCCTGTTTAACGTTATCCTCCCCTGCCCCTTT +AATTCCATTCCGAGGTACTTTACACTGCCTGTGAAGGTTTGCCCTTTGAAGTTTAAATTGATCTCGTCCA +GAAGAGCCAGCTCCGTTTTAAATCCCTCCAGCTTTACTCTTCCGTAAATTCCGTCGCTCAGTTCTATCCT +TCCATTTACCTTTTTCACAAAGGGAGTGCAGGAAAAGTCCCTAAATTTTGTCTCAATGCTTCCCAAAAAG +CTGTAAGAAATCTCCGAAATTTTTCCTCTGCACAGGATTTTCCCGTTAACGGAGAGAAAACCGAGGGATA +ATTTTGTGTAGTCAAACTCCAATGCTTCCCGATTCTGGAAGTAAACCTTTCCTTTAAAGAGTTCTATACT +CATGGAATTTTCCTTTACCTTCTGTGCGATTAGAAAGATTTTGTTCTGAATCAAAAGTCTGTCGAAGAGC +AAAAACTTCGGAAAAGTAGCAAGAGAAAGCAAACCAAAGAATATTAATGAAAAAAGAAATAAACCAAAAA +CCTTAAATATCCTCATCCCACCAGTCTTCTTCTTCAACTTCTACTTTCTTTTCTTCCTTTTTCTTTAATG +CCTTCATGAGCTCACGGGCGAGTTTTTCGTGCTCCTGGGTGAGCTTTGCGAGTTCCTGAGGAGACGTTAT +CACGTAAGGGGTGAGAAATATAAAAAGGCTCGTTTTGTCCTTCTCGTCCCTGTCGTACCTGAAGAGTCTT +CCCATAACGGGTATGTCTCCGAGGCCGGGTATTTTTTCAGTACTCTTTAAGCTCTTCCTGCTTATCAGTC +CCCCTATCACCACAGTTCTTCCATTTTCCACGACCACGTCTGAGTTCAGTTCCCTGTTTGAGGTTATGGG +CACCGTGTAGTTAACTCCTGAGACTTCGTTCGTTAAGTATCCCGTGATTTCCTGAAGTTTTAGTTCTATC +ACCAACCTCACGGTTTCTCCCGTGATTCTGGGAGTGATTTTCAGTTCAAGCCCCACGTCCTTGTAGTCGT +AGGTGATTATAGGGTTTCCGTTAACGTCGTACTTTATTCCCGTTGGAAAAGGAACAACCTGACCTACTTT +TATTAGGGCCTCCTGATTATCGAGGGTAAGGATTTTGGGGTTTGATACCACGTTAAAGCCCGTTCCCTGT +TCAAGGAGAGAGAATAAAAACACGAGGTCCGGGAAGAAGAAGTCTATTCCTCCTATACTCACCGTGGTGC +CGCTTTTGCTAAATCCCCCTATTACAAAGTTTCCCGATTTTATAGCGTTGTATACGTCCTGAAGTGAAGA +GCCTTTAAAGGCTGCACCTCCGTGGGTTCCCAGTATCTGCCACCTTATTCCCGCCTCAAGAATGCTCTTT +GCGGATGCCTCAATAATGGTCGCCGTGAGGAGGAGTTGTTTTCTCCTTTTATCTATCTTCTTTATAAATT +CCCTTACAGCCTCGTACTCGCTCTTCGTGGCGTAAAGGATTAAGGAGTTCGTCCTCTTGTCAAAACCTAT +CTTCATACCGCTTTTTAGGGTTATTGAGGTTAGAGCTTGAACACCCTTTCCCTTTTTAGCTTTTTTAGTT +CCCACGCTTACGCTTTTTATTCCCTTAAATACGGAGTTTAAGCTCTCGTAAATCTCTTCGGCGGATACGA +AGTTCAGGGGAATTATGTAAAAACTCCTTTCCGCTTCGAGGGAAGAAGGGTCATCCAGATCGGATATCAC +CTTTTCTATAATTCTGTGGATTTCCTTGTTTGCGTATACCGCAACAGCGTTCATCTCGTCCACACCCGCT +ATTACAACGGGCTCACCGTACCTTTTAGTGGAGAGCGTTGAAAAGGGATTCAGGAGTTTTACGACGTAGG +AGGGTTTTACATACTTGAGTTTGTAGACTCTTACTTCACCACCGCCAGAGTCTAAGTAAAAGAGTATCTT +CTTCACTTTGTTTACGGAATCCGCGTAATCAGTGATTATTACAGAGTTAGATTGAGCGTGAAAGGCTATC +CGACCGTAAGGCGAAAGGAAGGGTCTTAGAGCCGAAACCACCTGAGAGGCGTTTGTGTTTTTGAGTTTAT +AAACCAAAGTGACAAACTCCCCTCCCTTTCCCGCCTTTATCTCGGTAAAAGGATATCCCTGCGATGCCGG +TACGATCTTCATGGTGTCCTTTTCAAGGATCAGGGAAAACCCCTGAGAGGCGAGAGCCTGAGAAAAGAGT +TCAAGGGCTTCGGACTCGCTTATTTCTCCGTTTGATATTATCGTTATCTTTCCCTTAACCCTTGGGTCTA +TTACGAGGTTCTTTCCAAGAAGCTTTGCCACCTGAACAGCTACGGTTTTAATGTCAACTTCGTCAAACTT +GAGAACAACTCCCGAAAAGCCAAGGGAAAGGATGAGAAAAAGGAGTATTATAATCCTCATACCACGTCTC +CTTCCCGTGGGAGAAAGAGGAGCACTCCTAAGGTGCTGATGGCGTATCCGAGAAGGACACTCTGTATATG +TCCTGCAAACACGAAGAAGGCGTAACCTATGAAGTAGGGAGTCGTTAAAAGGAAATAACTCCAGAAGTAC +CGCCTCATGGCTATGTAGCCCCAGTACTCCCCTTGGGCTTTTACGGGAAGAAAGAACTTTCTTATCAAAA +AGGCGATAAGGTAGGAAATAGCTCCGCTAATTATCTCCGCCGTGTAAACGTAGTAAACGAGCTTCTCTAC +AACGGGCATCTTGAAGTAAGGGTAGAGGATAAAGGCACCGATAAGAAGAAGAGTGTATCCGCCTATAAAG +GCGTAGGCAAACTCCCTAGCTCTTTTTATGAATAGCCGCTTCTTGTCCGGAGTATCTCCTTGAGCCATAT +GTACTCGTCCCTCTTCGGTCCTGTGGATAGCATTACTACGGGGACACCCGTGTACTCTTCAATAAATTTT +ACGTAATCGAGAGCTTCCTTTGGCAATTCACTGACGTCTTTAGCACCTTTTGTGCTTTTCTTCCATCCCT +TTAAGGTTTTGTATACGGGTTTAACCCTTATAAGTTCCGAGTAGGAGGCTGGGAAGTAATCTATCACCTC +ACCGTCCAGCTCGTAAGCCACGCAAACCTTTACCTCGTCAAAGGTATCTAAAACGTCAAGCTTCGTTATC +ACAAACCCGTCGAGCCCGTTTACCTGAACTGCGTATTTTAGGGCTACGAGGTCTAACCAACCGCACCTTC +TCGGTCTTCCCGTAGTGGATCCGTACTCCCCGCCAAGTTCTCTGAGTTTTTCTCCCTCTTCGCCTTTGAG +TTCCGTGGGGAAAGGTCCTTCTCCTACCCTCGTGGTGTAGGCTTTTGCCACGCCGAGGAAGAAAGCGTCG +GAGAAGTACTTGGGAGGCATACCAGTTCCGTTGGAAAGCCCGAGAGCTGAGGCGTTTGAAGAAGTCACGT +AAGGGTAAGTTCCCATGTCAACGTCAAGGAGCGTTCCTTGAGCACCTTCAAATAGGACTGAACCTTTCTG +GGTGTTGAAAAACCTCAAAAGGTCAACGACGTTTTCTTTAAACTCCTCAAAGTACCTGAGCTGTTCCTCG +TAAATCTGGTTTATGTCAAGGTCAAACTTTTCGCAGAATACCTTTTCACAAATGTTTTTAACGAAATCTA +GATTGTCTTCCAGCAAGGTGTAAAAGCGTTTTTCGTCTTTCAGATCGCTTATCCTTATCCCCTTCCTTCC +GTATTTGAACATGTAGGCGGGGCCTATACCCCTTAAAGTCGTGCCTATACCCTTTTTCTTTTCAAAAAGG +GAATCTAGGAGCTTGTGGTAGGGCATAACGAGGTGAGCTCTGTCGCTTATAAACAGCCTTTCCTTTACGT +ATATCCCCTTTTCTTCGAGATTCTTTACCTCTTTGTGGAGAACTTCAAGATCCACAACCATTCCCTGTGC +TATTACGCCCTTTACGTGTTCGTGGAGTATGCCCGTGGGAAGGAGGTGGAGGATAAACTTCTGGGAGTTT +ACGACTACAGTATGTCCCGCGTTGCTACCGCCCTGATACCTTACGGTTATGTCAAAGTGTTCAGAAAGGA +GGTCTACTATCTTACCCTTTCCTTCGTCACCCCACTGGGCACCCAAAATAATGAGCTTTTCCATTCACAA +ACCCCGAACAAAAAATTATATCTTACCGCTCAAGAAGTGAGAGAATGTCCTCTAGTATCACGTCCCTGTT +TTCTGGAGTGAGTTCGATCAGAACGGCTCCCGGCAAACGCCTGATTTCTTTAACTAGAGGGTGCACGTCC +CTTATGGGAATAGTCGCCACCACGTTTACGTTCGGATCGTGCATTATCTGTCTTACAAGATCCCTGAACT +TTTTGGAAAAGAGTTCCATTTTACCGATCTCGTCTATGATTATCACCTTTCTCCTGTCTTTTTTTGCCTC +CCTATAAGCCCTTTCAAGGATGGGTATGGCAAGTTCTTCAAAGTACTGGACGTTAACACCGTAAGAACCA +ACCAGCTTTTTAGAGGTAAAAAACTTTGAAGAAAATATCTTCTTCTTTCCCTCAGTTGTTATTATCCTGA +ACCCAGTTCTCTTCTTTGTTTCAGGATCTCTCACTTCTTCCGTCCAGAAACCGATGGCTCTTTTTCCAAG +TCTTTCAACGATTTTTTTTACAAGGGTTGTTTTTCCTACACCGGGTTCACCGGTTATGATGATTTTCATT +ATCAAAATTTTACAATGAGCTGAGTACCTGTTTCTCTAATATATCAATAACTATAATTTAAATTGGTATG +AGTTTGAGTGCACACGAAATCAGGGAACTCTTTTTGAGCTTTTTCGAGAAGAAGGGACACACGAGGGTAA +AGTCCGCCCCCTTGGTTCCAGAGAATGACCCCACTCTCCTCTTCGTAAACGCGGGAATGGTTCCCTTCAA +AAACGTATTTTTGGGACTTGAAAAGAGACCCTACAAAAGGGCAACTTCTTGCCAGAAGTGCCTTAGAGTT +TCCGGAAAGCACAACGACTTGGAGCAGGTGGGATACACTTCAAGGCATCACACCTTCTTTGAGATGCTCG +GTAACTTTTCCTTCGGTGATTACTTTAAAAAGGAAGCTATAGAGTACGCGTGGGAGTTCGTTACAGAAGT +CCTGAAACTCCCCAAAGAAAAACTCTACGTTTCCGTTTATAAAGACGACGAGGAAGCTTACAGAATTTGG +AACGAACACATAGGCATACCTTCTGAAAGGATCTGGAGACTGGGTGAAGAGGACAACTTCTGGCAGATGG +GAGACGTGGGACCCTGTGGCCCTTCCTCAGAGATATATGTGGACCGGGGCGAAGAGTACGAAGGGGACGA +AAGGTACTTGGAAATCTGGAACTTGGTTTTTATGCAGTACAACAGGGACGAAAACGGCGTTCTCACCCCC +CTTCCTCACCCCAACATCGATACGGGAATGGGACTCGAGAGGATAGCCTCCGTCCTGCAGGGAAAGAACT +CCAACTTTGAGATAGACATAATATTCCCCCTTATACAGTTCGGAGAAGAGGTTTCTGGAAAGAAGTACGG +GGAGAAGTTTGAAACGGACGTAGCTTTAAGGGTAATAGCGGATCACCTAAGAGCGATAACCTTTGCGATT +TCTGACGGGGTAATTCCTTCAAACGAGGGAAGGGGATATGTGATAAGGCGTATCCTCAGACGTGCCATGC +GCTTTGGTTACAAACTGGGAATAGAAAACCCCTTCCTGTACAAAGGTGTTGACCTCGTAGTTGACATAAT +GAAAGAGCCTTATCCCGAACTCGAACTCTCAAGGGAGTTCGTCAAGGGAATAGTGAAAGGAGAAGAGAAA +AGGTTTATAAAGACGCTAAAAGCAGGAATGGAGTACATACAGGAGGTAATCCAGAAAGCCCTTGAGGAAG +GAAGGAAAACTTTAAGCGGAAAGGAAGTTTTTACCGCATACGATACCTACGGATTTCCCGTGGATTTAAT +AGACGAGATAGCGAGGGAAAAGGGACTCGGTATAGACCTTGAGGGTTTCCAGTGTGAACTTGAAGAACAG +AGAGAAAGGGCGAGAAAACACTTTAAGGTAGAAGCCAAAAAGGTAAAGCCCGTATACTCTCACCTGAAGG +AACTCGGTAAGACTTCCGCCTTTGTAGGCTATGAGCACATGGAATGGGAGTCTCAGGTTGTGGGACTTGT +AAAGGGAGAGGGGCTTGTATCCGAGTTAAAAGAGGGAGAAGAGGGGGAAGTAGTTTTAAAGGAAACACCC +TTCTATCCCGAGGGTGGAGGACAAATAGGAGACGCTGGAATAATAGAATCCGACAAGGCACTCTTTAAGG +TTGAAGACACACAAAAGCCCACCGAAGGCATAATCGTTCACATAGGAAAAGTTCTTAAGGGAACTCTAAA +GGTAGGAGATACGGTTCACGCAAGGGTGGACAAGGAAAGAAGGTGGGACATAATGAGGAATCACACCGCC +ACGCACCTGCTTCACGCCGCACTCAGGAACGTTCTCGGCGAGCACGTAAGACAGGCTGGTTCTCTCGTCG +CGGACAAGTATTTGAGGTTTGACTTTACACACTTTTCAGCTCTAACGGAAGAGGAACTCAAGAGGGTGGA +AGAACTCGTGAACGAAAAAATAAGGGAAAACCTCCCCGTGAATGTAATGGAAATGGCATACGATGAAGCA +CTAAAAACGGGTGCCATAGCGATATTTGAGGAAAAGTACGGGGAAAGGGTGAGGGTAATATCCTGCGGAG +AGTTTTCAAAGGAACTCTGCGGTGGAACGCACGTTTCCGCAACTGGAGACATAGGCTACTTCAAGATAAT +ATCCGAGAGCTCCGTGGGTGCGGGCGTGAGGAGAATAGTGGCACAAACGGGAAGGTGGTCCGTAGAAACC +GCCTTCAAAGAACACCAGACGCTCAAGAAAGCTTCTTCAGCTCTCGGCGTGGGCGAGGAGGAAGTAATCC +AGAAAATTGAAGAACTTAAGGAAGAAATCAAAGACAGAGAAAGAGAAATACAAAGACTGAAACAGGAACT +CCTGAAACTCCAGATAAGGGAAGTTGTAAAGGAAGAAAACGTTGGAGATTTCACACTCCACTACGGCGTA +TTTGAAGAGGTTGAACCCGAAGAACTCAGGAACCTCGCGGATATGCTGAGGCAAAGGACGAAAAAGGACG +TTGTGTTTATAGCCTCCAGAAAGGGAGATAAGATAAACTTCGTTATCGGAGTTTCCAAGGAGATATCGGA +CAAGGTGAACGCCAAGGAAGTAATAAGGGAGGTCGGAAAGGTACTTAAAGGTGGAGGAGGAGGAAGGGCA +GACCTCGCTCAGGGTGGAGGAAAGGCTCCTGACAAATTCCCCGAAGCGGTTAAATTACTAAAGGAAATCT +TATCGGGGTAAAGGTGTGATGAAGGAAGAGACACGAACGGGTATCGGACTCAAAGACGTGAGTATAAGGC +TCGTGAGCGAGTCTCCCCTCCTTCCCGTGGGGGGCTTCGTTTACTGTGAGTACGGAATCCCCGTAAGGTA +TCTGAAGATAGACGAAAACGAAGTAAAACTCGAGATTTCCGTGGAAAAGCTGAAAAATTTATCGAGGGTG +TGTGAAAACATAGAGCAAGTTGTTGACAAAGTTGTAGAAGAGTTGAGGTACGCCCTGCCCGAGGGTGTTT +TCACTATAGCGAAGGTTTACGCAAACGGTATTAAACTCAGAGAACTCTCTTACCTTGAAGAGTACACTTC +CGTGGGTAAAGGAATAATAATAGACGAGGACAGGGAACTGGATCAGGAAATGCCCGCTTACGTTAAGGAA +AACAGGGAAACGATCCTCGGCACTATCAGGGAAGTCATCCTGCTTGAGCTCATGTACTCTTCTTAAAAAG +ACATTATAAAGATATATAACACTGTTTTTGTCATAGCCTTGAAAAAGCTTAGGTTTTTTTTATTTTATAA +AAAACTGAGAGAGGTAAGAGACATGTTTGAGAAGTTCACAGAAAGGGCAAGACAAGTTATCTTGAGGGCG +AGGGAAGAAGCCCTCGAGCTGGGACACAGCTACTTGGGAAGTGAACATATTTTGCTTGCTCTGATAAAGG +ATGAGGACATACCCGTCCTCGTCCTCAGCAAGCTGGGTGTCTCTCCTGAGAAGATAAGAAAGGCCATAAT +GGGCCAAATAACTAAGGGAAGCCACTCGGGAGAGGTACTCTTCGCACCCGACGCAAAAAGGGTAATAGAG +TTTGCAGTTGAAGAAGCGAGAATTCTTCACCACCAGTTCGTAGGTCCCGAACACCTACTTATCGGAGTGG +TTAGAGAAAAGACGGGACTCGGTGGAAGAATTTTAAGGAGCTTTGGACTGGACGAGTACTCCGTAAGGAG +AGAGGTACTTCAACTACTCGGAGAACTTCCCCCTCAAGAAAGCCAGAGGTACGTATCCACTCCTAACCTT +GACAGGTTCTCAAGGGACCTCACCCAAATGGCAAGGGAAGGAAAGCTCGACCCAGTAATAGGCAGGGAAA +AGGAAATAGAGAGAGTTATCCAGATACTCGTAAGAAGAAGGAAGAACAACCCTGTCTTGCTCGGAGACCC +CGGAGTTGGTAAGACGGCGATAGTAGAAGGGCTGGCTCAAAGGATAGCAAATAAGGAAGTTCCCGAACCG +CTACTCAATAAGAGGGTAGTGGCTTTAGACCTTGCGGCACTAGTTGCGGGAACCAAGTACAGAGGACAGT +TCGAAGAAAGGCTTAAGAACATCTTAAAAGAACTTGAGAAGGCTAACAACGTAATACTCTTCATAGACGA +ACTTCACACACTCGTTGGAGCGGGTTCTGCGGAAGGCTCGATAGACGCATCCAATATGCTAAAACCCGCC +CTCGCGAGAGGTGAAATTCAGGTAATAGGAGCTACCACCGTAGACGAGTACAGGAAGTACATAGAAAAGG +ACGGAGCACTGGAGAGAAGGTTCCAGCCCGTTTACGTAGAACAGCCATCACCCGAGGATACGATCCAGAT +ACTTTACGGACTCAAACCCAAGTTTGAAGAGTTCCACAAGGTAGAGTACACACCCGAGGCAATAGAAAAG +GCTGTGGAACTCTCCGTCAAGTACATAACCGACAGAAACCTGCCAGATAAGGCTATAGACGTTATGGACG +AGGCGGGAGCACTCGTAAAGCTGAAGGCAACTCAACTCCCTCCTGAACTCAAGGAGATAGAGGAAAAGAT +TAAGGAACTCGAGAAGGAAAAGGAAAAGGCTGTAAAGGAACAGGACTACGAGAAGGCTGCAAAGATAAGG +GACGAAGAGTTGAGACTCAGGGCTAAGTTCGAAACGATGAAGGCTAAGTGGAAGGAAGAAATGGAAAAGA +ACAGACCCAAAGTTACGGACGAGGACGTTGCAGAAGTAGTCGCAAGGTGGACGGGCGTTCCCGTGAAGAG +GGTACACGAAAGTGATGCGGAGAAACTCCTCCACATAGAAGAAGAATTGAAGAAGAGGGTTGTAGGTCAG +GACGAGGCTATAAAGGCAGTAGCGAAGGCGATAAGACGTTCAAGAGTCGGACTGAAAGGAAAACACAGAC +CCATAGGCGTATTCATGTTCCTAGGACCTACTGGTGTGGGTAAGACCGAAACCGCGAAGGCACTTGCGGA +ATACCTATTCGGAACGGAAGACGCACTCATCAGGTTTGATATGTCCGAGTACATGGAAAAGCACACCGTT +TCAAGACTAATCGGTGCACCTCCCGGATACGTTGGATACGAAGAAGGTGGACAGCTCACAGAGGCGGTAA +GGAGAAGACCTTACAGCGTTCTCCTATTTGACGAAATAGAGAAGGCCCACCCAGACGTATTCAACATCTT +CCTCCAGATATTCGACGACGGAAGACTAACGGACGGACTCGGAAGGACCGTTGACTTCTCCAACACCATA +ATAATCATGACCTCAAACCTCGGAGCTAGACTCATCACAGGCGGAACGATGGGATTCGAAAAGAAACAGG +GACTCCTTAACTTCGAAGAGATGAGGAAAAACGTCCTTGATCAGGTAAAGAGAACCTTCAGCCCTGAATT +CCTAAACAGACTGGACGAAATTATAGTGTTCAGGCCTCTCGAGAAGAAAGACATAGAACAGATACTCGAA +CTACAACTAAAAGAGATAAACGAAAAACTAAAAGACTGGAACGTGAGAGTAAAACTCCACAAGTCCTTCG +TAAACTGGATCATAGAAAAAGAGTACAAGCCCGAATTCGGAGCAAGGAGCTTGAAGAGGGCTCTCCAAAG +ACACGTTGAAGATCTGCTCGCTGAAGAACTCATAAAGGGAACGCTCAAAGGCGTAGAAGAAGTAGAAATA +AGGGTAAGGAACGACAAGCCCTACCTCAAACCCGTAAAGAAGAAGGAAAAAGTAGAAGCCCTTCTCGAAA +AGTAAGCCCCTTTTTCCTTCTTTCCTTTATAATACTTTCCTTGTGAAAAAGGAATTTTTAACCCTAGCCC +TTTTTTTAGGTGTAGCTAACGCCGCAGAAATAGAAAAGATAATAATTAAAGGGAATAAGTACATTCCCGA +TGAATTAATAAGGGGACTTTTAAGCGTAAGAAAGGGTTCAGAGTTTTCCCTTGAAAGGATAAGAAAAGAC +ATAAGGAAACTTTACAGAACTGGACTCTTTACAAAGGTAGAAGCTTACGAAGAAGATCAAAATAAAAACG +GAAAACCTGAAGTAATACTGGTGGTTGAAGACCTTCCCGTAATTTACAAAATAGAGTTTGAGGGGAATGA +GGAGTTCTCTGACGACGACCTGAAGGAGTACCTCGGTATAGAGACGGAGCTCGGGGAAGTAGAAGTGGAA +GAAACCATAGAAGGATACACTTCCAGCCCTGCAATAGAAGAAAGACTTGCCGTAATGAAACAATTAAAAC +TCGGTCGTATACTTACCTTTCAGGAAATAGAGAGTTTAAGAAGGAGAATTGAAGAGGTATACAAGAGGCA +CGGCTTTGTAGGGACGAAAGTTGAGTACAAGCTCATCCCGAAAAAAGGAGCTTCAAAACTCGTTTTTGTC +ATACATGAAGGTAAAAAGATTTACACCTCCGATATAGAGATAGAAGGAAATAAACACTTCAGCGACCGGA +AGTTAAAAGGTCTAATGGAATTAAAAGAGCCAAACATTTTCCTCTTTAGACTGCACCCGGCTTTTAGTGA +AGAAACGCTAAAAGAAGATGTAAAAAAGATAGAGGAGTTTTATAAAAATGAGGGTTTTTTAGAAGTTGAA +GTATCTTACGAAGTTAAAGAAGAAGGACCAGCACGTAAGGTAATCGTAAAAGTAAAGGAAGGTCCGAGGT +ACAAACTGAAAGAGATAAAGATAGAGGGAAACACTCTCTTCGCTTACAGCGAACTAGTTGATAACATCCT +GAAAAAGAACGAGAGAAAAGGCAGGTATTTCAGAAGGGAGGTTATTGAGAAGATTAAAAACAGGATAAGG +GAGAAGTATGCGGAAATAGGATTTTTAAACACAAGCGTGGAAGAAAGGGTAAATGTAAATCCTGAAAAGA +AAGAAGTTTCAGTTCTACTAAAGATAATAGAAGGAAAACCAGTGTACGTAAAGAAGATAAAGATTAAGGG +GAATTACGAGACGAGAGATTACGTGATAAGGAGGGAAATGAGAGTTCAGGAAAACGAACTTGCCCTTAAA +AAGGGTATAGAGCGTTCGAAAACACGGATAATGAACTTAGGTTACTACGAAGATGTACAGATAGAGCCCG +TTCCGAGAAGGGACGCATGGTGGGATCTTCTCGTTAAGATAAGGGAGAGGTTCACAGGTCAGTTCTCTGT +GGGACTTTCTTACAACGAAGTTACGGGACTCGCAGGGTTTATTGAACTCAGGAAGGGTAATTTCAGGGGT +ACGGGGGACATAGCCGGGATAAGCGTAAGCTACGGTTCCCTGTACAGGAACAACGCTATCTCCTACACGA +GAAAGTGGTTCCTTAAAAAACCTGTGGATTTAGACCTTTCGGCTTTCGACAGGAGGATAGAGTACGACAC +TTACACTGTTGAGAGAACTGGTTTTTCAGTAGCGCTTTCCAAAGAGCTGAGTGAGTACTGGAGGGCGTCT +ATAGGAACTTCGATCCAAAGGGTAAAGTACAGCGATATAGACCCTGAGGCGAGCACTTATGTTAAAGAGC +AGGCAGGAAGAAGGGACTCGAGAAAGATATTCTTTACCCTCACAAGGGATACCAGAGATTACTACCTCCT +GCCCACAAAAGGTTCACTTTTTGTGTTTAGAAATAGCGTTGGGGTAGGACTCCTCGGCGGTGATGAGAAG +TTTTACAAGTTCGAAGTTGAGGGAGCAAAGTACTTCAGTGATACTTACTTTGACACGGGAATTATACTCA +GTCTGAAGGGTGAAGTTGGATTTGTAGAAGGATACGGCGGTAAAAAGGTTCCCATAGACGAGCGCTTCTT +CGTAGGGGGAGACTTTTCCATCAGGGGTTACGAATACGGATACGCGGGACCGGTGGATCCAAACACTTTA +GATCCCATAGGTGCTAAAAAGAAGGTGATTACGAGTTTAGAACTCATGTACCCGGTCTTTAAGAAAATGC +TTTACTTCGCGGGATTTTTCGATTACGGACTGGGTGCGGATAAGTGGAGTGACTTTAAGCTTTCAAACTT +CAGGGGTGGCTACGGTATAGGCGTGAGGATAATAACTCCCTTTGCTCCTATAAGGATAGACTGGGCATTC +AAGACAAAAACCGTACCGGGTGATACGAACCGCTCAAGGATACACTTCGTTCTCGGAACCTTCTTCTGAT +AAAAGTAAAAAAGAGAAGGGCGAATTACTCGCCCAAAACTCTTACGTTTTTAGCCCTTGGACCTTTTGTG +TCTTCAACTACGTCAAACTCTACTTTTTGACCTTTTTGAAGGGTCTTGAAACCCTCCATCTGGATATCGG +TAAAGTGGACAAAAACGTCTGCGTTTGTGTCCTCACGGGTAATGAACCCGTAACCCTTGTCCTTGCTAAA +CCACTTAACTGTGCCTCTGAACGACATAACTACAAGACCTCCTAAAAGTACTTCTTAAGGGCTTCCGACA +AAGGTACCTGCGGGAATGCCCTCCCCTCGTCAGAAGACCTTACTTTAAGTATATAGAGTTTTAAAAATTT +TGCAAGTCTTCAAGGGTTATCCTCCCCTCGTATATCGCCTTTCCTACAACCACTCCCTCAACTATCCCGT +AGAGCTTTTTAATATCTTCCAAAGAAGAAACCCCTCCCGAGGCTATCACGGGTTTCTTCACATGTTTTTT +AATCTCTTTATAAGGCTCTACATCTACTCCCTCAAGGCTTCCGTCTCTCTCTATTACCGTGTAGAGGTAT +CCCCAAATGGGATAATTTTCGTACTCCTTTGCAAATTCTTCGGGAGAAACAGCGGTCTCTTCCTTCCAGC +CTCCGATGGCAACTTTTCCTTGTTTCGAATCAATGGCGAGGATTACCCTGTTTGGGAAGTTTTCAAGTAT +CTTTAAAAACTCCTCTTTGTTTTTATAAGCCAGAGTTCCGATAACCACAAAGTCTATACCCTCGTCAAAT +AGAGCCTTTGCAACCTCGTAACTTCTTATACCTCCGCCTACTTCTACTTCTCCCTCAAAGTTTTCCCTTA +TCTTTCTGATAACTTCCAAGTTTTTGGGCTTTCCGCCCTCAGCACCTTCGAGGTCTACAACGTGAAGCCT +TTTAAAACCTAGGTCCGAGAAATTTTTTGCGAGTTCCCAAGGCCTTTCAGAGTAAACTTTTACTTTATTA +AAGTCTCCTTTATATAGCCGAACAGCTTTACCTTCCATTAAATCTATGGCAGGAATTATGAACTCCTTTA +AGTTCAAAGAATTACCTCCTCCATGGGCATAACTGGTCCCTCGTAACAAACTCTCTTAAACTTTCCGTCT +CTGGTCTTCACGACGCACCCGAGGCACACACCCCAACCACACGCCATCCTCTCTTCCAAGGAGAAGTAAA +CCTTGTGTCCCGTTTTCATTTCTTTGATGGTTTTTAGCATAGGCTTTGGTCCGCAGGCGTGAACCACCCA +GTCCGTGGAAAATTCCTTCAAAATTTCCGTGACAAAACCTTTTCTTCCAGCACTCCCGTCGTTCGTAAAG +AGTTCGTAAGGGAATTCTTCCTTCTCAAGCCACTCTACCATCCCTAAGTGTTCCCTGCTCCTGCCTCCGT +AGGCTATGAAAACTTTCTTTCCCATATCCCTCAGCTTTTTGGCGAGCAAGGTGAGTCCAGCAAGTCCTAC +TCCTCCGCCTATGAGGAGATGTTTGTCACCCTCGTAGGAAAAAAGCCTTTTGCCAAGTGGCAGGAAGGTT +TTTAACCTCTCGCCCGGCTTCCTTTTAGAAAGGAGGTAAGTCCCTTTTCCGTAAACATCGTAGTAAAAAA +CGGCTTTGTGTTCCTCTATGTCCGCAACTGCGAAGGCCCTCCTTCCCATAGGGTCGTAAGTGTCGGAGGG +CTTTATCATAGCGAAGTGCCCGGGTTCAATCTGTTTTAAGATTTTGTCGGGAATTCTCAAGGTAAGTCTG +TAGAGGTTTCCCGAGATGTAAGTGTTTTCAAGTACCTCTGCGTTTAATTCTGCGAGCATACTTGATTTAT +TTTAATTAAAATACAATAAAATGTTGTTTTAAAATTAAGTTTCAGGAGGAAGGAGAATGGATCTGTACGA +GTACGAAGCGTACGATAAAATTTTCAAAAAGTACGGTATTCCCACCCCGAAGTATATGTTCGTTGAACAC +ATTACAGATGATGTTGTTGAATTCGTAAATCAACTGGGTGAGTGCGTTGTAAAGTCACAGGTTCTAGTAG +GAAAGAGGGGAAAAGCCGGAGCTGTAAGGGTATGCTCCAATCCCGATGAAGCTTTAGAAGAGATTGAAAC +ACTCCTCAGGATGACTGTTTACGGAGAAATGCCTGTTGGCGTTCTCGTAGTGGAAAAGGCAAACATCCTG +AAAGAACTTTACGCTTCAATAGTTTACTCCACGGACCACAGGGCACCCGTACTTACCCTCAGCTTGGAAG +GCGGAATGGATATAGAAGAAGTTCCCCCTGATAAGGTAAAGTCCTGGCCAATAAACCCGCTAAAAGGACT +CTACCCCCACATGGTGAGGAATTACCTCCTTGAACTTGGATTTCCCCACGAATATATGCCCGTTCTCAGG +AAGCTCTCAGAAGTTATAGCAAGAATGTGGGACGCCTTCTGGGGGGCTGAAGCGAGACTCCTTGAAATCA +ACCCCCTTGCTATTGTGGACAGGGGCGGAAAGCCTGACGTTCTTGCCCTTGACGCGGTTGTTAAAATAGA +CGACGACGCATCAATACCGCCTGCAAAGATATACGGAGTGAGAACCGCACTCAGGAGACCTCCCACAGAA +AGAGAAATCGCAGCCGCGGAAATAGACAAGGACGACCACAGAGGAAAGGCAGGCTCTTACGTAGAACTCG +ACGGTGACATAGCTATGATGACCTTCGGAGGAGGAGGTTCTACCGTTACGATAGAAACGTGTTACGAACT +CGGACTAAAACCCGCAAACCTCACGGACATAGGCGGTAACCCGCCCGCCGAAAAGATGTACAAGATAACG +AGGATAATACTCTCCAAACCCGGAATAAGGGCTGTTCTAATCGCCGGAGGTACTGCAAACAACACGAGAA +TCGACGTTACTCTCGGTGAAGGTGTTGCAAACGCATTAAGAGACCTAAAGAAAGAAGGAAAACTCGACCC +CAACTGGATATTCGTGGTAAGGAGAAACGGGCCGGAAGCTGAAAAAGGACTCAGAATGCTTTACGAGGCC +TTTAAAGAGTGTGGAATAAAGGGAGAAATTTACGACTCCGCATTGCCGCTTACCGAAGCTCCCGTGAGGC +TTAAAGAACTCCTCGATAAGTGCCAAGCAAAAAAACTTGAAGAAGAAGAACAAATTAAGGAAGGACATAC +ATTTACGGACGAGCAAGCTTCTGACCTCGGAATGTAATTCTCCTTCCCTCCCCTTTTAAAATCTTCTTTT +ATGTTTAAATTCCACCTGATTACTAAAGACGGAAAAGCGAGAAGAGGTAGGATATACACCCCTCACGGAG +TTATAGAAACCCCTGTTTTTATGCCCGTGGGAACTCAGGGAACAGTAAAGGCGATGCTCCACAAGCTCCT +TGATGAGATAGGCACTCAAATAATCCTCGGAAACACCTACCACCTTTATCTGAGACCGGGAACAGAAATA +ATAAAGAAGGCCGGAGGACTGCACAGATTTATATCCTGGAATAAACCTATATTGACCGACAGCGGAGGTT +ATCAGGTATTCTCCTTGGCAAAAGGGAAGTTCGGAAACAGAAAAGCAAAGGTAAAGGTGAGTGATGAAGG +TGTTGAATTTCAGGATCACCTTCAGGGAGATAAACATTTCTTTACTCCGGAAAAAGTTGTGGAAATTCAG +GAAATTTTCGGCTCCGACATAATGATGCCCCTTGACGAGTGCGTGGAATACCCTGTGGATAAAAACTACG +CGGAAAAGGCTTTAAAAAGGACGATAAACTGGCTTGAAAGGAGCATAAAGGCAAAAAAGAGGGAGGATCA +GGTTTTATTCGGAATAGTTCAGGGAGCCTTCTGGAAAGACTTGAGGAAAAAGGCTGTTGAAGAGACCTTA +AAGTTTGACGAATTTCTCTTCGGATACTCTATCGGCGGGCTTTCTGTCGGAGAACCAAAGGAGATTATGT +ACGGAATGACGGAAGTTGTATGCGAGCTTCTTCCCGAAAAGAAACCCAGGTACTTAATGGGGGTGGGGAA +GCCAGAAGATATACTCGAAGCAGTGGAAAGAGGAGTGGATATGTTTGACTGTGTAGTTCCCACAAGAAAT +GCAAGAACCGGAACGCTTTACACGTCTCAGGGAGTTGTTGACATAAGGCACTCCAAATGGAAAGAAGATT +TCTCACCCCTTGATCCCGAGTGCGATTGTTACACCTGCAGAAATTTCTCAAAGGCTTACCTCAGACACCT +CTTCGTTGCAGAAGAAATATCCGCCTACGTTTTAAATACCATTCATAACTTGAGGTTTTACCTGAAAATG +ATGGAGGAAGTGAGGAAGGCGATAGAGGAAAAGAGGTTCAAGGAGTTGAAGGAAAAGTACCTTCAAAGGG +TTAAGAATAAACTTTGACTCCTTCGTTTCTCGCTTTTAGAACCATTACCTGTGCATCGTATCCGGAAAAC +TTGGTTATTACTTCTCTTATAGCTTCTCCTATTTTTTCTTCATTCTCGGTAGTCAGGGAGCAAATTGTTG +GTCCAGCACCGCTCAGGAATGTGGCAAGTGCTCCTTCTTTGTAGGAAACGAGTATGGCTTCCGAGAGTCC +GGGAACGAGTTTTTCTCTGTAAGGCTGGTGGAGCTTATCCCTTACAGCTTCCCTTAGGAGTTTGTAATCC +TTTGTCAGAAGAGCACTAACGAATAAAGCACTTCTCTGGACGTTGAAAACCGCCTCTTTTAACTCAACCT +TCTTTGGAAGTACCCTTCTCGCTTCAGAAGTTGAGACTTCAAAATCTGGGATAACAAAGACGATTTTTAT +ATCTTCAGGAAATGGGAGTTTTTTGAAAATAACTCCTGATTCCGACGTTGCACATACCGTAAAACCTCCC +ACGAAGGCCGGTATTATGTTGTCCGGGTGTTTTTCAAACTCAAAGGCTATTTTCAGTTTTTCTTTAAGAG +GTAGTTCTACTTTGTGAAGTGCAAGGGCTGCTTCTATGCCTCCGACTATCGCCGTGGCGGAGGAACCGAG +TCCCCGTGCCGGAGGCACCCTGTTTTCCTGTATGAGCTTTAAAGGTTTTGGTTTTTTCCCAATACTCTGG +CAAGTCTTCTTGTATACCTTTATAAACAGGTTTTTCTGATCCTTCGGGATACCCGAGGAGTACCCCTCAA +TTTGGACCTCGTACTTATCCGAAAAATCAACGCTGAAGGTATTTGTAAGGGAAAGGGCAAGTCCGAAGGT +GTCAAAACCACTTCCGAAATTCGTAGTCGTAGCAGGAACTTCAATCTTGATCATTACATTTATAAAATAC +CTTATTTGATTCTATAATGGTTATTGTAAATTATAGCAATATATCTTGATTTTTATAATTGCGGCAGCAG +CTACAGAAAAAGCTAGATCGTTTGGTGAAGCACTCATTATTTTGTTTTTGTCTTTATAGTAAGTCTTATT +TATTTAGCTTTTGTTGTTTACTTTATATACTGGCTTATTGATGTAAGGCAAATGTTGCACGATATAAAGA +AGGAATTGGAAAAACTTAATCAAAAACAATAAAACAGAGCTGTTGTATTTTCCCCTTTGTTTTTTAGCCT +TTCTTCACCATTTAAGTTGGCTCGTTTTTCTTGACACAATTTTAAAACACTGGTATATCTTTACATAGTT +TTTGCGGAGGGCACTTTTATGGAATACATAGCTCTAGGAATAGGTCTTCTTGTTGCACTGCTCATAGCCC +TCGGGCAGGCGTTCGTAAACGACATACTCGGAACGAGAAAAAGGGATCCATTAGAGGACTACCCATACGA +GTGTGGTGTCCCCCTTTACGATCCCGAAGCGAGGGGAACATTCAAGCAGGGGTATTACCTCTTGGGACTT +CTTCTCATACTCTTTGATATAGAAGCGGCTTACCTCTTTCCTTGGGCTGTAGTTTTTGAAGAGATAGGAA +TTTACGGATTAATTGAAGTCATTGTCTTTGTGGGAATACTCACATTAGGTTTTATATACGCTTGGCGTAA +GGGTGCGTTAAACTGGGAGATGTAGGAGGTAAGTGCCATGGTTGCAATAAATTCTAACGGTTTTGTAACA +ACTACCGTAGAAGAACTCCTCAGATGGGGAAGGAGGAATTCCCTCTGGCCCGTTACGATAGGGCTCGCTT +GCTGTGCTATAGAGATGATGCACACCGCGGCTTCAAGGTTTGACCTTGACAGACTGGGAGTGATATTCAG +GGCTTCTCCGAGACAGGCTGACGTTCTCATAGTTGCGGGAACTGTTGTGAACAAGGTAGCACCAATGCTG +AAACTCATATGGGATCAAATGCCGGATCCCAAGTGGTGTATATCCATGGGCGGATGTGCGTCCGCGGGAG +GACCTTTCCCGACTTATTCCACACTTCAGGGGGTTGACAGGATAATACCCGTTGACGTTTACATACCCGG +ATGCCCTCCCACACCCCAGGGACTCATATACGGAATACTCCAACTCCAGAGAAAGATCAAAGAGCAAGGA +ATAACAAAGTACGATAAACTCTTCGCAGACTTCAACAGGGAAATAGAGAAGGAAGGTATTTTCGTTCCCA +GAGAACTAAAGGTGTGAGGATAACTTATGAAATGGGTCAATAAGGGAACCGTTGAGAGGGTAAAGCAGGA +ATTTAAGGACGAAGTAAAGTACTACGAGACAAAACACACTAAAGGTTTTGAAGTCTCTCACGATTTTCTC +AAGCCATTACTTAAGTTCCTGAAAGAAAGGGAGAGGTTCCTTCACTTCGTTGATATGACCTGTATAGACT +TTCCCGAACATCCAAACAGGTTTCAGGGAGTTTACATACTCTATAACCCTGAGGAAAACGAAAGGGTAAT +AGTAAAGAGCTGGGCAAAAGATGGGAAACTCCCGACAGTTGAAGATCTGTGGCCCGGTGCAAAGTGGGCC +GAGCGTGAAGCTTACGACATGTTCGGGGTGGTGTTCGAGGGGCACGAAAACCTCAGACGGATGTTCATGT +GGGAAGGCTATGAGCACTACCCCCTAAGGAAAGACTTTCCCCTTCAGGGAATACCTGAAGTAGAACTTCC +CTCCCTGACGGAAGTGCTTCACGGGAGAACGGACCCGCCCTCTCACGACTTTGAACTCGTTCATACAAAG +CTTCCCACCTTAGAGGACCTTGAAAGAACGGAAAAGGCGAGACTCAAGAAGAAGGCAGAACTCGTTCTCA +ACTGGGGACCACTTCATCCCGGAACCCACGGAACAATATGGTTTTTATTTGACCTTGAGGGTGAAAAGGT +TGTTCAGAGTGACGTAATTCTCGGACAGCTACACAGGGGAATGGAAAAGCTTGCGGAAAACTTGCACTAC +TTCCAGTTCATTCCCTACACGGACCGTATGGACTACATATCCGCTATATGTAACGAGCTCGCTTACGTGG +AGACCGTGGAAAGACTCCTGGGTGTAGAGGTTCCCGAGAAGGCGAGATACATAAGGACGATGTTTGCGGA +ACTCCAGAGGATTAACTCCCACCTCCTCTGGCTCGGAACCGGAGCTCTGGACCTCGGAGCACTCACGGTA +TTCCTTTACGCTTTCAGGGAAAGGGAAAAGATAATGGACATAATTGAGGGAAATGCGGGTTACAGACTCA +CGAGCTGCTTCTTAAGGATAGGAGGGGTTCACTACGACCTCGCGGAAGGCACTCTGGACGTAGTAAAGCA +CTTTATAAAAGACTTTCCCAACAGACTAAAGGAGTATCACACTCTCCTTACGAGGAACAGGATATGGTTA +AGGAGAACTAAGGATGTTGGCGTAATAACGAGGGAAGACGTTCACAATTATGGGCTTTCCGGGCCCGTTG +CAAGAGGCTCGGGTGTTCCCTACGACCTGAGAAAACTCCAGCCGTACGCCGCTTACGACGAGGTTGAGTT +TGATATACCGGTTGGAGAAGTAGGGGACGTTTACGACAGGTACCTTGTGAGAATGGAAGAAATGGCCCAA +AGTGTGAGGATAATTGAGCAGTGTGTTCAGAAGCTTGAAAAACTTCCCAAAGACGCTCCATACCTAAACA +AGGAACACCCTGCGGTAATTCCGCCCAAAGAAGACGTATTCCACGACCTTGAGAGCATGGTAAAGTCCTT +TAGAGTTGTTGTTCACGGTGAAGATGCACCGCCCGGAGAGGTTTACTTTGCCGGTGAAAACCCCAGAGGA +GAGCTGGGCTTCTTCATCTACTCAAAAGGTGGCGGGAAACCTTACAGAACACGTATACGTTCGGGAGCTC +TTTACAACTTATCTATATTCCCGAAACTCATACAAGGAAGGACGATTGCGGATGCCATAGCACTTCTCGG +AAGTCTTGATCCGGTTGTTGGTGAGACGGATAGGTAAGGGGGCAAGCGGATGGAAGCGATAGCTTACTCT +TTAGCCTTTACCTTCTTGAAGATAGTTATAGTCTTTTCCCTGGCTCTCGGTATAGGGGCTTACCTCACGT +GGTTTGAAAGAAAGCTCGCAGGGCACATTCAAAACAGGTTAGGACCAACGGTGGTAGGTAAGTTCGGGAT +ACTCCAACCTCTTGCGGACGCCCTAAAGCTCGCAACCAAAGAAGTTATCATCCCTAGAGGAGCGGACAAG +CCCGTATACTACGCAGCTGTAGTGATGGCTTTAGTTCCGTCCATACTTCTGCTTACGATAATTCCCTTTG +GACCGGGTTTTAGAGTGGGGAATACCTACATAGAGCCCATAATTGCGGACGTGAACATAGCATTACTCCT +TGCCTTTGCCTTTGGTTCACTATCGGTTTACGGAACAATATTCTCGGGATGGGCTTCAAACTCCAAGTAC +GCCTTTATAGGTTCACTTAGAAAAGCCGCGGTAGTTATAGCGTACGAAGTAGTTCTCGGTTTTTCCGTTT +TGGGTGTTATTCTTCTTGCGGGTACGCTCAGCACGGTCGGGATAGTTGAAGCTCAGATACAGAAGGGAGT +CTGGTTCATCTTTTACCAGCCTGTGGCTTTTATCCTGTACCTTTTCTGTATGCTTGCTGAAAGCGGAAGG +GTTCCCTTTGACATTCAGGAGGCGGAAGCGGAGCTGGTTACGGGTTACAACGTTGAGTACGGCGGTATGA +AGTTCGGAGCTTTTCCTCTCGCAGAGTGGTACGTAAACGTAATAGCCCTTTCCGCAATAGCTGTAGTTCT +CTTCTTCGGCGGATGGGATGGACCTCACATCTTCGGGCCACTTTCTCCGTACTTCTGGTTCGTGTTCAAG +ACATTTGCACTGGTTTTCTTTACTCTATGGCTACACTGGACCTTGCCCAGATTTCAGGCAAAGGACATTA +CGGAAATTGCCTGGAAGATACTCCTTCCCATAGCGATACTTAACGTGATAATTACTGCGGTTGTGGTTTA +TGCATTTTAGGAGGATTTAGGATGGGTGTGAAGAAGTTAAGCAGGAAGGATTACTTGAACATACTAGAAA +GCATACTTTTTATAGACTTCCTTAAGGGACTTTCCGTAACGCTGAAAAACCTCTTGAGGAGACCAATTAC +TACGGAATACCCGAAAGAAAAACTCACTCCTCCCAAGCGTTTCAGGGGAGCTCACGGGCACTATGTGTGG +GACGGAACCGAACCTGACTCACTCAAAGCTATAGAAAAGTTCATGTCTTATGAAAAGGCAAAGAGCAGGT +GTGTTGCCTGCTACATGTGTCAGACAGCCTGTCCCATGCCAACTCTTTTCAGAATAGAAGCGGTGCAGCT +TCCTAATGGGAAGAAAAAGGTCGTAAGGTTTGACATGAACCTCCTTAACTGTCTCTTCTGTGGGCTCTGC +GTTGACGCGTGTCCCGTGGGATGTCTTACGATGACGGATATCTTTGAACTCGCAAATTACTCAAGGAGAA +ATGAAGTCCTTCGCATGGAGGACCTTGAGAAGTTCGCCATAGACTTCAAGCAAAGAAGGGGCAACGAGCC +CGACAGAATTTGGCCAAATGATGAAGAAAGGGAAAAACTGTGGGGGAAGATAGAGTGGAGTGGTTAATCT +TCTTCATCTTAGGAGCTTGGCTTATAATTTCTGCCTTGGGGACGGTTCTGGCTAAAAATCCCATTCACGT +TATGCTCTTCTTCCTTTCCTCCTTACTCGCTATGGCGGGTCTTTTCCTGAGCCTCGGGGCGGAACTCCTC +GCGGGTCTTCAGCTCATAATCTACGCGGTTGCCATAGTGGTGTTCTACGTCCTTGCCATAACCACGATAC +CTTGGGAAAAGATAAAGCGCTTTGAGGGTGTTTACAAAACGGAAATTCTCACTGCATCCCCTATACTGCT +TGTGCTCTTCCTCGTTATGAGTTACATGGTTATTAAGGGGAAGTTTGCTGAGCCTTCGGGTGTAGTAAAG +GACAACGTGGAGGCTGTGGGAAGGACCTTATTTACTTCTTACCTCTTTCCCTTTGAGGTAGCTTCGGTAA +TACTTCTGGTTGCAATGGTGGGTGCAATCCTTCTTGCCAGAAAAGAAGAGTGAGGTGGGGCTATGGATAT +AATCAAGGCTTATATCATCCTAAGTATTGCTTTATTCCTCATAGGACTTCTTGGTGTTATAGTTAGGAAG +AACCTCATTACGGTTCTCGTTAGCACGGAGCTAATGCTGAACGGTATTAACCTAGCTCTGGTTGCAGCTG +ACAAGGTTCTCGGAAGAGTTGATGGGCAAATTTTTGCCTTTTTTGTTCTGACGGTGGCTGCGGCGGAAGT +TGCGGTAGGGCTTGGTTTAATAGTCGCCATATTCAGGCTCAAAGGTTATGAAGCTTCTCATGAGATTTCT +CAGTTGAGGGATTGAGCATGATGGTGGAGTTGGGGGTTATCTTCACACCACTGATAGCATTTTTAATAAT +ATTGCTCTTCGGAAGAAAGATAGGAGATTTAGGAAGCGGGATAATAGCGTCAGTAGGAGCAGGACTTACA +ACTCTTTTCTCCTTGGTAGTCGCCCTCAAAGCCATTCACTCTCCCGTTCACGTCAAACTCTATGACTTCC +TCCCAATTGGCAATTACACACTCTCCCTCGGATTTTACTTTGACTCACTCTCTTCCTTGATGGCACTTGT +CGTCACATTCGTTGCCACTCTCATATTCGTCTACTCAATCGGCTACATGCGTGACGAGTTCGGCAAATGG +GTCTTCAAGTTCTACGCTTACCTATCACTCTTCCTCTTCGCTATGCTCCTTATCGTGCTCTCGGACAACC +TCCTCGGAATCTTCTTCGGCTGGGAAGGTGTGGGACTTGCTTCATACCTCCTTATCGGATACTACCACGA +ACAAAAAAAAGCTACAAAAGCTTCCTTTGAAGCCTTCGTTATGAACAGAATAGGTGACTGGCTCTTTATC +TTCGGTATCATCTACTCCTTTTATCTCTTCAAAACCTTAGAAATCACTCAAATATTCCCCAAAGTTGAAG +AAGTAGACAAGTACGCTCTTGGCGTTGCCACAATGCTCCTCTTTGGAGGAGCAGTCGGAAAGTCGGGACA +ATTTCCGCTTCATACGTGGCTACCAAACGCAATGGCAGGTCCCACTCCAGTTTCTGCACTCCTTCACGCA +GCCACGATGGTAGCAGCTGGTGTCTACATGGTAGCAAGACTCTATCCCATGTTTGAAGCAACACCTCAAA +CGCTAAAACTCATAGTGCTTATCGGAGCGATAACCATGACAATGGCAGCACTCGCAGGTGCTGTTCACAA +CGACATAAAGAAGATAATCGCATTTTCAACGATGAGTCAGCTCGGATACATGTTTGTTGCTCTGGGAGTG +GGGGACAAGGGCGGAGCGATGTTCCACCTCACCACTCACGCTTTCTTCAAAGCCCTCCTGTTTTTAGCGG +CTGGTGCTGTAATAACAGCGTTCCACCACCACCTTTACGACATCTTCAAGATGGGAGGGCTAAAGAAGTA +CATGCCTGTGACTTATGTGGCGTTTATGATAGGGGCACTTAGTTTGGCAGGAGTGTTTCCCTTCAGTGGT +TTCTGGAGTAAAGACAGGATAGTGGCGAGCATGTACGAGTGGAGCGGAGTGCTTGGAGTTCTTGGAACGA +TAGTGGCGTTTATAACTGCATATTACGCGTTCAGGGAAGGATTTTTGGTGTTTCACGGAAGAGAGAGATG +GAGGGAGATATACGATAAAGACGTTCATGAAGTAGAGGGAGTGATGACGGTACCTATGGGGCTATTAGGA +TTTTTGACCGTTCTCACAGGGCTATTTGGTCTTTGGCTAGAGCACTGGTATGTAGGCTTGATAGGAGGGG +AGGAGAAGGGGATACACCTGAGTGTTGCGCTAGTGTCGCTCGGAGTGGCAATAGCTGGGATATGGCTTCC +GTGGCCGGTATATGTGAAGAAGGTGATAGATTACAACAAAGCGTATGAATCTTTGAAGTTTATACACACG +ACTTTCAAGGAGCAATTCTTTACTGAAAAGCTCTACCACAACGTTGTTGCGGGTGGGTACCTTACTTACT +CAAGGAGTCTGTATTCCACCGTTGAAAGGCTTTTTATAGACGGTATTGTGAACGCTACGTATCCGATTGT +GGAACTCCTGGGAAGTGTGCTAAAGTTCTTCCAGAACGGAAGGCTCAGCTGGTACGTGATGGGTCTTGCC +ACGGGATTGACTATAATTGTCCTTATACTTTTTGCAATAACGATTAGAGGAGGGCTGTAATGGAAACTCT +CTTAAACGTTGCCATATTCCTTCCATTGGTGGGGGCACTGCTTGTCGCCGTAATAAGAAACGAAATTTTT +GCCAAAGTTGCTTCCATACTCATAGGTGCCGTTGTAGCGCTAATATCCCTGGTCCTCTTCGTTAACTTTG +ATTTCAGTAAAAAAGGGTTTCAGTTTGAAACATACGTTCCGTGGATAAAGACCTTAGGCATAGGCTACCA +CGTAGGCGTTGACGGAATGGCGATAAGCCTTATCCTCATGACTTCCATCCTCTTTCTCGCCGCATATATA +TGGTCCTGGAAGATAGAAGACAGACCTTCCCTCTACTTTGCCCTCTTCCTGGCACTGGAAACCGCCTGTA +TAGGTGTTTTCGCAGCACTGGACTTATTTCTCTTTTACCTGTTCTGGGAAGGAATGCTCATTCCTATGTA +CTTCATAATCGGTTTCTGGGGACACGACAGGAAGGTTTACGCGGCTAATAAGTTCTTCCTTTACACCTTC +TTCGGTTCTCTGTTTCTTCTCCTCGGTATTGCTTCTATACTCGTTTATGGATACTTTGAAACGGGTAAGA +TTTCCTTTGATTACTTTTTCCACCTCGGACTTGATTACCCCCTTTGGCTTGAGCTTATAGCTTTCCTGTT +ATTCGGTATTGGTTTTGCGGTAAAGATACCCATGTGGCCCTTCCATACATGGCTTCCGGACGCTCACGTT +GAAGCTCCTACCGCAGGTTCCGTAATACTTGCAGGTGTTCTCCTTAAGATGGGAACTTACGGTTTTGTAA +GATTTTCCCTGCCCTTCTTCCCAGAAGCCTCTAAGTACTATATACCCCTTATATTCACACTCAGCGTAGT +TGCAGTTATATACGCTGCCATGATGGCTATAGCTCAAACACACATGAAGAGACTCATTGCTTACTCTTCA +ATATCTCACATGGGACTCGTTACACTCGGAACCTTTGCTATGAACAGCGATGCCTTGAACGGTGCGATTT +ACCTCATGATAGCTCACGGGCTTTCTTCCGCGGCTCTCTTCCTAGGAGCTGGCTTTATATACGACAGGAT +ACACTCTTACCACATGGATGACCTGGGCGGTCTTGCGAGATACATACCTTACTTTACCTTTGCCTTCTTT +CTTGCGGTTCTTGCCGGTATAGCGTTCCCCGGATTTGCGAGCTTCGTTTCTGAATTCCTTATACTCCTAG +GCATATTTGAAAAGTTCCCCGTATGGGCTTTTGTTGCAGGTATAGGTATGGTTCTGGGAGCGGCATACTC +GCTATACATGTTCAGAAAGGTAATGCTGGAAGAGGAGAGTATTCCCGAGGAAAGAGTAGAAAAGTGGAAG +AAGTTGAAAGACTTGGAACTCCACCACGCTATTCCCTTTGCACTGATAATTGGCATGGCTCTCGTTATGG +GAATATACCCTTATCCCTTTGTGAAGATAGTGGAACACACTTCTAAACTCGTGTTCGGAGGTTGAAGCCT +TGAACTGGAACGCTATACTTCCCGAAGCCATACTCGCAATAGGAATTCTCACGGTTTTCATACTTGAGCT +ATTCCTTGAAAGGAAGCATTACAAGTTCTTGAGTGTCCTTGCTTTTATATTCGTTGTCCTTTCAGGGTAT +TCAATATTCTTCGTAAATTATCCTGCAAAACTCTTTTTTGACGGCTTTTCCGTAGATGCTCTTAACTTAA +TCGGCAAGCTTTTCATTTTGGCAGTCACCGGGTTTGTACTCCTTTCTTCCTACGACTACTTCTCCAAGAA +GAACTCCCAGTATGGAGAACTCCCATACCTCTACCTGATAGCAACACTCGGTTTAATGGTTATGATTTCC +TCCGACAACCTTGCGATAATCTTCACGGGACTGGAACTCGCCTCCATCACCATGTACATACTCGTGGGTT +TGTTCAGAAGGGAGTATCTCTCAAAGGAAGGAGCTTTTAAGTACTTGGTAATAGGAACTACTGGAACGTC +CATGTACGCACTCGGTTCAGCACTCGTTTACGCCTCAAGCGGTTCTATGGTTCTGAGTCCCGTAAAAGAA +GAGAACACTTTATTTGCCTTAGGTGTGATACTGATAATTTCCGCCCTTGCTCTGAAGGTTTCCGCTGTTC +CCTTCCACTTCTGGACGCCTGACGCTTACGAGGGAGCACCTACGCCCACTACAGCTTACCTTTCAACTGT +TCCCAAAATCGGTATGTACTTCCTCTTTGTCAAACTCACCATGTACCTCTTTTCCGCGTTCCCCGATTGG +AAGTACGTGGTTATGCTTCTCGCTGTACTTTCCATGTTCTACGGAAATATAGTCGCTTACGCTCAGAAGT +CCGTAAAGAGACTGCTCGCCTACTCCTCAATAGCACACGCAGGATACTTCCTTACCGCTTTAACCGCTGT +GGATAAACACCTCTTTTCCGCACTTCTCTTTTACGTGTTCGTTTACGCTCTTGCAACCGTCGGAGCGTTT +ACGGTTCTCGCTATCCTTGAGAAAAAGGAAGGCTGGACACATCACTTCTTAGATTTCAAAGGATTAAAAG +AGGAAAACCCTGTTCTCGCTTCTATGCTAGCACTCTTCCTCTTTGCCTTGATAGGTATCCCTCCCGCTGC +TGTATTTCTGGGTAAGCTCGGTATATTCTTCGGGCTAGTTAAAACCGATATGTTCGCCCTTGGTATCCTC +TTTGCCATAGCGAGTTTAATTTCCGCAGGGTATTACCTAAAGGTTATCGTTTACATGTTCCTCTACTCGG +GAGAAGTAAGACACGGTCAGACTACGGTTTCCGCTGGAGAGGCTTTCACGGTTCTCGGTACGGCTTTCCT +CGTTATATTCTTTGGTCTATTTCCCCATGTGGTTCTTGACTTTATCCTGCGTGCCCTCTCTTAATTAATT +TTTATGTACACGGCAATAATCCTCGCTGCTGGTAGAGGTAGCAGAATAGGTTTCAGGAAACAGTTTGCAA +CCCTTTGCGGAAAGCCTCTATTTATGCACTCCCTTGAGAAAGTTCTGGACATATTTGAAGAAGTAATACT +CGTTCTCCCAGAGGATTTCTTAGATAAAGTTAAAGTTCACCCGAAAGTGAAGAAAGTAGCGGGAGGACCA +GAAAGACAGGACTCTGTATTTAACGCATTGTTACAGGCCACAGGAGACATCGTAGTAATACACGACTCCG +CAAGACCACTCGCTACAAAAAAGATGTTTTTAGAAGTAGCCCAGCTCGGGGATTACCACGGGAAAGTGGT +GGCTTCTCCTGCAAGGGATACTTTAAAGGAAGTAGTAGAAGGTAAGGTGATAAAAACTTTAAATCGCTCT +TTAATCTGGCACGCCCAGACACCCCAGGCCTTCAGGAGGGATATTCTCCTCGAGTGTCACATGAGGGCAA +AGGCAGAGGGTTTCGTCGGAACGGACGACGCAAGCCTGCTGGAACGCTACGGCTACAGCGTGGGAGTTGT +TGAAGGAAGCTACTGGAATGTCAAGATAACTTATCCTGAGGATTTAGAAATGGTGAAAAAGATAATGGGA +TGCGAAGAGGATTAACCCGTTTCTTCCGCCCTCGGGAATTGCGGGCAGGCGTCTTCGGGCGGTATTTCTT +TTGGAAACTCTTCTTTATACTCGTTGTGATAACCGCAGACGTAGCATTGGATTTCTACGAGATACCCCTC +GTGGGCGTGTCCTATATCCCAACCGCACAGGGGACACTCTCCTTCCTGAGCCTTCAGAACTTCCGCTAAC +CTGCTTCCGTCTTTTAAGTAATTCAGTACATTCTTGACCCTCTTTATCGCTTCCTTTACCTCGTAAGAGT +TCCACTCAGCTCCGCAGTCCAGACACCTAAACTCGGCATATGTTCCTTCTCTTAAAAGTTTTACTATGTC +CGTGGAACCGCATCTGTCGTCTATGCACACGGCTCCTATTTCCTTTCTGGAGAGCTTGTCAAGAATTCTG +TAAACGGTTTCCTTGTCCAGTTTCATGGGAACGTCGTAAGCCTTATAACCGCAGCACTCGCAAAAAGCTT +CAACTCTCGGGTACGGTTCCATGTACTCACAAACCCTTAGAGCTATCCTGTTACAGGCGGGACAGAGTTC +TCTGTGTTGAAGATAAAAGCCCCCGTTCATACCATATCCTCCAAGCTTTCTATTACTTTAATAATATCCT +CTAAAGGTGTTTCTCTATCAACGGTGAGTATAACGTTTTTGGCGTCAACTTTTCCCACAGATATTTTAGG +GATTTCCTCTTCCCACTTAAAGCCTTCAAGGATGACTATATCGCAGTCCGAGAAAAACCTCTTTACTATT +TCCAGAGGCTTGAACTCTCCCCATTCCCAGTAGGTAACTCTGTTAGGAGAAAGGAGAGCCAGTTTCTCAA +CGAGTTTTGAAATCCTGTGTGTGTCAGACCCCTCCTTGTCCGTAACTCCGTGCCCTTTGGGGTCGTGCTT +CAGATAACACACCCTGTAACCTTTTTCCTTCAGTTTCGGGATTAACCTCTCTATGAGAGTAGTTTTCCCT +ACGTTGTGCTTCCCTACGAAAGCAATTACTTTCATATTTTTCTCCTATAAAATGTATTTTTACTATGATA +CCCATAAAAGATGTAAATCCCTCCAGAACTTTTCCCATAGTTAACTTAAGCATAATAGTTGCGTGTTCGT +TGATATGGCTTTACGAATGGAGTCTTACGGACGAGGTTATATACACCTTTCAGGGGGCGGTTACGAAGTT +TGAACTCTTCTTAAGGGAATGGGGACTCGTGCCGGTGGAACTTCCTCAGAAGCCTTACACTCTACTCACA +CACATGTTCCTCCACGGTAGCTGGGGACACATCATCGGGAACATGTGGTTCTTGTGGGTCTTTGGTGATA +ACGTTGAGGACAAACTCGGGAAGTTCAGGTACATAATCTTTTACATTCTTTGCGGACTCGGTGCTGCTCT +GACGCAAACCTTTATAAGTCTTGCTTTTGGCGGTGCAAACGTCCCCATGGTCGGGGCAAGCGGTGCGATT +AGCGGAGTTCTGGGAGCTTACATGAAGATGTTTCCCCACGCAAGGGTTCTTGCATTAGTTCCAGTATTCA +TATTCCTGACTCTTATGGAACTTCCCGCGGTTATTTTCATAGGTCTGTGGTTCTTTATTCAGATAATTAA +CGGTATAATTACACTTCCCTTTATAGGCTACGGAGGAGTAGCTTGGTACGCCCACATAGGCGGTTTCATA +ACGGGCTACCTGCTGGTTGATTACTTCAGGAAAAGGAGTTATTCCTAAAACTCCACTTCCTCGTAATTCA +GAATTTCTTCCAGTATCTCCTTCTTCTTCATCCTTATTGCCTTGTTTCCCAATAGGTAGAGCCCTGTGGC +GAAGAGTATCCTGTCGTCTACGAGGATGCCTTCCTTGTTCCTTTTGAGAAGGTTTAAAACTGCCTTTGCT +TCCCTCTTTGCGTTTTCCGAATACCTTTCTTCCTTGTACCTTTCTTCCATAAGGATTTCGTATAGGGCTT +TTTGTATGGAACTTTCACTCGGAAACTCCGAAAGGAGATTTTGTATGAGTTCCTCTGTAGGAGAGCCTAT +TTCTGGAACTTTAACGTTGTTGTAGTAAAGTAGCTTTTTAAGCAGGTTTGCCCTTATGTGTCCCGCACCT +TTTAATCCTCCTAGAGAGCTGTAATCCGTGGTCAAACCGTATTTTACCGAGTGTGCTATTTTCAAGAAAT +CTTTTAGGGAAAGGTCTAAGTCGCCGATTTTCTTTATTTCAATCATTGTTCTTATGAGGTGAAGGACGTC +CGTACCGAGGTAAGAAAACTCTCCGGGCGGGTTTTTCACGTTCTTGTACTTGAACGTTAATCCTTCTACG +TAAAAGAGGAATTGGTGGGTGTTGTCCTTTAAACACTCGCTTCCGCATGTCAGGAGTTTTTCCCTTACGT +ACATGTCGTCTTCAAGGAAGGTGTCTCCCTTTTTTACGAAATCGTAAAGTCCGTCAAACTTCTTCGTAAA +GAGAAGTGGTCTTATGTAAACGATTTCTTCAAGTCCCAAGTATTTTCTCCTCAGGAATTCCTCGTAATTA +ATTGGTGGCATTCCCGAACGGACGCAGAACAGTGCCTTGTCGCTTAACTTTCCCTTTTCTATGTAACCCT +TATCTTTTAACCACTCGTACACCTCGTCAATCTGAGGTGAGTAGGCGAGTTCCTTTAAAGAGTACGTCCT +TTCCAGAAACTTTCTAAAGTTTTCCCCCTCATAGAGAAAACCTACAAGTATAAATAGGCTGAGTACTTTC +AGTTTTTCCTCAGAAAGGAAGACTTCTCTAAGGTAAGGTTTGAACTCTTCCTTTAGCTTTTCCGAGAGAG +CTTTAGCGAGGTTTTCCTCCTTTGCCCCGTAAGGGAGTATGTAGGAGTATCCTTTTTCTTTAATACCGAG +TCTTCCGGCCCTTCCCTCCATCTGGAGAATGTCAAGAACGTCGGGGAAGAACTTTCTCTGTCTTCTTTCC +CTGTCGTAAAAGGAGCGAACGCTTATTATTACCGTATCCGCTGGCAGATTTACACCGTAGGCAAGGGTGG +ACGTGGCAACGAGAACCGGCAGTTTTCCCTCCCTGAAGGCTTTTTCTATCTCGTCCCTCTCCTCTTTCGG +GACGTCCGCGTTGTGAAAGGCGAGTTCTACCTCTTCCCTTTCCTCTTTTTCAAAAGGAGTGGTTTCGTTC +ATTATCCCTATCTTTTCCCTGTTTGCGATTTCAAGTACGTTCCAGCCCACGCTTTTTTTGTGGACAAAGA +GTATTACCTGCTCATCGGGTTTCTTTAAGGTGTAAAGTGCTCCCAGAAGCTTGTTAGCGATTTTTTCGTC +CTGAGTTGCCCCCTTCGGAAGTTTAGTAAATTCCTCAAACTTGATTAGGGGAATTATCTTTCTTTCCAGG +GGTACGGGTCTCCATCGGGATTCTATGAAGAGTTCAGCCTTTATCCACTTGGCAAGTTGCTCAGCGCCCG +GAAGTGTGGCGGAAAGCCCGAGTATTTCATAATTCCCGTCAAGGAGAAAAGTTATTATCTCTTCCAGTAT +CCATCCCCTGCTTCCCATAAGCTGGTGAATTTCGTCTATGACTACACCTCTCGCTTCCTCTATCCAGCTT +GCCCTGTTCCTTAGAGCAAGGGCTAAGCTCTCGTAAGTGGCAACCACAACCTCGCTTTTTATTTCTTTGT +AAAGTTCAAAAACCTCTCCGGTTCTGACTTCTACTTTTTTTCTGAATAATTCCCTCAGTTCACTTGCCTT +TTCGTAAACGAGGGAACGGGTGGGTGCCGTGAAAACCTTTATTCCTTCTTTTCCCCTTAAAAATAAGAAG +GCTGTCAGACTCTTTCCCGCAGACGTGGGAGCGCTGACGAGTGCATTCCCGCCTTCGTACTCTTTATAAA +AAAGTGTCTGTATGGGGTTTAAAAGCTCATAAGGTATTCTTTCATCCACTTCTTTTCCCTTTATCAGTTC +TTCCGTTTTTGGTCTCCCGCTTACCTTTTTGTAAACGAGCTTTCCCGAAGGTGGGTTTATCTTGAACTCG +GATTTCTCAAGAACGATGAAGTGTTTCATTCTAAATTAATATTAACCCTGACATGGAAACTCTCTTCCTT +TTGTCTATAATTTATATGCATGTTTAACTTTACCGAGGAGCAAATTAAGAGGTACGCCCGTCACATAATC +CTCCCAGAAGTCGGAGGAAAGGGACAGGCTAAACTCCTCCAATCTAAAGTGCTCGTTATAGGAGCCGGGG +GACTGGGTTCTCCCGCACTATACTACCTCGCCGCTGCGGGTGTTGGAACTATAGGAATAGTTGACTTTGA +CGTTGTAGACTTTTCAAACCTACAGAGGCAGATACTCCACACGACAGAAAGGGTCGGAACTCCCAAGGTG +GAGAGTGCAAAAAAGACTTTGGAAGCCCTTAACCCAGACGTTAAAGTTATTACGTACAACACAAAGATAA +ATAAAAACAACGTAATGGACATTATTAAGGACTACGACGTCATTCTCGACGGGACAGATAACTTCCCCAC +GAGGTTTTTAATAAACGACGCCTGTTACTTTGCAGGGAAACCCCTTGTTTCCGCTGCCATGCTGAGATTT +GAGGGGCAGTGCACCGTTTTTGACTTTAGGGACAAGGAAAACTCTCCCTGTTACAGGTGCTTATTCCCCG +AACCGCCACCGCCTGGGCTCGTGCCCTCCTGTCAGGAAGCGGGAATTCTCGGTTCTGTTGGCGGAATTAT +GGGAAGCATACAGGCAACCGAAGCGATAAAGCTCCTCCTCGGAATAGGCGAACCCTTAGTGGGTAAGCTC +CTCATAATGGATGCTCTATCTATGGACTTTAGAAAGGTAAAACTCAGGAAAGATCCAAAGTGTCCCCTTT +GCGGAGAAAATCCAAAGATAAAGGAACTCATAGAGTACGACCAGAGCTGTGAAGTGAGGTTTTAAGTGAA +AAAACTCCTTTCCCTTGAGAACCTCACGCTCCTTTCCCTAATCCTTGCCGTCTTTTTTGGTATTTACTTT +AAAGAAATAGCCCTGAATATCAAACTCTTCGGGGACGTTTTCTTAAGTCTCCTGAAAATGATAATAGTCC +CCCTCGTTTTTACCTCCGTTTTCACCGCCATACTAAACCTTGAGAGTCTGGCAAAATTCAGGGATCTGGG +TTTAAAAGCCTTTTTATACTACTTCACGACCACGGGAATGGCGGTTTTTACGGGACTTGTTCTCGTGAAC +ATAATACAGCCGGGAAAGGGTGCAAGCGGAGTAAGTGCAAAACCTGAAGAAATCCCGAAGGTTCAGGAGT +TTTCTCTTGAGAACTTAATTCTCGGACTTATTCCCCAGAATCCCTTTGAGGCTTTTTCTGAAGGAAAGGT +TCTCCAGATTATAGTTTTCGCGGTCTTTATAGGACTTGCTGTTCTGACTATAGATAAGTTCAAACAGGAA +ATAATAAAGAACTTCTTTGAGGGTTTTAACGAAGCCCTAATACGACTGACAAAGTGGGTTATAGTCTTAA +CTCCCGTGGGAGTTTTTGCCCTTGTTTCTTATCTGATAGCAAAGGTGGGGTATCAGGTTCTTATTTCCCT +GTGGGAATACGCACTAACCGTTTTGCTCGGCCTGCTCATACACGCCTTCGTAAATCTTCCATTAATTGCC +TACATATTCGGAAGGTACAATCCCTACAAGTACTTTATACAGGTGAGGGAAGCCCTGCTTCTTGCATTTT +CCACTGCATCCAGCGCTGCAACGCTTCCTGTCTCCCTTGAACTTGCAATCGAAAGGGGAAAGGTAAAAAA +GGAAGTGGCTGGCTTTGTCCTGCCCTTGGGAGCTACCATAAACATGGACGGCACGGCCCTTTACGAGTCG +GTGGCAGCTGTTTACATCGCAAACCTTTACGGAATAGACCTCTCAATCTCTCAAATGGTTACGATATTCC +TGACCGCGACGCTTGCCTCTATCGGTGCTGCGGCAATTCCCGGAGCGGGTTTAGTTCTCCTGACTTTAGT +CCTCAGTTCCGTAGGGATTCCTTTAGAAGGTATAGGACTCATAATCGCAGTTGACAGGTTTCTGGACATG +CTGAGAACTGCGGTAAACGTCTGGGGTGACCTGAACGGAGCTAAGATTCTGAATAGGTACGTAAACAGCT +AAAATTAAGAGGTATGCAAACATTACTGTACATTCTGTTTTTATTATTCCTTTTTTCCTGTTCAAAAACG +GAGGAGAAAAAAACTCCCCAAGCGAGGAAAATACAGGTATCCGTCGTAGAAGTTAAAAGAGAAAAGGTAG +TTGTAAGCGTTCCTTTCAAAGGAGTCCTGAAGGCGGTAAAAGAAGCCGAGCTCTCATCTCAGGAGCCCGG +AGTTTTAACAAGACTATACAAAAGGGAAGGGGAGTACGTAAAAAAGGGAGAAGTGCTTGCACAGGTGGAA +AGCAATCTTGCAAAGGAAAGCTACAGGAAAGTTTTAAACCAGTTAAAAGAAGTTGAAAAGCAAGTAGAAC +TCCAGAAAAAGATTTACGAAAGGAGAAAGAAACTCTTTGAAAGGGAGTTAATATCTAAGGAAGAGTACGA +AAGGGAAAAGTACAAACTTGAAGAATTAATCCAGCGAAAAAAAGCCCTTGAAAGCGAACTGAAGTACTTT +AAAGAAAAAGTAAGGAGACACTATGTAAGAGCTCCTTTTGATGGATACATTACTGAAAGGTACAAAAACA +TGGGTGATTACGTTACTCCCCAGACTCCCGTGTTCAGGCTGATAAACCTTGGAGAGCTTGAATTTTCCTT +TAAAGTCCCCGCAAGATACGTTTCCCTTCTGAAAAAAGGAAAAGAATTAAATGTGGAGCTTGAAAATGGT +AAGAATGTAAAGGGAAGAGTTTACTTTATCTCCGAAAGGGGTGACGAGAACAATCAATTTCTTGTAAAAC +TTTTAATAAATAACGAAGAAGGAAAGTTAAAGGCAGGAACGTTCGGGTTTGCGGAGGTACCAGTTAGGGA +GGTTTACGCCTTTAAGGTTCCCGAGGACGCTGTTATCCTTCAAGGGAACAAAAAAATAATCTGGGTCCTT +GAAGGGAACAGGGTAAGGTCAAGGGAGGTCGAAGTAATATTCATAAATGGTGGATACGCCTACGTTGAAG +GAGACCTGAAAGACGGCGATAAAGTGGTTACGGAAAACACATTTTTATTGAAAGAAGGAGCTGAGGTAGT +GGTGAGATGAGTGGTGAGATGAGAGTAATTTGGGTAATCCTTTTCCTTTTTACTTTTTCCTTCCCGCTTA +CCTTGGAAGAAGCGGTAAGTATAGCCTTGAAAAACGTAACAGATGTCAAGCTTTCACGTTACGAACTGAA +AAAGCTCGACTACGAGATAAAGAAAGCGCTTTCTGGCATACTGCCGAAGGTGACGGGTTCTTACTCTTAC +TTAAGGCTGGACGATTCCCTCGTTTACGGATTTGCCTTGAGGGACAGGCAAAGTTACGACATTACGCTTT +CTCAAACTATTTTCAACAAAGCAATTTTTGACAGTATCTCCCTTGCCAAAAGCCAGAAGGAACTCCAGAA +CTTAATACTTGAGGATGTAAAAAGGGAAGTTGTCTACAGAGTTAAAGACATGTACTACGCAATTCTCTAC +AAGTGGACGGTTGTTGAGTTAAAAAAGGAAAACCTGAAATACTGGGAGGAGTACTTAAAGACTGTTGAAG +AGAAGTATAAGGCGGGGATACTCCCGAAGGTTGAGTACGTAAGGGCTAAGGCTCAGTTTGAAAACGCAAA +GGCGGAGCTCGCACAGGCAAGAGCGGACTACGAGAAATCAATAGAAAACTTTAAAGCTTTTTTAAAACTT +GAAAAAACTCCTGAGTTCATGGGAAAATTAGAAGTAAACCTGAATGAAGACTTTTCTGAGGAAAAACTTT +TAGAGTTCCTTGAGAAAAACAACTCCACCTTGAAGGTAGCAAAGGCGAGGATAGAAGTGGCAAAGAAAAC +CTACAACTTGTCAAAGGCGGATTATTATCCTACCCTTGACGCTTACCTTACTTACGAGGGTTACACGACG +AGAAAGAGCCTCTTCGGAGGAAAGGAATGGGTTAAGGGCTATACTTTCGGTATCAGTTTGAACTACAAGT +TTTTTGACGGGTTTGCGAGAGAGGCGGAAGTTGCCCAGAGGAAGGTAGATATCTTTCAGGAGAAAGAAAG +GTTTAAAGATACGTTTTTTAACGTAAAGAGGGACTTAAAGAACGCCCTCCTCGAAATAAAGTCCCTGAAG +GAACGAATAAAGGCTGTGAAGCTCTCCCTTGAAGCGGCAAAGGAGACTTTAAAGCTCGCCACGGAAAGGC +ACAAAGAAGGTATTGGAACGTACCTTGAGGTTTTAGACGCAAGGAGGAATTACAACGACACTTTAGATAC +TCTACACTTTTTGACTTACAGGTATATGAGCACGCTCGCCTTAATAGAACGCTTAACCAGATGAGGCTTC +CACTTTTTCCCTCAACCTACAGACGGGGCAAATCTCTCCGACAGTGGGCTCTCCGCACACTTTGCAGGGC +TGGAGTTCTTTTTTCTCCTCTTCTTTCCTGAACTTGGGGTATATCTTCCTGAGGTAGTCGAGGTAAAACC +TCAATTTCGTTCCGGGAGAGCGTTCTTCTATTTCGTTTAGTATTTTCTTGTAAAAAACGGAGGTTGCGTC +TTCCGAGAAGGGACACTCTTCCTCAATAAAGTCTATGCCGTTTAGGAGGGCGTAAAGTGCAGTTTCCTTT +TCCGTGAACTTGCAGAAAGGCTTTACTTTCCTCACAAATCCTGCTTCCTCTTCCAGAACGGGGTATTTCC +TTCCCAAGTACTTTTCGTTCCAGTTGAGGACGTTTGCAAGAAGGGCACTTGCCTCGTCGTCCAGGTTGTG +TCCCGTGGCTATCACATTGTAGCCGTGTTCTTTTGCTACTTTGTTGAAGTTGTACCTCTTTACGAGTCCA +CACACGGAGCACGCTTCCCTTGATGTTATCTTTACGAGTTCTGGTATACCTGCAAGTTCCTCTTTAAGGT +CAACTATTATCGCCTTCCCGTTAATCTTTTCGGCGAACTTTAAGACCTTCTCCTTTGACTTTTCGGAGTA +CTCACCTATACCGAGGTTTATGTAAAGTCCGTCTGCTTCGTATCCGAGCTTTCTCAATACATGCCAAAGG +GCTAAACTGTCCTTCCCTCCAGAAATAGCAACGAGAACTTTATCCTTCTTTGTGAACATCTTAAACTCTT +TTATGGTTCTCTCCGTGTACTTTTCAAACCACTCTACAAAGTGCTCCCTGCAAAGGGCGAGCCTGTGGTG +AGGCATGTATATTATCGCTTTCTTTCCGCAAATCCTGCACTTCTTCATAAGAAAATGAATATAAGTATTT +AAACTTCGAAGAGTTTAATCAAACAATCTCTGCAGGGTTTATCTCCTCTGTTTGTAAGCCTTGCGATTTC +GAGCCTCGCCTCTTCAATAGGAAGACACTCCTTCTCTTCTCTCGCACCTTCGTAAGACTGGTTTCCACAA +AGGGAGACTTCTTCACATTTACAAACTGCTTCGGAGAGCTCTTCACACTTAAAGACGTGAACCTCTCCCG +TATCGCTTATCCTGAGGGAGTACCTGTCCATTTTTTACCTCCTTTACGTAAACTTTCTCTTATATTCTAA +ACATGCCCTTATGAAATCCCTAAAGAGCGGATGGGGAGCGAAGGGTTTGCTCTTGAACTCGGGGTGGAAC +TGACATCCCAGGTACCACATGTGGTTTTTGAGTTCCATTATTTCTACAAGTTTATCGTCGGGAGAAGTTC +CGGAAAAGACTACACCTTTACTCTCAAAGTCCTTTCTGTACCTGTTGTTGAACTCGTACCTGTGCCTGTG +CCTTTCGTAAATTAAATCCTTCTGATAAATCCTGTGGGCTAGTGTATTTTCCTTTACCTTACAGGGGTAA +GCTCCGAGCCTCATAGTCCCGCCGAGCTTGTCCACTTTTTTCTGTTCCTCCATTATGTCTATTACGGGGA +ACGGTGTATCGGGGTCGAACTCCGTTGAGTTTGCGTTACTAAATCCGAGAACGTTCCTTGCGAATTCTAT +AGCCATCAACTGCATACCGAGGCATATACCGAATGTGGGAATGTTGTTTTCCCTTCCAAAGTTAAGGGCT +TCTATCTTTCCTCTTATCCCTCTCTCTCCAAACCCTCCCGGCACCATTATCCCGTGTATGTCCTCTTGAA +GCTCCGAAATGTCGAGCTGTTCTGAATTTTTAAGGATTACGTTTACCTTTACCTTATTCGCAATCCCGCC +GTGTATCAGAGCCTCTATAACACTTTTGTAGGAGTCTTTCAGTTCCACATACTTTCCAACGAGTGCGACG +TTTACCTCTTCTTCCGGGTTTCTTAGGACGTTTACTATCTTCTTCCACTTCCCGAGGTTAACTTCCCTGT +GTTCAAGGTTCAGTCTTTCTGTTATTATCCTGTCTATTCCCTGTTCCTTTAGCTTTAGGGGAACTTCGTA +GGAAAACTCAAGGTCAGGGGCGGATATAACGGCCTCTTCTTTAACGTTAGTAAAGAGGGCTATTTTTGAC +TTTATACCCTTTGGCAGTTCCCTGTCAGCCCTGCATATTATCATGTCCGGCTGTATACCTATTGCCCTTA +GTTCCTTTACGGAGTGCTGGGTGGGTTTAGTTTTGAGTTCTCCCGCCGCCTTTATGTAGGGAACATATGT +GAGGTGTATAAACATAGAGTTTTTCCTGCCAAGTTCCAGGGAAAGCTGTCTTACCGCTTCTAAAAATGGT +AGTCCCTCTATGTCTCCAACCGTTCCTCCGATTTCCACGATAACTATGTCGTTGTCCTTTTCTACCCTCT +TTATGGACTCTTTAATTTCCTCGGTTATATGGGGAATGACCTGAACTGTTGCCCCAAGATAATCCCCTTT +CCTTTCTTTTGATATAACGTTGTAGTATATGCGCCCTGCGGTAACGTTGTTGTCCCGCGTCATAACGGCG +TTCGTGAACCTCTCGTAGTGTCCGAGGTCTAGGTCAGTTTCCGCACCGTCTTCCGTAACGTAAACCTCTC +CGTGTTGGTAGGGGCTCATAGTTCCGGCATCCACGTTGAGGTAGGGGTCGAGCTTCTGGAGGGTAACCCT +GTAGCCCATTTCTTCGAGTATGGAGGCTATGGAAGCGGAGGTAATACCCTTGCCGAGGGAAGACAGAACA +CCTCCTGTGATGAAGATGTATTTAGCCATGTAAGAAAATTATCCTACAACGAGGTTTAACGGACAAGTTT +TGAAGTAGAATCTTTGAAATGAACATCCTAGTAACTGGCTGTGCTGGATTGATAGGGTGGAAGGTATCCG +AGAAACTGCTGGAGCATGGACACAGGGTTATCGGAGTAGATAACTTAAACTCTTACTACGATCCGAGGCT +AAAGGAATACAGACTGGAGCAACTAAAAAAATTTGAGAACTTTAAGTTTTACAAGGTTAATATAGAAAAC +AGGGAAGCTTTAAGGATTCTGTTTCAGGAGTTTGAATTTGACGCCGTTATAAACGAAGCCGCAAGGGCTG +GGGTGAGGTACTCAATACAAAACCCTCACATTTACTTCACAACCAATACTCTAGGAAATTTAAACTTATT +AGAACTTATGAAAGAATTCGGAGTTAAGAAACTCATTCTCGCCTCTACTTCTTCCCTTTACGCTGGTCAA +CCAATGCCTTTTAAAGAAGAACTTCCCGTAAACACACCCATTTCTCCTTACGCTGCAAGCAAGAAGGCGG +CAGAAGTTACCGCATACACCTACCACTACCTCTACGGGATAGATGTCGTTATCCTGAGGTACTTCACCGT +TTACGGACTGGCAGGCAGACCCGATATGGCTGTATTTAACTTTATCTACAAAACACTGAAGGGAATTCCT +ATAAAAGTTTACGGGGATGGAAGTCAGAAGAGGGATTTCACTTACGTCGACGACGTAGCGGAAGCCACTG +TAAAAGCCCTGAACCTCAAGGGATACGAAATAATAAACGTGGGAAACAATAAACCGAGGGCTTTGAAGGA +GTTAATAGAACTTATAGAAAAGTACACGGGTAAAGAAGTAAAAGTTGAGTACGGAGATTTTCACAAGGCG +GATATGAGGGACACTTGGGCGGACATAACGAAGGCAAAGAGATTACTCGGGTGGGAACCTAAAACTTCCC +TTGAAGAGGGCGTAAAGAAAACGGTGGAGTGGTTTCTTGAGAACTGGGACTGGGTAAAAGATTTAAGGGT +TTAGTAGAACACCATTCCCGCGTAGGAGACCTTAGAGTCTGTGGGTGCTTCGTGGTAAACGTCGTAATCA +AGGAGCTTTCCTTCTTTAACTCCCAAGTTCTTGAGAATTTCTAAGAATACAAAGTTCGTAAACTGTCCGT +CTATGCGTGTTCTGTTGTTGTCACTCTGAAGGAGATTAAATGCCTCCTCGTTCTTAAGCTCCGCCAGTAG +ATTTATGTACTCCCTGTCCCTCGGAGAAGGGTCGTAAGAGTGCGGGTCCCCAAACTTCCTTCCCACATGT +GAAAAATCCACGCTGGAAATTATGAGAGGGTTTTGAGAGTCTTCCAGTACTTTCGTGATTTTATGTGCGA +TTTCTTTGAGACTTTTCGTATCTCCGTAGGAAACTATCGCAGGTATTACCTTCACTTCGGGAAATAGGTA +CTTCAAGAAGATTGTTTGAAACTCTATGGAGTGTTCGTTTTTGTACGCAAGTACATCGTGAGAAAGGTCG +TAATCAAACATCTTCTGGAGTTCTTCCACTCTTTCTATATCAACTTTCAGGTCACCTAAGGGAGTCCTCA +GGTCGAGCGGCAGGACGGAAAAGGGTGTTTCGTGAAAGTAGTGAGATACTCCGAGGAGAACAACGGTGTC +GTATTCGTTTTCCTTTATTGCAGAGTAAACGCTCCCGTAAACTCCGCTTGCAACTCTCAAATCCATGTGA +GGGACTAAAATGCCTCTCGCTTTAAACTTTTCGGAGTTTTTATTTACAGTTTCCTCAATAAAGTTTTTTA +GTTCTTGGGGATTTTCAGGATAAGCCTGGCCTGCGTGGGACGGTTCCCTGTAGCCCTTTTTCAGGATTTT +CTCCCTTTCCTCTTTTAGTTTGTTTAAAAATCTTTCGTTATAAAGGAGGTAGTTCTCGTCCAAGAAATTT +ATTACCTGATTTATCTCCTCCTTCGGGATTAAATGTCCTGTTTTTTTGAAAAACTCCGCCTGAAGGTCCG +TTATATCTCTCGTTCCGTCCATTAAGGAGAGTAGAAAAAGGAGTTCGGGAGTTGCTATAAAGGGCTGGGA +GATGCCCACGGGGTCGCGAACCACGAACTTATCCCCGTAGGGCTGGAGGTCAAAAAACCTTACCTTCGGC +TTCATACCGCCTGCTCGAATATGAGCTTCGGTTTTTCTTTGTTCTTCACAACATTCTCGTCTATTATTAC +CTCTTTTACTCCGGGAAGGGAGGGAACTTCAAACATAATGTCCGCCATTATGTCTTCCATTATGGCTCTT +AGTCCTCTTGCCCCTGTTTTTCTCCTTATGGCTTCCTTTGCGATTTCCCTGAGTGCTTTTTCCGTGAAGG +TGAGTTTAACACCTTCAAGTTCAAAGAGCTTTTGGTACTGTTTCACTAATGCGTTTTTTGGTTCTACGAG +TATCCTCACGAGTTCATCTTCGGTGAGTTCTCTCAGCGTCGCTATAACGGGGAACCTTCCTATAAATTCG +GGTATCATCCCGAACCTTATGAGGTCGTCTGGCTCAACGAGTTCGAGAAGATCCTGTTCTTTGTCCACTT +TCTTTATTTCCGCTTCAAAACCTACTCTGGACTTCCCGAGCCTTTGCTTTATTATGTCCTCAAGTCCTAC +AAACGCCCCGCCACATATGAAGAGTATGTCCGTTGTGTCCACCTGAATGAATTCCTGATGGGGGTGCTTT +CTTCCGCCTTGAGGGGGAACGTTTACGACGCTTCCCTCAACTATCTTGAGGAGTGCCTGCTGTACTCCTT +CTCCCGAAACGTCCCTCGTTATGGAAGGGTTTATACCGCTTTTTTTCGCAATCTTGTCTATCTCGTCTAT +GTAAACTATTCCCTTTTGTGCCGCTTTGACGTCGTAGTCGCAGGCCTGAAGTAGTCTGACGAGTACGTTT +TCTACGTCCTCACCGACGTATCCGGCTTCTGTGAGAGAAGTTGCGTCCGCAATCGCAAAGGGAACGTTCA +GTATTTTTGCGAGGGTTCTTGCAAGGAGCGTTTTTCCCGAACCTGTGGGACCTATCAGGAGTATGTTGCT +CTTTTCAAGTTCAACGTCGTCGAGGGAGAGTCCCGCTTCCTTTGCCTTTATGCGCTTGTAGTGGTTGTAA +ACTGCAACTGAGAGGATTTTTTTCGCCCTCTCCTGACCTATAACGTACTCGTCTAGTATCTTCTTTATCT +GTTCGGGCTTCGGGATGTCTTTGAGCTCAAAGTTATAACTCGTTTTCTTATTTTCCCTGACTATCTGATA +ACACTTTTCAACACACTCGTCACATATGTAGGTGTTGTTAGGTCCGGCTATCAGTATCAGTACTTCGTCC +TGTCTCTTTCCGCAAAAGGAACAGAATTCCTTGTTAACTTTCACAGCCATGGTTTAAAAACTTAAGCCTT +TACTCTCTCTTTTCAATAACCTTGTCTATTAGACCGTAATCTTTGGCTTCGTAAGGAGACATGAAGTAGT +CCCTTTCTATGTCGTTCGCTATCTTGTCCTTGGGTTGTCCCGTATGCTTTGCGAGTATGTCTATGAGCAT +TTCCTTAATTCTCTTTATCTCTTCAGCGTGGATGATTATGTCCGTAGCCTGTCCCTGTATTCCACCGAGG +GGCTGGTGAATCATTATCCTCGAGTGGGGAAGTGCGTACCTCTTTCCGGGAGCTCCCGCGGCAAGGAGTA +TTGCTCCCATGGAAGCCGCCTGTCCCATGCATATAGTAACCACGTCGGGTTTTATGTACTGCATAGTGTC +GTATATGGCGAGTCCTGCTGTAACCGAACCGCCCGGGGAGTTTATGTATAGGTATATATCCTTGTCCGGA +TCTTGGCTTTCGAGGAAAAGTAGCTGGGCAACGATTAAGTTGGCAACATGGTCGTCTATAGGAGAACCGA +GAAGGACGATCCTGTCCTGAAGGAGCCTCGAATATATGTCGTAGGCTCTTTCACCTCTCGGCGTTTGCTC +TATTACTATGGGAACGAGCTGGTCAAGTATTTCCTTGTGATTCATTCTTTACCTCCTCTTTTTCTTCCTT +CTTTTCTTCTTCCTGTTTTTGCTCCACTTCCTTTATCTTAACCTTGGAAATGATTTCCTTAAGGGCTTTC +TTTCTCCTTGCGTCTTCGTAAACAACCTGTTCGAGGTTGTTCTCCTTGAAGTACTTCTTAATTTCATCCA +CGGTAGTTCCGTACTGCTCTGCGAGTTCTTTGTACTGTGCCTCTATATCTTCTCCAGTAGGTTCTATTCC +CTTCTCCTGAGCGTACTTGTCGAGAATAAACCTGAGTTTTATGTTAGCCTCGGCTATAGGCTGAACTTCT +TCCACTATCTTCTTTATGTCCACGTACCTGGTATCTATACCGAGTGCCTGAAGTTCCCTCAGTCTTCTAT +CAACTAGGAAGGATAATTCCCTTCTCAGGAGCGTCTGGGGCACGGGAATGTCGTGTATTTCCACGAGCTT +GTCTGCAACTCTTTCTTCGATTACCTGCTCTTTCAGTTTTTCGAGTTTTTGTTTTATGTCTTCTCTGATC +TTTTCTTCGAGGTCCTTAAGGGACGCGTAGCCAAGTTCTTTTGCGAACTCGTCGTTTAGCTCTGGAAGAA +CCTTCTTCTTTATCTCCTTTATCTTGATCTTTATGTTAACTTTTCCTACTTCCTTACCTTCTTGATCGTA +GAGGGGGAGTTCTTTTAGTTCTACTTCTTCTCCTACCTTCTTTCCTTTGAGGGCTTCCTCTACTTCGGGT +CTGAGCATTCCCTGACCGAGTATTACGGAGGTTTCCTGTTTTACCTTCTCACCTTCTCCGCCTATTTCTT +CCACTTCGTATTCAACGACGAGCATATCTCCCTCTTGGGCGGGTTCGTTTTCATCTTTTGGTTCCCAGAC +GGCGTTTGCCTCCCTCAGTCTCTCGAGTTCCTCCTTCACGTAATCTTCCTTAAACTCTATCTTGGGAACT +TCTACTTCGAGGTTTTCTACGTCTTTTAGCTCGAACTCGGGAGCAACCTCGAAGCTCACCACGTACTTTA +CCTTTCCTTCCTTTTCGTCAACTTCTACCTTTTCTAAGAAAACGTCTGCCACTGGCTTCAGGTTAGCCTC +TTCCAGAGCTTTCTGAAGGGTCTCATCGGCGATCTTCTTTCCTACTTCTTCCTCTACGTAGTCCTTGTAC +TTAGCCCTTACTATCCAGAGGGGAGCTTTCCCTTTTCTGAACCCTTGAATCTGAACGGTTTTCTGGAGTT +GCTTGTACATCTCGTCTATTTTTTCCTTAACGCTATCTCCCTGTATTTCAACGGTTAGGGCTTTGAAAAG +ACTTCCCTGTCCTGAACCTCGACTTTCATTTTTACCTCCGTTTTTGTGTGGTGCGGGTGGCGGGAGTCGA +ACCCGCACGCCCTTACGGGCACCGGATCCTAAGTCCGGCGCGTCTGCCAGTTCCGCCACACCCGCTAAAT +AGTTAATTATATTTAAAATTCCACGATGTGGTTATCCATTAACTTAACCAAGTCAGAAGGTCTCGAGAGT +GTAAAGTCGGGTATTTGAGAGTTTAACTTAACGTAACCCCACAGGGCAAGGGCCGTTTTAGTTCCCGCCC +TTTTGCCAGCCTCTATGTCCGCATCCGTGTCTCCTACTATTAAGGCCTTTTCGGGTTCTTCTCCCAATAT +TTCGAGAGTCTTCAATACCGGCGTAGGAGAGGGCTTCTTTTCTCCGAAGGTATCTCCTCCCACGATCAGG +TCAAAGTAGCCCGAAAGATTAAGTATGTCGAGGATCTTCTTTGAGAGTTCCTCGAGCTTGTTTGATACTA +CAGCGAGTTTAAAACCTTTACTTTTCAGGGCTTCGAGTGTATAAGGAATTTCCGGATAAGGTTTCGTATA +AACCACGGGGTTTTCGAGGTAGTGTTTTCTGAAAACTTCAACGTACTCTTCCCTGAACTTGTCTTTGAGA +ACCTTCTCAAGCAGAGCCCTGACTCCCCCGCCTATGTACTTGGTTACGTTATCGGGATAGTACTCCTCTA +AACCGAGCTCTTTTAAAGTCTTCTCAAGAGCCAAGGCTATATCCTTTGCAGAGTCTATAAGTGTTCCGTC +CAGGTCAAACAGAATTACTCTCATGCGCACTTCTTTATGTAATCTTCCAGTCTTTCCTTCTTAAACTCCT +CCTTCTTCACGTAGTTTATAACGCACGCAAACTTCTCAGGAGGAAGGTAGCCAGGAATCTGGAGTATTAA +GTTTCCGTTCTTGTCGTAAAAGATGAGGTTCGGAAAAGACGTAGCCTTCAGTTTTCTCGCGAGTTCCTTT +TCGGACAAAACTTCAACCTTCCCGCCTATGTTAGTCTTGACGGGCTCGTAACTCTCGTACAGGAGTGTGT +AAATGTCTATACCCTTCAGGGCTTCCTGAAGTCTCTTTTCAGTCTTTATATCCTTCTTCAACTGGGCACA +GTATATACAGCTTTTGCTCTCCACTATAAGAAGCGCATACTTGTTCTTCGGTATTATGGACTTTGCCTCC +TGAACCTGAGATTTTTCCTCTCCCGAGGAACACGCAATCAGGAAGATAAACACGATAAAGAGAAATTTGT +AAATCACTCTCATAATAGATATTTTAAAGATATGGCTACATACGAAGATGTAAAGAGAATGGTTCTTGAC +CTCGGTTTAGAAATCAAGGAGGAGATTCCGGAAGAGGAAGTCATAATCGTGGAAGACGAGGAGAGGGGAA +TAAAAAACATGGTAATTGACTGCGAGGAGGAAGTCCTCATAATAGAACAACCGATAGGAAAGGTTTCGGA +AAAACATTACGGATGGTTTTTGGAGAGGAACAGGACCTGCCCTTCGGAGCTTTCGCTTTGGACTCAGAAG +ACGGGATAATTCTCTTTAGACAGACTTTGAGGCTCGATACCTTCGATTACGAGGAACTCGAAGCGAGTAT +ATCCTCACTTGAGATATTTTTCGCAGAGTGGGGAGACGAGCTTTTAAATATCCTGAAGGAGGCTAAGTGA +TGGGACTTTTAAAGAGGCTTTTGAGAGTTGTAAGGGCGGAAGCCCATTCGGTTGTAGAAAAGCTTGAGGA +CCCTATAAAAATAACCGAAGAGGGATTGAGGGAACTCAGGAAGCAGTTAAAAGAGGCTATGGAAGCCTTG +GCACAGGTAAAGGCAAGCCAGATAAGGTTTGAGAGGGAAGCCAGAAACGAAAAGGAAAGGGCCAAGGCAC +TCGTGAAGAAAGCCGAAAGCCTTTTACTCCAAGCACAGGAAGGAAAGATATCACCCGAAGAGGCAGAAAA +ACTCGCCGCGGAACTCATCCAGAAGGCTGAACTCCACGAAAAAAACGCAAGAAGACTGGAAGAAGAGGCA +AAGAGACAGAGGGAAATGGCGGTTAAACTTCAGGCAAAGATTGACGAGCTCAAGGTCCAGATCGCAAAGT +ACGAGGCCGAACTAAAAACACTAAAGGCGAGACTCGCTACCGCAAGAGCGGTAAAAAAGGTAAACAAGCA +AATTGCGAAAGTTGACCCTTCCGATACGATAGCCATGCTCGAGAGAATGAAGGAAAAGGTAGAAGAAGAA +GAGACGCTTGCACAGGCTTACGAGGAACTTGCAAAACAGGAAGTAGCACTGGACGTGGAAAGCGAAGCGG +AAAAGAAGTTAAAGGAAGTGGAGAGTAAACAGAAGTTAGAAGAATTGAAGAAGAGACTCGGTCTTTCCTG +AGATGGGATTTCTTGAGAGGATAAAGAAACTCTTTTCGAAGGAAGAAGAAAAGCAGGAAGAAAGCATTCT +CTCCAATCCTCTGGAAAGACTGAAAAAGGGGGACATAATCGAAATAGACGGGGAGACGTGGGAGGTTACG +GACGTTGCTCTTTATGATTACGGGGCGAGTAAAGAAAAGGAGTGGGAAATTCGTTCCGCCTCCCGCAGAG +GATTTTTGAGCCTTGAGGAGGGAAAGATATACTTCTTTGAAGAAATTGACCCAGAAGAACTGGAACCCGA +TCCGGGAGAGCATTTTAGAAAGTACGGAAAACCTCCGGAGTATGTAACCTACAAAGGAAAGAGGTACAGG +CTAAAGTACGCGGGAAAGGCAAAGTACATTAAGAACCTCGAGAGTTATCCCGTAACCATCTGGGAGTTCA +GGAGCGAAGACGGAGAAATGATAGACCTTGAGATTTGGGATGAGTACGAAATTGAAGCCTACAAAGGGAG +AGAACTACAGGAATGGGAAATTGAGAGTATTCTTCCTCGTTAGCCTATTACTCTTTCTCCTTTCCTGCTC +CTCTCCAAAAGAGGTAAAGGGAAAACCTGAAGAGTTTTTCTTAAAGAACTACGAAAAGGGTATTTACAGA +TACGCGATTTTAGAAAATAAGCCACAGGACACGGAATACTGCAAGGTCCATCTAAAAGATCTTATAAAGG +AAGGTGAGTACATCTTGAGTCTTCCCTCCCGCTACAAGGTGGAAAGGGAAAAATTGAGCACAAAGCTTTA +CTGCGAACTCTTTTCCAAGGGAAGGTTTCTGGAGGTTGCGGGAGAAAGGTTTACACCTCCTTCCGCTCTA +AAGGTGGTGACCTTCGTAGAGTTAAAGGAGGGTTTGTTCCTCTGGTTTCTTGAAAGGGTTCGTGCTCAGG +GCGGTGGTGGCGGGGGGATAATATTCCTTCCACTGCCCATTCCGTGGGGAGGAGGGTACAATTACGAGGG +TAGGTACAGAACTCCGACGGGGAGGTACGGAAAGTGAGCGGATTCTTAATAGCCCTTTTCTGGGTAATTT +TTTCTAAGTACGTTTTTGACGTGCTCTTTTTCAGAGAAGCAAAGATTGAAAGGGAAATTTTCGGGAATAA +GAACCTTGCACTTTCCCTGTCTTACGCGGGTTACTTTCTGGGACTTGCCTTTTCCTTTTACAGCGTTTAC +TTTTACGAGAGTCTTTTCAGGGAAGTTCTTTACCTGATTTTCGTGAGCTTTACACTCCTTCTCGGAGTTT +ACATATTTGACCTCATCTTTTTGAGGAAAATAGACCTGAAAGAAGAAATTCTTAGGGGAAACGCAGGTGC +GGGGATCACGCAGGGCATTTACTTTCTTTCCCTCGGTATTTTGATATCCGCTTCCTTCTGGAGAAAGGAG +AGCTTCATCCTTTCGGTAATCTACTCCTTAATTTACCTTTCGCTCGGTATGGTTATGCTCTTTATTTCCA +CGCTTTTAATGTCCAGACTCCTTAAACTTAACTTTGAGGAAGAAGTAAAGAAGGAAAACTTTTCCGCTTC +CCTCGTGCTTGGAAGTATAACTCTTGGCGTTTCCGTCGTTTTATACGGTGCGATATCGGGAGAGTTCATG +GGAAGCCTTATTTTTGACTTGTTCTCAACTGTCCTTTACTTCGTCGTTTCTCAGGTACTGATGGTGATTT +TTTACGTTGTCGTTGAGTTTTTACTGTTCAGGAAAGTTATTCTTTCCTCAGAGGTTTACGAGAATAACCT +TAGTGCCTCCCTTATACTGAGTGCTACATTCATAGCGAGTGCCTTCATAACCCTTGCGGTTATGGGATGA +GTGTTTCTACAGCTTTAAAGCTCTGTATTTTCTTTACTGGTTTTGCGGGAATAGTTGCCGAGTACTCCCT +TGCCACTCTGGCTACTTACCTCCTCGGAAACGCGGTTCTCCAGTGGAGCGTGGTGATTTCCATCTTCCTG +CTTTCTATGGGCCTTGGCTCTCACGCGAGCAGGTATATTCCTGATGATAAAACACCTCTCGCTTTTGTCC +TCGCGGAACTCTTCCTCTCCCTCCTCGTTCCCTTTTCCGTTCCCATAGCCTATCACTTCGCAAATAACTT +CCTTCACCTCCAGACGGTTATTTACGGACTTTCCTTCGTTATAGGGAGCTTAATAGGTCTGGAAATTCCC +CTGGCTGTTCGTATAAACAACATGTACGAAGAACTCAAGGTAAATATATCTTCCGTGCTCGAGAAGGATT +ACCTTGGCTCAGTTCCAGCGGGACTACTTTACGCATACCTTTTTCTCCCTAAACTCGGTCTTCCCCTAAC +GGCTATTCTCGCGGGATTTTTCAACTTAATTTCTGCATTTTTACTGGTAAAGGTATTAAAACCGAAAAAG +TTTTTAAAGTTTTTGGCGATTTTTACTTTCTTTTTACTCGCAACTTACGCAGTTGGACACAAGAGGATAA +CACTCTACGAAGAGCAGAAGTTTTACGGAGAGGAGATAATCCACTTTGAGCAAACCCCTTACCAGAAGAT +AGTTTTAACACGGTTTGGAAAACACTACTCTTTATACTTGGACGGACACCTCCAGTTCTCAACACTTGAT +GAAAAACGCTATCACGAGACGCTCGTTCACGTTCCCGCCTCTTTTTTAAAAAGATATGAAAAGGCTCTAA +TACTCGGCGGAGGGGACGGACTGGCTTTAAGAGAACTCAGGAAATACCCTTTCGGGGAAATACACCTCGT +TGATCTGGACCCTAAAATGATTGAGTTTTCAAAAAAGAATCTCGTTATGAGGAAAATTAACGAAAACAGC +TTTTACGACACGAGGTTAAAGGTATTTTCGGAGGACGCCTTTAACTTTGTAAAAAAGACAAAAGAGAAGT +ATGATTTCGTGATTGTGGACCTCATAGACCCCAGAACCCCATCAAGTGCGAGAGTTTACTCCCTGGAGTT +TTACATGTCTTTGAAAAACAAACTAAAAGAAGACGGCATTTTCATAACTCAGGCGGGAGACACTTTCTAC +AAGAGGGAGGTGTTCTGTTCCATTCTAAAAACTATTAAGAAGGCGGGATTTTACGCGTACCCTTTAGTTG +TGTACATCCCTACCTTTGGCGAGTGGGGGATGGTTATAGGGAGTAAAGAGCCTTTAAACTTTGAGAACTT +TGAACTCAAGGAAAAAACCGAGTTCCTGAACAGGGAAAGGGCTTTAGCCTTTTACACACTCGGGAAGAGT +TTGGAGTGCCCGAATGTGGAAGTAAACACTTTACTGAAACCCGTGCTTATTTATTATTACTACAAAATAC +AAAATTAACACTTTTAAACTAAATTAATATAACATGGAAAAGGTATTGGCAGAGGAAAGGATTGACCTCG +GAAGATACGACGAGAGATTTTACGCAATTGTGGGAAGGGGAGACGAAAACATAAAGTTCTTCTCCAAGTT +CTTCGACGTGAGGATAGTCCCGAGGGGAACTGAACTCATAATAAAGGGAGAGGAAGACAAGGTAAGGGAG +TTCGTAAACTTCTTAAAGGCTGTTTTGAAGAGGCTCGAGCACGAAAGGCTCACCGCGGAGGAAGTGAAAG +AGTACGCAAAACAGTTTTTGAAGAGCGTGGAAGCATACAAAATTGAGGAACAACCGGGCAGGGAAGAGAA +AGAACTTGAAGAGGAAGTAATACTCATAACCCACAGAAAGAAGGCAATAGTTCCCAAGACCGAAACCCAA +AAGAAGTACGTAGAAGCCATAAAGAAGAACGACATAGTGTTCGGTATAGGTCCCGCAGGTACGGGAAAAA +CATACCTCGCTATGGCTATGGCCCTCCAGCACCTCAAGGAAGGTAAGGTAAACAAGATCATCTTAACGAG +ACCAGCGGTAGAGGCGGGAGAAAAGCTCGGATTCCTTCCGGGAACTATAGCTGAAAAGGTTCACCCTTAC +CTCACTCCACTCTACGACGCCCTATACGATATGGTGGACTACGACAAGGCTAACTACATGCTTGAAAGAA +ACATAATAGAGATAGCTCCCCTTGCCTTTATGAGAGGAAGAACCTTAAACGATGCCTTCATAATCCTCGA +TGAAGCACAAAACGCAACCAGGGACCAGATGAAGATGTTTTTAACGAGGATAGGATTTGGCTCTAAGGCA +GTAATCACCGGTGACGTTACGCAGATAGACCTTCCCAAGAAAAAAGAGTCTGGACTAATAGAAGCTATGG +AAGTTCTCAAAAACATAGAAGGTATAGAGTTTATATTCTTCAAACAAACGGACGTTGTGAGACACCCGAT +AGTTGCTAAGATTATTAACGCTTATGAGCAGTACGAAAAGGCAAAAGAACAGAGTTCTGGTAAAACTGAA +GAAGAGGAAAGTAAGGAAGGACAAGATTGAGAAGTGGGCCGAGCTTGCCCTTTCGGCCCTCGGTCTCAAT +AACGTTGAACTCTCTGTTTACATAACAGATGACCAAGAGATAAGGGAATTAAACAAAACTTATAGAAAGA +AAGACAAGCCCACGGACGTCCTTTCCTTCCCAATGGGTGAGGAGTTCGGTGGATACAAAATACTCGGTGA +CGTTGTAATTTCTCAGGATACCGCGGAAAGACAGGCAAGGGAACTCGGTCATTCTCTTGAGGAAGAGGTA +AAGAGACTCATTGTTCACGGTATAGTTCACCTACTCGGATACGACCACGAAAAAGGCGGAGAGGAAGAAA +AGAAGTTCAGGGAACTGGAGAACTACGTACTGAGTAAACTCTCAAAAGCTTTGTAAGAACTCCTTGCGTT +CGGCTTGCTCACCACGAACTTAAATCCCATCTCATAACCTATCTCTTCAAATTCTTTAAACTCCTCTTCG +GAGTAGTACTTTACTACGGGATGGTGTTTTAAGGAAGGCTGGTAATACTGCCCTAGGACGAGAAAGTCGC +AGTCCACACTTCTTAAATCTTCCATAACTTTTATAACTTCCTCCTTCCTCTCGCCGAAACCTAAGATCAG +GGCAGACTTTGTGTAAACGCTTTTGTCAATCTCCTTGCTCCACTTCAGGATGTTTAAACTTCTCTTGTAA +TTAGCCCCTATCCTCACACTCGGGTAGAGTCTCGGAACAGTCTCAACGTTGTGGTTCAAAACCACGGGCT +TTTCCTTTAGGACAACTTCCAGAGCTTTTTTGTTTCCTCTGAAGTCCGGGATGAGAACTTCTACCTTTAT +ATCCTCAATATTCTCTTTTAGAACCCTTATACACTTTGCAAAGTGGGAGGCTCCGCCGTCGGGCAAGTCA +TCCCTCGTCACAGAAGTTATGACGACGTACTTCAGTCCCAGAGTCTTTACCGCTTCGAGGAGTCTGTAAG +GCTCTTCCGGATCTACACCCTTTGGAAAGCCCTTCTCAACGTTGCAGAAGGCACACCTCCTCGTGCACCT +GTTTCCCAAGATCATAAAGGTTGCGGTTTTGTTTCCGAAGCACTCGGATATATTGGGACATCTGGACTCT +TCACAAACCGTGTAAAGTCTGGATTTCCTGAGTAGCTTTTTTACTTCGTATAACTTCGAAAAGTGAAGGA +CAGGTTTCATCATAAATAGATTAAACTACTAAAAAGTAATGGGAAAGGTTATTCAGTTTCCCTTCGGAGA +AGAACCAGAAAAGAAAGAGGAGAAGGAACTAAAAACCGAACCCCTCACGGAAGAGGACTTCAATCAAGTT +ATAGAAGTGTTTAAAAAGGATTTAAAAACACTATACCCTTCGCAAGTGAAAGACATTCTCGGAGTTATAG +GCCTTGGAGAGAAGTACGGAGATGAAAAGTTCGTAGTCGGACTTTTGATGTGGGAGCATTACAAACACTC +CCACCCTCTGGTTTCCAGTTTCGTCGCCGTTTTAAAAGGAGACAAACTTGAGAAAATTTCGTTCCTTGAG +GCGAAGAACAATTACTGGGACTGGAAGTTAATGGTTAAAACTTATAAGGATAAATTCCACACCGAAGAAC +TTATGAGAGGCTTGTTTGAACTAAAGGAAAGGTTTGAAAAGGGAGAGATTTAGTTGGTAAGTAAATAAAA +ACTCTCTGATATACATCATAGAAATTAATTTACAACAAAGATCAAACTTTAAGTGTTGGGTTAATGATTA +TTAACTTTTAACCTTCCGGAGGTTCGAAAATGGATGCAGTACTCCTTGCGAGGATTCAGTTTGCACTAAC +CGCCATGTACCACTTCCTGTTTGTGCCCATAACTTTAGGACTATCCTTACTTCTTGCCATCATATGGACA +AAGTGGGCAAGGGAAGAAGACGACGAGAGGCACATCCTTTACGAGCGTATAGGTGAGTTTTTCACAACAC +TCTTTGCCATAAACTTTGCCGCTGGAGTAGTAGCCGGAATTGTTCTGGAGTTTGAGTTCGGTACCAACTG +GTCCGAGTACTCTAAAACGGTAGGTGATATATTCGGAGCACCTCTCGCGATAGAGGCTATATTCGCCTTC +TTCCTGGAATCTGTATTTCTGGGGGTCCTCCTCTTCGGAAGGGACAGAGTTTCTCCCAAGTTTTACGCTT +TTTCCACATGGATGGTCGCAATAGGGACTAACTTATCCGCTCTATGGATACTCGTTGCAAATTCGTGGCA +ACAAACTCCGAAGGGCTTTTACCTTGAAGGTGGAAAGGCTTACCTGGCCAGTTTCTTTGATGCTGTCGTA +AACTACTCCACACCTTACAGGTTTGTACACATGTTTCTCGCGGGAGTAATAACCGGAGCCATATTTGTGG +CGGGAATTAGTGCCTACTATATACTCAAGAGGAAACACCTTGACGTGGCTAAAGAATCTTTTAGGATCGC +GGTAACCATAGGAATGATTGCCTCCCTTCTGCAGATAATAGCGGGTGACCTACACGGGTATCAGGTTGCA +AGGACACAACCTTTGAAACTTGCAATGATGGAAGACAAGTGGGAAACGGAAAGTGGTGCCGGACTGGAAA +TTGTCCCGGGAATAGAGATTCCCAAACTTCTCAGTATTCTCGCCTACCACGACCCCGACGCCAAGGTTTA +CGGGATAAAGGACCTTGTTCAAACCTTCCAGAAAATAGCAAAAGGTGAAGAAGTGGGTGAAGACGAGCTT +CCCGAACTCTGGCTGGACCCCAGACAATTTGCTGGAAGACAGTCCCTTTACATAACAGAAGAGGAAATAC +CGCCCACCTGGATACCCTTTTGGAGCCTAAGGGGAATGGTATTCCTTGGATTCTTTTTCGCCTTCATAAC +TTCCCTTGGCTTTATCTTTACAGTTCAGGACACAATAGAGCAAAGAAGGTGGCTTCTTAAACTATTCTTT +TACTCCATTCCTCTTCCCATAGTGGCTAATATCTTAGGATGGATAGTGGCAGAAGTTGGAAGACAACCAT +GGGTTGTTTACTACATACTCAAGACAAAAGACGCAGCTTCCCCTCTTCCTGCAGGTCAGATACTCACCTC +AATAATTTTGTTCTCAAGTATTTACTTCATAGTGTTCCTTATATTCCTGGGACTTATGGTTCAAAAAGTA +ATCAAGGGCCCTAAGAGACCTGAGGAGGTGGCTTGATATGGAACTCCTTCCCGTGATTTGGTTCGTTTTA +CTTGGCTTTATAATAGCCATGTACGCCGCACTGGATGGCTTTGACCTCGGTGTCGGGATAGTTTATCCTT +TCTTGGCTAAAGATGAGGAAGAAAAGAGGATACTTCTGAACTCCATAGGACCCGTCTGGGACGCAAACGA +GGTATGGCTAATCCTGGCAGGCGGAGCTCTGTTTGCGGCTTTTCCCGTAGCTTACGCAACGCTCCAGAGC +GGTCTATACCTTCCCGTAATACTCATACTCTTTATGCTGATCCTCAGGGCGATAGGTATAGACTACAGGG +GCAAGATGCCAACTCCAGCACTGAAGAAAACTATGGACATGGTTTTCTTTTTAGGAAGTCTCGGAGTCAC +GTTTTTATTCGGTCTTACCCTCGGAAACGTTATAAAAGGACTTCCCGTAAAACTCGTTGAAAAGGAGCTC +TACGGCGAAGTGGTAAAAACGCACATGATATGTGCGGACCAGGACTGCAGTTACACGGGACTCCTGATAA +ATATACTTGATCCTTACGCCCTCCTTGTAGCACTCCTAACAGTTAGCTTTGTTGCAATGCACGGTGCTAT +ATATGCAGCTTACGTCACAAACGGAGACCTATCCCACAGGGCAGCCTCTCTGGCGAAAAAACTGTGGTTC +AACTCAGCACTCCTCTACTTAATCGTTCACATACTCACTATGATTTACCACCCACTCCTCATAAAGAACT +ACTTCACAAGGATGTTCATATTCCCCGCACTTCCCATAGTGATAGTTGCGTTCATAACGATTATCGTTGC +TCTAAACAGGCAAAAATACTCCCTTGCATTCTGGTCCTCAACTGCCATGATATTCAGTGCTATAGGTATA +GCCTTTGCAAGTATATACCCGACGTTAGTACCTTCTATATACGACGAAAATCCTTTTGAAAACCCGGTAC +ATTCAATAACAGTTTTTAACAGTGCTTCCTCTGAAAAAACACTCCTCACCATGCTTATAATCGCCCTGAT +AGGAGTTCCCATGGTTTTAACTTACAAGTTCTTCGTGTACAGGATCTTCTGGGGTAAGGTGAAAGTACCT +AAGGAAGGAGGCTACTGATCTTTTCCCCTTCCTTCAATTTCTTTATATACTCTTCGGAGAGTTCAACGAG +TACCGCCTCCTCATCGCAGTTTGGGAATTTAACGCAGTTTATACACTCACCCCAGACCTTGTGAGGCAGA +ACTGATTTGTCTATTTCTTTGAAGCCGAGCTTTTTGAAGAATTCCTTCACGTAAGTCAAAGAGAAAACCT +TCTTAATACCGAGTTCCCATGCGTCCTCCAACGCTCTGATAACGAGCTCCCTGCCTATCCCTTCCTTTTG +ATACTCCTCTTTTACCGCCAGACTCCTTATTTCCGCAAGGTCCTCCCACATAACGTGCAGGGCTACACAG +CCAACTACTTTACCGTCTTTTTCGTAAACCCAGAAATCTCTGATGTTCTCATATATGGAGTTAAGACTAC +GCGGTAGGAGAATTCCCCTTTTCGCGAATTCTGTGAGAAGTTCGTATATGTACTTGGCGTCGCCTACCTT +AGCCCTTCTAATCATTTTTCTAAATTTACTTCTTTTAAGAACTCCTCGCACCACTTAGATATACTTCCCG +CCCCTAGGAAGAGAATAACATCTCCTTCGTCGTGAACTTCCCTTACCTTTTCAAAAACTTCTTCTTTGTC +TTTTGCAAAGACGGCACCGCTTTTTCTGGCGAGTTCTTCTGCACTCACTCCGTAAACGTTGTTTTCGCTT +GCGGGGTATATGTCAGTCACTATTAATTTGTCTATGTCTTTAAGGACTTTTACGAAGTCCTCAAAAAGGT +AATAGGTTCTTGAGTACCTGTGGGGTTGAAAAACTACGAGAAGATTTTTGTCCGGGTACATATCCCGGAG +TGAGTTTATTACGGCCTTTATCTCCGTAGGGTGGTGTCCGTAATCGTCGTAAACGGGGGAGTTTTTGTAA +TAACCCTTCAGTTCAAGTCTCCTTTCCGCGTTTCTGAATTCTTCCAGTGATTTTTTTATAACTTCAAAGG +ACACTCCAAGTTCCAGAGCAACTCCCGTTGCCGCAAGGGCGTTGTACACGTTATGAATTCCCGCAATACC +CAGGTGAATCCTACCGAGTTCCTTTCCTTTAAACTCAACGCCGAACTCATATCTGCCTTCTTTCAGGTAC +AAATTCTTTGCCCTAACGAGTGCGGGTGAGTTTATTCCGTAGGTTATAACCCTCTCGTGTGATTTTTTAA +CGAGCTGGGCAAGGGTCGGATCGTCTAAATTCACGACCGCAAAGCCGTAAAAGGGAACTGAGTTCATAAA +CTGCTCAAAGGCTTCCTTTACACGTTCAAAGTTCTCGTAAAAGTCCAGGTGTTCTTTGTCCACATTTGTT +ATTACCGCAACGGCGGGCTGGAGTTTTAAGAAAGAACCGTCGCTTTCGTCAGCCTCCGATACGAGAAGTT +CCCCTCTCCCGAGTTTTGCATTCGTACCAAGCCTCTTTAGCCTCCCTCCGATTATTACCGTGGGTTCCAG +TCCCGCGTTTATGAGTATCTCAGCTATCATGGACGTTGTCGTGGTCTTCCCGTGGCTTCCGCTTACCGCT +ATGCCTTCCTTTAATTTGAAGAGTTCCGCGAGCATCTCCCCGCGCGGTATCACAGGTATGTTTCTCCTCT +TTGCCTCTTGAATTTCGGGATTATCCGGTTTTACCGCGGAAGAGTAAACGACTACCTGAGCATCTCCCAA +GTTTTCAGGTCTGTGCCCAATGTAAATCTTCGCTCCTTTTTGTTTAAGGAGTTTGGTGTTTTTATTTTCG +GAAATGTCGGAACCTGAAACTTTATAGCCCATTTCAAGGAGTATCTGGGCTATACCGCTCATTCCTATCC +CGCCTATTCCGATAAAGTGAAACTTCTTTATCCTTTCCCTCAGCATTACTCAACCTTTAGAACTACTTTA +CCGAAGTGTTTTGACTCTTCAAGGTACTTGTGTGCCTGCGGTACTTCCTTTAAGGGAAATACTTTATCTA +CCACCGGTTTAAACACGCCCCTCTCAAATAACTCCGTTATCTTAAAGAGGTTTGCCCTGCTCCCCATGTA +AACACCTAGAAGCTGTATTTCCCTGACGAAGACGTACCTTATGTCTATCTCTCCTTTACTTCCCGTAGTT +GTTCCGAAGAATACGAGTTTTCCCCCTTTTCTCAGCATCTGAACACTTTTCCAGAATGTAGCCTCTCCTA +TGTGATCAACCACGACGTCCACACCCTCTTTAAACACTTCCCTTACCTTTTTGACTACGTCGTCTTTGTA +GTGATTGAAAACAAGATCCGCTCCTAGTTCTTTACACTTCTTGGCTTTTTCCTCGTTTCCGGCTGTAGTA +ATCACGAAAGCGTTAAAGGCTTTTGCCAGTTGAATTCCCGCAACACCTACGCCGGAAGAGCCCGCCCATA +TAAACACCCTGCTGTAGGGCTTTATCTGAGCCTTATCAACGAGTGCGTTCCAGACCGTTAAAAAAGTGAG +CGGATAAGAGGCTGCTTCTTCAAAGGAGAGGTTTTTGGGTTTTTTAATAACATTCCTTGCGGGAACAGCC +ACGTACTCAGCGTAGCCCCCCTTGTTCTTAAGACCTAAGATGTCATAATCTTTACAATGGTTATCTCGTC +CGCTCTGGCAGTCCCAGCAAACCCCGCATGAAAGTCCCGGGGCAATTATCACCTCCTCTCCTTCTTTTAC +GTTTTTAACCAAAGAGCCCACCTTTTCGACTACACCGCTTACGTCCGAACCGAGTATGTGGGGAAGTTCA +GGCTTTACGGGAAGGGCTCCCATACGAACCCATATATCGAGGTGATTTAATGCTACCGCTTTTACTCTTA +TCAGTACTTCGTCTTCTTTGGGTTCTGGCTTCGGGAAGTCTTCCACGTACTTTAGGTTTTCAATCCCTCC +GAAACCGGTGAGGATAACAGCTTTCATAGTAAGATTGATTTTAAACGTTTGTGTCTATAAGGAAAAGCGG +TTGTCCGTACTCAACCGTCTCACCGTTTTCCACGAGGATTTTCTCCACTCTTCCCCTCACATCGCTCTCT +ATCTCGTTCATAACCTTTAGAGCTTCTATAATGCATAGAACCTGTCCGGGGGAAACTATATCCCCTACTT +CTACAAACGGAGGTGCTCCGGGAGCGGGAGAGCGGTAGAAAGTTCCGACGAGGGGACTTTTTATCACGTG +GTACTTCTTTTCTTCCTGTTCACCTAACTTTACATCTTCGCTCGGAGGTAGAATTTCCAGATGCTTGTAC +TCTTCCGTTTTCTGGGGTTTTACGCCCTCCGGTGGCTGGATTTCTTTGTAGGTTTCAATCTGGAGTTTGA +AATCGCCCTTTTCGATTTTCAAGCTCTTAACGTTGGAGTTCTTGATCAGATTAATGAGTTCCTTTATGAA +ATCCTTGTCCATCATTTTGCTTCTTTAACCCTCTCAACGTAACTTCCGGTTCTCGTATCCACTTTCACTA +TATCACCTTCTTTCACGAAGAAAGGCACCTGAATTACAGCTCCCGTTTCGAGTTTTGCGGGTTTTGTTCC +TCCAGCCTGCGTGTCTCCCTTAAAGGCTGGTTCTGTTTCAACGACTTGGAGCTCAACGTGTTTGGGAAGT +TCTATTCCTATCGGCTGTCCCTTGTACAGGAACACGATTACTTCCATACCTTCTTTTAAGAATTTAGCTT +CTTCTTCTATCTTCTCCTTCGGTACCGCTATCATGTCGTAAGTTTGCGTATTCATGAAGTAGTAATTCTC +ACCGTCGTTATAGGAGTAGGTAGCGTAGACCTGCTCAAAGTCAGCAAGAGGTATTCTGTCGGAAGCTTTA +AAAGTGAGTTCCGTAACGTTTCCGGTGAGCATGTTTTTGGCTTTTACCCTCACAAAAGCCTGTCCTTTTC +CCGGTTTTACGTGTTCGTAATCGAGAACCCTGTAGGGTTCGCCTTTGTGTTCTATAAAGATGTCTTTCTG +GATTCTGTTGATGTCTATCTCCGTCGCCATGAGGAGATATTTTAACTCAAGTGGAGGGGAAAGGGGACTT +GACGAGATAAGATTTTTTCTATATATTAATAATTTGGCAACGCGGGGTGGAGCAGCCTGGTAGCTCGCCG +GGCTCATAACCCGGAGGTCGCGGGTTCAAATCCCGCCCCCGCAACCATATCACCAGTATCTAATAAAATA +AAATCCCATGAAAATCCTGAAAGCCCACGAAATGTCTTCTATAGACAATAAAACTATAGAAGAAATAGGC +ATACCTTCCCTGGTTCTGATGGAAAACGCCAGCAAAGGTGTGTTTGAAAATATAAGGAAGTACTTTCCCG +ATGCAAAAAATATTTTGGTAGTAGCGGGAAAAGGGAACAACGGAGGAGACGGTCTTGCTTTAGCAAGACA +CCTTTACTTAAACGGTTTTTCCGTAGACATTTTTCTAGCTTTTGGAGAAGTAAAGGGTGATGCTAAAACC +CAGTTGGAAATTCTAAAAAAAATCGGGATAGAACCTCTAAAGAAAAAGCCAGATTTTAAAGAATACGACC +TTATAGTTGACGCAATTTTCGGGACGGGTTTCCAGCCACCTGTAAAGGGAGAAGTAGCTAATTTAATAAA +GGAAATAAATAATTCAAGTGTTCCGATTGTTTCCATTGATATACCCTCTGGACTTTCCGCCGATACCGGA +GAAAGTTTTGAACCTTCCGTAAAGGCTGACCTTACAGTTACGTTTCAATTTCCGAAAATATGTCACTACC +TTTACCCTGCGGCAAAAAAGTGCGGAAAGGTAGAAGTTGTGGATATTTCAATTCCCGAATTTCTGGCAAA +AGATGTAAAAAGGGATTTACTCCGAAAGAGCGATTTAAAACCTTACAAAAGAGAGCCGGATACGTACAAA +ACTAAGGAAGGTAGCGTACTTCTGGTAGGTGGAAGTGTTGGGAAAACCGGTGCTGTAATAATGAGCGCAA +AAGCGGCAAGCAGAGCTGGTGCCGGACTTGTTACCGTAGGAATTCCAAGGGAACTAAATCCTATTTTTGA +ATCACTGTTGATAGAAGAAATGAGCTTACCCCTTTCTGGAACCAGCAGGTTATCGGTTTTCTGTGTAGAA +GAAATTTTGGAATTAAAAGATAGATTTCACGCACTCGGTATCGGGATGGGAATGGATAGATATGAAGAGG +GACAAGATATAGTAATTAGCTTACTTGAAAAATGGGAAAAGCCTATTTTGATAGATGCAGATGGGATAAA +TAACTTGGCGGATTACGGAGATTACACACCGTTAAAAGATAGAGAAATTCCCGCAGTTCTAACGCCTCAT +ATAGGAGAGTTTTCAAGGCTTACAGGATACGACACTAAAACAATTACCTACAACCAAATAGATATTGCTC +AAGAATTTTCAGAAAAGAACAGGTGTTATTTAGTTTTAAAAGGTGCAAGGACTGTTATCTCTACCCCTGA +CGGAAGAGCTTACTTGTTTGCAGATGGAACACCGGCACTGGCAAAAGGCGGTACGGGAGACGTTTTGGCA +GGCATTCTCACGGCTTTAATCGCAAAAATGGATACAGAGGAAGCTTTAAAATTAGGTGTCTACCTCCACG +GACTTGCGGGAAAAGTAGCAGAAAAGAAGCTTCATACAGAAAGCGTAAAAGCTACCGATGTTACTGAGAG +TCTACCTGAAGCTTTCAGGGAAATTTATGTAAATTAATTTTTTAGTTTTAGTAAGACGGGGTGGCCGAGC +GGACGAAGGCGGGGGACTCGAAATCCCTTGGCGGGTTACCAGCCCGCCCGTGGGTTCGAATCCCACCCCC +GTCGCTTATTCCAAAAACATCGAAATACCTGCAATACCATAAGCTCCGTTCTTATAGCACACTTTTATCT +TTTCCCAAGTAATTCCTCCAAGGGCGTAGACTGGTATATTAACTTTTTCAGAAACTTCCTTCAGCGTTTT +TAAACCTATTGGCTGTGCTTCTGGATGGGAACTTGTCTTGAAAATGGGACTTAGTGTTATAAAATCTGCT +CCTTCTTTTTCTGCGTACTTTGCACTCTCTAAGGAATGGGCGGAAAAACCTACTATAAAGTTTGGATTTA +CTCTCTTTACCACGGAAGGAGGGAAACTCTGCTCTGGCAGGTGTACTCCGTCAGCCTCTACAGCCAGTGC +TATGTCAAACCTTTCGTTTATTAAGAGGAGCGCCTTATACTTTTTCGTCAAAGCCCGTACTTCCTTTGCA +AGTTTATAGAGTTCCCTGTCTTTTAAATCTTTTTCCCTCAGTTGAACCATCCGAACGCCTTTCTTAAGAA +TTTTTTCTAACGTTTCTAAAAAGTTTTCTCCGTACTTCTTCCTATCAGTTATCGCGTAAAGCCTTGGCAG +TTCCATAAAGGTTTAATTTACACGTTTCCTTTCTTCTTCCAAACGAGATAAATCGTAAGAATAACCCTCA +GGTTGGTTATTATCGCAAGAACTACGAACAGAGCTTTAATCCATCCAAGTATTGTAAAGATCATTATCAT +GAAGATGCGTTCATCCCTTTTTCCGAGGAGATAGCGAAGTTCCTTTATGACCGCGTAAGCGTCTTCACAG +TAGGCTCCTTTGTATCTCTCCGTAGAATAGCTCACCATAACGCTTCCAAATAGAGCTGCAAAAACCCAAG +GCATAAAATCCCACGAAGGTTTTAAATGCATGGCTAAAGCGCTTAAGAAGGCAAAGTCCACGTACCTGTC +GAGGACGGAGTCAAGCCAAGCTCCAAACTTGGTCGTCCTCATCTGAGCTCTTGCGACTTCCCCGTCGAGT +CCATCAAGCATGGAGTTTATTTGAAGGAGTATTCCCCCGAGAGCAGGAGAAAAGTAAGCCACAAGTGCGG +AAAACATACCGAGGAGAAAGGTAAGAACGGTAAGCTGATTAGGAGTAAACTTGTCCACCAGGTAAGGTGA +TATCCTCGTAGAAACCTTTCTGTTTAAATTTCTGGAAATAAAACCGTCTCCTACTCCTTTTATTGCAGTT +TTAACAAGATACTTTTTCGCCTTTTCTACGTCTTCTGGTGTGTCTACGTCCATCCAGAAGTATCCAGAAA +CCTCAGTACACGGAATTTGAGCTCTTTTTGCAAGTTCGCTCATCGTGAGTTTTTTCTGTTCTTTTAAAGC +CTCTTCTGCCACTTCAAATATACTCTCGTCCAGAACGAAAAATCCCGTATCAAAACCATCGTACTTTTCC +AAATTTTTTCCTATATATTTAATTCTTCCTTCTTCACACTTTACTTTCGTCGCTTCATTTTTGTTTATGT +AAAGCCCGAGTCTGTCCACGATTAACCCTTTCCCTTCTACTGCTTTTTCGAGGAATGCTTTCTCGTAAAT +GTGATCCGACATTACAACTGCAAACTCGCCTTTAATTCTTCCTTTTGCGAGGTAAAGGGAGTATCCGTTT +TCCTTTTCCGGATGCTCGTTCGGTATAACCTCCGCTTCAAAGTTATGTTCCTTTAAGAAGGCCTTTACCT +TTCCCTCAAACTTTTTATTTACAACGATAACGAAGTTCTTTACACCTACATCCTGAAGTTGCTTTATAGT +CCTGTATAGGAGTTCCCTTCCCGCAACCTTTAAAAGGGCTTTTGGCACTTCTTCTGTGAGAGGTTTTAAC +CTGTTTCCTTCACCTCCCGCCAGTATTACAGCAGTTTCTACCATTGCATTGGATTATTTTACTCCCCGTT +TTTTAAGTTTTTGTTTTTGAGGATTTCTTCTATACAAATCCTTCCCCTTACTACTATGTCTAGTACTCTC +AGAATGTCCTCTTCCAGAATATTTGAGAGCTTAACGAGTGCTTCTTTTAGTTCGGTTGTCGATATGCCTT +CCGTTCTTGGAAGGTAAACTACTTCACAGTACTCTTTAAGGTAATCGAACTTCCCCTTCCAGTCGTCTCC +CATAACGAATACATCAACGTTGTACTTCTTTATGTCCTCTATCTTCTGCTCCCAGTTCCTTTCGGGAATT +ACCAGATCCACATACTTAATGGAACGTACTATTTCCGCCCTGTGCTCGTAAGGGTAAACAGATTTCTTTC +CTTTTATAGCGTTAAACTCGTCCGTGGAAACTCCCACTATGAGAAAGTCTCCGAGGGCTTTTGCCCTCTT +CAGTAAGTTCAGATGTCCTATATGAAATAAATCAAAAGTTCCGTAAGTAATGACAACCTTTCCCTTTTTA +TTCATAGTATTGAGATTTTACACCCTGATGTTTCCTGTTAAAATTTTTTTAAAACTTTTGAGAGGTGATG +ATATGGAGATACAGACTTTAGTTCGTTCAGATAAAAAACTCACTCCTGAAAATGTAAGGGAATTTTTAAA +AGAAAATTATCCCGAAAAGTATAAACTCATAGAAAACTGGGAAGAACTGCAAGGAGAGTTTGATGTTCAA +AAGCTGGGAGGAAACGAGTACTTAGTCATATACAGAATCCCCGAAAAGGAGTTTGAAAAGGAACTCGGAA +TATTCCAAAGTGTTGAAGAGGCGATGGGTGCCTTCCTTTCCACAGCACTAGAACACGGATGGGAAGAAGT +CCCTAAGAACTACGTGATATACCACGCAGATTTTGTTGAAGGCGGAAACAAGTTAATAGCAGCGATAAAG +ACTGAAGAAGGTATATCTACTTACGACCAGTTGAAGTTAGAAGAGATGATGAAGAAGATGGTCAGGTATC +CGAGGGTTGTAGTTTACTCTTCAGACGTACTTACGTATATAAAGGATATATACCCCGACGTTCAGAGTAA +GGCTTACGTAATAGCAAGGGAAATCGCAAAGGAAACGGGAAGTGCCCCAGAACTCGAAGAACTCGGAAAA +ATATACGGCGTGGACACGTCTACTCTGGAAGGAAAACTGGAGCTTATAGAAAAGCTACTCCAGAACCCCG +TAAAACTTCCCGGTGGTAAAGAAGTAAACCTGAAACCGTACTGGTATCCTCTGGAAGCATGATAGCTTTA +ATCTTCTTCCTGATTCTTTCCTTCTCTGTTTCAAAGGAATTATTTTTAGAAGATCCCCTAAAAGAGTTCA +GTGAGTTTAAACTTTTCTTAAAAGAAGAAAGAGAATATAAAAGGATTTTCCGAATTTTTAAAGTAAAAAG +GGATTGCAGGTACGAAGTTGGATACGCCTCCTGGTACGGACCTAAATTCCACTACAGGAAAACCGCAAAC +GGTGAGCGTTTTAACATGTTCAAGCTTACAGCTGCTTCGCGGACGTTTTCCCTCGGAACTTACGTTCTCG +TTTACAACTTAGAAAACGGCAAATTTACTGTTGTGAGAATTAACGACAGAGGACCATACGTGGACGGAAG +GATTATAGACCTCTCTATGGCTGCTGCCGACGAAATAGGTATGCTAAAAAAAGGTGTGGCAAAGGTTCTT +GTGATACCTTTAAAGTGTCTCGCACCTTCCACTCAAGTAAAGATTTACGAGGAAGTAGTAAAGGACATAA +TGAAAACTTACTAAAATTTTCCTTATGGAAAAACCATGGTCGGGAAGGTTTAAAGAAGAAACGGATAAGT +TTGTGGAAGATTTCACGGAAAGTGTATCCTTTGATAAAGAGCTCGCCTTTGAAGACATAGAGCAGGATAT +AGCCCACGTAAAAACACTTCAGAAAGCCGGCATCCTCACGGAAGAGGAAGCGAGAGAACTCATCCAAGAA +CTCCTGAAGATTAAAGAGGAGATCAAAGAAGGGAAGTTCCAGTGGAAGAAGGAGCTGGAAGACGTTCATA +TGAACATTGAGGCTGAATTAATAAACAGACTCGGTGATGTAGGGAGGAAACTCCACACCGCACGCTCCAG +AAACGACCAGGTGGCAACCGACGAAAAACTGTACCTGAAGAAAGAAATAAAAGAGGTACTCCAACTCCTG +AAAGAATTGAGAAAGACGCTCGTTGAGCTTGCGGAAACAACTGTGGACTTCGTCATGCCCTCCTACACGC +ACCTCCAGAGGGCACAGCCCATCAGAGTAGCCCATTACTTTCTGGCTTACCGGGAGATTCTTCTTAAAGA +CTCGGAGAGGTTGATGGACACGTACAGACGGGTTGACGAGCTTCCTCTGGGTAGCGGAGCTGTTGCCGGT +GTAGACTTTCCCCTCGACAGGTTCTACACCGCCGAACTTCTCGGTTTCAACAGGGTAACGAGGAACTCTA +TGTATGCCACTGCGGAAAGGGACTTTATAATTGAATTTCTTTCAAATTGTGCACTCATAGCCCAGCATCT +TTCAAGGCTGGCAGAAGACCTTATAATCTGGAACACGGAGGAGTTTAACTTCGTGGAGCTTCCCGACAAA +CTCTGCACGGGCAGTTCCATTATGCCCCAGAAAAAAAACCCTGACGTTCTTGAGTTGATAAGAGGGAAAA +CGGGAAGGATTTACGGAAACCTGATCGCCCTTTTGACCACCATGAAAGCCCTTCCCATGGCCTACAACAG +GGACATGCAGGAAGATAAAGAACCCCTATTTGACACACTTAAAAACCTTAAAAACATGATAAAGGGTATG +ACTTTAGTCCTTTCAGATCTGAGGGTTAAAGAACAGAACATGAGAAAGGCTTCTGGAAACTTCCTGCTTA +TCACGGATATAGCGAACTACCTCGTAGAAAAGGGTGTACCTTTCAGGACAGCTCACCACATAGCGGGAAG +CATAGTTGCCTACCTACTTGAAAAAGGCAAGAAGTTAGAAGAGATGACTTTAGAGGAGTTCAAGCAGTTC +TCCGAAAAGTTTGAAGAAGACGTGTTTGATATTTTGAGCCCTGAAAGGGCAGCGGACAGAAAGAGGGTTT +ACGGAGGAACTGCGAAAGAAGAAATCTTGAGGATTATTGAGGTGGCGAAGGCAGAGGAAGGTTTATAAGC +AGTTTTTATGGCTTTTCTTATTTACCCTCAATTAAATTTTTGTTAAACTTAAAAATCACTTCGGGAGGAA +GGTATGCACAGTTTCTGGATAAACCTTCTCTTTGCAGTGATAAAGATCGTCGTTATACTTCTTATCGCCC +TTGGTATCGGAGCTTTCCTGACATGGGTTGAGAGGAAAGTCGCGGCACACATCCAAAGAAGACCTGGTCC +CATGGTTGTAGGATGGCACGGACTGCTTCAGCCCCTCGCAAACGGTTTAAAACTCCTGACTAAAGAAGAT +CTCTTCCCGAGGTACGGAGATAAATTCCTTTATCACCTCGCTATAATCCTCGCCCTCGTTCCGGCTACGC +TCGTGTTTTCTGTGGTGCCCTTTGGTCCTGAATTTGAAGTCTTCGGGTACAAGGTAAAACCGATACTTTC +TGACGTAAACGTGGGCCTCCTCCTCGTTTTTGCTCTCGGTTCTATGGCAGTTTACGCTGTAGCCCTCGCA +GGGTGGGCTTCCAATTCCAAGTACCCCCTCATAGCTTCTATGAGAAAAGCGGGAGTTTTAGTCTCCTACG +AAGTAGTAATTACCTTCGCCGTAATGGGTCCCATTATGCTTGCGGGTACTCTCTCAACTTACGAAATAGT +CCAGAAACAGATAGAGCAAAATTTATGGTACATATGGGTTCAGCCTATAGCCTTTGTGGTTTACATGTTC +GCAGCCCTTGCGGAAATGGGAAGAGTTCCCTTTGACGTTCAGGAAGCTGAGGCAGAACTGGTCACAGGAT +TTACCGTAGAGTACGGTGGTATGAAGTTTGGACTCTTCCCCCTCGTTGAGTGGTACATAGAAGTCTTACC +TTGTCTGCTATAGCTGTAGTTCTCTTTTTCGGTGGATGGTCTCCTATAAATATACCATTTGTAGGATTTG +TGGATCCTTTATTTTTCTTGGGTCCTCTATCACCCTTCGTGTGGTTTATTCTAAAAACTACGGCGCTCTT +CCTCTTTATCCTATGGCTCCACTGGACGCTTCCCAGATACAGGATAGACCAGATTACTCAAAACGCATGG +AAAATAATGCTCCCTCTTACACTCTTCAACATTGTTCTCACAGCTGTGTTAGCTCCAATAGTTTGGAGGT +GATCGGCCATGATTAAGAAGGTAGCTGCAAAGCCTCTCAGCTGGCTTGAGAGGATATTTTTCATAGATTT +CATAAAAGGTCTCAGGATTACATTAAAGAACGCCCTGAGGAAAACTATCACCACTCACTACCCTTACGAA +AAAATAACTCCGCCGAAACGCTTCAGGGGTTACTTTGCACACAAGGTGGTTGACGGAACGGAACCCCAGC +CGGCGTTTCAGGAATGGGTAAACAGGTACAACATCTTGGTTGAGTATGGAAAGAGCCGGTGTGTCGTGTG +CCTCAGGTGTAAAAGGGCTTGTCCTGTTCCTCAGCTCTTTGAAATAGAAGGGAAAAAACTCCCAAACGGC +AAAAGAGTTGTTAGCGTCTTTAACATGAACATGCTCCTCTGCACTTATTGCGGTTTTTGCGTGGACGCAT +GCCCTGTGGATTGCCTTTATCAAACAGACATACACGAAAATGCCTCTTACACCAGGAAGGACGCTGTACT +CACCCTTGAAATCCTTGAACAGATAGGCAGGGACTGGCAGAGAAGAAGGGAAAGAGAGCCCGACAGGATA +TGGATAGACGACGAGCAAAGGATGAAGCTGTGGGGTGAGAATAATGTAAAATTACCTAAACCCGAGGAGG +TGTGATGGGGAGACTGCTTATATTTGGATTCTTCTCTATTCTTGCTATTTTGTCCGGTATAGGGATAATC +ACGCTAAGAAATCCGGTTTACGTTGTAGTAGCCCTTCTTTCTTCCCTAATTGCGGTTGCGGGAATCTTCT +TCACCGCTGGAGCGGAACTTGTAGGAGCTCTCCAGTTACTCATATACGCCGTTGCGATAGCGGTGTTCTA +CATCATCGTGATAAGTGCCGTCCCGTGGGAAAAGGCGAAAAAGAGCGAATCCCACTACCGTTTTGAGGGA +CTAATCTCTTTACCCGTGGTTCTCTTCCTCTACATAGAGATGATCGTTGTCTTTCTACTTGGAGTTAAGG +CTTCTCCCGAGGGAAAAATAGCAAAGTTCATAGAGAAGTTCGGTAATACGGAAGTGATAGGTGCTATACT +TTTCAGCAAGTATTTTCTTGCCTTTGAGGTAGTTTCAATAGTTCTCCTGATGGGTATGATAGGTGCCGTT +TTAATAGGTAGAAAGGAGAGTCAGACCTATGAAGACGATACCGCTTGAGGCTTTCTTAACGGTAAGCATG +ATACTTTTTGGGCTGGGGCTAATAGGTATAATCGCCAGAAGGAATTTGGTTACCGTTTTGATGAGTTTAG +AGCTTGCCCTTAACGCTGTAAACATAGCCTTGGTGGGTGCTGACCATTACTTAGGTCTTGCGGAGGGGCA +GATATTTGCCCTCTTTATAATAGCCCTTGCCGCTACTGAAGCCGCTGTGGGTCTCGGGATTATAATCGCC +ATATTCAGGTTGAAGAAGGTAGAAAGTACGGACGAAATAAGAGAGCTGAGGGGCTGAGCATGGAAGGACT +GTTTGTAATATTTACGCCGCTAATAGCTTTTCTCATAATACTTGCATTCGGAAGAAAGATAGGGGATTTA +GGAAGCGGGATAATAGCGTCAGTAGGAGCAGGACTTACAACTCTTTTCTCTTTGGTAGTCGCCCTCAAAG +CCATTCACTCTCCTATTCACGTCAAACTCTACGACTTCCTCCCAATTGGCAATTACACACTCTCCCTCGG +ATTTTACTTTGACTCACTCTCTTCCTTGATGGCACTTGTCGTCACATTCGTTGCCACTCTCATATTCGTC +TACTCAATCGGCTACATGCGTGACGAGTTCGGTAAATGGGTCTTCAAGTTCTACGCTTACCTATCACTCT +TCCTCTTCGCTATGCTCCTTATCGTGCTTTCAGACAACCTCCTCGGAATCTTCTTCGGCTGGGAAGGTGT +GGGACTTGCTTCATACCTCCTTATCGGATACTACCACGAACAAAAAAAAGCTACAAAAGCTTCCTTTGAA +GCCTTCGTTATGAACAGAATAGGTGACTGGCTCTTTATCTTCGGTATCATCTACTCCTTTTACCTCTTCA +AAACCTTAGAAATCACTCAAATATTCCCGAAAGTCGAAGAAGTAGACAAGTACGCTCTTGGCGTTGCCAC +AATGCTCCTCTTTGGAGGAGCAGTCGGAAAGTCGGGACAATTTCCGCTCCACACGTGGCTTCCAAACGCA +ATGGCAGGTCCGACTCCCGTGTCTGCACTCCTTCACGCAGCCACGATGGTAGCAGCTGGTGTCTACATGG +TAGCAAGACTCTATCCCATGTTTGAAGCAACACCTCAAACGCTCAAGCTTATTGTTCTTATCGGAGCGAT +AACCATGACAATGGCAGCACTCGCAGGTGCTGTTCACAACGACATAAAGAAGATAATCGCATTTTCAACG +ATGAGTCAGCTCGGATACATGTTTGTTGCTCTGGGAGTGGGGGACAAGGGCGGAGCGATGTTCCACCTCA +CCACTCACGCTTTCTTCAAAGCCCTCCTGTTTTTAGCGGCTGGTGCTGTAATAACAGCATTCCACCACCA +CCTTTACGACATCTTCAAGATGGGAGGGCTAAAGAAGTACATGCCTGTGACTTATGTGGCGTTTATGATA +GGGGCGCTCAGTTTGGCAGGAGTGTTTCCCTTCAGTGGTTTCTGGAGTAAAGACAGGATAGTGGCGAGCA +TGTACGAGTGGAGCGGAGTGCTTGGAGTTCTTGGAACGATAGTGGCGTTTATAACTGCATATTACGCGTT +CAGGGAAGGATTTCTGGTGTTTCACGGAAGAGAGAGATGGAGGGAGATATACGATAAAGACGTTCATGAA +GTAGAGGGAGTGATGACGGTACCTATGGGGCTATTAGGATTTTTGACAGTTCTCACAGGGCTATTTGGCC +TTTGGCTTGAGCACTGGTATGTAGGCTTGATAGGAGGGGAGGAGAAGGGGATACACCTGAGTGTTGCGCT +AGTGTCGCTCGGAGTGGCAATAGCTGGGATATGGCTTGCGTGGGCGGTATATGTGAAGGAGGTGATAGAT +TACAACAAAGCATATGAGTCTTTGAAGTTTATACACACGACTTTCAAGGAGCAGTTCTTTACTGAAAAGC +TCTACCACAACGTTATTGCGGGTGGGTACCTCGTAGTTTCTAGAGTAGCTTACAAGGTGGGAGACAGAAC +CGTTATAGACGGCTTTATAAACGCCTTGTACAAGTACTTCTTTAAGTTCGTTAAGTTCCTGTGGAAGTAC +CTTGACATAAAGATTATTGACGTTCTTATACACGAGACTGTTCTAACCGCTTTCAGGCTCGGCAGGTTGT +CAAGAAGGCTTCAAACTGGGCTTGTGAACCACTACATACTGTTTTTGGCCGTAGGATTGACCTTTATCCT +TGGAATCATGCTCTATATACTGGATAGACTCTAAGGGGTGGTGATATGGAAAAGGTGGGGTTTGAGTTTC +CCATAATATCCGTTTCCCTGGCTATACCTGCGGTATTTGCCGTTCTCATACTCTTCTTTAAAGAAAAATT +CGCAAAATACATAGCCCTTCTCGGGACGGGACTTACCTTTCTCGTGTCCTTAATAGCACTGTTTAAGTTT +GACTTTGCGAGAGATAATGTAATTCAGTTTTACGAGGAGTACACAATACTCAAGGAACTGGGAGTAAAGC +TCTCCCTCGGTATGGACGGACTCTCGCTCCTTATGTACTTCCTCACCACCTTAGTTTCCCTTATAGCTGT +TATATGGTCCATAGGCGATGAAAAAATAAAGCATAGACTGAAAGAGTACTATATAGCCTTTTTACTTACC +GAAAGTTTTGTTATAGGTGTGTTTACTACGTTTAACCTCATCGTTTTCTACGTGTTTTACGAACTCACAC +TCCTTCCCATGCTCTTTGTGATAGGTATCTGGGGATATAAGCTCAGGCTTTACTCAGCTTACAAGTTCTT +TGTATACATATTTATCTCTTCTTTGTTCTTGCTACTCGGTATAGCCTCAATATCCACTTACCACTACAAA +ATGAACGGAAGTTTTACCTTTGAGTACCTTGAGCTCTTAAACTTGAACATTCCAAATGGTTTTGAGATCT +TCCTATTCTTACTCTTCTTCATAGCTTTTGCGGTAAAGACTCCAATAGTTCCTTTCCACACATGGCTTCC +CGATGCTCACGGTGAGGCTCCCACCGCAGGTTCTGTAGTTCTCGCTGCAATCTTACTTAAGATGGGAACT +TACGCTCTTGTCAGGTTCAACATAGGGCTCTTCCCTGATGCAGCTTTAGAACTTTCTCCCTACCTCGTGG +CACTTGGTATTTACTCCATTATTATGGCTTCATGGATGACAATATCCCAGACGAATATAAAACGTTTCGT +CGCTTACTCTTCCGTTTCCCACATGGGTTTTGTGGTAACCGCGGCATTCCTTCTAAATATGGAAGGTCTC +AGGGCGTCAATTATTGAGATGTTTGCTCACGGTCTTACAAGTGCCGGACTCTTTATGGTTGCCGGATACA +TATACAACAAGCTCCACACATTTAACTTCGCAAGCTTGAGAGGTGCTATAAAGTTCATGCCCTTGTTTGC +AACCATTACCGCTGCAACAGCCTTTGCCGCCATGGGTCTTCCCGGCGGTTCTTCCTTCTGGGGTAAGTTC +CTCACGATTTTGGCTGCAAGGGAGTACTCAACACCTTTAGCCTTCTTGGTAGTCTTTGCGGCGTTCTTCA +GTGCGGCTTACGTACTTTACTTCTTAAAAACTCTTTATTTGGACGTCAGAGAAGAGAGTGTACTTATTCA +CTTCAAGGATGTAAGCGGTTATCCCTTGGTGGCATTTTTGATGATCGTTATTCCTGTTCTATTGGTAGGT +TTTGTTCCGTTTATATTCTTTGCCTTCTACAACGAGTTCCTTGTGCACTTGTTAAAGTACGTTTTAAAAT +TGCCGTTTTAGAGGTGAGTAAAAGATGGATTTAAGGGCGTTAATAGGCGTAATAGAGATACCGGATTTAA +AGAAATTCCTCCCGGAGTTTATACTACTGCTACTTGCCTTTATACTATTCACATTAGAACTCTTCATAAA +AGGAAAAGAGCGGAGACTCGTCCTTAACGTTGTGAGTTACGTAGGGTATTTCTCCGTTTTAATGTCTTTG +TTAATTCCTTGGATGTACAAAGGTGACACCTTTTACGGGAACTTTACGAATGATCCGTTAGCGGTTACTG +TAAAAATATTCGCTGTTTTAATTACTTTAGCTATACTCCCCTTTGCAAGTTCCTACTTCTCCGCTAAAAA +ATCCTTCTACGGAGAGTTTTACTACATCCTCGCCTTTACACTTCTTGGGGTATTCGTACTGGCCTCCACT +TACAACCTCATAATCCTTTACGTGGCTCTGGAGCTCGTATCCGTCGGTTTTTACATATTGACTGCACTCC +TGAGAGGCTCTACGGAAGCGAAAGAGGGAGCGTTTAAGTACTTAATCTTAGGTGGTCTTTCTATAGCTCT +CGCCTCTTACGGTGCCGCTTTTATGTACATATACTCGGGTAGCCTTGACCTTCGTGAAATACTGACCTAT +CAGGGGAAAGATATTCACTATCTCGTTCTCGGACTCGTTTTCTTCCTTATAGGTCTTGCGGTAAAGATAG +GTGCGGTCCCCTTCCACTACTGGGTGCCAGACGCTTACCAAGGTGCTCCCACGCCTGTTACCGCCCTCAT +GGCGTCGGTCGGAAAGCTTGCATTCTTCATTCCACTTGTGAGGGTTATGCCTCTAGTTCAGGAAAAGTTC +TCGCTTGTCTGGACAATAACCGTGGGAGTTATAGCGGCACTTACAATGCTCTACGGTAATTTAGTGGCCC +TCGTTCAAAAGGATGTAAAGAGACTGCTCGCTTATTCCTCCATAGCTCACTCAGGTTACATAATGGCAGG +TGCTGCGGTTGCAAAAGTTATAGGTATGAAGGCGGTTATTTACTTCCTCGTGGCTTACGCGGTCATGTCC +GCTGGAGCTTTCTTGGTTTTAGCCCTCATGGAAAAGAATCCGGAATGGCAGAACTACATGGAAAACTTTT +ACGGACTCAGGTTTAACGCTCCTTACATTGCCTTTGCATTCTTCGTTTACATGGTTGCGCTCCTCGGTGT +TCCTCCCACGGTAGGTTTTGTAGGAAAGGCTCTGGTATTTATGGCGCTTTCCTTTGATAAACTCTGGTGG +CTTGCCTTTATCATGATACTTTCCGCTGCGATATCCACGGGATACTACATAAGACTTGTCGTGGTTATGT +ACATGCACGAGAGGGAAAAGGAAATACGGTCCGCCCCCTCTCACTTGGGTGAAAAGTTTTCACTCTTCGC +CCTGACACTTGCAAGTGTACTTTTAGGGGTATTACCTTCTTTAGTGTGGTTTCTCATTAAGCAATCTGCG +GAAAATCTTTTTACGGGGTGAGAGAGATGGAGTACGTATGGATTTTAGTATTTGCTGGAATTCTCCTCGT +TATAGGTCTTGTTATGATATCTCTTAACGCTCTGCTCGGACCCCGTGAGCCTCAAATATACGAAGACTAT +CCTTACGAGTGCGGTGTTCCCCTTTACGATAAAGACGCACAGACTACCTTCCATCAGGGTTATTACCTGC +TCGGTTTACTGCTCCTTCTCTTTGACATAGAAGCCGCTTTCCTCTTTCCTTGGAGCGTTGTTTACAGGTA +TTTGGGAGTGTTCGGTTTTATAGAAATGTTCATATTCATATTCATACTTACATACGGATTGCTGTACGCA +TGGAAGAAAGGAGCACTTGATTGGCAATTTGAAATTGAAGAGGTTTGAAGAGGTTAACTTAGTTCTTTCG +GGAGGGGCTGCCAAGGGTATCGCCCATATAGGTGTTTTAAAAGCTCTGGAAGAGCTCGGTATAAAGGTAA +AGAGGCTCAGCGGGGTAAGTGCTGGAGCTATCGTTTCCGTCTTTTACGCTTCGGGCTACACTCCCGACGA +GATGTTAAAACTCCTGAAAGAGGTAAACTGGCTCAAACTTTTTAAGTTCAAAACACCGAAAATGGGCTTA +ATGGGGTGGGAGAAGGCTGCAGAGTTTTTGGAAAAAGAGCTCGGAGTTAAGAGGCTGGAAGACCTGAACA +TACCAACCTATCTTTGCTCGGCGGATCTGTACACGGGAAAGGCTCTTTACTTCGGCAGAGGTGACTTAAT +TCCCGTGCTTCTCGGAAGTTGTTCCATACCCGGGATTTTTGAACCAGTTGAGTACGAGAATTTTCTACTT +GTTGACGGAGGTATAGTGAACAACCTGCCCGTAGAACCTTTGGAAAAGTTCAAAGAACCCATAATCGGGG +TAGATGTGCTTCCCATAACTCAAGAAAGAAAGATTAAAAATATACTCCACATCCTTATAAGGAGCTTCTT +TCTGGCGGTTCGTTCCAATTCGGAAAAGAGAAAGGAGTTCTGCAACGTAGTTATAGAACCTCCCCTTGAA +GAGTTCTCTCCTCTGGACGTAAATAAGGCGGACGAGATATTCCTGCGGGGATATGAGAGCACTTTAAGAA +TTATGAGAAATTTCGTAAAACATTAAGAAAAATTTATATAAAATTTCATTTATGGATTGTAAAGAGCTTG +CGAGGATTTTTTACGCCCTTTCGGAGCCAAAGAGGCTCTGTATGGTGAAGTTGCTTCTGGAGAGAGAGGA +ACTTTGTGTGTGTGACTTTATGAGGATTTTTAAGGAGTCCCAACCTAAGATATCCTTTCACCTTAAGGTA +TTAAGGGAAGCGGGGCTTGTGACTTCGCAAAAAAGGGGCAAGTGGAATTATTACCGCCTTAACAAGGAAG +CTCCTGTTATACCTTGTGTGGAAAAGCTCCTTAAAGATGTAAAGCTTGAAGAAAAAATCCAATTGGAGGT +GAAGAGATGAAGGAAATTAAGATTCTCAGCGGGACAAATTGTCAGAACTGTGAACTGCTTTATCAAGTCG +TTAGCGAAATCGTAAAAAGAAAAGGTATTGATGCGAAAGTTGAAAAAGTCGTGGACATTCAGGAAGTTTT +AAAGTACGGGGTGATGACCACTCCTGTTCTGGTCGTGGACGGTGAAGTAAAACACGTGGGCACACCCATA +CCAGCACCTCAGAAGATAGAAGAGCTTATCGGAGGGTGAGAGATGTTTGAGATTTACGAGAGATTTGCCG +ACTTAGTGGTTTACAATCTGTTAGGACTGCAGAAGGGCATGCATCTTGCGGAAGCCCTTCATTTTTTTGT +TTACGATACTCTGAAGATATTTACCTTGCTTACCGTTATTATTTTCGTTGTTTCCTTTATAAGGAGTTTC +TTTCCCCTTGAAAAGACACGGGAAATCCTTTCAAAACACAAAGCGGTGGCGCTTCCCCTTGCCGCTTTCC +TCGGCATTTTAACGCCTTTCTGTTCTTGCTCCGCTGTGCCGATGTTTATAGGTTTTGTAGAAGCGGGAAT +TCCTCTGGGAGCTGCCTTTACATTCCTTGTTGCTTCGCCTATGGTAAACGAAGTGGCTCTCGGTCTTCTT +CTAACACTCTTTGGCGTTAAGGTAGCCGTTCTTTACGTGATCTTTGGAGTAATCGTTGCAATAGTAGCGG +GCTACGTAATAGAGAAACTAAATCCCAGAGAACTGATAGCGGATTACGTATTTCAGGTAAAACTCGGCCA +AACTCAAATTAAAGAAATGACCTTTAAGGAAAGGCTTGAGTTTGCAAAGAACAACGTCAAAGAAATCCTC +GGAAAGATATGGATTTACATAATTATCGCTATAGGGATAGGAGGGTTTATACACGGTTACGTTCCACAGG +ATATAGTGGAAAGAGTGGCGAAAACCGCAGGACTCATAGCCGTTCCGCTGGCCGTACTGATAGGAATTCC +CCTCTACTCAAACGCTGCGGGAATACTGCCCGTGATACAGGCTCTAATCGCCAAGGGTGTGCCTCTGGGA +ACGGCCCTTGCCTTTATGATGGCTACAACCGCCTTGTCTTTTCCCGAGTTTATGATACTGAAGCAAATCA +TGAAGCCGAAGTTAATAGCATTTTTTGCGGGAATAGTGGGCATTTCTATAATAGCAGTGGGTTATCTTTT +TAACTTTATCTTCACACTCTGAAGAGTTCCGCCTTCCCTTGGCTTCCGTAAAGCCTTATCCTTTTCTTTA +CAATATTTTTTACCTCTTCCATGGCGGGTTTTAAGAACTTCCTCGGGTCTATTACCTTTTTTTCTAAAGC +CATTAATTCCCTCAGCTTTGAGATAAAAGCGAGCCTGAGGTCCGTATCCGTATTTACCTTGTTAATTCCA +AGTTCTACGGCTTTTTTCAATTCTTCGTCCGGAACACCTTTCGCTCCTTTTATATCCCCTCCGTACTTGT +TGATTTTTTCCACGTATTCTTCGTAAACGCCGCTCGCCCCGTGGAGAACCAGGGCAATACCTGTGAGCTC +CTTAACCTTTTTTAACCTTTCAAAATCAAGCTTTGGTTCTCCTTTAAATTTAAAAGCCCCGTGAGCCGTT +CCTATCGCGGGAGCCAGAGCGTCAATTCCTGTTCTATCAACAAACTCCTTTGCTTGCTCAGGATCCACCA +GAACTTCTTCCCTGCTTACAACTTCGTCCTCTACACTTACGAGTTTTCCAAGTTCCGCTTCAACGGATAT +CCCGAGAGCTGCACAAATTGATACGACATATTTCGTTACCTTTAAGTTTTCTTCATAAGATTTGTCTGAG +TAGTCTATCATCACCGACGTGTAGCCGTGTCTTATGGCGAGTAGGATAGTTTCTACATGTTTCCCGTGGT +CTAAGTGAAGTGCAAAGGGAATGGAATACTTGTCTTTTACCGCATGTACCATGCCTGCGAGATATTCAAT +GCCTGCGTACTTTATAGCGCTTTCTGTGGTTTGGATAAATACCGGAGCTTGTTCTTCTTCAGCAGCGTCC +AGAATTGCCTTGAGAAATTCCATATTGTTGAAATTGAAGGCACCTATTGCAAAGTTATACTCGTTTGCTT +TTTCAAAAAGAACTTTTCCACTAACTAAGGGCATAATAATTTATATGGTATAATTTTGAATAGCTCCTTA +GAGGGCTACAATGCCTCTTGGCTCCTTGGCAATTGAATAAAGCGGATTGGTCTAATAAGTGATGCTTTGA +TTGTGTGATGGATTGATATCATGATGCAATAAACTTTAATAGACTGAAAATCAAAGATAAAAATTTTACA +AATGTATGCTCAAGTTTGCAGAACTTGGGGTTAGCGGAAATTAACATTCGTTTCGTGAAGGTTAGGTGTC +TAATAAGTTATTGATAAAGCGTTATTTTTCAGACATAGGCGCGCAGGGTTCCTAATGTACCGTGTGGAGT +TGAAACTTTTCGTAAGCTCTTGAAGCGCTTGTTTAAGTTCCTGTTCCTAATGTACCGTGTGGAGTTGAAA +CATAAGTGCCTGCGTGTTTTGAAACTTCGTTAATTATAGTAAGCCCGTTTAAAAAATCTTGACACAGTGG +AAGAGAAGAAGTAGAAGGAAGGGAATGAGAACAAGAAATAACAAGCAATTGATAAAACTGATATTAACCA +AAAGCAGGGAAATATGCAATACCATTAGACCAAGTCAGTACAACAAAAGAGGAAGACCCAGAGTTTACGA +AGATCACCTCATAGTAGCAGCACTACTGATTAAGATCTTAGAAAACCTCTCCCTCCGAGATTTAGAAGAA +AGACTAAAAGACCTATTCCCCAAAGTACCTGACTTTACCACTCTCCACTACAGGTTCAGAAAACTAAACC +GGGGCTATCTCAAAGAGCTAATACACAGGACCGCAAAGGAGATAATGGAAAAGCTTCAGGCAAAAGAGTT +TTACTGCCTTATTGCTGACGGAACCGGATTTGGATATGCACAGGCATATGAACTCAAGTGGAAGAAGGGA +AAGGAACTTAGGAATGTAAAATCTCATGTGAAAACAGAAGTTCTTGTAGGAGTTGTAAGAAACAAAGCTA +TAGTAGTGGATATAAACACAGGCAAATCCTATGCAGATGAGAATATGCTGCTAAGATCCATGCTCAAAGA +ACTTGGCTTTAGAGCGAGGTATTTTCTTGGGGATGCCTACTATGGGAAGTCTGCAGGAGTTTTAGAGGAA +ATAAAGAAGCTACGGATGGAGTCTATAGTTCCGGTGAGGGATACTGCACATACAAGAGTTAGGAACATGT +ATAGGCTATGGGCTAAGAGGAATTATGAGATAAGGAGGAAGGTTTATAGAAAGAACAGGTACAGGGTTGA +GCAGGTGATAGGGATAGTTAAGAACAGGTTTGGGGACAGGGACAATGTTTATGACTTTGAGATTGCGAGT +TTGTATGTTCTAGGGAGGTTTGTTCTTTACAACTTGATCCTTCTTCTGAAGCTCCTTTTATTGTGTCTTA +ACCTTTTGAGGATTACATGGGCTTCCTCTCGCTTTATTCTCTAAGTCATGACGATTTTTTCAACAGGCTC +AATTATAGTTGACATTTCTAAAAACTTTTTTATAATAAGAAATGCACACAATTAGAAAAGGAGGCAGGAA +GGGAGCTTTTCTATTGTTGGAAACTCCCTCCCTCCCCCTCCCTCCCCTATAGTTTTTTGGCCCTCCGCCC +GGAGGGCCCTTTCTAAAGCAAGTGGTAAAATCTCCTTCATGTTCATTTACGAGAAAGTTTTCTTTATACT +TCTCATAATAGCCTTTGCATATACTCTCAAGAGGGGAGGTATATTTAAAGAAGAACACGCACTTCCGTTC +ATAAATTACGTTATTTACTTTGCCCTTCCCTTTACAATTTTCAAAAATCTCAGGTTTTTAGAAATAGGAA +AGGAAGTGCTCGGCGTGGTTTTAATCGCTTGGGGAGCTATATTTCTTTCCATTTTATTTGCCTTTCTCTT +CGGAAAATTCTTAAAACTTGAAGAAAAAACTCTGAGGGCTTTTTTACTTGTTTCTTCGTTCGGAAATACA +GCCTTTATGGGATATCCCTTTTTGTACGCTCTGGAAGGGAATGAAGGTTTGAAGTACGCCATTTTATACG +ACCAATTAGGTTCATTCTTAATGGTAATTACCTTAGGACTGTTTTTAGCGATAGGCAAATTTGATCTCAA +GGAATTAATTCTTTTTCCGCCTTTTATAGCTTTAGTATTGTCTTTTTTACTTCACGGGGTTCGTTTTCCG +CAGTTTTTTGAGCATTCCGTGGAAATAATTTCCGGTTCGCTTATCCCGGTTATACTCTTTTCTCTGGGAC +TTCGTTTAAATTTCACAGATATGAAGTCGGATTACAGAACACTTTTTTCCGCACTCTTTATAAAAATGTT +CTTAGTTCCTCTGTTAATTTTAGTTTTTTTAAAAATTTTTGGACTCACTTCCTTGCCATATAGAGTGGCT +TTAATCGAAAGTGCTATGCCCCCGATGGTATTTGCTGGCGTACTCGCTTTAAAATACGAACTGGACTTCA +GACTTGCTTTTTCCGCAATAACACTGGGTATTGTCATCAGTTTATTTACAGTTCCTGTGTTTAGGATCTT +ACTCTAATCTTTCTTTGCATTCTGTACATTTCTATAATTTCCTGTTCGGTGGTTGCGTCTTCCGGTCTTT +TGTCGAACCTGTACCTTCCGGTAAACCTCGGAAATCTCAGCCCAATTCCCCTGTTCGGAGAGACTTTTCC +CCACCCGCACGTGTGAACAGGACTCAAAGTAAGTTCAGCTCCCGTTATTTCAAGAACCAGATAGGGTTCA +AACCACATGTCCGCTTCGAGAATTGAATTTACCCTCGGGTGTCTGTGGTTCAGTTTCCTCGGCATGAGTA +TCTCTTCAAGTTTCTTGAAGTCGTCTTCGGTAAATCCCGTTCCCACTTTAGTCACTGTTTTAAACATGTC +ACTTTCAGGGTCGTAGCACGCCATCAAGAGAGAACCGAACGTTCCCTTCCTCTGTCCTTTTCCGTAAAAA +CCGCCCACGACCACAAGGTCAAGCGTGTCCGCAAGTACCGACTTGTAGTCTCTCTTGTACTTAATCCAGA +GAAAGCCTCTCTTTCCCGCCTGGTATATGGAGTTGGGAGCAAGCGACTTACAAACTAGCCCCTCACATCC +CTCTTCTATTGCCTGATAAAAGAAGTTTTCAAGATCCTCCACGTTGTCCACTATCTTTCTAGGAACGAGG +CCTATACGGTCCGTCCTCTTTACGACTTTTTCTAAGATTTCCCTCCTCTCGGGGTAGGGCTTCAGGGTTA +GGTCCTCACCGTCAAGGTATATGATGTCAAAGAGAAAGCCTGCAACGGGGTATTTCGTGATGTGGTACTT +CGTTACGTACTTTACTTTTCTATGCATAAGTTCCTGAAAGGGTCTTATCTCACCACTTGCGGGGTCTATA +ACAACCGCTTCCAGTTCAACTATAAAGTCGTGGGGTATTGCTTCTTTTAAAAACTCTATAAGATCCGGGT +ACTGGTGAGTTATATTCTCAAGTCTCCTTGAAAAGAGATAAAACTCATCTCCCTTTCTGTGGGCTTGAAT +TCTCTCCCCGTCGTACTTGTACTCCGCTCCGCACTTTCCCCCGAGCTTTCTGAGGATGAGTATGGGACTG +CTCATACGTTCTGCGAGCATGGGTCTTACGGGTCTTCCCACCTGTATCTTTACCTGTTTTACCCCTTCCA +GTCCTTTCTCCGCGAGGATTTTTGCCACGTAGCCGAGATCAGAAGTCAAGTTGTAGGCCCTCTCCACCAC +TTCCCTGTTTACAGAACTTCCCGTAAAGGCTATGGAAAGAGCCTCCAGTATGGTGTTGTCCCCTATTCCG +AGTCTCAGCCTTTCCGTTATCGTTCTCAAAAGGTACTTAGCTTCAAGAGGGGTTGCCTTTTTCAAAAGAG +ATGCGAATATGCTTATCTTTCTCTCCTGCGAGCCTATGCCTACGGCTTTTGCTATGTTTAAGAGTCCGTT +GTAAACCTCTTCTACGGTTAGCGTCCCTTCGGGTTTAAAGCCAAGCTCTTCGTAAAGTTTCCTTCCAGCC +TCTCCCAGATCTCCCTCTTGCCTAACTCTCTTTTCTATTTCCAGGGCGGGTATTTTGAGGACTCTGGAAA +GAGCCCTTATGGCAAGCTTTTCACCGAAGTTGTAGTCAAGTCCCGTGTACTCGGGAGCTATCTTACCTAT +TGATAGGTAAACGACTTTGTCTATTAATTCTTTAGGAGTTTGTTTGAAGAGCTCCACGAGGGAGCTCACC +ATTTCGATCCTGCTCGTTGTCTTCTCTATCCTCTCGTAAAACTCAGCCAGTATTCTGTATTCCATCACTT +GCTTGCAAGTTTTTCCTTAGCGTAAGCCATGAGCCCGCCTGCTTTGAGTATGTCCTGAAGCTCTTTGGGG +AACTTGGTCGCCTGATACTCCTTTCCAGTTCTCAGGTTCTTAATTACTCCCTTTTCGAGGTCAACTTCTA +TCTCGTCTCCGTGTTCAATTTCGTCTACTGCTTCCGGAGCTTCCACTATAGGGAGACCTATGTTTATGGC +ATTTCTGAAGAAAATTCTTGCAAAGGACTTTGCTATTACCACGGGTACGCCGGAATACTTTATGGCGATG +GGGGCGTGTTCCCTGGAAGAACCAGAACCGAAGTTTTTGCCCGCTACTATAATGTCTCCTTCTTTGTGCT +CTTTGGCAAACTCGGGATGTTCGCTGTCTTCCATGACGTGCTTTGCGAGCTCATACGGATCTGATGTATT +CAAGTACCTTGCGGGAATTATTTGGTCCGTATCTACGTTGTCTCCGAACTTCCAAACCCTTCCTCTAAAC +TTCATTTGCATAATAATTAAATATACCTTACCTAAGCCTAGAATTTTTTTAATATTTAAAATTATGATTA +TGAAATTTTTTAGTGAAAAGGCAGAAAAGAAGAAGGGAGGTGTAGAACCAGCTGTAGATGGTGTACTCTT +AGAGCCTTCAAGGGAGAACTTCACCGTATCTTCTTTCCTCGAAGTAATAGCAGACGTAGGAGACGAGGAG +GATTTGTACTTCTTTCAAAATAAGGCAGCTGAGAAGATGTCTTTAAAACTCGCAGAATACGTAAGGGAAT +TCAGCGGGAAGGAATCAGTCGGACTGTTTATTTCCTTCCTTAACTTCTTTCTGGAGAGAGAAAATCTCGG +AAGTGTGAATTACGTAAAGGTTGACCTTTCGAACAAAAAGTTCGTCGTTGCGATTGAGAACTCTGCCATA +GCTCTGGCTTTGAAAAAGAAGTACAAGAAGAAGGTTTGTAAATTCTACGAAACTCTACTTTCCGAGCTTT +TTTCCGATTTGATCGGAGTGGACATAAAGTTTAAAGAGATACAGTGTCTTGCAGAGGAGGGGCAGCGTGA +AAAGATTTGCATTTTTGAAAGTACTTAGTCTCCTTCTTTTAATTGCCTTGTCCTTTTCCCAGACCACATC +TGTAAAACTCTCGGAATTTCTCGGAAAGAATGTCCTCGATCTTAAGGGAATGGACGCAAGGGGTAAGCTC +TCCTTTCCGGTGAACCCGCTCTGGAACGTTGAGAAGATAAAGTTCTACATCTATTACAAAGCTTCGCCAG +TTTTAAAGTCCGAACGTTCTGAGATCACTTTATTGCTAAACGGAAAAGTAATTACATCCAGACAGATTAA +GGACGAGGGGTTAATAACCGTAGAAATAGAGAATCCTAAACTCTTTGATTTCAATACGCTGACTTTTAAA +GCATCACAACACTACTGTATAAATTGCTGTGAAAACGAAAACAGTCCTGAACTTTGGACGCAGATAGATC +TAAAAAAATCGTATATACAGTTTCAGTACACCAAAAAACCTTTTCCCGAAAACTTAGCCTTTTTAAAGGA +TATTTATCTATCCGAGAGACTGCTCAGTCCTGTGGAAATAGATATTCTGACGGATAAGGGAAGTAACAGA +CTCCTTACTGCAGGTGCGATATTTTCTGGGTACCTGGGTGCGAAGATAAAGTACAGAAGAATTTACGTAA +ATTACACGGAAAATCTCAGGGCAAAGGATACCGTTGTGATAGGTACGCAGGACTTTGTGAGCAGAGTGAT +CGGAGAGCGTGTATCGGGAAACATATACGTGACGCAAAACCCGAAGGATAAGAGTAAGTTCCTTTTAGTA +TTTACGGGAAGGGATGAAAAGGAAATCCTGAATGCAGTTAGAGCTTTTATACTCACTCCTTCTTCTTACC +TCTCGGAGAAGTTCGTTTACGTTAGTGACGTAGTCCTGCCGGAGATAAAAGCGTACTCGAGTCCCGTTCT +CTTGGCTCCGGGAGAGGAGATAACTTTAAGGAAGATAGCCGGAGGCGACGTAGTAGTCAGAGGTTACGCC +GGAAGATTCGATTTTTCCTTCTTCATTCCACCCGACTTAATGCTGAATCCGAAGGAAAAGTTGAGATTAA +AACTCTTTTACAACCACGGATTGCTAGTAAGGGAGGGCTCAACAATAAACCTTTACATAAACGGAAAGTT +CGTTTACTCCATTCCAGTTGATCCTTACGATAAGAGTGATTTAAAAGTAAGGGAAGTTTTAATTCCTACT +AGTGTACTAAATAAAGGTTTTAACGTCCTCACCGTTGAGTCTGCACTCGTACCGAACAAAGAGGACTTCT +GTGCAGCTGCGAATTTTGAAAGCCTTAAGGTTATAATCTACGGAAACTCCCTAATAAGTCTTCCCGACCT +CGTCCACTGGACAAAAATGCCCAACCTCGTTTACTTCATCTCAACCGGTTTTCCCTTTACGACTTACCCT +GACATGAAGGACGCGGCCGTTTTAGTTGAATCCACAGATGGGGAAACACTTTCCTCAATGTTTACCCTTC +TTGCCTTCATCGGAACTAAGATACAATTTCCCCCTCTCAGACTCAGTGTGTACGTAGATAGACTACCAAA +TGACGTTGCACAGTCCAAGGATGTAATAGTTTTCTGGAACAGAAATTCCTTAATAAAGAAACAAATACTG +AATTCTCTGGACAGTGTAGTCCTCGTAAAGGGAAAACTCTTTGAAGAAGATCAAAAGGAATTTTCCGTAA +ATCTCAGGAAGAGGGATTACGTCTTCACGATGGCTATGAGGGAGTCTCCCTTCAAGCCCAAAAGAACGAT +ACTGGTTTTAAATTCTAAATCTCCCGGTACACTTCACAAGTTCGTAAAAATGCTTTACGACCCCGTAGTC +CTATCTAAGATAAAGGGTGATACGGTATTTTACGACGAAAAAACAGACACAATCCTTTCCTCCTCTTCGG +GACAGGTTTACTACATAGGGCACATGCCCGTATACAAGAAGGTATACTACGAAATAGGCTACAACCTTAA +GTACCTGGTAGGACTGCTCTTAATATCACTCCTCGTACTCGCCTTTGCGACGAAGAAGCTCCTGGACTAC +AGGGCAAAGAAGAGACATCAGCAGGAAGAAAAGGAGGGTAAGGAGGAAGAGAAAAAGTGAAGTTCTTTAC +TGTTCTTTTGTTTTTCCTTTCATTCGTTTTTTCGGCGAGTATTGACGTGTGGAAATTGTGGGAACATTAT +AAAAAGACCTTTATAAGTAAAGAGGGGTACGTGGTAGATCCTTACAACAATTACAGGGTTACTTCGGAAG +CTCAAGGCTATACACTTCTCATATCCGCCCTCATAGGGGATAAGGAAACCTTCTACAGGGTATGGAACTG +GACAAAGGAAAATCTCAAAAGGAAGGATAATTTATTCTCCTGGCTCTGGATAAACGGACACGTAGTTGAC +AGAAACAACGCAACGGACGCCGACCTGTTCATAGCTTACGCTCTGCTAATCGCTTCTCAAAAGTGGAAGG +ATTATACGCTCCTGAGCGAGGCAAAGAGGATAAAGGATTCCGTCAAGGAACTCGTTGTGCCCGTGTGCAA +CGGAAGAAGGGATTACCTTTTTATACCCGCAAAGGAAGGTTACATTAAAAACAATATAGTGAGTTTAAAC +GTAGTCTACTACGTCCCATTCATCTTCAGAAAGTTCTACGAATCTTTCGGAGAGGACGTGTGGAAAAACC +TCTATAGGTACACCTACGACATTTATACGATTAGGAATATATCAACGCACCTTACATACGACCTATTCAA +AAAGGAATTGAGAAAGGGGAATTTTATAGACATAGACGGCATGCGTTTCCTGATATACGCTTACGTGGAC +GACAAAAGGAGTCTCCTTTACATGAGGAACGCAGTAGAGGGTATTCTGAAGTTTTACAGAGAAAAGGGTT +ACATTCCTTTGAAGTATAATTACGTAACCGGTGGAGCAAGCAAGTTAAAAGCTCCCTTTTGTTTTTACTA +CGTATTCAGTAAGCTCCTTCCTTCCGATAAAAACTTAGAAAAGGAGTTCAGAAATGGGCTTGAGTACGAC +AAGAAGAATTACTACTGTTACGCTCTGCTTCTTATTGCTCTCCTACACGATTAGCTTCGCAGTGTACTAC +GTTAAAGTTCTGGAAACTACCGATAAAGCGAAGGCGGACGCAGTGCTCTACGAACTGGTAAACAGCGGTA +TAGACAACTGCAATGTAAAAAAAGCACAGAATTACGTGGTGTTTTGCGGTCCTTACTCCTCGCTCGATGA +AGCGAGAACTGTATCTTCAAAAATCAACAAACTCGGTTACTTTACGGTTATAACGGAAAGAATTAAAAAG +GAAACTAAAAAAAGTGTAAGAAAGACTGTTGAAAAAACTAAAACTACCGTAAAAAAAAGAGGACGGGTAA +GGGAGGCCTTTTTAGGCCTAAAAGTTAAAGAGATGTACGACTACTTGAACGCAAACAAGTTAGTGGAAGC +CCAGACACTCGCGTACAGCCTCCTGAATACGGAATTCAGAAACGAAGCTATATTTGTACTTGCACTTATA +AACATGAAGAAAGGAAATCACGAAAAAGCCTGTGAACTTTTCTCAAAACTTCCCGATAAATTCAAACCCA +ATCTGGAAGAATTAAGGTCTATATCCTGCCTGTACGCGGAGAAAATAAAAGAAAAACCAGAAGTAAAGAA +GGAGGAAAAAACGGTTTACAGAGCTGATTTAACACAAGCCGGGAAATTGCTCGCACAGGGAAATCCAGAA +GAGGCCATCGAACTTGCCAAAAAAGTTCTTCTCTCCGACCCAACAAACGTGGAAGCCATGCTCATTATAG +GGGACGCCTACATGGAACTGGGCGATTACTCTAACGCCTACTCCTATTACAAAATGGCACTGGGTTTTGA +CAAGGAAAACTTAAGAGCCATTAAAGGTTTGATGTACGCTTCACTGGCGTTAAAGAGATACGAGGAAGCC +TACAATTACGCAAGGGAACTGGGGAGGTTGGGTGTTGAAAACGGAGACATAGAGAGGGTAAAAGCCCTGT +ACCTTGCAAAGAAAGCGGAAGATTTTGTTAAGAGAAAGGAGTACGACAAAGCCTATATTTACCTGAAGGA +GGCGGAGAAACTCGCTCCCGATGATCCTTACGTGCTTTTACTCCTCGGGGATATTTACTTCGGCAGGGGA +GATTACACACAGGCGTACAAGTACTACGTGGAGGCTTACAAAAGAAAAAGGGATTTTGACTTTCTTTTGA +AGATTCTTTACGCACTTGCTAACTTGAACAACTACGATCTTATAAACACTTACCTCTCCCAGATAGACGT +GTCGGAACTGAATGAAGCTCAGAGGAGGAAGTTAAAGAACTTTTACAAGGTACTTTACGTAAAGGCATCA +TCTTACTACCTGAGTCAGAAGGACTACGAAAAGGCTTACAGGATAGCGAAAGAAGGATTGATTCTTTTTC +CAAAGAATAGAACGCTGCTCAAAAATTTGGCATGGAGTTGCTTGAATTTAGAGGATTACAAGTGTGCTGA +AGAGAACTTTAAGAAAGCGTTAAGTCTTTACGAGAATGATTACGACGCATTGTACGGTCTTGCTTTAACG +TACGCGAGGGAAGGAAAGGAAGGCGAAGTAAACAAAATTGTGAAAAAGCTTGAAAAGAAGAGAGACAAGG +AAACCTACATGAAGATAGCGGATATATACGTGATCCTGGGAGATTACGACAGGGCAGAGTACTACCTGAA +TCAGGCTAAGAAATTGAGCAGGGCTAAGCCGGTAAAGATTAAGAGGGTCAAAATTCGCCCACGTGAAGAA +AAATTAAGAGAGGAAAGAGTAGAAAGCACGATCTTTTACAACCCGTTTATTAAAGGCTACGAAGGAGAAG +AGAAGGAAACAGAAAAGGAAAAGGAGGAAAAACTTTACCCTTTTGAGCTTGAAGAGAAGAGGATTTCGGA +GCTTGAAGAGAAGATAAAGGAGGCGAAGAAAAAGGAAAACACGGACTTTATAGAGTCGGGTATACAGTTC +AGTCAAAATCGGGAAGAAAAGGTATGGACAAGTTAATACACACGAGCGTTTACCTGAACGCAGAAAAGAA +GTTAGCGAGGGGGTTTTATCTGTGGACGGAAAACGATTTAATATTTCTCGATTCTGGCGGTAAACCTGAC +TACACGCACTTCGGTGGTATAAATCTTCCCGTTATAAGGGACACGGATACTTCTTTTATAGGAATTGAGC +CTATGGTAGGTGTAAGAGTTGGAAGGAAGAGTTACCTTAAACTCGGGATAGGCTCCACGCCCTTCGGAAA +CTCAAAGGTTCGTCCCACGTTTAGGGGAATATTCGAGGCAAATTACAGGGAAGAGGACATACTCCTCAGA +CTTACACTGAAACGGGACAGTGTAAGGGATTCCCTACTTTCCTACGTCGGGGCAAAGGATCCCCACGCAG +ACAGGGAATGGGGGCGCGTTGTGGAACAGGGAGGAGAGGTTAAGTTCCAGCTCGGTAGCGGATACAGAGA +AAGCTTCCTTTCTTTGAAAGGCGGTTATTACGACATAGAAGGTAAGAACGTGAACGACAATTCAAGGTAC +TTTCTGGAAATTTATCCTTCCCTTTACCTCGGTAATTTACTGATAGACGAAAACTACTTAGGTCTCTTCT +TCAGGTACGAGAACTACGATAAGAACGAAAATCTGTTTTACTTTGGAAACGGAGGTTACTTCAGTCCGAA +AAACTTTGTACTTTTAGGGCCAAAGTACACCGGTTACTTTTACACGGACAGGTTGATGTTCAGGCTGAAT +CTTCTTCTGGGATTCCTGAGGTTTGAAACGGACGGTGATACGACGAACACTCTTGCTGCAGACATCTCGG +GAGAGTTTGAGTATAAGCTGAAGGAGAAAATATCACTTATAGGTGGCTTGGGCTACAGAAATTCAAAGGA +TTACGACGAAGTTTCTTTAAACATGGGAGTAAAATACTACTTCAACGGTCTTGAAAGCCCATTCAGGTCT +ACGGTGGATAAAGTAGACGAGAGGTTGTTCAAATGATTATTCCAGTACTTTCCTCAAAAGGAGGAGTGGG +TAAGACAACTATAGCCACAAATTTAGCCTACACACTTTCCAAGAAAGCAAAAACCGTTTTGATAGACACG +GATCCCCAAAACGGAGTGGCTTCCGTTTTGTGCAAGCGTCACGATATCGGACTTGCGGACATACTACTCG +AAGGAACAAATTACGGGGAAACCCTCCGGCAGGTAAGGGAAAACTTTTTTATAATACCTACGGGTGCAAA +AGCTATAGAGAATGAGTTTTCCTTTAATGAAAGTTTTAAGTACGAAAATATTCAAAACCTCTGTCTTAAA +CTCGAATCAGAAGGAGGATTTGAGTTTATTCTTTTCGACACACCTCCGGGGTATACGGTTCAGTCAAACG +TACTCATGAAGTTGGCAGATGTAATTCTTGCGGTGTTCGAAGCTGAACCCGCTTCCTACGCTTCTTTCAA +GGTGTTCGAAACGCATATGTTTACAAAGGAAAAAGAAATTAGGGAAAAGTTGTGGTTAATAATAAACAAA +GTAAGGGCTTCGGAAATAAGCGAAGATTTTTCATTCATTTTCAGGTACGAGGCCGGAGGGAACATCCTCG +CCTACCTTCCTTACGACGAAGCCGTGTCCGTAGCCTCGGGGGAGTGCCTGCTCGTTGAGGAGTACAAACC +TGACTCTCCTTTTGTCAAGCTCATGTATGAATTAGTTGAGAAATTATTGACACTCCTTAAAAAATGAGTT +TTAACCTCAAAACTTTGTTTCTGTAAGTAACGCTTGCGTAGTCTACCGCCTTTATACCCTTTACTTTTCC +GTTTTTAAAGCCCTCAAGCTCGAGTACGTAGGTTATCTTATCCCTTTTGTAAACCCTGCACCTTACCGGA +ATAAATCCTTCTTTTTTGTTAAGGATGAGGGCGTAATTTACAGCGTCAGCAACGGAGTAAGGAAAGTAAC +TCTTAAAGGTTATTTCCCTTTTTGTGAGCTTTCCCTCAAAGGAAACAATGTCTTCGAAAACTTTTTTAAC +AGCTTTACATATTAACTCCTTTTCATTTTTTCCGTGAAGTACCAACTCCTTTCCGTTAAAACTTTCCACT +TTCTTTTTCACATTTCCTTTGTTTATACTTACTATCCTGTCCTCGATATAGTAACACGTTCTGAGGAATG +CCCCAGGATAAACGCTTTTTACTTGAGAAAGGTACTCTTTAGCTTTGCTTTTATTTTCCCACAAACCGAC +TCTTACGGTGTAATAATCTCCTATCTTTTCTATCCGTGCATGAGGGTAATCTGCGAGTTTTCGGTAAGCC +CTTTCAGCGGAACTAAGATCTCTCGAAGACAGAACCTGTATACAGTAATAAGCTTCCTTGGAAAAGGAAA +AGACTATTATTAAGAGGAGAAGGATAACCCCCATTTAATTCCCCTCCTTATGTAATTCCATACTGTATTT +AGGATATCATTTTTGAAGTAGTTGTATATGGATATGTAAACCTGTCCGAAGTCACGTAAAATTTGTTTCG +TAAGTACTACAAAACCCTCAAAGGGTGTTAATTCCCTTTCCCTTTCAAGGAGGATTACCCACCTGCTGCT +TGGAGCGTAAACTATATCTACTATCTTACTTACAGTTTCCACATCTTCAGGTTTCCATTCAAACTTCATT +CTGAGGATATTCCTGTCCTTTTCGTAGCGAACCACTTTCGGTTTTATGTACACCAGCTTATTTTCTACAT +TCCTTATTACTCCTTTTACTTCTTCACCTTCCTTGAATTCTTCCTTTGGTTTAGTTTCAAGTTTTACCGC +AAGTCCTCCGAGGGATATATCAATCACCCTTCCCAGAAGGGTTTCAGAGTCCCTGTAAATTATTATCTGG +TCGTTTGATGGTATTCTGTGGAATTTCCTTCTCTGCCTTCTTTCGTAAGAAACATAGAGTGCTACCGTCA +TAACAAAGAAGTTAAAAGTGTTCCACCACAAGGTAATCAGAACCGTTCCCCTCTCGTCGGGGTACTGTAT +CCACCTGTATATGCCGAATAAATAACCGAGCAGGATAAGGTGATACAGGATAAAGTAAGGTTTGTAAAAG +GGACTGATATAGTCCCTGTCTAGGAGTTCGCCCTTTGGTGTAACCCTGAAGGTGGGGTTCTTGGGATTTA +AAAGGGTAAGTATAGATGGAATAAAGATAAATATACCGAGTATGCTTTCGTATATCTCGGATATAAAAGG +CCACCTAACCCTGCTGAATAAGTAGTAAAAGAGTAACAAGCTTGCAAGAAAGTGGGGTATGGGATAGGCT +AGGACTTCAGCTAAAGAAGCGTCGTATATGTGAAGTCCGAAAAGGAGGTAAGCGAGGGGAGCTATAAGGA +ATATAGTCCTTGCAAGTCCGAAGAACCAGAAAAAGCTAGCGTTAAAGTAAGCGAGTTTTTGATACCACTT +CAAGCCCTTTTTAAGTATAGGGTTTTTGAGTATGAATATCTGGATCATTCCCTGTGCCCACCTTATCCTT +TGGACTATCATTCCCGACAGCGTTTCAGGGTTCAAACCGAATATTAAAGGTCTGTCGTAGTAAACACTTT +CGTAGCCCCTAGAGTGTAACTCTAACGCTGTTTCTGCGTCCTCTGTAACTGTTGTTGTCTGTATTCCCCC +CACTTCTTCAAGGTACTTTCTCCTCAAGAGTGCAGCTGAACCGCAGAAAAAGGAGGAATTCCACAGGTCA +AAGCCCTTCTGAATGAGGAAGTAAAACATTTCGTTCTCTCCGGGCATCCTTCCGAAAACACCGAGGTTTT +TCTCTATAGGGTCGGGATTGTAAAAGGTGTGAGGGGTCTGTACGAGAAATACTTTTGGGTTTTTAACGAA +GAATCCCACAGTTTCTTTTAAAAAGTCCTTTGAAGGAACGTGATCTGCATCCAATATAAGGATAAGGTCT +CCTTTTGTTTTCTTCAGGGCTTCGTTTATGTTACCTGCCTTTGCGTGTACGTTCTTCTCCCTTGTAAGGT +AGTGTATATTTTTGTAACCGAGTTTCCTCAGTCTTTCTACAAAGGACTTTAATTCCTCAGCCCTCTTTCT +GAAGTACTCCCTCCTTTCAGGATCGGGATCATTTAGTCTTTGTTTCGTTCCCCCGTCGTCGAGTATGTAA +ACGTTAAACTTATCCGAAGGATAGTCCATATTAATCGCAGCAAGTGCGGTAGTTTCTGGAATTTCGGGCG +GTTCGTTGTAGGTAGGTATGAACACGTCAACCGTGGGCAAAGATTCCATATCCACTTTTATGGCTTTTCT +ATCTATAGGTCTTATAGAGAAGAAAATACCGAGAAGTGCTATTGTTACACTGTAGAATTCTGCAAAGTAA +AGGGCTGTTGAGAAGATAAAGTTCCACACGTTGTCCGTGTTTATAGTGTTGAAAGTTCTCCACCAGAAGT +ACCTCAGCATTATAAAGACGAGCAGGTACACGGTAAGGTAATGGGTATAGCCGAAATTAAACCGTTTCCA +TACAATGAGAAAAGCTCCCGCAAGGAGTGTGGAGTAGGCTATGTAAAATTGAAATTCTAAGGGAGAAGGG +GCTACTATGACACTGAGGTAAGTGAGAAGTCCGAAAATAAAGGTGTACTTAAGAGCTTTTATAAATAAGT +TTTCGTCTATGTGAAGGTTAAACTCGAATAAAGTAAAGCGCTCTGTCATCAACTACTCCTATTTTTAAAG +ATATTTCTCAAGTCCTCTATAGTCAGAGTCCTTTTAAACTGCTTTTTTTCCGCTTCCCTTTTTTCTTCCT +CCTCCTCTTGAACTATGTGGTTTACTATTTTCCACTTTTTAGCTAACCTTTTGAACCTCGCCTCGTCCCT +GAAGGAGAAATCATCCATAGGTTATAGAATAATATCTTAGAGTGGGAAAGTATAAGAACCTTTACATAGG +ATGCAGCGGCTTTTCATACAGGGACTGGAAGGGAACCTTTTACCCTTCTCACATACCGGAAAGTGAGATG +ATAATTTATTACGAACAATTTTTTAACGTGGTTGAAATTAACTACACCTACTACACTATGCCTCATCCCT +ATACCTTCCAGAGTTTTTTGGAGAAAACGAAAAGGCTTAGGTTTGCGGTAAAGGCAAATCAGGTATTTAC +ACACGAGAGAAACTACACAAAGGAAGATGTAAAGAAATTCATCGAAGGTATTAAGCCACTCCTTGAGGAA +GAGGAGAGGTTCATAGCTATACTATTTCAGTTTCCCGAAAGCTTTCGCTACACCCCTGAAAACCTTGAAT +ATATTAAAAGGCTTTCTCTGGACTTTGCGGGAATAGACAGAGTAATAGAGGTAAGGCACAGGAGTTTTGC +AAACAGGGAATTTTACGAGTTCGTTGAGGAAGTGGGCTTTTCCACCCTCGTCAACGTGGACGCTCCGAAG +GTAAAGGGACTTTTGATAGGACCGTGGGTATCCGTGGGAACGATAAATTACGTAAGACTTCACGGTAGGA +ATAAAGAAAAGTGGCACGCACACAAGGAGGCTTACGAGAGGTACGACTACCTTTACTCGATAGAAGAGTT +AGAGGAAATTAAAGAAAAGATATTGAGGATTTACGAGGGAAAAGATACTTACGTGTTTTTCAACAACCAC +TACAGGGGCAAAGGAGCCCTCAACGCCCTTCAGTTAAAAGAGCTCTTCGGTGAGGAAGTTAAAATACCAA +AGGGACTTCTTTCCACTTTTGCACCTAAATTATGGGAGTAATTGGAGGTGTGGTATGGACAGGATAGCTT +ACTTCAAGAGTTTACTTGAGAAAAATCCGGACAACCCTATGGTTCACTATTCCCTAGGACTTGAGTACTT +CAAAGTGAAGGATTACGAAAATGCCATAAAGCACCTTGAGAGGTACTTAGAACTTCAGGAAGACGAAGGT +GCGGCTTACAGAACTTTGGCAAAGTGCTACGAGGAACTTGGAGAGTTCCAGAAGGCTATAGAAGTTCTGG +AAGAAGGAATAAGACAGGCGATGAAGTACAATCACCCCTCCATGGCTCAGGAGTATCAGCAGTGGATTGA +GGAGTTAAAGGGAATGGCTTTCTAGTCAGTCAGTTCTCCGTGCAGGTACTTGTCGTAAGCGGATAGGTCA +AAGTATCCGTGTCCTGAGAGGTTAAAGAGTATCACTTTTTCTTCACCGGTTTCCTTGCACTTTAGCGCTT +CGTCTATGGCTGCTTTAATTGCATGGGCGGACTCGGGTGCGGGAACTATGCCTTCCGTTCTCGCAAACGT +TACAGCTGCTTCAAAAACTTCCGTCTGCTTATACGCCACGGCGTCTATGTATCCCAAATTGTATAGTTTA +CAAACTAAGGGGGCGTCTCCGTGGTACCTCAGGCCTCCGGCGTGTATAGGCGAAGGAACGAAGTCGTGAC +CTAGTGTGTACATCTTTATTAAAGGCGTCAGTCCTACACTGTCTCCGAAGTCGTACTTGTACTCCCCCTT +CGTCAAAGTGGGGCAAGCTTCGGGCTCAACCGCCAGAACCTTTAAGTCTTCCTTCCTCTTGTCTCCCCTC +AGTACGTCCGCCAAAAATGGAAAGGAAAGTCCTGCAAAATTACTCCCTCCGCCCACGGCTCCGATAATAA +CATCGGGGTAGTAGCCGGCTTCTTCCATCTGCTTTTTGGCCTCAAGACCTATCACCGTCTGGTGGAGCAG +GACGTGGTTAAGTACGCTCCCGAGGGAGTACTTTGTATCCTCCCTGCTTGCGGCTTCCTCTATTGCTTCG +CTTATCGCTATTCCCAAACTGCCCGGATGTTCTGGGTTTTCTTCGTAGTACTTCCTTCCCGCGTTTGTGT +AAGGACTTGGGGAAGGTATCACTTCTCCTTTCCAAGTTTCCATAAGTATCCTTCTGTAAGGTTTCTGGTT +GTAACTCACGCGAACCATGTAAACCCTGCACTGAAGATCAAAGAACTGCGTTGCGAAGGAAAGAGCACTG +CCCCACTGTCCCGCTCCCGTTTCCGTAGTAAGTCTCTTTACTCCTGATATCTTGTTGTAATAAGCCTGTG +CCACTGCAGTATTGGGCTTGTGACTGCCGGGAGGGGATACACTTTCGTTTTTATAGAAAATCTTTGCAGG +CGTGCCGAGAAATTCTTCAAGGTTCTTAGCTCTGTGCAGGGGCGTAGGACGCCAGAGAGAGTATATATCG +AGAACCTCTTCGGGAATATCAATCCACTCCTTGTCTGAGACCTCCTGCTCTACGAGCGGTTCGGGAAATA +TAGCGAGTAGTTTTTCCGGCTTTACGGGTTCCATAGTTTCTGGATCTAACGGGGGTTCAAGGGGTTCGGG +GAGTAGCGGGAGGATATTTAACCACTTTTTAGGGATTTCTCCCTCCGAAAGAAGAAATTTTCTCATAATA +TTAATTTAGCTTAACGTAATCCCTATCCCTTTTCCATCCGCCGAAGTAATATAGAACCTTTTCCTCCGGA +AGCTTTTCCTTCGCACAATTCAGGGCGTAATTCACGTCAAAGGGCATCATGTCCGTCCCGAAAATGAGAG +GTGCCCCTATCTTATCCACAAGGTCTATCGGGTTAATCCTTTTCGTTCTCTCCTCACCGAGGGCTTCTAA +ATAAATTTCCCTATAGTAGCAGGTGAAGTTTGGTTGCATGCAGAGGAGCAAGTTGAGCTCTTTTACTCTC +CTTATCTGGTCCTCACTTATTAGTTCCGCGTGTTCTATACGGTGGTACTTGAGCTTTGGCTCAAGTTTTT +CAAAAGCCTTTATGGCGACCTCTATCGCTCCGTCCCCTATGGCGTGAAGGGAAGCCCTTAGGTTCAAACT +CTCCAGTTCCTTCAAGATTTTTAAGAGTTTCTCTTCAGAGATTAAAAGTTTTCCTTTTGTTTTAGTATCT +CTGTAGGGCTCCTTCAGGTGAGCGGTTCTGGCGGAAATAGAGCCGTCAAGGTAAACCTTCACCCAACCAA +GTTGGAGTTTCTCACTTTCCCCTTTTTGTTCAAATAGTTTTAAAACACTTTTTAAACTCTCGTAGTAGGG +CATAAGGACCACGTTTATCGGAAGCTCTTCGGAGAAGTAAATCCTTGCAACTTCCTCGTCAACGTAGTCG +TGAACCTCTGAAATTCCCATCTCCTTTGCCTTTTTAAGGGCATTCCTTATTGCTTTTCTCAGGGCTTCAC +CCTTTGGTTTTAACTTGTTTGCCGCTTCCCAGAGTTCGTGTTCCACAAGGAAATAGCCCTCTTTATTCAG +GAGTTTCTTCATATGTTTGTTCAAAATCCCTTTGTGTCCGTCCTTGTAGATTAGGAGAAGAGGGAAGTTA +ACGGTGTTTAAATCTTCGGGCGTAATTCCCAGACCGTAATCAAGTCCGTAGGCAACCAGATAATCCCTTT +TTAGGGATTTCAAAAACTTTAAGAGCTCTTCCTTTTTCTTGAATTCGTGAAAAGGGACCTCAGATATGGC +GAAGAGCTCCAGGTGCGTGTGGGCGTCTACGAGCATAATTTAAAATTTTCTTTATGGAGATTAAAGAGTA +CAACCCGAGGGAAATAGAGGAAAAGTGGAGCAGGTACTGGATAGAGAAGGCACTCTACCACGTGGAAAAA +CCCGATAAAAGGAAGAAGTTTTCCGTTGTTATACCTCCGCCAAACGTCACGGGTTCCCTTCACATGGGAC +ACGCCCTGAACGCAACCCTTCAGGACGTTATCGTGAGATGGCAGAGGATGAGAGGAAGGGAGTGTGTATG +GGTTCCCGGGTTTGACCACGCGGGTATAGCGACCCAGTACGTCGTTGAAAAGCAGCTCGCAAAGGAAGGA +AAGAGCAGGCTTGAACTTGGTAGGGAAGAGTTTTTAAAGAAGGTATGGGAGTGGGTACCAAAGTCCAGAA +ACGCAATAAGGACACAACTCACAAAACTTGGTGTCTCCGTTGACTGGAAGAGGGAACGCTTTACCTTGGA +CGAGGGATTTTCAAGGGCGGTAAGGAAGGCTTTCAGAACACTCTTTGAAGAGGGTTTAATATACAGAGCG +GAATACATAGTAAACTGGTGTCCTAATGATAGAACCGCACTTTCGGACCTTGAGGTTGAGTACGAAGAAG +AAAAGGGAAGTCTCTGGTACATAAAGTACCCCATAGTGGACGAAAACGGAAAGGACACGGGAGAGTTCAT +AACCGTTGCAACCACGAGACCCGAAACAATGCTCGGAGACACGGCGGTAGCGGTGAACCCGAATGACGAT +AGGTATAAACACCTTGTAGGCAAAAGGGCTAGACTTCCCCTTGTCAACTGGGAAAGGAAGGATCTTAGAG +GAAACTCCGTATCAAACCTCATTCCCATAATAGCGGACGAAAGGGTAAAGATGGACTTCGGAACGGGAGC +GGTGAAAATCACCCCCGCCCACGACCCTCTGGACTTTGAAATAGGAAAGACCCACGACCTTCCCTTTGTA +AGGGTCATAGACGAGACGGGAAGGATGAACGAAAACGCGGGAGACTTTGCGGGAATGGACCGCTACGAGG +CAAGGGAAGCCATAGTCGCAAAACTGAGAGAAGACGAACTCCTGGAAAAGGAAGAGGAAATCACCCACTC +CGTAGGGCACTGTTACAGGTGTAAGACCGTAATAGAACCTATGGTCTCGGTTCAATGGTTCGTGAAAGTC +TCCGACCCCAGAATAAAGGACATTTCCATAAAGGTAGTTGAAGAGGGAATAAAGGAAAGGGAAGAAAAAG +AACTCTTCGTTCAACTCGCACAGGTAGAGGAACTCAGCGTAGTAATTCCTCTGAAGGAGGAAGGAAGGCA +CAAGATAGTAGTAGTTCTGGACAAAACAGCCAAGTTTCTTGTCGGAAAGAGAGAAGGAGAGCTCGCATAC +ATATACTACCCCAAGGGTGATGAGAGGACCCTTGAATTCGCAAAGAGACTCGCGGAAGAGTTCAAAGACT +ACGAGTTCATGGTCGCGTACGAGGGACTTCCAAAGATAGTTGTAATGGGAAACGAACAACTGGTAGAGCC +TGGAAGCTACCTTTTTGTCTACGACGGTAAGAAGCTTGACCTTTATAAACTGGAAGGGGAAAAGCCCAAG +TTCTTGAAAACCCTCGGAAAGGGAGAGGCGGATTTAGAAGTAACCCAGAAGTCAATTCAGATAAAACCCG +AAAGGATTAAGAAAGTAGAGGAAAGGGAGAAGAGGGTAAAGTTTATTCCCGAACACTGGAAGAAATTCTA +CCTTGATTGGATGTACAACCTGAAAGACTGGTGTATCTCAAGGCAGATATGGTGGGGCCACAGGATACCG +GTTTGGTATTGCAAGGACTGCGGGAACGTAAACGTCTTCACGGACGACGACTTTGATAGGGCACACGACA +AGATAATCTTCAACCTTATAGCGGACGGAAAGATAGACCAAGAGTTTACCCCTGAAGAAGTAGAAAAGGT +GTTAAAGTCCCCTCACTTCGTCCACCCCGAGATGACAGTTCTTGACTTTTACAAAAAGTTCGTCTTTCAC +AGATACTACAACATGGACATAACCGCGGATTCCCTCAGACTCCTCTTTACTCAGGACATGAACCCTATGG +CCATGCTCACTCCCGGCGTGTCCACGAGGAACATTTACAAGTACGACTCCCAGAAAAAGAAGTGGAAGAT +GGTTCTCAGGTGCAAAAAGTGCGGTTCTGAGAACTTAGAACAGGAAAGGGACGTTCTTGATACGTGGTTC +TCTTCGGCTCTCTGGCCTTTTGGAGTGTTCGGCTGGCCCGAAAGCACGGAGGACCTCAAAAACCTCTACC +CCACGGACTTGCTTGTCACGGGCTTTGACATAATCTTCTTCTGGGTTGCGAGAATGATTATGATGGGAAC +GCACTTTATGAAGGACATACCCTTTTATGATGTTTACGTTCACGCCCTCGTGAGGGATAAATACGGAAGG +AAGATGTCTAAAACCATAGGAAACGTAATAGACCCCCTTGACATAATAGAGCGCTACGGAGCGGACGCTC +TGAGGTTCACGCTCGCAATCCTGACCGTTCAGGGAAGGGACATAAAACTCGCGGAGGAGAAGTTTGAAGG +ATATAAACACTTTGCGAACAAAATATGGAACGCCGCAAGGTACGTTTTAATGAACACACCGGAGGACTTC +ATAGCGCGAATTCCCTACATGGCACCCTTGAAACCCGAAGACAAGTGGATAATAACGAAACTCAACGAAA +CTGCGGAGGAAGTAAACAAAGCCCTTGAAAATTACCAATACTCTCAGGCGGCTCACGCCATATACGAGTT +CTTCTGGAGCGATTACTGCGATTGGTATATAGAGTTCACAAAGGAAAGAATTTACAAAAAGGCCCCGGAA +GATAACGAAGAGGAAAAGGCAAAGGTGGAAAACGAAAGGACTACCGCACTCTACACCCTTCACTACGTTC +TGGAAAAAGCCCTCAGAATTCTCCACCCCTTCATGCCCTACATAACCGAGGAACTCTGGCACAAACTCCC +GAACGCCGAAGGAGAGAGCATATCCTTAGCGGAATTTCCCCAGAAAAACGAAGATGAGATATACGAAGAG +GACAAACAGAAGGTTGAGAGGTTAAAAGAAATAATCTCTGCGATAAGGGCTATCCGTTCGGACCTCCAAA +TAAAACCGAGCGAAAAGATAAAGGCTTCCTTTAAAACTGAGAGCGAGTTTTCCAGAAGAGTAATTCAAGA +GTTCAAGAACCACATACTCAACCTCGCAAAACTTGAAAGCTTTGAAGAAGTCTCTCAAAGGCCTCAGAAC +ACCGTGGCCACATTCTCAAAGGACACCGAGATATACGTCCACATAGAGGGACACGTGGACCTCGATAAAC +TTATTCAGTCTTACGAAAAGAAGAGAGAAAAGCTTTTAAAAGAACTTGAAAGGGTAAACAAGAAACTTTC +TAACGAGAACTTCCTGAAGAAAGCTCCCGTGGAAGTTGTTGAGAAAGAAAAGCAGATTAAGGAAGAACTT +GAGAACGACTTAAAGAAAGTTGAGGAAATCCTGAAGGTTCTCCGCTCCTGATTTTTACTTACTTTTCTGG +CAGTCTTCGCATATACCGAAAATCTCAAGCCTGTGGTGAGCGGGCTTGAAGTTGTACTTTTTGCATATTT +CTTCCTGAAGCTTTTCTATCTCCTCATCAACGAATTCTATTATCCTCCCGCATTCCGTGCACACCAGATG +GTCGTGGTGAGAACGTCCAATAACGAACTCGTAAATGGTTTTATTGTCCTTTTTTATTACTTCCTTAACA +GCTCCGAACTCTTCAAGGAGTTTTACGGTTCTGTAAACGGTAGAACGTGAAACTTTTTTATCCTTGTGAT +TTGCAATCCAGTTTACTAATTCCTCAATCTCAAAGTGTTTGTTGTAGTCCGCTATAAGGTCTATGAGGTT +TAAACGGGATTTGGTTACTTTCATGTTCTTCTTTTTCAAAAATTTAGTAAACTCCTTCTTTAGTTCTTCA +ACGTTTACCCTCATTAGTATCATAATATATTAATAATGATTTTCAATTGCAAGAATTCTTTTTAAGTCTT +CCTTTGTATTCATGTTAAGTAGCGTGTATCTAAGCTCTTCTGGTATTTCCACCTCGTTGTATCCGACATC +CTTTAAAAGAGCCCATATTCTGTAATCTCCCTTTTTTATCCTTTCTTCAATTTTTTCTAAAAGTTTTTTT +GAGTAAACACCTACGAGTGTGTGCAGCTTTTCCGTTTTTGCCACGCTTACGGGTTCTTTAAAATTCTCAA +GGACGTAAAGTACAGTCTCCTTTTTCATTAAGGGAAGGTCACCAGAAAGTACAAATACGTTTTCCTCTTT +TGCGTGTTTTAGAGCGGTATAAAGACCAATTATAGAAGCACTTTCTTCAAACTCGTCCAGAACCACGGGA +GCGTTTAAGAAGGAAAACTTCTCTCTGTCTTTTGCCACTATGTAAACCTCTTTAAAAACGCTTTTTGCTG +TTTCGTACACCCTTTCTATGACTTTTTTCCCCTTTATCTCATAGAGTAGTTTGTCCTCTCCGAATCTTTT +ACTCTTCCCTCCCGCGAGCACGTAGCAGGTATTCACCTTTGACAAGCTTCCTTTCCTCCACGTAAACGTT +CGCATTTTTGGGAATTTTTCTTCCCCTTATGTGAGGATTTAAATCCCTGAACCTTGACTCGTTCATGGAA +TACATTATCAGGAAATCCTCAACGCTCATAGGTATGCCAACCTTTACTATAGCAATTTCTCTTGAGGGTT +CATAAAGATGTATTCCGTAATATTCAGGGTTTTGAGCAATTAGAAGCGTTGCAAGAAAGAGAGGAACGTA +ATTCTGAGTCTCTTTTGGGAGCTTTCTCCTCTCTTTCCAGAAATTGTAGTTTACATTTCTCCTTATGCAG +TTTTCACCGCAGTTGTATGCAGCGAGGACAAGCTCAAGGTTTTTGAACTCTTCAAGCAAATCCCTCAAAT +ACTTTGCCGCTGCGTGGGTGGACTTTACCACGTCAAAACGCTCGTCGTAATCCTTCCTGACTATAAGTCC +GTACCTCCTTGCAGTTTGTGGCATGAGTTGCCAGATTCCCGCGGCTCCGCTCCGCGATACCGCAAAGGGA +TTGTACATACTCTCAACAATCGGAAGGTACTTGAACTCCTCGGGCAGTCCGTAGCTCCTGAGTATGGGGA +CTATTATATTTTCGTAAAGCTTCATTCTGTAAAAGGCATACTTCAAGGATTCTCTTTTGGTGAGTAAGCT +CTTCAAAGCTCTCAGAACTTCCGGTCTATTCACTTTATTTACGTAAAGAGAACGACTCAATTTAATTATG +TCTTCCTCCGAGAGGGCGGGTTTTCCTTCCTTAATTACGACGTAGTTCCTGTTTTTCAGAACTACTTCCT +TGGTCTTCGGTGTGCATCCCCCCACAAGGATAAGTATTATTGTTAAAAAAAGCAGCATTTTACTTTAGAT +TATATATCCTATGGAAAACGTAAAGGAAGACAGGACCTTGGATCTATCTGGGCTCAGTTGTCCTCTCCCT +GTCGTTATGACATCTGAAACGATGAGAAAAATGGAAGAAGGGCAGGTTTTAAAGGTGATTTCCACGGATC +CGGGTTTTGAGAGGGATATATGGAGCTGGGCAAAGCAAAGTGGGAATATACTTCTCAAGGTTGAGAAAGA +AGACGGAAAGACGATAGCTTACATAAAGAAGGCAAGCGAGGCACACGAGCCATCACTCTGGTACTGGATA +AAGTTCCACTCCTTAGGTGTAAAGCTCCACATAAGGCAGTTCTGTATACAGATAAACCCCTTCGTAAAGA +AACCCACGCACTTTATAACCTTCAGTGCCATCTCCGAAGGAACGAGGGCTGAAAAAGAACTGAAAAAACT +CGGTGAGAAAGATGCAGTTCTGATACCAATTCCGGATGAAATAGACCCGAGGTGCGGAGTTGTTCTCGCT +GTTCACGGCGAGAAAAAGGCAAGGGAGATTTACGAAAAGTTAAAGGATATGGACATAGCGGTTGAAGCCA +TTTACGAAAAGAAAGGAAAAGAGTACGAGAGAGTTTACCCTTAAGCCCTCGCTAAGTTCTTCCTCTTTTT +GTAAACGAATTCTTTTAAGCCTTCTAAATCAAAGGTATTTATTACTTTATCTGGCGTAGCCCAACCTCTC +CTTGCGAGTCCTACTCCCAGAAACATTAAGTGCAGTTGCCTTGCAGAGTGGGCGTCCGTCACTATCCCTA +TATAAACTCCCGCTTCCATACACTTCCTCACGTTTTCGGGAGATAAATCCATCCTCTGGGTGTTCAACTC +AAGGGCTGTTCCCGTTTCTTTGGCCTTTTGTATGAGTTTTTCTATGTTTACGGGATAACCTTCCCTGTAA +CCGTACTGTTTTCCGGTCGGGTGCCCTATCATGTTCACGTAAGGGTTTTCCATAGCCTTTATAATTCTTT +CAGTGTTGTCCTGCTCAAACCGCGAGTGAACCGAAGCCACGACAAAGTCAAACTGCTCCAGCACTTCGTC +GGGAAGGTCCAGAGAACCGTCCGGGAGAATGTCCACTTCCGCCCCTTTTAGTATGTAAAAACCCTTAGGG +TTATACTCCTTGTTTAGCCTATCTATTTCCTTCCACTGCTGTTTATACCTTTCTGGATCAAGGCCGTTCG +CAACCCTAGCACTCTGGGAGTGATCCCCTATGACTATGTACTGATAACCAAGCTTATAAGCTGTTTCCAC +CATCTCCTCAAGGGTGTTCACCCCGTCGCTCCAGTTTGTGTGCATGTGAAGGTCCCCTTTTATGTCTTTG +AGTTCTACAAGTCTTGGAAGCTTGTGTTCAAGGGCGAGTTCTATCTCTCCCCAGTCTTCCCTTAGCTCGG +GAGGTATCCACTGCATGCCAAGGACTTCGTAAACACCTTCTTCCGTTTCTCCTGCAATCCTTTCTTCCGT +GTCCACCTTAAACACTCCGTACTCGTTTACCTTCAGACCCTTTTCCTTTGCTATGTCCCTTATCCTTATG +TTGTGCTGTTTCGAACCGGTGAAGTACTGAAGGGCCGCACCCCAGCTTATGGGCTCTACGGTTCTGAGGT +CCACCTGCCTCCCCGTATCGAGAATAATGCTCGACTTTGTCTCTCCCTTTGCAAGAACTTCTAAAAGTCC +CGGATACTTGGTAAAGTGCTCGTGAATAGCTTTCCAGTTTTCCTTCTTGGCGGAAACGAGTATGTCAATA +TCCCCTATTGTTTCCTTCATTCTCCTCAAACTTCCCGCTATTGAGATGTTTTCGTACTTATCCTTAATCC +TTTCCATGTACTTCAATACTTCCTGAGCCATCGGGTATGCTTCTATCAGGGATATCCTTTCCTTGCTCTT +TTCCCAGAGTTCTATTCCCCTCAGTATTTTTAAAGCCTTTACGGGGCCAAATCCTCTGATCTTGTTAAAC +TTTCCCTTTTTAAGGGCCTCTATAAACTCCTCTTTTGTCCTTATTCCGAGCTGTTCGTAAGCTATCTTTA +AGGTCTTCGGTCCGACTCCCGGAGCGTCAAGGAGTTCCAGCAGGTCTTCGGGAACCATGCGTCTCAGTTC +TTCATACTTCTTTATAGTTCCGGTCTTCAGGAATTCTTCTATTTTTAATAGTGTTGACTCACCTATCCCG +GGCATGTGGTGGAGTTTTCTCGTATAAAAAGCCTTTTCAACGTCTTCCTGGAGCTCGCTTATGAGGTTTG +CCACCCTCCTGTACGTTCTTATCCTGTAGGGATTTTCTCCGAGGAATTCAAGGATATCGGCCATTCTCTC +AAAGATTTTTGCAAGTTCCTGATTCTTTCTGGACATACTTTTAAAGTTAAGCCTTGAATTAAGATTTAAA +GTATGAGACTCGGAGTAAACGTTGACCACGTGGCCACCGTAAGGCAGGCGAGGAGAACCTTTGAGCCCTC +CCCCGTATTCGCGGCCCTCATAGCCCAGCAGGCGGGAGCGGATCAGATAACCCTCCATCTCAGGGAGGAC +AGGAGACACATACAGGACAGGGATTTAGAACTCATAAAGGAACTAATAACCATTCCCGTAAACCTTGAGA +TGGCTCCCACTGAAGAGATGAGAGAAATAGCCCTGAGAGTAAAACCTGACAGAATAACCCTTGTTCCCGA +AAGAAGGGAGGAAATCACCACCGAAGGTGGTCTTGACGTAGTATCACTGAAGGAAAAACTCAAAGAATAC +TTAAAGCCCATAAAGGAGGCAGGTATTGAAGTCTCCCTCTTTATAGAAGCTCAGAAGGAACAAATAGACG +CAAGTGTAGAAGTAGGGGCTGACGCCATAGAAATCCACACAGGAAGGTACGCAAACCTCTGGAACGAACA +CAGGTTTGAGGAAGCGAAGGAAGAGCTAAACAGGATAAAGGAAGCGGCAATTTACGCGAAGGAAAAAGGA +CTGAAGGTTTACGCGGGACACGGACTTACTTACCACAACGTAAAAGACTTTGTCAGGGAACTCAAAGGCT +ACGTAGAAGAATTAAACATCGGTCACTCAATTGTGGCAAACGCCGTGATATTCGGATTTGAAAGAGCTGT +GAAGGAGATGTTAAACCTTATTAAGACTTGACTCGTATTTTCTCAAAACTTCGGTTATTAATTCGTTGGA +TATTAAAAGGTGCTCTTCCTTTATCCTCAGCCTTCCTCCTTTTACTTCAAAGAAATCCCTCAAGTATTCT +GGTACAAATTTTAAGTACTTTTCTTCAATACCTTCGGTGGTTCTCAGTCCCAGCATAATCCTTTCCTTTT +CCAGTTCCGTTTCGTCAAGTTGCACCCTAAACTCAACGGGCTTTTTGTCTTCCTTTAGAAATTTTACATA +CTTGCTTATATTTTTCGTGTTCCCGTACCTTACATTTTCGTAAAAGCCCCATGCAGAAACGCCTACCCCT +AAAAACTCCTCCATTTTCCAGTAAACGAGGTTATGCCTGCACTCAAAACCCTCCTTAGCCCAGTTGGAAA +TCTCATACCTTTTAAAACCGAGCTCCCTCAAACCTTCCGAAAGCATTTTATGAAGTTCTACCACTTCCTC +TTCTTCCAGAGGCTTAAACTCACCCCTTTTGAAAGCAAGACCCATAGGTGTGTCCTCGTAAAGAGTGAGG +AGGTATGCGGACACGTGCTTTACGGGAAACTTTTTCAGGTGTTCGAGTTCTACTTCCAGATCTTTCAGGC +TCTGAGTGGGCCAGCCCCATATGAGGTCGACGTTCACGTTTTCAATTCCCGCCTCAAATAAACTCTCAAG +ACACTCAAGACTGTCCTTTACCGTGTGTTTCCTTCCGAGAACCCTTAACCCTTTTTCCGTGAAGCTCTGA +ACACCCACGCTTATCCTGTTTACACCGAGTTTTTTTAACTCCTCAAACTCCTTTTTGCGGTAAGTTTCGG +GATTGCACTCAACTGTTATCTCCTTGACACCCGAGAGCCCGAAAACCTTGTCAATTTCCTCAATAATTTC +ACCGAGTTCTTCTGGTTTTAATAACGTGGGCGTTCCACCGCCGAAGTAAAGAGTTTCAAGTTTTACGTCA +AGTTCTCTGTACAAATTTATTTCTCTCTTTAGAGCACTCAGGTAATCCCTAACGCTTACGGGAGAGTTTA +CAAGGGACAAAAAGTCGCAGTAAGGACACTTGTAAGAGCAGAAAGGTACGTGCACGTAAAGGGCTTTTAT +CATCAAAACTTTAAATTTAGGTTGTATATTAAAAAATCACTATGCCTGCGGATCCGAGAAACGCCGGAAA +GGACAAAGGAAATCTTCAGATGGAGCTCCAGAACTTGCTCACTTCCGCAAGAATAAGGAAGATGGAGTAC +GAAGCAATAGTGGAAGAGCTTGAGGAAGACGAGCTCAAATACGACCTCTTTGAGTACCAAGACTACCTTG +AAAATTACATTATGCCCTACGTTGAAAGAGCTTACAAAAACGGCAGTAAAGAACTGATAGGAATGGCGGA +GGAAGTAAAGAGTATATTTGAAGAAATTATTGATATGATAAAGGCGAGAATAGAAAAGAAGTGAAAAAGA +TATTCCTCTCTTTAGCGGATCGCTCTGCCTCCAATTACGTGTATGAAATACTTAAGGAAGGCTTTGAGGA +GTACGAAATCTACGGACTTACTGACGAAAAACTGGAAAAAATAGGCGTAAAAAGTGTGGCAAGGTATTCT +GAAATATCCACGGTAGGACTGATAGAAGCGCTTCCAAAAGTATTTAAATTCTTAAAAATTTACAGAAAAA +TCCTTAAAAACTTAAAAAATACTGACACCCTAATAGCATGCGATGCTCCGGCCCTTAACTTAAGGCTTAT +AAAAGATGCGAGAAAACTCGGAGTAAAGCGGATTATTTACTTCATATCTCCTCAAGTGTGGGCTTGGAAG +CCAAAAAGAGCGGAGATTATAGCCAATTACTGCGATCACGTAATAGTAATCCTCCCGTTTGAAAAAAAGA +TTTATAGAAAATTCCCGAACTTGAAAGTTCACTACGTAGGACACCCCCTAGTGGATTTGGTAAAACCTCA +AAAAACAAAAGAAGAATTTATGAAAGCTTTCAAAAAAGAGCCACTGCCCCTACTTCTCGGAAGCAGGGAA +GGTGAAATAAGGAGACATGTTAAATTATTAAAGGGAATAATTGAAGAATTAAAAAAGAGTTTTGACGTAA +TTTCTCCGACTTTTAGAGAATTTTCAAAGTTTATTGAGAGAGAACTTAAAGTGAAAACCCTTACGTACGA +AGGGGCTTCTTACGACTGCTTCTTTTACTCAAAAGCCTCACTAATAGCCTCGGGAACAGCTTCCTTAGAG +GCGGGAATTGCGGGAAACCCTCACGTGGTTTATTACAAGGTAAACCCGATTACCTACTTTCTTGGGAAAA +GACTTGTAAAAGTTCCCTACATAAGTTTAGTAAACATACTTTTAAAGGAAGAAGTAGTTCCAGAGTTTAT +CCAAAAAAGTTCAGATGAGATACTGAAAGGTTTTGAAAAGGTTTACAAAAACGAAGAAGAAATTAAGGAA +AAACTTGGAACGTTGAAGTTTATCCTCGGTGAGAGGTTCGTTATAAGGAAGCTCAGGGAGTTGTTCTTGG +AAATAGTATAGTTTTAAAGTATGCTCAGGTTTGAGGATTGGGAACTCGCGGTAGTTATAATTCTCACGAG +GTTTATGGAAGCAATAGCGATAATAATAAGCATATACCTCGCCTTTAACGGCTACAAGCTCAGGTATGTC +CTTGCAACCGCAGGTGTATTCCTTTTGAGCGTGTTGATAAACTTAACGGGACTCATTTTCAGACCTTACT +TTATTTACTTTTCCTTAGCGAGTATATTCCTGAGTGCGCTTATACTTACCGCTTTAATTCTTTACGTTAA +AAAGAACCCGGAAAAGACTAAGAGTTTTTCCCTTCCGGAAAACGCCAGATGTCCGGTTTGTAATGTTCTA +ATCCTCAAAGAGGACGAGCTCTGTACCGCAAAAATTGGGAATTATACTTACTACTTTGATACGTGTCACC +ATCTGGTTCAGCTACTTAAGGAACCCGATTACTTCGTAGAAAGGGGAAACATTTTTAAAGGAGAACTAAA +AGAAGTTTTCGTAAAAACTAAGGATACAAAAAAGTGGAAAAAATTCAGTGAAGTGAAACTCGTGGGAGAG +GACGGAAGACTTGTCGCTTATGAAAACCCTCCGAAAGGAGCAAAGGTAATAAATCCGGAGGAAATTCTTA +GAGAAAGTCCCTTAAGTTGAACGGGCCGGTATTTTATCCTTTATAGCCTCGTATATCTTCAAAGTTGCGT +CGGACTTGTTCAGAGTGTAGAAGTGAAGCCCCGGAACTCCGTGTTCTATGAGATCCAAACACTGATTTAT +GGCAAACTCAATCCCTATCTTTTTTACTTCTTCCGGTTTATCCTCCACTTTTTCAAGCTTTTCTATAAGA +CTCTGTGGAATCGTCGCTCCGCAAAGAGAAGCAAACTTTCTTATCTGTTTGAAGTTAGTAATAGGCATAA +TTCCCGGAATTATAGATATATCTATCCCTGCATTTTTGCACATTTCCACAAACCTGTAGTAGTAATCGTT +CACGAAAAACATCTGAGTAATCGAGAAGTCTGCACCTGCCTCTACCTTTTCCTTAAAGTACTTCACTTCC +CACTCGAGGTTCGGTGATTCCGGATGTCCTTCAGGATAAGAAGCCACTCCGATAGAAAACCAGTCTCCGA +ACTCCTTCCTGATCAGTTCTACGAGCTCTTTTGCATACTTGCACGCACCCTTCGGCGGTCTCCAGTCCGG +TTTGTCCCTCGGAACGTCCCCCCTCAAAGCGAGAATGTTCTCTATACCTATGTTTTTGTAATCTTGAAGG +ATATCAATAAGCTCCTCTCTCGTGTGTGCTATACAGGTGAGGTGTGCCATAACGGTGAGGTTAGTTTCCT +CGTGTATTTTCTGTACTATATTCCTAGTTCTATCTCTAGTCGAACCACCTGCCCCGTAAGTAACGGATAC +AAAAGTAGGATTTAATTTCTCAAGTTTCCTTATAGTTTCAAAGAGCTGTCTTTCTCCCTCTTCAGTCTTC +GGTGGAAAGAACTCAAAAGAAATACTGAAAACTCCTTTCCTCAGTATATCTCCTATTTTCATAAGGAAGT +ATTTTAAAGGTGGACTAAGAATTTTTAAGAAATAAAATAAAAAGTGTAAAAAACTTTCAAGGGAGGTGTG +CCATGAGTCAAGTTACTCAATCTTTCAGAAAAAGTCTCAGCCTCAACAAAGGTTTTACCTTGATTGAACT +CCTGATCGTCATCGCGATCATCGCAATCCTTGCAACCATGGCCATTCCCAAAATTCAGGAGTACAGAAGG +GCTGCACTCATAGGTAAGCTCACGAATAATGCGAGATTGTGCCTATCAGCATATGCACAACAAGAAGCTG +TTAGTGGAGTAACCGGAGCTGTATCCGTTACCGCCAACGTACCGCCGGGATGTACAGGAGACGCATCATC +GTGTACATGCAGTGAAGGAGGTGTTTCTGTAACTTGTTCCGTACAAAACGATGGTAGTATAACCTGCAGT +GAAAGTACTTCCTAATCTGCTAGGTTGCACCCTTCTTTCTTTTTCCTCTTTTCTTTTAACCTTTATTTAT +ATAGGATTTTTATCATGCCAAAGGAGGGGGGATTTACTTTAGTAGAAGTTCTTGTAGCACTCATGATCGT +TCTCGTACTGGCAGGACTCGCCATTCCACTTTACGAGATCACTTTTAAAAGAAACGCTATGCGGGCAGTA +GTTCTTAGCGATTTAAGACAATGTCTTTCTATTATCTCCGTACACATGAGTACCGGAGGGAACTCCCCTT +CTGAAGTTTTGGGCGAGTGTCCTAAATCTGACTACACGCAGGAAATAAGACTTCTTTCGGATAACCCTAT +AACCATAGAAGCTGTAGGAAGGAGTGATGTGGGAGAGGTCAGGTGTACCTATGACGGAAACACCGGAGAG +ATAAGCTGTGATAGTACTTTTTAAAAGGGGATTCACCCTTGTAGAACTTTTAATAGTAATAGGAATAATA +GTTATTTTAAGTACAGTGGGGATTTTAAAATTCAGGGAGTGGTACGAAAACTACAAATACCTTGAGGAAG +TATCAAAACTCGAATACTTGGTTAGGAGGGCTAAGGTAATAGCCCTTGAGCGTTCTTCTTACGTAAAAGT +GCGTGTTAATGGAAATAATTTAGTAATAGAAGATTGCGGAATAGACAACTCCTCCTGTACTCCCGTGGCT +TCTTACAGATTTGAGTTTAACTTGGATTCGACCAGATCTGTGACTTTCAGTCCGAGGGGCTTGGCACATT +CATGGGGAAGCTTCTGTATTTCAAAAGATGGAATGTCGTACAAGGTTATAGTAAACAGGGAAGGTATAAG +GGTAGAAAAAGGAGGAACGTGTTGAAAAAAGGATTTACACTGATAGAGGTTCTCGTAGCATTGCTCGTTT +TTATAATCGGCGTGGGGAGTATATTCTACGTTTTTTCTAAATTTTCCGATTTAATGAGAAACAGGTTCGT +AATTACGTGTGTGACCGAAGCCGCGTATTATGCATTGGATGCCTGTGCGGCGGGAGCGGCACCGCCCGGA +TCGTTGACGTGCGGAAATATAACAGTTGACATTAGTGTAAGCGGCTGTGAACCTTCACCGGGAGCTTGCA +GGAACGTTTCCGTAACCGCCTCTTACAATACTATTAGCTTTTCTTTAACTACGAAAAAGTGTGACTTAGG +AGCTTCGCCATGAACAGGGGAATGACGCTTATAGAATTACTCGTAGCTCTTGCACTTTCTATAATTCTCT +CCCTTGGACTCTACTACTCTTTCCGTTATTCGGGAATATTTTTCTCTCAGGATAAAGCAATATCCGACCT +GATAGAATACGCAAGAACTGCAGAGGAACAACTGAAGTTTTACTTCGACAGGTGGGGAAACGGTGTACCT +GAGGGAGGTACTGATTGTACTTACTCATTTCCAAATGGATATCCCAAAAATAGATTCTGCATCATTAAAG +GAAGTTCGGGTAATTGTGATGAGATAATTTTTTACGGAAACACACAAGGATTTTTGATAGTGCTGGATGA +AAAAGATGAAGATGAATTTAACGCTTTAGCGTGTAGGATGACAAACGATGAAGACGATTATTACTACATT +TGGAAAGAAGATAAACCTGTGGATACAACAACCGGCAACAGAATAGGTGTAAGCGGAGGAGACTGTGGGA +TAAAAGGAATTATTCCTAATGCGAGTGTAGCGAAAGAGATTAATACATTAGACAAAGGTACAGTTACTCT +ACAAACAGGGGATGCCATTATTCGGGTACCGAAGATTATCAAGATATATTGCAGTGAGACGAATGGAGAA +CTATATTTAAAGGTATCAGAACAAGAAGCTAATAAAGCTCCTGTAGAAAGTCCATTAGTCCCTGTAAAGG +AAATGGAAGCGACGCTCCTGCCCGAGGGATGCGATCCGACAAACGGAGAATGTACAGCGGTAAGGTTTCG +TATAACCTTCGTAAACAGAGTAGGCAACGAAGAATACACGCTTACGAAGGACATAGTTCTCGGGAGGTAA +TGAAATGAAGGGTTTTTCTCTTGTAAACACTATAGTCGCCACATTTATATTTACAGCTGTTGGGTTTGCA +TTACTCGTTATGTCCGACGAAGGTTTCAGGATTACCAAGAGTAGTATAAACGCAAATATCGCGGAAGCTA +ATGCGGTGTATGCCTTGAACACAGCCCTTGAACACCTTATAAACGGTGGAAATTGTGAAGGGAGTGCAAG +TGGAAGTGTAAACGATGGTAGTTGGGAATACACTTTATACCCAACTCCTTCAGGACAGTGTTTTATCTTA +GCATCCGGCAGAAAAGATAACGCTGTTAGGTACAAAATCGCTTATGCGGGATTCAGTGGTGGCGGAGGAT +TGGGAGCATTAACTATTAATTATCTAAAAGGAGATGAATTTTCCTTACAGGGAAGTTCAAAGATTTCTAA +CGGAGGAACGAATTGCCCTGCGGTAGTTTATTATGAGAAAAAAGCAGATATAGAATATAAAGGAAATGCA +AAAATTGAAGGAGGTATAGTAAATAAAAAAATAAACATACCAAGCGAAATATTCAAGGAAGAGAATGCTT +TTGAAGATATAAAGACCTACTATAAGGAGTTATACGAGGATAGGTTTAATAATGTTTCTCTTCCTGACGT +ACCCTTAACTACCGAAGACTGTACTCTTGAGGTTGGAAATTCTGATTGTTCTTTGAAAAATAATGAAATT +AATTGTGGAAACACGAAGTTAACTGTGGAAAACTGCACAAGTGTCCTTATTAAGGGAGGAAAAATATCCC +TGAACATAAATAATGGCGAATTAGACATACCTTTAGTGATAGAATCGGACGAGCTTGTTTCACTTACAAC +GGTGGGTGATACAAGCATTAACGACATATATGTAATAACAAAAACTTTCGGGAAATTAGAAACAGGGGGA +TCAACAACTATAAACGGTAACGTTGTTATTAAAGCGGATAGTTTTAAAAACCTTGGAGAAGACGAACAAA +ATATTGTCCTAAGTGGAAGTACAAAAGTAGAAGGAGGTATGTACATATCAACTCAAGATAGCTCTCTTCC +ATCTTCTGGAAATGAAGCTAAAATAAAATTCGCTGGAAGCTCAGAAATAGGGGAGAACTTTTACTTTTTA +GGATACGGTGTGGATTTACATTATACAGGTGGCAGTGGAATAAGCGGAAATATCTATATAAAAACCTATC +ACGAATATGAGCTTGATATTAGCCACTATGGGAACTTTGTAGGGGGAAGTATTTATGCAAACTGTGTATC +TTCGGATTGTGAAGGGGAAGTTGAAATACACAATGGAAACTTAAAACCCGCAGAGGGAAGTGAATTTGTG +TTTCTAAGTGAAGGTAAAGAATTAGAGGCGGAGTTGAAGTCAGGTTCAGGAGGATTAGATGGGTATTTTG +TTAATTTATCCGATAATGGGGAACTTAAACTTGAAATTAAAGCCGGAGGACTTGAAGCGAATGGATTATT +CATAGGAAATAAAATAGAAATTGAAGGAGGGGAAAAAGAAAAATTAACAGGTAGTAATAAGATAAACGGA +ATTTTAGTTGGAAAAATTGTTGAAGGTCTAAAATTAGGAGGAAGTGCAGAAATAAACGGGTTAGTTGCTG +CACTTGAGGAATTTGATGAATTAAATCTAAAAGGAAGATCAAAAATAAAAGGAATGGTTATAGGAAATAT +ACTAGAAGGTTCCGTTTCCTTAATTGGTAATTCTGAAATAACCCTTGATTTCGAAACGATAAATTCCTTT +ATTTCTAAATTTGGATTGGAGGACTTCTTTAAAACACTTACTTGTGAAAGTGAAAAAGGCAGTGGAAATC +TAACCCTCCCACAACACTTAGTAGGTTCAATATACTAACATTGTATGTTCGCCTTGATTTTGGCTTTCCT +TATTATGTTTCTATCCTTCCTTCCCTTTCACCTTCTTTCTTCTCCTAAAGGTGAAAAACTTCAGATAATA +AAAATAATAAAATTAGATATACAAAAAGCCTTTCCCGAAATTCCTCAGGAGATTTCTAAAAGAGTTTTGC +GTTTTCATTTATCCTCCGATCCCAAAACCCTGAACCCTGCCCTTGCCATGGAAACCTCTTCCACCGCTGT +AATCGGAGATCTTTTTAGCGGACTTACGAAGCTTGATCTAAAGACGATGAAAGTAAAACCGAATCTGGCT +CAAGGCTGGGAAGTAAGAGAAGGGGGGAAAGTATGGATTTTTTACTTACGAAAAGACGTAAAGTGGAGCG +ATGGAAAGCCTTTTACCGCCGATGACGTTGTATTTACCTTTAACGAGGTTTACCTGAACGATAAAATTCC +CACCACTGCAAGGGATATATTCACGATAAAAGGAAAAAAGATAAAAGTGAGAAAAATTGACGAGTACACC +GTTGAGTTTATTCTACCCGAGCCTTTCGCACCCTTTTTAAACTCCCTCGGAGTTGAAATACTCCCGAAGC +ACAAACTCGAAAATTACGTAAAGGAGGGAACTTTCTCAACAGCGTGGAACGTAAACACAAACCCTAAGGA +AATAGTGGGAACCGGAGCCTACAAAATAGAGGAATACGTGAAGGGACAGAGAGTAGTTTACAGGGCAAAC +CCCTATTACTACGAGAAAGACGAAAATGGAAACAGACTCCCATACATTAAAGAAAAAGTAGGAGTAATAA +TTCCGGATCCCGATACCGCACTCCTTAAATTCGTAAACGGGGAGATTGATTACATAGGCGTCAGGGCTCA +GGATTTGCTCTTTTTGGCTAATCAAAAGGATAAGGATTTTGTAGTTTACGACCTCGGAGCTACGCCTTCA +ACCACGTTTCTTGTCTTCAACCAGAACCCTAACGCAAAAATCCCGAAGTACAAAATAAAGTGGTTCAGGG +ACAGGACATTCAGAATAGCCATTTCCCACGCAATAGACAGGGAGGGAATAGTGAAACTCGTTTACAACGG +GCTTGCTCAACCGCTCTACACACCAATCACACCGGCAAACAGACCTTATTACGAGGAGAGTTATTACCCG +AAATTTGAGTTTAACCTGAAAAAAGCCAGAGAACTTTTAGAGAGTATAGGTTTTAAAGACAGGGACGGCG +ACGGAATACTGGAAGACCCTGAAGGACACGACCTTGAGTTTACACTCATCACAAACGCAGGAAACAAAGA +AAGGGAAATGATGGGAGCTATCATTAAGGAAGATTTAAGGAAGATCGGTATAAAGGTCCACTTCCAGCCC +ATAGACTTCAACACTTTAGTTTCAAAACTCACGTCTCCTCCCTACGAGTGGGAAGCGGTGATAATAGGAC +TCACGGGATCTATAGACCCTCACTTTGGCAGGAACGTATGGCACTCTTCGGGAAGTCTCCACATGTGGTA +TCCGAGACAAAAACAACCCTCAACAGAATGGGAGAAGAAGGTGGATGAGCTTATAGACAAGGGGGCAACG +GAACTGAACTATGAGAAAAGAGTCCAGATTTACAGGGAAATGTTCAGGATAATTACGGAAGAACAACCGA +TGATTTTCATAGCAGCTCCGAAGAGTATGGTAGCGGTAAAGAAACACCTCAAAAACGTATTTCCCACCGT +GTGGGGCTGGTACGAGCCATACAGAGTTTACCTGATATCGGACAGGTGATTTAAGTAATGGAACAAAATT +TTTAAAAATTTAAGATTTAATCCATGCTCAAACTCGTACTCATAACAAAAGAAGACTGTCCGAGGTGTGA +AAGGGCTAAAAAGCTCCTTCAAAAGGTAAAAGAGGAATTACCGATAGAGTGGGAAGAGGTAGACATGTAC +GAGTACATGGACGTACTTACTTACCTCGGTTACAAAACCGTACCTCTCCTGCTTCTTTACAATGAAGACG +AGGATTACACCGAAGAAGACGTTATATTTGTCGGTGAACTTCCGAGGATCTGGAGACTTAAAGAAATATT +AAAATCAAAGCTGGAAGAAGTAAAAAGAGCCTGAAAATTACATAATCTTGACACAAACAACTTCAAAGGA +TAGTTTTATGGTAAATGGAAGAGGTAGAAAAAATAAAAGTAGGGGGATGTCCACACGAATTTTTAGCAGA +TGGAAAAAAGTGGAGTGAATTACTCCACAGAATATCCGAAAAAACAGGAAAGGATATAAACCTTGTCATA +TACAGGGACTTTGAAGAAGAAAGGAAGAAGATAAAAGAGGAAGAATTTGACCTTTATTATGCAAGTCCAG +AAATAGCGGTAGAGCTCTACAGGAAAGGATACGTTCCCGTAGGTGCGATAAAAGGACAGGAGGACGAAGT +AGTTCTCGTATCCAAAGAGAACCTTAAGGAAAAGGAATTCTACAAGGTAGCACTTGTAAACCTGAAACTT +TTTATGCTCGGACTTTTGAACTTTAAAAACATAGATAAAGATCGGATTGAGCTTGTTTTTACGAAATCCC +ACGAGGAAACTATTGAAAAAGTTCAGAACTGCGAAGTTGATTACGGGATAATTTACGGAGAGACGCTAAA +AAGGCTGAAGCCCCAAAATTTAAAAATCGTTTCCTCAGGAACGCTGAAATCCAGACACTTTTTTATGGCA +AAGAAGGAAAAAGCAGAGTATTGGAGAAAAATTTTATCGGAATTCAAAGAAGTTGAAATTCTGAATGAAA +GTGCAATAGAAGACACTTTAAAGCTTTTTGAGGAGCTTGAAGAACTCCTCACATGTTGGCAGGAACACGA +CACAGCGAAAGCCATTCAGAACATAGAAGGAATAGGCGTTCTCATATACAGGGACAGGATAATTTACGCA +AACAAATACGCGAGGGAAGTTTTGGGGTATTCGGAGGAAGAGATAAGGAACTTATCCGCTCTAGATCTTG +TTTCAAAGGAATACAGAGAAACTATACAGAAAATCGTAGAAAGGAGACTCAAGGGTGAACGCTTTCCGGT +AGTTTATAAAGAGCTGAAAGTCAAAACGAAGGAAGGAAAAAGTTTATGGATACTCGCCTTTTCTCAGACT +ATACTTTACGAGGGGCAATACGCCGGTTTCGTCATTTTCGTGGATATAACAAAAAGAAAGAGGCTCGAAA +AACTTTACAAGCTCCTCAGGGAAATAAACCAGACCATTACAGGGGTTTTCCACGAAGGGGAGATTTTTGA +AAAGATATGCCATAATCTCGTAAAAAACCTAGACCTTAAGTTTGTATGGGTAGGCAAGCTCAGCGAAAAG +GGAGAAGTAATTCCCGTGTACACGTGCGGTGAAGAGGAAGATTACGTAAAAAAGGTTAAGATCTCTATAA +ACCCTGATGAGCCCGAAGGCTGGAAGCCCACTGCAAAGGCTTTAAGAGAGGGAAAAATCGTAATAAACCC +GAACACGTTGGAAAACCCTGATGTAGAGCCGTGGCGTGAAGAAATGCTGAAGAGAAACTTCCTATCTTCC +TGTGCAATACCTATCCAGTTAGAGGGAGGAACAGGGTACGTTATAAACCTCTATGCCTCAGAACCATACT +ACTTTGAAGAAGAAAATAAAGAAATACTTTACGAGCTGAAGGAAGACGTTGAGTTTGTCCTGAGGCGTGT +AAGGGAGTTGAGAAATTATTTAATCCTTTCAAAGGCTCTTGAAGAATCCAGAGAGTGGGTGCTCATAACG +GACAGAGAAGGAAAGATAATATACGTAAACAAAGGAGTGGAGGAAATAAGCAAGTACAGTGCGGAAGAAC +TTATCGGCAAAACGCCGAGGATTTTTAAGTCTGGTTATCATCCTCAAAGTTTTTTCAGGAAGTTGTGGCA +AACTATCCTTTCAGGGAAACCCTTTCACGCTGTATTTGTAAATAAAAATAAGTACGGTGAACTGTTTTAT +TTAGATCAGAAAATAATTCCACTTAGGACTCCTGAAGGAGATTTGTTCTTCATAGGACTCTGCAGGGATA +TAACGAAGGAAGTGAAACTAACGGAAGAAGTGGAGTGGATCACTACTCACAACGTAGAAACCGGACTCCT +AAACAAGGTAGGATTTCAGAAGGTTCTCAGTCCACTACTCGGTAAACTAAGTTCTACAGGTGCGTTAATT +GCCCTCGATATGGTAGGTTTTTCCAGATTGATTAAAGAATTTGGAGAAGAAGCGATAAAAAAACTCCTTA +AGGAAATAGCTGTAAGACTGGAGAAAACTTTCAGAAGGGGAGACATAATAGCGAAAGGGGATGGTGATGA +GTTCTTAATATTCGCCTACCCTCTTAAAAAGAAAGACGATGTACTCTCACTCATTGAAAAAATAAGACAA +AAATTTTCCAAACCTCTAACAATTGACGGCAAAAAAATCCGCCTGTCCTTTTACATAGGAGTGGTTACGT +ACCCGTACGACGGAAGGACCTTTTCTGAGCTTTATTACAGAGCCATAACTGCCGTGAAGGAAGCAAAAAG +GAGGGGAGCGGGAGAAGTTGTACTCTTTGACGAAGAACTGGACAAAGAAGTAGAAAGGTTAATTGAAGGA +GAAAAGCTCCTCAGGAAAGCGGTAGAAGAGAACCTGTTTACCTTTCACTTCCAGCCCATATACAGACTTA +GGGATATGAAAATCTTCTCCCTCGAAGCGCTCGTAAGGATAAAGGAAGGGGATAAGATACACTACCCCGG +AGAATTTATAGAACTTTTGGAAAGAGGTGTATTTATAAAGGAGTTTGAGGAATGGATGATTAGGGAACTC +AGAAGGCTCCTCGGAAAGTGGAACGTGCCGATTTCCGTAAACCTGAGTGCCATAAACTTCAAAAACGACG +AATTTATGGAGAACTTAAACCTGGTCTGTAAAGAGTATCCGGGAAAACTCATCTTAGAAATCACCGAAAG +GCTCCTGATAGAAAACGTAGAAAGGACAAGAAGAATCCTTGGGGATTTCAGAGAGTGCGGACTTGTGGCG +GTTGACGATTTTGGAACCGGGTACTCTTCCTTTTCCTACTTAAAAGAACTCCCCCTTGATTTGATAAAGA +TAGACATGATGTTTATAAAGAGTATGCTGGAGAGTTCAAAGGATCTTGCACTCGTTGAGGCTATAGTGTT +CTTCGCCCAAAAGATAGGACTTAAAACACTCGGAGAGGGAATAGAAAACGCCAAGCAACTCGAAATGTTA +AAGAGAATGGGATGCACTTACGGACAGGGCTTCTACCTTGCAAAGCCGATGCCCGAAGAAGAAGTGGAAA +AGCTTTTAAGGGAAGAAGGTTTACTTTAAGTTTACTCTTTCAACCTCCCCGAAAGGCTCCTTTTCCTGGT +AAACCTCTCCGCTGAAAACGTAAACTTTGGTCTCTTTGTCTTTCCAGCAGTCCTTAGGAAGACCTGCTTT +TAAACACGTATACTCAAGAAACTCAACGGGACTCCAACCATATTCCACAGGGACTTGAGGAAGTAAGAGT +CCCTTCTGTTCTCCCTTTTCAATTATTAATCCGTGTTTTCCTATTTCTATTTGTTCGGGGAGTTCTTCCT +TTGGAACTTTCAGTTCCTCTGGAGGAGTTAGCAGAGTTATTTCCCACAGCACTTTGTCAAACTCTTCCTT +TTTCAGAGGATAAAACCTCGGATCCTGAAAAGCAGCCTGAAGGGAACTGTAAACCGTTGCGTACCATAGC +GGATAAACGGGCAAAGGAACACCTATACATCCCCTTAAGTTGTGTTCGGGATAGGTTTTTAAAGTGGTAA +ACACTCCCATATTCCGGGAATACTTCTCCTTTAAAGCCTCGGGAACTTTTATTTCCTTGCCTTCAAATGC +GTTCCAAACTGCATACCTCCCCAAGTGTACAAGCTCTCTGATATCCATAGTATCAAATAATTTAAGTTTC +TTATTATAAGATTTCAATCCTTAAGAAGTCTTAAGGTATTCAGAACTACGCTCACGGAGGATAGAGCCAT +TAAAAGACCCGCAAACTCCGGTTTTAAGTAAATGCCTTTACTCCAGAGTACTCCCGCGGCAATCGGTATA +AAGGTCACGTTGTACGCAAAAGCCCAGAAGAAGTTTTCCTTTATTTTTCTGTAAACCCTTTCTGAGAGAG +TGAAAACCTGCGGAAGGGAACTGAGTTTGTGAATTACGACGTCGCCTGAAAGCTTTGCAAGGTCTGTCCC +CTCCGCAACCGCAATCCCGAGGTCTGACTGGGCAAGGGCGGGAGCGTCATTCACCCCGTCCCCTACCATG +CACACCTTTCTCCCCTTTTCCTGAAGTTCTTTTACAACCTTCAATTTCTCTTCAGGCTTTACGTTCGCTA +TAACTTCCTTTATCCCGAGCTCCTTTGCTATCCTTTGTGCGTTTTCCTTTGTGTCTCCCGTGAGGAGAAT +TACGTTAATACCTTTTCCCTTTAAAAACTCCACCACTTCTTTTGCTTCCTTCCTGACGCTGTCCTCCAGA +ATGATCTCACCTATGAGCTTGTCCTTCGTCCCGAAACCCACCCTTATCACTCCGTTCTGGGAGTTTTTGC +CCCACAGTTCTGCCTTTCCAGCGATAAACTCTCCACACCTTACACCGACTCCCAGTATTTCTTCGCAACC +CTCAAGCTTAGCTTCCCTTTTTACATAAGGCTTTAAGTACTCCCTCACAGCTTTGGCAACGGGATGGTTT +GAGTAATTTTCCATGCTGTAGAGGACATCAAAGTACTTCTCCGGAACGTTTATTTCCTTTACTTTTAACT +TCCCTTCCGTTAAAGTTCCCGTTTTGTCGAAAATCACAGTGTCCACTTTGGGGGCTACTTCAAAAATTGT +TCCCTTCTTCGGCAGAATTCCCCTCTTTACAGCTTTGTATATGCCTACCGATACCGCAAGGGGAACGGCT +ATACCGAAAGCACAGGGACAGGAAACCACAAGAACCGCAAGTGAGAACTGAACCGCCCTGTTAATCTCTC +CCGTTTTTATAAACCAGGTAAGGAAGGTAATTACCGATAAAATCACCACGAACAGGACAAAGTAGTGGGA +AACCTTATCGGAAATCCTCTGGATTTTTGGCTTTTCCTTCAGGCTTTCCTCAACGAGTTTTTTCATCGTG +TTTATGAAAGAACTCTCAAAGGTTTTAGTAACCTTCGTAATTATGTATCCCTTTTCTAAGACTGAGCCGG +AGTAAACCTCGTCTCCCTCCTTCTTCAAAATCGGCACAGGTTCTCCCGTGATTACAGCTTCGTTCACAAG +TCCCTCGCCCTTGATAATGACACCGTCTAAAAGAATCTGCTCGCCGGAGCGGTAAACTACCTTCTCACCT +TTGAAAACTTCCCTTACGTTCTTCTCAACTTCTTTTTCGCCTTCAAGAACTTTTACCTTTCTAAATGAGA +GGTTCACGAGCTCTTTGAGTCCCTTTACGGCCCTCTCCTTAGCCTTTTCCTCTATGAACTTTCCGAGTCT +CACAAAGGTTATGAGAAATACGTTCGTCTCAAAAAACGGAGTGGAATTTATAAGGTTAAAGTAAGAAAGA +ACGCTGTAAACGTAAGCTCCCGTAGTACCGAGGGCAACGAGTGTGTCCATACTTCCGATTCCCTTTTTAA +GGGAAGAGTAAGCTCCTCTGTAAAACTTCCACCCCGCCGTGAACTGAACAATACTGGAGAGTAAGAATTG +AAGTTCGTACTTTAAAGGGAAAGTAAAGAACATCCCGACGAGGAAGAAGAGGGAAGAAAGCACACCTAAA +CCTAAAAAGAGCTTGTCGTAGTCCTTCTTTCTCTCTACCGAATATCCGAGTTCTTCTATTTTCTTTACTA +TTTCTTCTTCGGATATTAAGTCCTCGTCAAATTCTACCTCCACCCTTCCCAGTTCAAAGGAAACGTTTAC +GTTTTTTACACCTTCTGTTCTCTTCAGCGTTATCTCTATCGCCCTTGCGCAGTTAACGCACGACATCCCG +TAAACCTTAAAAGCTTTCCTCATACTTCATAAATTTACGGAAAGAGTGTTATGATAAATTTGTGAAATTG +AAGATAATATTAAAGGAGTCCGTACTTTTTCAGTATTGCCTCGAGTTCTTTATCGGTTTTAGCTTTTTCT +CTGAGAGCGTTCATGATTTTTCTGAATTTCTCGGGCTTTAACTCTTTTTCCATCTCTTCAAAAGTCTCTT +CTTTGGTTTTTCTTATAATCGTTCTCCTGTCCCACCACGCAAAAGCTATAACGCTTGCCGTTAGTGTGGT +AAATATTCCCGTTATTATCCAGAGAAAGGTGTATAGCTGTTCAAATCTTTGATCCACGAGTTCAAACCTT +TTATTCATATCCTCCCTTAATTCAATAAATCTTTTATCCACGAGCTCGAACCTTTTGTTCATATCTTCCC +TGAGATCGTTTAACCTTCTATTGAAGTCTTCAAATCTTCTATTGACATCTTCAAATCTTTTGTCTACCTG +TTCAAATCTTTCGTCCGCTTCCCTTATGAAAGCTTTTAATGTAGTCTTTATCTCAGCGATATCTTTCAAA +AGCTGTTTTTCCTCTTCGGGAGTTAAAGAAAAGCTAAAACTTGCCAGAAATATAAGAATCAATAAAAACT +TCATCAATAAAAATATAATTAAAGCCAGTACATAATATCACCTTCCTTTTTAATGGGTTCTATACCCCTC +AGCATCAATTTAGTGATTTTGTCTGAGTAGTGAACCGTTGCTGGGAGTTTTATCGGCTGAAATGAAGAGT +AATTCATCAAAGTTAAACTCAGGATTTGAGAGCAAAGGACTTCTACGGGGAGTTCTCCGTAGACCTTTCT +CACCTTTATGGGCTGGTGTGTCCCTTCGTAAACTTGATTGTAGGTTGCCAAAATTACGGAATCCTCGGAA +AGTTTGTAAAAATATCCCTTTATGAATTTTTCATTTGAGAAAAATCTCGGATTGTTCCTCTTTATAATTT +CAAGGAGTTCAAGGGAATAACCGTAAAGTTCTCCGTATTTTTTAAAGGCTGCAACTTCATCTCTGTACAG +TCTTCCATCCCTGTGAACGACGATCTTACTGCCTTTTTTGAAACCAAGCTTTTCAAGGAGTGAGAATACA +TCCCCTATAGCTTTTTCCGTTAACTTTTCACCGAATGCAGGGTAAGACGTGAGATAGTACCTTACGAGTT +CACCTTTTGAGTTAAAAATTTTTGTGAATGCTACTGCGTTTACGGTTTTCCCGTCCCTCGTTATCCTGCT +TATATCTATCCCCACAAAGGCGTCCACTTTTCCTTCTATTTCCTTCAGCTTGTACGGAATGTTTCCAGTT +TTTGCGAGCACCTGCTCCGCTACATTGAGCAAAACAAACTTCAGATTTTCATTTTTAAGAGTCCTGTTGA +GGATTACCTGGGAAGGTATCATCTTTTTCAGCAGTTCCCGTTTTACAAAGTCGTAAAGGAGAAAGCTTTT +GTAAGGGTCTACCTTCGGGTACTCTTCTAAAAAGACTATCACAAGGTCAACATCTTTTATTTTGTTAATT +ACGGGTATTAGTTTTTCCTTTGCCTCTTCTCTCGTCTGGGCGAGGATTAAACTTTTTCCTTTAATCTTAA +GCTTTATTCCTTTATTTTTCAGAAAGTTTATTAATTCCTTCAAAAATTCCTCTTTTCTCCATTCGAGTTT +TTTATATACAGAAACGGAAATAATTTCTACAGAAAGCACATCCTTTTTAACGAAAGGTCTGCAAAGTTCC +AAGAATTTTCTAAGGTTCGTTATTACTTTCGTGTTTTTCCCCTTTGCGTCAAGTACCGTATCCTTGAAAT +TCAATTTTCCTTTAGCCCTTTCTTCTTCTGGAGATATGTACCATCCGTAATCCCGAAGAGCTTTCACATA +CCTCCTCAGAATGTACCTTATAAGATTTAACCTTTTACCTGGTTCCATTCTTACTATATCTGCAACTTCG +TTCCTTTCTTCATCCTCAAGGTTTTCGTAGGTGAGCACGGGTTTTAAAATTGTCGCCGGATACGTGTATC +CCTTTTCGAGAACGACTAAAAAAGCCTTTTCCCTAAGCTCTCTATTTTTAAGGAGTTCCTCCCAAGCTTT +CTTTGAACTTTTGTGAGTTGATCTTTCCATACATAACCTGAAAAATTCTTCGCCTTTTTCTTTTGCCTTG +AACACGTCTTGAACCCTTCCCACAAAGTCTATGCCTATGGGTTTTACTCTGATTCTCTTCGGATTAAAGT +CGTTTCTTTCAAGTAACGTCTGGAGCGTTTCAAAGGGTTGAATCCTGAACTTTAAGTCTAGGTGCAATAA +AAAGTATCCTTCCTCGCTCTTTAATACCTTTTCGTTCACTTCCGGAATCAGGGCTATTTTTCTGTTTTTC +CCCTGAACCGTAATTTTGTCCCTGAACTTTTTGTAAAAATCACTTATAAACTTATCTTTTACCTTCGTTT +TGGTGAGAAAGTCCCTGAACAGTTCCTGACATTCTCGTTCATTTTGAAATCCCCTGAATTCTTCTTCACC +CACTCTTTTCAGTTCCACAATTTCTCCATTACTCAGAGTTAAGTAAAGGGTATCCTTTTCTACTTTTCCA +GCACACCAGAACTCGTCCTCTCTCCTGAAGGTAGGGAGTCCAGTTTGTAAGAATACCCTCCACCTTACTT +TGTTTAATTTCTCCTTCTGGATTTCGTGCGTGGGCTTGAAAACTGTAAACGTGGTGTCTTTCGGTCTGTA +CTCAATGCGGTAAAGGTTTAAAAGAGCTTCCTTTCCCATAAGTTCAGTAATTTCCCTTTAAAAAGTCCAA +GATTATTTTCTTATGGTCAAACACAAGTTTGTCAAGAGGGATTTCTTCGAGCCTGTACACTTTTACCTTT +TTGGCGTCACTTCCCGCCTTCGGCTCCCCCTGAGCGTCTCCTATCCACACAACCGACACCACGTGTGCCC +TCGGATCTCTTTCAGGATCAGAATAAACACCCATCAATTTATGTAAACGGACTTCAAGACCCGTTTCTTC +CCTCATTTCCCTTGCGGCGGCTTCCTCTACCCTCTCCCCTACTTCTACAAATCCGCCAGGCAGTGCAAGT +CCTACGGGAGGGTACTTTCTCTCTATGAGGACTATTCCTTTGAAATTTTCCCCGTCCCACAGTCTGATAA +TTACGTCCGTGGCGAGAAGAGGCGTTTTTACGTTAAAGCCCATTTTTATCTATTCTATAATCAAAAGTAT +TATGAGAAAGTTCTTACTCCCTTTCCTATTGATAATTTCAGTAACTTTTTCCAGCACCCTAAAAGACCTG +GAGGAAGATATAGTAAAACTCGTAAACAAGGTAGCTCCCTCGGTAGTGACGATATTCGTTATAAAGGAAG +AAAAGAGTATATTCCCCATGCCTGAGTTTCCCTTTGACTTTCCCTTCAGGTTCAGAGAACCTTTTACGAG +AAAGGAACGTTCTCTCGGAAGTGGTGTAATCGTCAAGTACGACGAAGATAAAAAAGTTGTATACATACTT +ACAAACGCCCACGTTGTAAAGAACGGAGTGAGGATACTCGTAAAACTGGACAGGCACACTGAAAAGAAGG +GGGAAATAGTAGGGATAGACACGAAAACCGATATAGCCGTGGTGAAAATTTCTACAAGAGGTATAAACGA +TATAGAGGATAGGATCGCGAAACTCGGGGATTCGGACAACTTAAAGGTTGGGCAGATAGTTTTTGCCATA +GGAAATCCTTACGGTCTTGAAAGGACGGTAACGATGGGCGTTATATCCGCACTAAGGAGGAGCATAGGGA +TAACCCAGTACGAGAGCTTTATACAGACAGATGCGGCTATAAATCCGGGAAATTCAGGAGGTCCGCTCAT +AAACGTTGAGGGAGAAGTCATAGGAATAAACACGGCTATAATAGCCGGTGCTCAGGGACTTGGTTTTGCC +ATACCCATAAACCTCGCCAAGTGGGTAATGGAACAGATAATAGAACACGGCAAAGTAATAAGGGGATGGC +TCGGTGTTGTTATTCAGGACATAACTCCCGACATATCCGAAGCCCTTGGTATTAAGGAAGGTGTCCTAGT +TGCACAGGTAGTTCCCGGCAGTCCCGCGGACAAGGCTGGCTTAAAAGTCGGTGACGTTATAGTGGAGGTA +AACGGAAAGAAGATAGAGGACGCGAGGGATCTCCAGTTCACGATTATGAAGATGAAACCGGGAACGAAAG +CGGTACTCAAAGTAATAAGGAATGGAAAAGAAAAGGAAATTACCGTAATAATAGGTCAGTATCCCGAAGA +GGGAGTATCCAGAGAGGGTAAGGCGACTCCTGAAAACCTCGGACTCCTTTTAAGGGACCTGACGTTAAAG +GAAAAACAGGAGGCGGGAGTTCCCTACGGAGTGCTCGTTGAGGGAATTTATCCAGACTCCCCCGCGGAGT +ACAGCGGACTCCAACCCGGGGACATAATACTTAAGGTAAACAACCGTCCCGTAAGGAGCGTCAGAGAATT +TTACGAGATAATTAACAGATTAAAGGAAATGGGAAGGTCTAAGGCTCTGCTCCTTGTAAGGAGGGGTGAC +AGAAATATCTTTATAACTCTGGACTTAGAGTGAGGTAGTAGCCATGATACCAGATACAGAGCAAGAACTT +ATAAATCAGTACTTGAAGAAAATTTCAAAGATACCGCTCCTCACACCGGAAGAGGAGAAGGAGCTGGCGA +GGAGGGCTAAACAGGGGGACAAAGAAGCTCTAAAAAAACTCGTGGAGTCTAACCTCAGGTTCGTGGTGAG +CGTTGCAAAGCAATACATAGGTTACGGTCTTCCTTTTTCCGAATTAATCGCCGCGGGAAACCTCGGTCTT +CTGGAAGCCGCTAAACGCTTTGACCCCGACAGAGGGGTTAAGTTCATCTCTTACGCGGTATGGTGGATAA +GACAGGCGATAATGCAGGCACTCTCTCAACAAACGGGGGCTGTAAGAATACCCCTGAAACAGTCCCACAT +AATCAACAAGATTTCACACATATACGGAGAACTTTCAAAGAAACTAGAAAGAGAACCCTCTCCAGAAGAA +ATAGCTGAAGAGCTAAGCAAACAGATGATAGCGAAGGAACTGGAAAAGGAACTCGGCAGAGAACCTACCG +AAGAGGAAATAGAAGAAAGGTTCAAAAAGGAAGGATACAAAATTACCCCCGAAGAAGTTGAGAAGTACCT +TCAGGTTTGCAGAGTTCCCCTCTCTCTGGATGCTCCCGTAGGCGAAAACGAAGACACCTTCTTCATAGAC +TTTTTGAGCAAACACGGGACTGCGGAAGTGGAGGAAAAAGTAATACAGGAAGTAATACAGAAGGAAATAG +ACGACCTCCTGAGCAAGCTGACGGATAAAGAGAGGAAGGTAATAGAACTCAGGTTCGGCCTTAAGGGAAA +CGAACCCAAGACCTTAAGGGAAATAGGTGAGATACTCGGACTCTCCAGAGAAAGGGTAAGACAGTTGGAA +ACAAGAGCCCTGAGGAAATTGAGAAGTCTTGCGATGAAGAGGCACTTAAAAGACTTCCTTAGCTGATGAA +GTGCGTAGTTTACGGTTCAAAAAGTCCGGTTCTTCACCAGGCCCTCGAAGAGGTAAAGAGAAAATTTCTG +GAGGAAAAGATACTCACGGACTTTGACTTTATGATAATTTCCCTCAATTACAAGTATCCCTACGAGAACC +TGCACAGGGATTTGGTAAAGATATTTGACATCAGTTCGGACGCTTATTTTGGTTTTCACTCAACCGAGAC +CATAGAGGAGACGGAAATTCACGACGGTTTGGCGGTGTGTTTTATAAAGTTTGAAAACAGGGGAAGGTTA +AAGGTTTACTGGGACAGCGGTATAAGCGATTACATGTCTAACGGATTACTCCAGAGATTAGTGGAATACC +TTGAGGAAAACAAGAACAACTTAAACGTTTTCTTTTCCGCTTGGGAAGACAAAAATTTGGGACTCTTTAT +AGAGGACCTCGGGAGGATTCTGGGACAGAAAGGCTTTTACCCGAACTTAGTAGGCGGAGTATCCTCAGGT +AGGAAATTTAACGGAGAACTCAGAACTTTTCAGTTCTACAAAGGAAAGGTAATAAAGGACGGATTCGGAA +TACTTACCTTTGAAAATGTTGAGTTTACGCTCGGTATATCCCTCGGTTTTAAACCGATAAGTCCCATTTA +CGAGGTGAGAAAAGCTGATAACTACAAAGTTTACGAAGTAGACAGCCGAGTTCCCTTTAAAAGGATAGTA +GAAAATTTTCTAACTGGACTTGAGAAGAAGATAGAGTACCTCTGGTACTGTCCCATAGTTCTGGTTGAAG +AACGAAGAGGGATACGTAAGGGTGCAGAGAACCTTTAAAGAGATAGGAGAGGACTGGGTAGAGTTTTTCG +CACCGGTTCATGAAGGTGATAAATTTGCCCTTTCCTTCGGAACGCCCGAAATGCTCCTTCAAAGCACACA +AAAAGAAATAAACAAGATGAAAGAAAAGATAAAGTATCCCGAACTCACTTTTAACTTCTCTTGTATAGCG +AGGCAGTATGTACTTGAGGATAAGAAGGAAGAAGAGAATATCCTCATATCTCAGAACTTTGACTCCCCAC +TTTTCGGCTTTGCTACTTACGGGGAGATAGGACCCGATAAGGACTTCAGAAAGGTAAAGCTTTACAACGA +AACTGCAACCATTGTATCTTTAAAGGAGAAGGAGGTATGCGGGAAGACGTAAAACTTCGCCTCTTGATGA +ACATAATTGATGAAGTAACGAGAAAGTACAACGAACTACTACACAACTACAAAGTTCTTTTGAAAGAAAC +GGAGTTCGAAGCTACCCACGATCCTCTCACAGGCTTGTTCAACAGAACCGCACTCCAGCAACTCTTTAAA +TACGAAAAGCAAAGGGCGGACGTTTTGGGAAAAAAGGTGGCCTTCCTGTTTATAGACCTTGACAACTTCA +AGGAAGTTAACGATAGATACGGACACGCTGAGGGGGACAGGGTACTGAAGGATATAGCCCGCATAATAAG +AGAAAGCATCAGGGGGACGGATATAGCGGTAAGGATAGGGGGAGACGAGTTTTTGATAATACTGCCCAAC +AGCAACATAGAAACTGCAAAGAGGGTAGGGGAAAGGATAAAGAACGCAATAGAGGAGACCTTTAAGGATT +ACGGAATTTCTGCGAGTTACGGTATTTCTATTTACCCCAATGAAGGTGAAACCTTAGAAGAACTCATTAA +CTTAGCTGACAGCAGAATGTATCAAATGAAGAGGGAAAAGAAGCTAAAGACCGGGCGGTATCTTAAAGGG +AACGTTCATAAGGGGATTTTCCTCCTCCTGCTTCACTATCATTGCGTAAACTCCGAAACAGTACTTTCCT +ACTTCAACAACTCTTCCAACTCTTATACCTGCGTCCTCCAGAATTAATCCAACTTCCCATTCGGAGTAAA +CTTCTTCCGGCGGGGGTCCTTTGTCCCTCTCCTCCTTCTTCCAGTCTATAATGGCAAGGTAGGCAAAGGG +CTTTGCCACTCTCTTCAACTCTTCTAAGAACTTAAGTGGTTCGGAAAGCTCGTGAAAGGTAAAAGCCATG +AATATAAAGTCGACTGTGTTATCAGGAAGGGGTATTTTATTCTCTTCAGACTTGAGGACTTCCACGTTTT +TCAGACCGAGTTTATTTACCTTTTCCCATGCGTAATTTACCATTTCCTCCTGAACGTCTATGGCGTAGAC +CTTTCCCTTTTCTCCTACCATCTTAGAAAGGTAAGGGAGGTAAAATCCCGCTCCCGTTCCTACGTCAAGG +ACAGTCATACCTTCCTTCAGTCCGAACTCTTTTAAAACTTTCTCGGGGTCAAAGAGTTCTAAACGGGAAG +GGTCATCTAGCTTCTTTATTTTTGAAGGGTCAAACTTGTGTGCCATGATATTATTCTACTTTATGCAAAC +TCCCCTTTACTATGTCCATAAACACCTGAAGGCAAAGTTCACGAACTTCGCAGGCTGGACAATGCCACTC +CAGTACACCTCAATAATAGAAGAAGTAAGGGCTGTAAGGGAAGAGCCGGAGTGTTTGACATCTCCCACAT +GGGCAGACTACTAATAGAAGACCCTGAGAAAAAACTCCAGTACTTTACCACCAATAACTTGGATAAACTG +AGCGTGGGAAAGGTTCAGTATAACCTCCTTCCAAACGAAAAGGGAGGAATAAAGGACGACGTCACCGTTT +ATATGCTCTCAGAAATTGAGTTCTTTCTCTGCGTGAACGCCGCAAATAGACAGAAGGTAATAAATTGGCT +CTCTCCTCACTTAAAGTTAAGGGATTTATCTGGTGAACTTGTCCAGATAGCCCTTCAGGGCCCGAAAAGC +GAGGAAATAATTTCTAAGTTTTATCCGGTCTCCGATTTAAAATACTACAGGTTCAAGGTTTTTGATAAAA +CCATTATTTCAAGAACCGGTTACACGGGTGAAGATGGATTTGAGATATACGTCTCTCCCGAAGAGGGAAA +GGAGTTATTTTTAGAACTCGTAAAACTCGCAAAGCCCTGCGGACTCGGAGCGAGGGACGTTCTCAGAATA +GAAGCGGGACTCCCACTTTACGGAAATGAGCTCTCCGAAGAAATAACGCCGATAGAGGTAAACCTTGAGA +AGTTCGTGGACTTCTCAAAAGAATTCATAGGAAAGGAAGCGATGCTGAAAAAGAAAGTAAAGAAAAAGCT +CTTTGGTCTGGAGCTGACGGAAAAAGGAATACCGAGGAAAGGCTACAGAGTGTTTAAAGGAGATAGAGAA +ATAGGCTGGATTTCGAGCGGTACTTACTCTCCGACGCTTAACAAAGGCATAGCCCTCTGCTTTGTTGATA +TTGAAGAGAGGAAAGAAGGCAACGAAGTGGAAATCGAGGTAAGGGGCAGGAGAGTTAGAGGGGTATTGAG +AAAGTATCCCTTCGTGAGGACACCAGCGGGAAGGTATCAGAAATGAGCAAAGGTAATTAAATCTGATACA +CTTCCCGCAAAGTGTCCTTCGCTGTCCCCTTTTGGGGAACAGGATTTACTACCCGCTATCTCCCAAAGAA +CCGGGAGACTCGCAGGATACCTGAATAAATTTACCTTCACAGGTCTTGACAATTTGTCTAACCAGTTCCT +TAAACTCAAAAACTCTTCCCTTACTTTCTTACCTAACGCTTTTATCGCTAAATTTAGTGCTCCGTTCAAA +TCCGCATTAAATACCTTTTTTAGTCTTCGGTCTCTAAAAAGACCTCTCTTTATCCTTCTTCCTTCAAACT +TCAGCTTCTTAACTTCTCCTTCAGGTATTTCTTCCTTCAAAACTTCTATGTTCCCGCTTACCGACGAAAC +CTTTGAAGTCCAGCTCTCGTCTTCTTTTACCACTTCTATACCACAAAGCTCACACTTGTACTCTATCATT +TTCACAAGCTCTCCAAGTGGTATAAACCTGAACTCCTGATTGAACCTCGCTCCCTTTTCGCTATCCTTTT +GATATTCTTCGTTCAAAGAATTCGGAATTATTACTCTCCCTATCCCTCTCTCAAGGCAAACTCTCACTAT +CAGGTTTGCCACCTGATGGAAAAATCCCTTTATCCTCTTTTTCCTGTATCTCCACAGTTTTCTTTCAAGT +CTTTCTTTTCCCTCACTCCTTAGTTTCGCACTTAGTTTGTTTACCCACTGGTTGAACGACTTTAATGGAT +TTCCGTCAACTATAAAACTTCTTAAATTTTCGTCATTTGAAATGCAGGAAACGAGGTTTCTTACTCCTAA +GTCTATACTCAACCACTTTTCCTTTAGGAGTTCCTTTTGAGCTTTCGGAACTTCGTAGCTTATCCTGAAT +ATAACCTCTGTATCTTCGTACCAAGTTATCTTTACATCTCGGATATTTATCCCCTGAGGAATTTTCACCT +TTACAGCTCCGAAAGAAATTCCGAGTCTAACCACTATGGAGTTTTCCCTTCTTCTCTTTAGTTTTCTTTT +GTCCACTAACATATTGGGATTTGTAGGAACTGTGAATTTATGAACCTTCTTGAGTTTTCTTGGTCTCGGG +AGGAAAGCTCTTTCTCCCTTCTTCCATTTTTCAAGGACGCTTTTTACTTCTTTTGAAACCTGACGAGCGA +GAGCTTTTACCGTATCTGAACCTATCTCTTTTTCCCAGAGTTCTTTTAGCTTTTCCCTGTAGCTTTTAAT +TTTCTCGTTTTCAAAAGGTAGGTTTTCCTTTCCCTTTACGAACTTCTCAAGGAAAGAAACACTCAGGAAA +GGTTTTACGTCTTTCGTGTTTTTATAGTATTCAAGCAAGCAAAGGTATAGAAGGTTTTTGAATTGTTGAA +AGGTTAGGCTCGCTCTTTTGAGTTTATTTAGAACGCTTCTCTTTGTAGTTGATATTTCAAGTGTCAGAGT +TTGCATCCTTCGATATACCTGATATATTTTGATAACGAAATTGTCAACTGTTGTGGAGGAGGAAGAAGTA +ATGGAACTTCTCCTGTTTATCTGGGGAATAGTGGTGGGCACAGTATTCTCAACGGTGGGAGCTGCAGGTG +GGATACTCGCGGGCTTCGGGCACATATCCCTTTTTGGCATAAACGTAGCAAACTCAGTCAAAGTCATGAA +CCAGATACTCGTGATAATATCCACACTCATTTCCGTTCCCACATACTGGAAACAGGGAAGGTTAATCTTT +ATTCTCGGAGGACTGCTCGGTATCGGTAGTGTCATAGGAGCTATCGTCGGTTCTACACTCTCCTACACCT +ACCTTTCGGGTTTAAAAGCCTACAAATTCCTTTTTGGTATTTTTACGCTAATAGTAGCCTTTAAAGTTTT +CCACGACGTGTTTGTAAAGGAAAGAGAAAGAGTAAAGAGCATAGACAAAGATTTGAAGGAAGGCAAGGAA +AGAAGGGTAAAGGTGCTAAAGAGAAGCATGAAAGAAGTAGAGTTTTCCTTTCTCGGGAAGAAATACTCTT +TCAATCCAATTCTCCCCGTTCTGGCCGGCTTTGTGGTTGCGGTTATATCCTCCGCCCTAGGCGTAGGAGG +GGGCTTCCTACTAGTTCCCTTTATGGTTTCCGTTCTGAAAGTTCCCATGTACCTTGTTCCGGGAACGAGT +GCTTTTGCAGTTTTAATAACGACTACGATCAGTATGCTCAACTACATAAAGCTCGGGGCTGTGGTTTACT +GGAAGGTAATCTTTGCGGAAGCACTCGGGGTTATAGTGGGCTCTTTCATAGGCCCCCACATTTCCCACAT +TCTGGGCGAAAGGAGGCTCAGACTTTTACTCGGCTTCATACTCCTCGGTATAGGACTTAAGTATATCTTT +ATAAGATGATGGAAGTGAGGATAAATAAGTTCTTATCGGAAGCGGGAGTAGCGTCGCGCAGAAAAGCGGA +AAAACTAATTCTGGAGGGCAGAGTAAAGGTAAACGGAGAAGTCGTAAGGAGCTTGGGAGTAAAAGTAAAC +CCAGAAGTGGACATAGTTGAAGTGGACGGAAAACCCGTAAAGCCCCAGAGAAAACGGTACATAATCCTGA +ACAAGCCCTGTTGCTATTTGACTCAGCTCGGAAGGTCCCCTGACGGGAGGAAGACTATTGAAGAGCTTAT +AAAGGACATACCCGAGAGGGTATTTCCTGTGGGAAGGCTTGATTACAACACTGAAGGGCTTTTGATACTA +ACCAACGACGGAGAGCTCGCAAACAGGATACTCCACCCGAGGTACAAACTGCCGAAGGTTTACCTCGCAC +TCGTTGAAGGGAAAGTAGACCAGAAAACTTTAAAGAGGATGAAGCAGGGAATAGAACTGGAGGATGGCTT +TGCAAAACCCGACAACATAAGGATAGTACGCTACGAAGGGAAAAACACACTCCTTGAGATAACATTCCAC +GAAGGGAGGAAGCACTTAGTTAAGAGGTTTTTAGGAGCTTTCGGACATAAGGTAAAGCGTTTAAAGAGGA +TAGCTATCGGACCAATAAAACTCGGTAAGCTCTCTCCGGGCAAGTGGAGGGAACTTAATCAGGGGGAACT +TGCCCAGCTCTTTAAAGCGGTGGGACTGAAGTACGTTCCGAGGAAGAGGAGATGATAAACAGGAAAGTTG +TTTACGCACTTTCCGCCCTTTTGCTCTTCGTGTATTCCTATGCCTTTATAAGCGACTTTTCGGAATTTAA +AAACTTCCTGAACATCCAGTACTTAAAGTTCAAGGAATTTCTATTCCTCCTGAACAACGCAGAGGAAAAA +AGAAGGGGAACCCTAAACGAAGATGTTTTAAGGCAGTTGACCGAGAATTTAGAACTCGTGAGTATAAGGT +ACGAGTATGGGAAGTACGAGGTGAAGCTGAGAAAAGTAAACGCAGTAGAACTGGTAAGTTTATTAAAAGA +ACTTGAGAATTACGGTAAGGTTGAGAAACTGGAGGCTGTTGACAACACGGGAAGGGGGATTTTTGACGTA +AAGTTCATCGTTTCTCCTTTATAACTGTAACGTTTACGTAGTACGGGTTTACCGCAACTGGTTGTATAAA +GTAAGGCAGGGGAGAAACCACATCAACCCTTACCCTGTGAGTGCCTTCCTTCAGCTCGAAAACGTAAATT +ATCGCTCTTACTCTTTCAAGTAGTTTTGATTCTAGAAATCTTCTGGAAACGATAAGCGTAATGTCAACCG +TTTGGGGCTCTACCCTGTAAACGTAACCTTCCCTCTTTCCCTGAATTTCTACAAACCTTACTATATCAAG +GGGTAGTCTCTCTCCGAAGTTGACGACAAACCATATACTCAGGCTCAGAATCAGAGCTACAAGAACGTGT +ACTAAGTTTTCCTTACGAGCCATGTTTAACCCCAAGGAGTTCCATTAATTTGTCCTTTAAAAGCTCGTGA +TCCAGAATTTTTTCAATATTCCCTTCAACCGCCACGGATATTTCTCCGGTTTCTTCCGAGACCACTATCG +CCACGGCGTCACTCATCTCGGTAATCCCCACCGCTGCCCTGTGTCTCGTCCCGTACTTTTTGGGGAGCTC +CGGGTTTTTGGATAGAGGCAAAACGCAGGAGGCAAAGGCTATCCTGTCGTCCCTTATAACAACAGCACCG +TCGTGAAGGGGAGTGAGGGGGTAGAAAATCGTTATTATGAGTTCAGCAGTTATGTAAGCGTCTAGGTATA +TACAACCTTCTATTAAATCCTCTATGTTCTGCTGTCTCTCTATTACTATTAAAGCACCTATCTGTCTTTC +CGCCATAAACCTGCACGCTCTTACTATCCTGTCTATTGAACGCTCTTCGTACTCTTTTAGTTTTATTACC +TTTGTCCTTTTTCCTATGTTTGCAAGTGTCCTCCTTATCTCGGGCTGGAATATGACTATGAGTGTAAAGA +GGATAAGTGTCCAGAGTTTTTCAAACATCCAGGAGAGTGTCGTTAAGCTGAGTACTTCAGCAAAGAGCCA +GAGTATACCCAAGTAAATCAGAAGCCTGAGAATGTAGAGTCCCTTAGCTATGTAAAGAAACCTTATAAAC +AGGTAGAAAAATAGGAATAAACCGAATATGTCTAAGATATCTCTCCAAGAAAAGAACTCTTTTAAAAACT +CAAGAAACGTCATACGTCCTCACAGCGTCAAGCAGAGCTAAAAATTCCCTCGTTTCCTTAACGTCGTGAA +CCCTTACTATGCTAGCACCTCCCAGAACCGCGGGAGCAAGAGCTCCGAGACTTCCAAATAGCCTTTCCTT +TGGCTCCGTCTTCCTGTTTAAGAACCCTTCTAAAATCAATCCTATAAAAGACTTTCTCGATACTCCAACC +ATGAGTATTTTTCCGAAAATTTTAAATTCGTGAAAGCGCTTGAGTATTTCAACGTTGTGCTCGGGCAGTT +TGCCGAAGCCTATGCCTGGATCAAGAATAATTTTTTCCTCTTCTCTAAAACCTAACTCCTTTAATTTATT +TATCTGATTTTTAAAAAATTGTGAAATTTCTTCCACCACGTCCTCGTAAATTATGGGCTCTTCCTTCCAC +GTTTCGGGTCTTCCCTTCATGTGGTTTATAACGTAAGGGCACCTGTACTCTGTAACAACTTTCAGTATTT +CCGGGTCAAACGTCCCACCGCTCACATCGTTTATTATGTCCGCTCCCTCGTCAAGGCAAGCCTTTGCAAC +CTCCGCCTTGTAAGTGTCCACGGAAATCCATGTGTCAGGAAGTTCTCTTCTCACTTCCTTTAAAGCGGGT +AAAACTCTATTTAGTTCTTCCTCAGCACTTATCCTTTTTGAGCCCGGTCTCGTGCTCTCTCCCCCTATGT +CTATAATCTCCGCTCCCTCCTGTGCCATCTTTACAGCCCTTTCAACCGCTTTCTTTGGTTCTAAGAACTC +TCCTCCGTCGGAAAAGCTGTCAGGCGTAACGTTTAAAACTCCCATTATCGCGGTTTTTAGCCCCAGCGGA +AGTATTTTCTGATTGTAATTTAATTGAAAGTACTTTTTTCTGTACCTTATAAAACTCTCAAGTATTTCCT +GAGCGAGCTTCTTAGCCTCAGGGTATTTTACGAGTTCCGAACAAAAGTCCTTTAGCTTCGCTTCACTTCC +GCAAACTACGGTTCTTCCGTCCTTGTGAAAAATGGAAACACAACTCTTCCTTGCAGATTCAAATAAGGCA +TTCGGAGGAATAGAGGGATCGGAAAAGTAAACGCAGTGAAAAATACCCTCAAAAGCCCTCTGCTCAGCCT +CTCTAAAAAATACGCCGATTTTCTCTTTCAGAAATTTGTAAAAGAGGTCCTTATCCTCAAAGTGTTTGAT +TAGAAGCATTTAAAAGAATATTTTAAAGGAAAATCAGCAGGTGCACTCTTTCACCCCCAGAGCTCTGTAC +AGGCTGACTACGGGACACCAGTTAGTGAAGGCCGACTGTATTTGATTTATTGACATAAACACTATAAACG +CCTTCCAAAACCAGTGCACATCCTGAGCTGGCAGTATTCCGAATAAGAACACTATAAGCAGTACTACACC +AGAAGTGAGTCTGAGGAGTCTGTCCATAGTCATGTCCGTACCTCCTTATAAGTTTTTAAGGATATAAGAA +TATTCTAATATTTTGAATTTAGCTCCGGAAAGGAGTTTTTCAAGAGGGATTAGAAGGGATTACAAAACCA +AGGAAAAAATATCTGATAAGCCACAATCCCTTACTGTTAGGGCGTAACCCAATCAACACTTTTTAGTAGC +GGTATTCTCTGAACTCGCAGTCGCAATCCCTCACTATTAGGGCGTAACCCTGCGTGCCTGTGTCTAAAAA +ATAACGCTCTATCAATAACTTATTAGACTTCTTACCTTCACGAAACGAATGTTAATTTCCGCTAACCCGA +GGTTCTGCAAAATTGAGTATGCCTTTATAAAGTTTTCATACTTGATTTTCAGTCTCTTAAAGCTTGCAGC +ATCATGATATCATTTCATCACATCATCAAAGCATCGCTTATTAGACCCATCATCCCTATTCAGTTGCCAA +GGAGCCGGAATAGGGCGAAAAGCCTTTTTTTATAATTATACCTAAAAAAATTTTAAACTTATTAATTATG +TTTAGAAAAGTTCTCGTTGCCAACAGGGGTGAAGTTGCGGTAAGGATAATAAGGGCCTGTAAAGAGCTGG +GAATAAAAACAGTTGCGATATATTCGGAAGCGGATGTGCGTTCCCTCCACGTTAAAAAAGCAGATGAAGC +TTACCTCATTACGGGAGATCCGATAAGGGCTTACCTTGATTACGTGAGAATAGTTGACCTTGCAAAGCAG +GTGGGGGCGGATGCCATTCACCCGGGTTATGGCTTTTTGGCGGAAAACGCCGACTTTGCGCGTTACTGCA +GGAGGAGGGGGATAACTTTTATAGGCCCTACTCCCGAACAAATAGAGATGTTCGGAGATAAAGTAAAGGC +TAAAAAGGTTATGAAGGAGGTGGGGCTCCCTACAATACCTGGAACGGAAGAGCCAGTAAGAACTCTTGAA +GATGCAAAACACGCCGTTAAGGAGATAGGTTTCCCCGTGATGCTGAAAGCCGCTTACGGCGGTGGCGGTA +GGGGGATGAGAGTTATTAGAAACGAGGAAGAACTTGAAAAGAACTTCGAGAGCGCGTTCAGGGAAGCGGA +AACCTTCTTCGGAAAAGGAGACCTATTTATAGAAAAGTACGTGGAAAACCCAAAACACATAGAAGTTCAA +ATCCTCGGAGATAAGTACGGAAACATAATACACCTAGGAGAAAGAGATTGTTCAATTCAGAGGAGACACC +AGAAGTTAATCGAGATAGCCCCGTCCCCTAAACTCCCTCAGGATCTCAGGATGAAAATCCTCGGAAACGC +CGTAAGGGCGATGACAAGAGTAGGATACGAAAACGCAGGAACACTTGAGTTTTTGGTGGACCTCAAAACG +GGAGAGTATTACTTCATTGAGATGAATACAAGACTTCAGGTGGAACACACAATTACGGAAGCAATTACGG +GAGTGGACATAGTTGAAGCGATGATAAGGATAGCGGCGGGAGAACCTTTGCCTTACCTCCAAAGCGATAT +AACTTTCAGGGGATACGCAATAGAGTTCAGGATAAATGCTGAAGATCCTAAGAAAAACTTTGCACCTGCA +CCCGGTAAAATTACCTCTTATTACTCCCCCGGAGGGCCTGGTGTAAGAATAGACGCCTCCGTTTACAAGG +ACTACATTATCCCGCCCTACTACGATTCCATGATTGCAAAGATGACAGTATGGGCACTAACATGGGAAAA +GGCTGTGGCAAGGGCAAGGAGAGCACTTGATGAGTTCGTAGTGAGGGGAGTTCCCACGAATATACCCCTC +TACAGGGAAATAGTAAGAGACCCCGACTTCTTAAAGGGAGACTTCGGAACAAGGTTCTTGGAAGAGAAAA +TAGCGAAGGGAGAGTACGACTTTGAAATAGAAGGCGAAAAGCCCATGGAAGACGTAGTTCTTGCAATATC +GGCGGCTATAGCAGCCCACTACGGACTTTAAGACTCCTTTTTTGCCCTCCTTTGTTTCTTCTTCTTTTCC +TCTTCTTCGGCCATCTTTATCTGTTCTTCAGGGGAAGGATACGAAAGTCTTATTTCGCCGTTTTTGAGGA +GTACGTAGGATTTCTCCAGGATGTCCCTTATACCTTTCTTGTTTTGAAGGAAGTTTTCTATCTCCTTTGG +TTCGCTGTAACCCTTCATTACGTACTCTCTTTCCTCTCCGTTGTCAAAAATTATCTTTACTTTTAAACAC +CAGAACTTTGAGTTCTCGGCGTCGTGACATCTTTCAGGCTCACCCAGCGGTTCTATCTTAACGCTTCTGG +CCACTATATCTTCCTGTTTAAAGTCAAGCATTTCCGCCTCCTTGAAGTTCTCGTAAAAACATTTTAACGA +CTGTAAATTAAATTTAATGCAATTTGTGGATAAACTTCCCTGTGACGAATCCGCCGAGAGGGCGGTTCTT +GGCAGTATGCTTGAAGACCCCGAAAACATACCTCTGGTACTTGAATACCTTAAAGAAGAAGACTTCTGCA +TAGACGAGCACAAGCTACTTTTCAGGGTTCTTACAAACCTCTGGTCCGAGTACGGCAATAAGCTCGATTT +CGTATTAATAAAGGATCACCTTGAAAAGAAAAACTTACTCCAGAAAATACCTATAGACTGGCTCGAAGAA +CTCTACGAGGAGGCGGTATCCCCTGACACGCTTGAGGAAGTCTGCAAAATAGTAAAACAACGTTCCGCAC +AGAGGGCGATAATTCAACTCGGTATAGAACTCATTCACAAAGGAAAGGAAAACAAAGACTTTCACACATT +AATCGAGGAAGCCCAGAGCAGGATATTTTCCATAGCGGAAAGTGCTACATCTACGCAGTTTTACCATGTG +AAAGACGTTGCGGAAGAAGTTATAGAACTCATTTATAAATTCAAAAGCTCTGACAGGCTAGTCACGGGAC +TCCCAAGCGGTTTCACGGAACTCGATCTAAAGACGACGGGATTCCACCCTGGAGACTTAATAATACTCGC +CGCAAGACCCGGTATGGGGAAAACCGCCTTTATGCTCTCCATAATCTACAATCTCGCAAAAGACGAGGGA +AAACCCTCAGCTGTATTTTCCTTGGAAATGAGCAAGGAACAGCTCGTTATGAGACTCCTCTCTATGATGT +CGGAGGTCCCACTTTTCAAGATAAGGTCTGGAAGTATATCGAATGAAGATTTAAAGAAGCTTGAAGCAAG +CGCAATAGAACTCGCAAAGTACGACATATACCTCGACGACACACCCGCTCTCACTACAACGGATTTAAGG +ATAAGGGCAAGAAAGCTCAGAAAGGAAAAGGAAGTTGAGTTCGTGGCGGTGGACTACTTGCAACTTCTGA +GACCGCCAGTCCGAAAGAGTTCAAGACAGGAGGAAGTGGCAGAGGTTTCAAGAAACTTAAAAGCCCTTGC +AAAGGAACTTCACATTCCCGTTATGGCACTTGCGCAGCTCTCCCGTGAGGTGGAAAAGAGGAGTGATAAA +AGACCCCAGCTTGCGGACCTCAGAGAATCCGGACAGATAGAACAGGACGCAGACCTAATCCTTTTCCTCC +ACAGACCCGAGTACTACAAGAAAAAGCCAAATCCCGAAGAGCAGGGTATAGCGGAAGTGATAATAGCCAA +GCAAAGGCAAGGACCCACGGACATTGTGAAGCTCGCATTTATTAAGGAGTACACTAAGTTTGCAAACCTA +GAAGCCCTTCCTGAACAACCTCCTGAAGAAGAGGAACTTTCCGAAATTATTGAAACACAGGAGGATGAAG +GATTCGAAGATATTGACTTCTGAAAATTAAGGTTTTATAATTTTATCTTGGCTATCCGGGGTAGCTCAAT +CGGCAGAGCGGGTGGCTGTTAACCACCTGGTTGGGGGTTCGAGTCCCTCCCCCGGAGCCATTTCCACAAT +ACAATAATTCCTATGTACCTTGTATACGCCCTGAGTTTAGCTTTTACTTTATCCGTATTCCTCAGCGTGT +TCAGTCTATATTACCTCTTTAACCGCTCCCTTGACATTAACTTCGTCCCGAAGGTTAAAAAAGAAGAAAG +TGTGAATTTGGCAAATCTTCAGGGGAAATTGAAGGAGATATTCAATTACTCCGTTCAGGAAGTAAAAACC +TCAAAACCTTCGGTGAGCTCCGCTGTTTCTCCGCCTTCGTTCAAGGTCAAAGGAATTATAATTTCGGAAA +GGATAAGGGGTGTGATACTCGAAGAAGGTTCAAAAGATGTTTTCTTATCCGAAGGTCAATCTTTCAAGGG +CTACAAGCTTGCAAAGGTAGAAAACGATAGGGTAATTTTTGAGAAAAACGGTGTAGAATTTCCCCTAGAG +TTTAAAGTAACGAAGGGAGAAAAGAGTTTAACTCAAGTAAACCCTACTCTTTCAAGCCTTCCCTCGGAAA +TCGTGGTAAGTAGGAGGGAAATTCTGGAACTCACCAAGGACCCCGCGAAGATGTTCACTCAAATACGCTT +AGTGCCTTACATAAAAAATGGAAAAACCGAGGGCTTTATATTCGAGTGGGTAAAGCCCGGAAGTTTGTTT +TACAAGCTCGGGCTGAGGAGAGGAGACATTCTCGTTTCCATTAACAACACTACGATAAGGAGCGGAGAGG +ATGCCTTCAGGATACTGCAAATGATAAGGAACGAACCTAACTTAAAAGTAGAGCTTATCAGAAGAGGTAA +AAGGGAGGAGATAAATGTCCGAATTGAGTGAAAGCTTTGAGTACATAGTAGAAGAAGAAAACGAGAGGGA +ACTCCTCGTAATCGTCCCTCAAAATTACAACTTTTTTGCAGTTGAGGAACTGAGATTTAAGAAGGGGAAG +GACGTAAAACTAAAAGTTTTGAGCGAAGAGGAATACGCAAAGCTCATTCAGGACAGGATTTCCGGGGAAA +ACGTAGTACTTGAAGAGGAAGAAGAGAGGGAAGAAAAGAGCGAGGACATACTCTTCCAGAGGGACACATC +ACCTGCCGTAAGGCTGGTGAACACTGTTCTCATAAAAGCCTCTTCCGTTAACGCCTCGGATGTCCACTTT +GAACCTTACGAGGACGAAGCGGTAGTCAGGATAAGGATGGACGGAGTTCTCCACGACTATACTAAGGTAT +CGCCTTCCCTCTATCAGGAAGTGGTATCCCGCATAAAAGTTATGGCAAAACTGAACGTTGCGGAAAAGAG +GATACCGCAGGACGGCAAAATAAGGGTGAAGATAGGAAAGAGGGACTACGATATCAGAGTTTCCGTAGTG +CCGACCGTTTTTGGGGAAAGGGTAGTTCTGAGACTCCTTGAAAAGACTGGACAACTTTTAACACTCTCAG +ACCTCGGTTTATCGAAAGGAGACGAAGAAAAGGTGAGAAGACTCGCGGAAAAGCCTTACGGAATAGTTCT +CGTGACTGGTCCGACAGGTGCCGGAAAGTCCACTACTCTTTACGCTATGCTCCTTCACGTGAAAAACCCA +AAGAAGAACATAATAACCATAGAAGATCCCGTGGAGTATCAGGTAAAAGGGATAAGCCAGATTCAGGTAA +ACCCGAAAGTCGGACTCACCTTTGCACAGGGACTCAGGGCAATCCTGAGGCAGGATCCAGACGTCATAAT +GGTGGGAGAGATAAGGGACCCAGAGACGGCGGAGGTAGCAGTTCAGGCGGCATTAACGGGGCACTTAGTT +TTATCGACCCTTCACACAAACGACGCACCTTCTGCAATTACGAGGTTAAAAGACCTAGGTATAGAACCTT +TCCTCATAGCCTCTTCCCTCGAAGGAGTTATAGCCCAAAGGCTTGTGAGAAAGATATGCAATAACTGCAA +AGAGCCCTACAAACCCTCTAAGGAAGAAATAAGAGAACTGGGTCTTCCCGAGGAAGATTACACCTTCTAC +AGAGGAAGAGGTTGCGAACATTGCCTCGGAACTGGCTACAGGGGTAGAACCGGAATTTTTGAAGTACTAG +AAGTGGATGAAGATATGAAGAAATTGATAAACGAAACTCAGGATTCTGTAAAAATAAGGCAATTTGCGAG +GAAGAAGGGGTATAAAACTATGCTCGAAGATGGTATAGAAAAGATACTGAAAGGTATCACTACGAGCAGT +GAAGTGCTGAGCGTTGTTAAGTGATGTTAAAATCTTTAACTATGGAAAACGTTAAGGTAGTTACGGGAGA +AATAGAAAAGTTAAGGGAAAGGATTGAAAAGGTAAAAGAAACTCTCGACCTTATCCCGAAAGAAATCGAG +GAACTGGAAAGGGAACTTGAAAGAGTTAGGCAAGAAATAGCAAAGAAAGAAGATGAATTAATAGCGGTAG +CGAGAGAAATCAGACACAAAGAACACGAGTTTACGGAGGTAAAGCAAAAAATAGCCTACCACAGGAAGTA +CTTGGAACGCGCAGATTCTCCAAGAGAGTACGAAAGACTTCTCCAAGAAAGACAAAAACTCATAGAACGG +GCTTACAAACTCAGTGAGGAAATATACGAACTCAGGAGGAAGTACGAAGCCTTAAGGGAGGAGGAGGAAA +AACTCCATCAAAAGGAGGACGAAATAGAGGAAAAGATACACAAGCTCAAGAAGGAATACAGGGCACTGCT +AAACGAACTAAAAGGTCTCATAGAAGAACTGAACAGGAAGGCAAGGGAGATTATTGAGAAGTACGGTCTT +TAGTCTCCTCTTTTTCTTTTCACTTCTATTTTCAAGTGAGTGGAGGTTCTTCAAAGAGGTAAGTTTTGAA +GCCCTAATAAATGAATTACTAAACTATCAGGTGATATACCTGGGGGAGGTTCACGACAACGAAGAGATAC +ACGAACTCCAGTTAAAGATTTTTAAGTCAATCCACGAAAGGTACAGGAATGTAATCCTCGCCATGGAGAT +GTTCCAGCAACCCTACCAAAGATTTCTGGATGAATTCGTTGAAGGATATATAGACGAAGAAGAGATGCTG +GAAAAAACCAGATACAAGAAAACCTGGGGGATGAGTAAAAAGCTTTACGAAAAACTCTGGAATTACGCGG +AGCGCTGGGGAATAAAGATAGTAGCTCTTAACGTACCCTTTGAACTTTTAAGAGAAGTTAGAAAAAGGGG +AATAGAAAACGTAAAGAGCGTTTACCTGCCTCCTGAGATAGTCTATCCTCCCGAAGAGTACAGGGAATTT +CTCTTAAAGGAATTAAAAAGGCATAAAAAGAGCAGTAAAAAGAGTTTTCTGGATATCCAAACCACTTGGG +ACAACGCAATGGCCTACAAGTTATTAAAGACCTTAATACTTCATCCTGATTACAAAGTAATAGTTATAAT +CGGAAAGGGACACCTCTACAAAGGCTACGGCGTTCCCTACGTTTTGAAAAAGCTATATCCGGGCGTGAAG +CAAGCTGTACTTTATCCCGAAGAAAATGAAAAGTTTTACTTTCTGTTTTCCATAGACTTTTCTAAGGAGT +ACTCGTCGACGAATTCTATCAGGCTTCCGAATTGAAAGCCGTATGCAGTTCTCGTGATTTTTACCGCGGG +AAACTTCCTCCTTATTAAACCCGCTATGTAGTTTGCGGTTGCCTCTCCCTCCACGTTGGGATTTGTAGCG +AGTATAACCTCTTTTGGTTGATACTTTTTAATCCTTTCCATTAAAGCGTCTATCGTTAAGTCCTCCGCGG +ATATCCCTTCCAATGGTGCTATGTGTCCCTGAAGGACGTGGTAAACCCCCTTGTAGCGTTCCAATTTCTC +TATTGCGTAAGCGTCCTGACTCTCTTCAACCACACATATGAACTTCTTTGAACGCTTTTCGTCGGAACAT +ATGGGACATACTTCCCTGTCCGTTATCAAAAAACACTCCCTGCAAGGTCTCAAAACCTCAACGGCTTCGA +GTACTTTCTCTATTATCTCTTTTCTCTTTTCCTTCTCAAGCTTCAAAAGGTTGTACATAAACCTGCTCGC +TCCCCTTTCCCCGTAGGTTGGTATTTCCTTGATTCCTTCGAGTGCTTCTTTCAGGGATTTTGGGAATACA +TCCTCAAAGGCCAAGTCCCAGTCCTCCCAAAAGTCCTCCAAAGCGTTTACTGAAGGCTTCCTTTACCTTG +TCCCTCGCTATGTCCTGAGCCTGATTTATAAGTTCTATCAGGACGGGCTTTAACTTCTCGCAGTCCTTTT +CTTCTCCCTTAAACTCTATGTTTAATATCTCTCCAAGACCGTTGAAGACTATTTCCACTCCGTCCTTTTC +AAGGATATCCTTTTCATCCCTCAGTTCCCTTTTTACCTCCTCCATAGTCTCCTGAAAGTTCTTAAACTGC +TTCATAAAGTCGTATATATTCATCTCTTAACCTCCAGAGCTTTCTTCGTTTCGTAAACCCTTTGAAAAAC +GGTTATCAAAGAACCAAGTGTAATGATAAAAAGTCCCAGTTTTAACAGTCCCAGGAGTATACTTCCCAAG +AGAACTATCCACCTTTCCGTTCTCTCAAAAACTCCCCCAAGACCGTAAACACCGAGGCTTTCTGCCCTCG +CCCTTGTGTAGCTCACACCGAACGAACTAATAAGAGCCAAAAAAGAAAGCAAAACTCCTGTCTCATCCCC +GTAGGATGCGTAGTGAACACCGAGAGCGGTGAAGGGCAGAGCGTCAGAGAACCTGTCAACGGTTGAGTCG +AGAAACGCCCCGAACTCTGTTTTGAGATTTAGCCTCCTCGCCAGAGCCCCGTCTATACTGTCTGCCAAAG +CACCGAGGAGAAGTAGCAGAAAGGCGAGGATTAGGTTTTCTAAGTACAGAAAGAAGGAACCGAGTCCTAC +CAGGAAAAGACCGAAAAGTGTGATTAGATTTGGACTCACGTTGTACTTTCCGAAGAAGTTTACAAGGGGT +TCCAAGAGTTCTTCGTAGTAGGGTTTTAACCTTCTCGTGAGCAGACTCATTTAAATATCATTTTGCCATA +TCAACGCCAAGACTTCCTATTACCGCGAACACGTTAACGAGGAGTGTTGCTTTTATAAGCGTAGTTGTGT +CCTTTATAAAGTCAGGGTATATCCCGAACATGAGCAAACACACAAGGGAAACGAAAAAGGAAATCCCCAT +ACTCGTGATGAGTCTAAGGGGTACAAATCCCGCGACGTTTTGTTGTTCCCAGTTCTGGAGTTTGGAGTAC +TTTATGAATATAAAAACAAAGAATAGAACGAAGAAGTATATGAATAGAACTCTCAAGAGTGAAAGCCTCT +GGGCAAGCTCCCACACCTCTTCCGTGAGGGAAAAGGGAAGCGCTATTACGGCGGCACCAATAAGTTCTTG +AACCAAATCCGAAAACGTGAACCTTTGAAGCGTGTGTCTTTCTTCGTATTCCCTGTGAAGGTCTTCAATC +TTTTCCTCTATTTCTTTAATCCTTTCTTCCATCCTATTCAATTTATCCATCATTGTAGTTTTTTTATCAT +CCTTATCCAGTAGTTGTACCTGCCGCTCTCCTGAAAGCCGAACTTCTTGTAAAAGTTTATAGCCTTGTAG +TTTTCGTCTCCTACCCAGAGCTCTGCAGTGTCAAGACCCTTCTTCTTGAAGTACTCCAGAATTGTGTTCA +TAAGAGCCGTTCCGACCCCGTGTCCCTGGTACTCAGGGTCAACAACGATTTCGTGTATTGCACCTACTCT +CTTTCCTTCTCTTCTACTGAACCAGTTTGCGTCCCCTGCCCCAAAGCCCACTATCTTTCCGTCCACTTTT +GCCAGGAATATGCCTTCTTTATCCCTGTTCCACAGCCACTTCAGGTAACTTTTTACGTCCTTTGGATGGG +TGTAAGCGTACTCTTCAAGACCTTTATACGCCCTTAGGTAGAGATCTACAAGTTTAGGTAAATCCTCCTC +CTTAGCCCGTTCTATCTTTAAATTAATCTGCGTCTTCTTACTCATACCTTAGCACCTTAAAGCCTTCGGG +TATACTTGGCTTAAACAACTCATCGGTAGGCGTGTAATTGCGAACAACTTCTATAAAGTTTATACTAATC +TCAGAACCTTGAGCGTCGTATGTTTTAAGTCCTAAAATTTCTCCGTCTTTTGAGAAATAAATCTTCACCT +CCTTCACGTTCTCGTCCTTCTTTAAGGGCTTTAGGAGTAGTACCGTTTTATCCCCTTCCTTAAATTCACC +GATGGGTTTAAAAACTTTCTCCGGCTGTTCCGATAAGAAGAAAAGACTCGCTATAACGGGAGATGTGTTT +CGCTTTATACTCTCTATGTAAACGACCTTTTCCTCGAAGTTAACGAGTACAACTTTTTTCCTGTCCACGA +ATATACTAACTCTGTCGGGAGAGTAGTAATCTATCCTTACCTTTCCCCCCTTTGAGGCGTAAAATATCCC +CTTGCTCACGTCCGCTTTCGGATACCACTCGTACTTTACCTTCTGCACGAAGGAAACCTTAATCGTTTTC +GTGTTTTCGTAAAGCTCTTTTAACCTTTGAAAGGTGTCAGAAAATACGAGTGTAATCGTTAAAAGGATTA +ATAAAATTAGCATACTCTTTATTTTAATTGACACCCGAGGAGTTTTTTCAGTCTACTCTCAAGCTCCTCC +TTGCTTTTGTTTGTGTTAATTACGCAGTAATCTATCTCTTCGGGAGCTTCAAACTCCTCCTTTTGTTTCA +GGTAGATGTTCCAGTCCGCATCCGAAACGTCCTTTCTGCTCTTTAGTCTCTCTTTTATCACTTCTTCGGG +GGCAAAAGCTAAGATAAAAAAGGGATCCTTGAAGTTTTTTAAAACGAGTTCCCTCTGCCACCTCTTTATA +AAAGTCGCGTCGAGAACTACTTTCTTTCCTCGATCTATTAACTCCTTTGCTCTCTTTACCATTTCCTCGT +AAACTTTTTTCGTAATTTCTTTCGTGTATATCCCCTTTCCGTAATCCGCCTTTGCGCTTTCCTCGGGCTT +TAAACCGGCGAGTTGCTTTCTAATTACGTCGCTCCTGAGCCACTCGTAACCGCACTTTTCGTGGAGTATT +GAGGCAAGGAAGGATTTTCCACTTCCCGAGAGGCCGAAGATAACTACAAGTTCCCTCATGACTTTATGAA +GTTCTTACTGGGTTTAAATAGGACTATTTTCCTCTCGGGAACCTCCACGATTTCCCTCTTTTTTATGTTC +ATACCTTTCTTTGGCTTTCTTGTTTTTACTACAAAGGTACCGAAGCCGGATATCTTTACCTTTTCACCTT +TTAGGAGACACTCCTGAATTATAGTGAAAACTTCCGAGACGAGGTTATATACTTCCTTTTTCTGTATTTT +TACGTTGTAATCCCTTATAAGGCGGTCGTAAATCTCTTCCGCTATTTCTTTTTTAGTCATAGGAAGGTAT +TATAAGGGAAAGGGAAGGGGATTAGAGTTTCCACCTTTTCTTGAGTATCTCTCCGAGTTTGAAACCGCCG +GTTGTAGCGGTTGTAACTTCTTCCACCTTTTCTTCTTTTTCTTCGGGCTTTTCGCCGTATAGTGCGTTTA +TGCTAAAGGTAATCTTTCCTTCCTTGGGATTTATGTCTATTATCTTCACTTCGTACTCCTGTCCCTTTCT +TATACGTATGTGTCTGGGAACTTCGGAGAAGGGCAGTAATCCTTCTACACCTTCGGGAAACTCAAGGAAC +GCTCCGAAGGGTGCAAGCTCTTTTACGGGTAACTTGACAACGTCTCCGACCTTGTACTTTTCCTTGACCT +TTTCCCACGGATTTTCCGTAAGTTGCTTTAGACCGAGTTTTACATACTTTCCTTCCAGACCGAGAACCGC +AAATTCCCTCTCTTCTCCTTCTTTGAGGACTTCCTCAACCCTCTTTGGTCTCGTCCAGGAGAGGTCACTC +CTGTGGATTACACCCTTAACGCCGTCTTCCAGTTCAACTATAGCCCTGCTGCCTTCGATTTTAATAACCT +TACCCTTAACCTTAGAACCGACGGGATGTTTCTGGAGGAAGATTTCCCAAGGTCTTGGCTGTGCTCTCTT +GATGGAGAGGATAAGCCTTCTCCTCTTGGGGTCTATCTTCATTATCTTTGCCTTTACGAGATCACCCTTC +TTAAACTCTGGTTTTCCTTCCCACGCGAGCTCCTCTTCGGGAACGAAGCCCTCTACTCCTTCCATTACCT +CAACGACTACACCCTTAGGTGTAACTGCAACGACTCTTCCTTCTATTACGTCTCCTTCTTTGTGCTCTTT +TAGGAACTTCTCCCAAGGATTGCCCTTGAGTTCCCTGAGGCTTACTATTATGAAGCCCTTTTGTTTATCT +ACCCTCTTTACCTTTACCTTTAAGGTTTCACCTACGTCCGTGTAATTGTAAGGATTCTTATCCCTTCCCC +AGGAGAGCTCCTCTTTTGGCAGGAATGCCCTGAGAACCCCTTCTATTACAAGTGTTACACCTTTGTTTGG +ATCTATCTTTACAACTTTACCTTCAACGACGTCACCGGGCTTTAAGGTGTTGAGGAGTTCCTGTTTTCTC +TTTTCCCTTTGTTCATCCAGGTATGCCTTGTGGGAAACGATTATCTGGGGTCTCTTTGAATCAAGTTTAA +AGTCCAGAACCTTGAAGGTTAGTACCTGTCCTTCCTTTAGCTTCTTACCTGCCTGGGACATTGGGAGGAA +GGCTTTTACCCCTTCGAAGTCCACTATGAAGCCGCCCTTTACCTTTTTCTCTATCTTTCCGACTACGTCA +GACTTGTTCAGGTAAGCTTCCTTCAGCTTTTCGAGTTCCTTTTTCTCCTGCAGGGGTTTTACGGAGAGTA +CAGGATTGGGAATCCTGGGTGAGAAGCGAACCAGAACCGCTTCTATTTCTTGACCTTCCTGAACCTCTGG +AACTTCTTCCTTTGAAATGACAGCCTCGGTTTTATAACCTATGTCTACAAATACGGTATCGCCCGCAACC +TTAACGACCCTTCCCTTTACTACCTGCCCTCTTTTAAACTCTTCGGGGGAGGCTATTGACTCTTCGAGGA +GCTTTTCAAATTCGTTCATTAACTTCCTCCAGACAGAATTTTTTATTGTAAAACATTCTCACTTCTTTTT +CAAAGAGATTTAAACTTAAAGAAGGTGCTTGTGCTCTTTTAACCATTCCTTGAATGACTTTCCAGATAAT +ATACTATTTAAAATGTCTTTTTCAAGTTCTGTCAAGTCTTTAGGTATTAAATCCGGTCTCTTTTTTACCG +TGTTTTCTATCCTGTGCCATAACTTCCAGAGTTCTATCAATTTGTGGTGTCCTGAAAGGAGCTCTTCCGG +AACCTTCATCCCCCTGTATTCCCTTGGTCTCGTGTAAACGGGGTAGCCAAGCCACCTGTTTTGAAAACTG +TCTTCCTGAATGCTCTGAGGTTCACTCAAAACTCCGGGGAGAACCCTGCTCACCGCGTCAATTACCGCGA +GGGCTACGATTTCACCTCCCGAGAGTATAAAGTCTCCAAGAGAAATTTCCATATCCACGATTTTCTTAAC +CCTCTCGTCCACTCCCTCGTACCGCCCGCAAATTATCATTATCCTTTCCTTTTTAGAAAGTTCGTTTACC +AGCTTTTGGTTTAGTTTCTCTCCCCAGGGCTCGGTAATTAAAACGAAGGGTTTTCCGTAATTTTCAACGA +CGTAATCGTAGGCTTCGTATATGGGTTCTGGTTTTAAAACCATCCCTGGAAGTCCGCCGTAGGGGACGTC +GTCAACTTGTCCTTTTGGTGCAAACTCACGAAGGTCTATGGGATATACTTCTACTTTTCCCTTTTTTATA +GCCTGCTTTACTATACCGTACTCCGAGTAACAGGAGATTATATGGGGAAATATGGTGAGGACGAAGAAGC +GGAGGGGATTAGAACTCAAAGTCTTTCAGATATTTTGCCCTTGCGGGGTGTCTTAACTTCCTGAGGGCTT +TGTTTTCTATCTGTCTTATCCTTTCCCTCGTTACGTTAAACATCTTTCCTACCTGTTCCAGGGTGTACTC +AGTTCCATCAACGAGTCCGTACCTGTACATGAGTATTTCCCTTTCCTTTTCGGAAAGCGTGCTCAGAACC +TTCTGGAGTTGTTCCCTGAGGAGCTTTCTCGTGACCTGCTCCTCGGGGTTTGGTATGGACTTGTCCTCTA +TGAAGTCCTTGAGGAAGGTGTCGTCGTCGTCACCGATGGGCGTTTCAAGGGAAATGGGCTCTTGGGAGAA +CTTCATAACTTTCTTGACTTTTTCTACAGGGATATCCAAGTATTCCGCTATTTCCTCGGGGGTGGGTTCT +CTTCCATTTTCCTGGAAGAGTTTCTTAGAGGCTTTAATTATCTTGTTTATCGTTTCTATCATGTGAACGG +GTATCCTTATGGTTCTTGCCTGATCGGCTATAGCCCTCGTTATGGCCTGCCTGATCCACCAGGTTGCGTA +TGTAGAGAACTTGTAACCTTTTCTATAGTCGTACTTGTCAACTGCTTTCATTAGACCAATGTTTCCTTCC +TGAATGAGGTCGAGGAAGTGGAGTCCCCTGTTTACGTACTTCTTCGCTATGGATACGACAAGTCTGAGGT +TTGACTGTATCATTACCTGCTTTGCCTGAACTACCTTTTTCCTTCCCTGTTCTATTATCTTCATAACTTT +AGGAAGTTCTTCTTCGGGAAATACGCCTATGAGGTTTTGTATCCTCTGGACTTCTCTTTTGAGGGAGTTG +TACTCGTTTATTAAGTTGAGAACCTTTTCCGTGGGGATGTTCTTTTCCTGAACTATCTTCTGGAGGTTTT +CATCGGTTAAGAAGTTCTGAGCAAAGTAATCTGGGTCTTTGTAGAGAGCCTTTAATTTCCTTATGCGAGC +GTTGAGGTCCTTTCTCTTTCTTGCGTACTCCTTGTATATCTTTATTATCTCTTCCGTAACTCTTTCGAAT +TTTGCGTACTTTATCTTCATTTCCTTGATTATCTTGTTCATCCTAGCGTGAGCGTACAGGTACTTCTTTC +TGCTTTCCTCACTCGGGTTCTTTATGTACTCTTCTCTCACGTCCAAGAGGTTTCTGTAAGCTTTTGCGAG +TTCGTATCCCTTTTCTATGAAAAACCTCTTGAATTCGTCAAACCTGTCTTCAAAGTCATCGTCGTTTTCG +TACTCAACGAGATCCATAACTTCCTGTATTTTTAACTTTCCGTTACAGAGCTTTGCCCAGTCGTCGAGTA +TCTTCTCAACGAGGAAGGAAGTTCTCATAAGACCCCTTCTCATTATCTTTCTTCCGATTTCTATCTGGCG +TGCGTAGTATATCTCTTCCTCCCTCTTGAGAAGGGGGATTTTGCCCATTTCCCTGAGGTAGAGCTTTACG +GGATCTCCGTCTCTGGAGCTGGAGGTAAGGGAACCAGAAACTACCACTTCCTCTTCTTCTTCCTGTGTCT +CCTCGGACTCTTCCTCGTATTCCTCTTTACTCTCTACTACCTGAATGTTCATTCTGTGGAGAATGTCTAT +TAACTCCTCAAAGAGTTCGGAAGAGGTCACGTCTTCCTCGAGCACTTCGTTTATCTCGTCGTAGGTCACG +TAACCCTTTTCCTTTCCCATTTCGATTAGAGCCTTCACGCTTTCCCTTCCTAGCATTCTCTTACCTCCTA +ACTCTAAAAATTTATTAAAGTTAATTAAGTATTTACATTTTTCAACCCTCTTTTCTTCCTCTTTTTCCCA +GATTTTTGTAAATCCCTAAGGATGTTGTTAAAAAGTTTCTCCAAGTTATCCACCTGGTACTCGAGAACTT +CTTTTGGAAGTAAATGCTCCTCTCCGTTTAAGGCGTTAACTGCGAGTTCCTTTAACTCAGGACTTAAGTT +CAGGACTTCAAGGTCTATTTTTGGTTTTAATTCTATCAGTCCTTTCAGGAAGATTTTTTCCTTAAAGGAG +AGTTTAATTTCTTTTTCTTGAGAATTTTTTTCAATTTTCATTAATAAAATTTCCATAGGAACTTTGTACT +TGGTGTGAAACTCCGAAGCCAGAGCAAAGCGCCTTACTCCATCGGAAATAAAGCCCAGATAATACCTGAA +CTCACGCGTTTTCTCCTCTAAGTTTTCCCTTGCGGTTTTTATGAGCGTTTCAAAGAGCTCCCCTGAGCTG +TTTATCAGTCTTCTTAATTCCTCTTTCCCGAATTCCTTTATAAACTCGTCGGGATCGTATCCTTCGGGGA +GGTAAACGGGATAAACTTCCACTCCTGCACTGAGGAGTAGGGGAATGGCACTTTTCATAGCCTTTCTTCC +CGCATCATCTCCGTCGTAAAGGATGTAGACCTTTTTTGTGAACTTGGAAAGGAGGTTTGCCTGATTTTGG +GTCAGGGCTGTACCGAGGGGTGCAACAACGTTCCTTATTCCCTCGGAAAAAAGTCTCAAAAGGTCAAAGT +ACCCTTCCACAAGTATCGCAAATCCTTCTTCCTTTATATACTCCTTTGCCTCGTAAAGACCGAATAAGTT +CTCCCCCTTTTTAAATACCCTGCTGTCTGGAGAGTTTATGTACTTGGGAGATTTGTCCTCTACTATCCTC +CTTCCACCGAAACCTATAACTCTTCCCCTCGGATCCTTTATCGGGATCACGACACGCCGAAGAAAGAGAT +CCCTGTAAACACCCTTCGTAGGAGAAAGGAGGTTTTTAGTTTCAAGGTAAGCCTCTAAAAGATCGTTCTC +TTTTAAGACTTTTACGAGTGCTTCACTGGAAGGTGCGTACCCAAGATCAAACTTCCTCGCTACTTTAGGG +TCTATTCCCCTACTCTTTACGTACTCACTTGCCTCTCTGTTTTTGAGAAGGCTTTCCCTGTAGAAATCAC +AAACCCTGTCAAGAGCCACGTATACCTTTTCGTCTTTTGATATCTTTTCAAGGTCTAATTTCTTTCCGTA +GCGTTTTGCGAGTTCAAGGGCGGCTTCAAAATAGGAGATGTCCTCGTAAAGGGAAACGAACTTTATCGCG +TCTCCCCCTACCCCGCAACCGAAACACTTGAATATTTGTTTACTTGGAGACACGTAAAAGGAGGGTGTAT +CGTCAGGGTGAAAGGGACAGTTCGTTCTGTAATTGGAACCTACCTTCTCTAAGTTTAAGTATTCGGAAAT +GACGTCTACTATATCTATTTCCCGTCTAAGTTCGTCTATGTCCGAGGACATCACTCAAAAGAATTTATTT +TATTTCTGATCTGTGTCAAGCTGAAGAAATACCTGTAAAATCAAATTATGCCCTTCATTTACAGGAGGAG +AGTCCAGTTCTACGAGACCGACGCTCAAGGGATTGTACACCACTCCAATTACTTTAGGTACTTTGAAGAG +GCAAGGGGTGAATTCCTTCGCTCAAAGGGTTTTCCCTATTCAAAGATGAGGGATATGGGACTGGAAGTGG +TACTTTTGAATGCTTACTGTGAGTATAAAAAGCCCTTGTTTTACGACGATGTATTCGAAGTACACTTGAA +CCTAGAAGAACTTTCTCGCTTTACCTTTACCTTTTCCTATATAGTTTTTAAAGAAGACATAGCGGTTGCA +AAGGCTAATACAAAACACTGCATGGTAAAAAATGGAAAGATAGTCTCAATTCCGAAGGAAGTTCTTGAAG +TTTTAAAGGATTAAACCCTCGTGTTTTAATAGTTCACTCTTAATTTCTATACCTTGATTAAAACCACCTA +AATCCCTTTTAGAAATAACCCTGTGGCAAGGTATGATCACAGGAAAGGGATTTATCTTCATGCAGTAACC +TACGAATCTCGGGTGCAAATCAGTCAATCTCGCAAGCTCTCCGTAAGTAATAATTTTTCCAAAGGAAGCG +ACTTCTTTCAGTTTTAAGTAAACTTTTATGCATTTTGGATTTATCCTTTTCAAATCGAGATATTCTAAGT +TTATTAAGGGATCACCTTCCTTTAGAAAATATAATAAAAATTCCGGAATAATTTTCTGTTCTTTTTTCTT +TAAAATCGAAATTTTAGAAATTTTTCCTTTATCAAAAAAAATTTCAAGGGAAAGAGAAGGAGTAAGAGCT +GTTTTAAGTACAGTAATTGGGATTACAGTCTTTTTCGTCTGACTCTTCAAGGAGTATACACTCTTCACAT +ATCTTTCCTCCGGGAGGTCTTGTAGCTCCGCACCACGTATCGTAATCTTCCTGAGGATAATCAGGGCAAT +TTGTGCAGAAGTGCCACTGATCACTTCCCTTCTTCTTTCTGTACTCAATTAGTGCCATGATACCCACCTC +CTTCAGGTTTTTCTTAACTTCAAATATATCCATGATTAAAGATACTTCAACGCATAAGCAAGTGCCCCCC +TCGCTCCCATAAATTCACCCGCCCTTGAAAAGGAAATTTTAAGACACAAGGCGGGAAGCTCCTCGGAAAT +TTCTTTCACCTTCTCGGGAACGTCTCTCAAAAATTCTTTAAAGGTTTCTATCACTCCTCCGGCTAAAACT +ATCCTGTCGGGGTTAAATATGTGAACACCGTTCATAAGCCCCGTGATTAAGTAATCTTTAAAACTTTCCA +CAACTTTTAACGCTTCTTCTTCACCTTCTTTAGCCTTTTCCGCAATTTCGTAATCTTTTAAAGTTCTACC +GGTAAGCTTTTTATACTCCCTTTCTATTGCGTAAGAGGAGCAGTAAGCTTCCCAGCACCCTTTCCTCCCG +CAGTTGCACAGCTCTCCGCCCTTTTTTACAGTATGGTGTCCCATCTCTAAGGCACTTCCGCAAACACCGA +AAAATACCTCACCTTTGTACACGAGTCCGGTTCCCAAACCTGTCCCCACCGCTACGAGTAATAGTATCTT +GCTATCCCGATAATCGTAGTACCACTCCCCGAAGGCTCCGAGGTTTACGTCGTTTCCTACAACGAAAGGT +ATGTTAATATCTTCAAGAACCTTCCTGAAATCCGTTTTATCAAGTGCAGGAATGTTAGGCGATTTGTATA +CGATACCATTAAGAGAAGTAAAACCAGCAACCGCTATACCAACACCGCTCGGATTTCCCGCCTTTATAAC +CTCTCTGATTTTTTCCATTAGTGCTTCTCTGTCCTTTTTTAAATCCTTTATGTAGTGCTTTTCCTTCTTT +CCGTCTTCCCAGAGGACTTTTATAAATGTCCCTCCTATGTCTATGCCCTTTTTCATACTGAGTTAAGGTA +CTCTTCGAGGATAATCATAGCCGAAATCACGTCCTTCAACTCCTTCTTTTTCTTAGGAGGTAGTCCTTCG +AGCCTCCTCATAGCCTCTGCCGTGGTCCATCGTTCGTCCCAGAGTATGATTTCCGTATTTGGCAGTTCTT +CCCTCAGCTTTTCCACAAAATCTTTAACGAGTTTAGCCCTCTGCCCTTCTTTTCCACTCGGAGTTAAGGG +CAGACCTACAATTACTTTTCCTACCCTGCTCTTCTCTACGATTTCCTTTATCTTTTTTACAGCTTCTTTT +GAGCTTACCGTCCCCTTGGGAGATACAATTTTTAATTCTTCGTCACCAATTGCAAGCCCTACACGTTTAG +TACCGTAATCAACCGCAAGAACCTTCACCCCGTCCGTATGCCGAGTATCTTATACAGCGGACAGAACCCT +ATTGCGGACGTCACTATGAACACTATGCCGATTATTCCGAGAATCCAGTAAAGCCCTCCGTTGGTGAAGG +CGAGGTAAAGGAATATAACCGCTAAAATAACCCTTATGATTCTGTCCCATAGCCCCATGTTCTTTTCCAT +TTTGTCCACCTCCTATACTTAATTTTAACTCAGAATATGACTTTTGACATATGAGTTTTTAAATAACTTG +AGTTAGAATTTTTAATACCAAAATACTTAAAGTAAAAGGAGGTGGAAACCATGGGTGTACACAAGATACA +GCCAAAAGACCACTTAAAACCTCAAAACCTTGAGGGTATATCCAACGAACAAATAGAGCCTCACTTTGAA +GCTCACTATAAAGGTTACGTTGCAAAGTACAACGAAATCCAAGAAAAGCTTGCGGATCAGAACTTTGCCG +ACAGGAGCAAGGCAAACCAGAACTACTCCGAGTACAGGGAACTGAAAGTAGAAGAAACTTTTAACTACAT +GGGTGTTGTACTCCACGAACTCTACTTCGGAATGCTTGCACCCGGTGGAAAGGGAGAACCCTCCGAAGCC +CTCAAGAAGAAGATAGAAGAGGATCTCGGCGGACTTGATGCCTGCACGAACGAGCTCAAAGCAGCGGCAA +TAGCCTTCAGAGGATGGGCAATTCTCGGACTGGACATATTCAGCGGAAGACTCGTTGTAAATGGACTTGA +CGCTCACAACGTTTACAACTTAACCGGACTCATACCCCTCATAGTTATAGACACATACGAACACGCTTAC +TACGTGGATTACAAGAACAAGAGACCTCCGTACATTGACGCATTCTTCAAGAACATAAATTGGGACGTTG +TTAACGAAAGATTTGAAAAGGCTATGAAGGCTTATGAGGCTCTTAAGGACTTCATAAAGTAAAAAGTTTG +TTCCTTTTTCTTTTCTTTCTCTTAATTCTTTCCTGCGGAATAAAAGCACCACCCAAGCCCCTTCCAGAAC +CCCAATTTTCAGTAAAAAGAATAGGAGAAGTAGTTTACGTTTCAGGTCAAAACATTGAGGTAAAAAACTT +TAAAAAGTTAAACGAATTCTGGTATAAAAAAGAAAAAAGTTCTTTCTGTTTTGAAGTAAAACACGTAAAA +GGAAAATCAAAAAAAGTTTGTGTAAAAGAATCGTCCGGAAAACCACCCGAATTAGAAATTAAAGAGTTAA +AGGAAAAAGTTTTACTCATTCCAAGAGAAAGTGGAACTTTCAGAATTTATAGAGTTGTAAAAGATAAAGT +TTTATATCCAATTCCTTTAAAAGAGTTTTCAAAAGAAACGGAAGTACAGAAAGACTACGAACCTTATTAC +ATAGGTGTAACGAAAGTATTATCGCAAGATTACGAAAGCGAACCTCTTATAATAAAAATTTCACCCAAAC +CAAAGCCCGTACCAAAACCACCTTACTCCGCAGGTTATACTGTAAAAGGAAAAAAACTAATAATTTACTG +GTTCCACGAAAATTACGAGGAATTGATAGGTTTTAACGTTTACAAAAACGGAAAGAAATTAAATGAAACA +CCACTAAAAAGGAATTACTTTGAAGACGAACTGCCGAAAAAAGAAACTCTATACGAAATAACGGCTGTAA +ACAGGTTCGGGATAGAGAGTAAACCCGTTAAGGTTTTCTTTCATCCTGTAGAGTCTCAAACGCCTTGAAA +AGCAGAAGGTAAAGAGGAAGGAGTGCGTCCCAGAAGAAGGTAAACACAGACTGGATTAAATGCAATCCCA +AGGGAACGGAAAGAAGATAGGTATAAATATCTTCCTCTCTTTTTATTCTGAAGGAAAGTACCTTTTTAAA +GTACATAAAGTAGATGTAAAGGATTCCAAGTAATCCTAAAATTCCCCTTTCTATGAATTCTGAAACTATA +AAAATGGACTCGTACCTATGCTGGGTCATTCCGTACCTGTGGGGCATATACTCGCCCGCCCTTACTCCGT +GTCCTATCAAAAGATTGATAAACCTTTTATTCTCAATATCTTCTTTTATTATTGAAATTCCCTCCAGAAG +CAAGTTTAACCTTCCAGAGGAAATACTATTTAAATTCTGGTAATTTAATTCTTTCTTTCCCAGAATTATG +TCGTTTAAAGTTTTAAACCTGTGATCTTTTTGTGAAAGGTATACGTATCCTCCTATAAAAGATAAAATTA +TTAAAAAGTTTACACTCCAAAAAGCTAATTTTCCCAATTTTTTACTCTTAAATAGAACAAATAATATGAG +ATAAAATATCACAAAAAAAGCAAGCATCATGGAGCGTCTGGCAGATAGGAATATTACGGCTAAAAATAGA +AGAAATAAAGGTATGTAAATAAACCTTCTTTCCTTGAAAAAGAGTAAAAAGGTCGTTATGGAAAAGAGTG +CGTAGAAAAACCCAACTTCGAAGGTTCCGCCCCATATCGGTTTGGGCTCACCGTACTTGTAGAATTTGTA +AAAAACTACAGGAAGAAGAATTAAAGAAATTCCGAGTAAAAGTTTTGGAAATATTTTTGAAAATCCTTTC +ACCTCTTCTTTTTTTAGGTTTAAAAAGTAAATAAACTGGAACAGTCCCTCTTCTATTCCCTTCAGAAATC +TTTTAGGGTAAAAGATAGCTGTGGATAATACCGTTGAAAGAGAGTACAAAAGAATTCCAGGTGTTAAACT +GCCCTTAATTTTTCTTTCTTTCAGGATTTTGTAAAGAACAAGTAATAAAGTAAGAATGACAAATCCTTCG +AAAAGGCTTATAGATAAGAAAGCTGATATAACTAATGCGTACAAAAGTACTTCATTTCTACTCATTTTCA +ACAAATTCTACCATTTTTTCTTTATTTCCGAGGACTAAAAGCGTATCTTCTTTATCGAGTACGTAATCTC +CTGAGGGGTTGACTACTATCTTTCCATCGGGTTTTTTTACGGCGAGAACTGTAATGTCGTAGCGTTTCCT +GAGGTCGAGTTCTTTTAAGCTCTTGCCGTGGAAGTTTTCAGGAGTTTTTATTTCAAAGATACTGTAACCC +GGGGCAAAGGGTATCTCTTCTATGAGTCCTTTCAGGAGAAGGGAGTGTGCCAGCTTTATCGCTGTTTCCA +TTTCGGGGTAAACTACCCTAGCAACTCCTAGTCTTTCCAGAACCTTTCCGTGAAGCTGGTTTATGGCCTT +TGCCACTATTTCTTTCACACCTTTTTCTTTGAGTATTACTACCACAAATATACTCGCCTCCACGTTCTGA +CCTATACTCACAATTGCCGTGTCAGCGTTGAAAACACCTGCCTCCTCCAGAGCTTTCTCATCAAGAGCAT +CTGCAACGTAGGCGTGCGTAACGATTTCGGAAATTTGTTTAACCTTGTTTTCATCTACGTCAACGGCTAT +CACTTCTGCTCCGAGTTCCGCTAAAGTTTTCGCAACGTAAAACCCGAACCTCCCCAAACCTATTACCGTG +AAAATCCTCTTCATACTAAAATCCTTGCCTCCGGATACTTAATCCTCTGCACTTCAGACCTGCCCGTGAG +AGCTAGGGCAAAACCCAGAATGCCCAACCTTCCCACAAGCATCGTAATTATTATCACAATTTTCCCAAGC +GGCGAAAAATCCGCACAGAAACTCAAGCCTTCCGGATTTCCGATGGAAAGCCCTACGGTGGAAAAGGCAG +AAACTACTTCAAACATCGTGTAAAGAAAGTCCTTATTCTCAAACTTATCGAGCATCAGGTTAACGAAGTT +TATAAAGAAAATTGAGAGCGAGAGTATAACGAGAGCCTTCTTTATAGTGCTTTCGGGAACACTCCTTTCG +AATATCACGCTCTGTTCCCTTCCTCTTACAAAGGAGTAAACGGCTATAAGAATAACAACGAATGTAGTCG +TTTTTATGCCTCCTCCCGTGCCTCCCGGAGAAGCACCTATAAACATTAATATCATTAATAAAAACTGGGA +AGATTCACTCATATCTATTAAATCCACGGTACTAAACCCTGCAGTCCTTGAAGAAACGCTCATAAAGTAA +GAGGAGAGAATCCTTTCGTACCAGTCGTACTGCCACAGTCCTTTATAATTTCCGAACTCCGTGAATATAA +GTCCCACCGTTCCCAGAAGGATTAATAAAACACTCGTTATCATAACAAGCTTTGTATGAACTGAAAGTCT +TGGAACCTTTTTTGTGTACCAGAGGTATATATCGTTTACCACGAAAAAACCTATTCCTCCGAGTATTATC +AGGAAAGAAATAACAAGGTTTACGAATAAATCTCCACGGAAATCCAGAAGTCCATTTTTGAAAGTTGAAA +AACCCGCGTTGTTAAACGCGGAAACCGAGTGAAAGATGCCGTTAAAAACTGGGTCTTCTACACCTTTTAG +GGAAAAGTAAATACTGAGTAAAATCGCTCCCGTGAGTTCCGTAATGAAGACAAAGGAAAATACTCTCTTG +AGGAATCTTATTAATCCGTGCATACTCGGGTATTCCAGAGATTCAGCGAGTATAAGTCTCTCTTTGAGTC +CTATTCTGCGTCCGAGGAGAACCAAAAAGAAGGTTGAAAGTGTCATGTATCCGAGTCCGCCGACCTGAAT +GAGGAAAAGGATTACGAGTTTGCCAAAAAGGGTAAAGTCCGAGTAAGTGTCCAGAACCGCGAGTCCTGTA +ACAGTTACCGCCGAGGTTGCGGTAAAGAGGGCATCTAAGAAGGATATTGGTCTAGTTGTGGAAATGGGAA +GGTATAAAAGCAAAGCACCGACTAGTATAAGGAGGGAGAAGGAAAAGAGAAGTGTACGAGATGGGTTTAA +CTTTTTTACCACTTGAGTTCGTTGGCTTTTGAGTAGGTCTGAGGCTTTGCCTGGAAGAAGTCCGTTTTAG +TGTTGTTTATCTTTCTAAACTCGTCTATCCACTTTAAGGGGTTTTCTGTAACCTCTGGATATATCGGATC +AAAGCCGATCTGAGTAATCCTCAGGTTTCCGAGATACTTTATATACCTCTCTATCAAGACGTCGTTAATA +CCGAGTATCTGGTTCTGGGTAACATACTGCCCCCATTTGATTTCTTCGTTCACCGCGTACTTGAAGTACT +CCACTATCCACTTTTCTATCTCAGGCGTAAATAATTCGGGATTTTCTTTCCTGAGTGTGTTTATTATGTT +CCTGAAGAGCGTAACGTGGCAGTTGCCCGCAATACAAACGCTGTCTTTGTATCTCACAACTATGTTCCCT +TTGGGAACGCTCACGCAGTACACCTTACCTTTGTAGTAGAACTCTTCCTTCACCATTGTTTGGGTATTTA +TGTAGTCGTCCTCTAGGTAAATCCATATCCTGTAAACGGGGTTTTTCGCCTTCGGATTTCTCTCTCTACT +GACAACAGTTCTCATACCTCCCAGAGCACAAAGTGCCTGCACAAAGTCCTTGTTTCTTTTTTCTTTTGTG +GAGTAATAATAAACCTTCTTTTTATTCCTGTCTTTCGGAATGTGTCCGTCCCACTTGACGAGTTCTTCCA +CAAATTCCCTTATCCATTCTTCCGTTATCTCATCAAGTCTCACCCATTCGTCAAAGAACTTAGTAGGCTT +TATCGGAAGGTCATTCGGATAGTAAACTGTGTAAGCAATTCCGTCTTGGCGCTCGTACTTTTTCCATTTA +ATTCCGTAAGGTGCACATTCATTGAGTATTTTTTCAAACTCGTTAATCTTTCTATACTTTGAGAAGAAGA +ACTTTAATTGTTGGAAGCCTGTGAACTTTCCATTTCTCTTACTGTCTATTGTCCCGTCCGCCTGAAGAAC +TATCAGGAGTTTTTCTATCGGTGTTAACTTATTCTTCACAGCACTCCTCGTTTTAAGAGTTATACCTTTT +CCGCTTACGAGTTCCCAGAGGTCGTACTCTTCCACTTCTCCCGTGTACCTTCCCGCAACGGGAATTGCAG +AGTAGGGATGTAGTTTTACCTTTTCTATCGGTTCCTTTCTCTCCTTTCCTGTTTTCAGGTTCCTTACTAT +GAACTCGTGCCCTTCAGTAGCTACTACTTCCCAGTTGCTTTTAGGATGTTTTAATCTGTACATAGAACCC +TCGTAATCCCTTTCAACGTAGGCGTAAGGTTTTGTCCAGGAAATTTCCCCTGTTTCTATATCGTACTGAG +CTACAAGATCGTCTTCCCTCAGCTCCCTGAAATCAACGAACCCCCTCTTCGTCAAAACCTCCGTTCCCTC +AATGAAGCAGAGCTCATCCCTGTTGATATATTTGATTTGCTGTACAGTGTTTCTCATTTTGCCCTGTCTT +CCCAGTGTGTAGAAGAAGGCAAATCCAGAGTAAAAGTACAGGCTCTCGAGTATGTAGTTCCCTATTGTTG +CCTTTATAAAGTTTTCTTCGTTGGGTTTTCTAATGAATTCGTTGTACAGCTCTGCTATTACTTTATTCCT +TTCCAGAAGTCTTTCATCCTCCCGCCAGTAGTTGTAAATCTCGTCCGCTTTAACCGGATCAACTACAGAC +TCGAGTATGAACTGGTAAGAGTACGCGTGGACGGATTCCTGAAATTCCTGAGCTGTTATGGCCATTTCTA +CTTCGGGGGCGGTTATCATCCTTCCGAACTCTTTAAGCATGTCCACTTGAAAGGAGTCAAGGGCTATGAG +GAAGGAAAGGACGAGTTCGTATGCCCTCTTTTCGTAGTCTGATAGAACGGTCTCGTACTGTTTCCTGTCT +TCAAGCATCTGTATCTCTTCGGGTATCCAGAAGTTTGTAAAGCCCATTAACTTGTAAAGGTCAAAAGCCC +AGGAATACTTTATCTCGTTAAGTTCAAATATGTTTGTCGGGTTTCCCTTTATTATCTTCCTTTTGCTCGC +CTCCCTGTCTCCTTGAGGGTTGAAAATGAGTTTTCTGACAAGCTCATTTTTTTCTGTCTTTTCCATTTGG +TTTACCTCCTGAAGGGTGGAGTGTTGCCCCGAAAATAAATCCTAAATCCTTCCACAGGAATTTGGAAGTA +GAAAATTCATGAAAAGAGGTGTTATAATAACTTAAATTTTCCTGACGAGGAATATCCCATCCCTTACCGT +GAGAAGGACTTTCTCCACTCTTGGATCTTCCTTTATCATCTCGTTCATCCTTGCTATGGCTTTACTTCTG +TTGTCGTCCGGTTCAAGAACTTTTCCTTCCCAGAGGGCGTTGTCTATCGCCATAAGCCTGCCCTTTTTTA +GGAGTTCAAGGCACTTCTCATAATAGTAAGGGTAAGAGGACTTGTCAGCGTCTATAAAGATGAAGTCAAA +GCTCTCTTTTTTAAATTCTTCAAGCACTTTTCTTGCGTCTCCCACGATTACTTCAATTTTCTTTCCCCAC +GGAGCTCTTTCTATGAAGCTTTTAGCCATTTGGGCGTATTCGGGATTTACCTCTATTGTCGTGAGTTTAC +CGTCTTCTGGAAGCCCCTGAGCCATCATGAGGGCGGAAAAGCCCGTAAATGTTCCTATCTCAAGCACTCT +TTTCGCTCCCGATATTTCCACGAGCATCTTCAGGAAGTTTCCCTCCGCCCTTCCCACCATCATCTGGGGG +AGGTCCGTATTTTTATAAGTAAACTCCACGAGTTCTTCCAAAATTGGGTGTAGCTCGGAAGAGTGTTCTT +CAGCATAAGCCTCTATCTCTTCAGGACAAATGAACGCCATAATCTAAATTATAAAGTGCAAGTTCCTTTA +GGATTTGTCTTACGTGTTCCTGTCCCCTTGCAGGTTCAATAAGCTTGTTCCCGAGCTTTACACCTACAGA +ATAACCTTCCTTTGAGAGTTTCAGAACCAAATATGTGAGCTTGGAAAGCTTTGTTTCCAAATCCCCACTC +ACGCTGTCCAGAGAAAGGATAATGGGGTTCTGTTCTTCCGTAAGCATTTCCTTTACCTTCAGTTCTCCAA +GTCTTGCGGAAGCCTTCCAATGGATTAACTTCATAGGCTCACCCACGTAATCCCTTATCTCTTTCACTTC +TTCATAACCTTTTACTACGCTGGAGCTTTGCTTCTCCCCCTCTTCTTCCTTCATAGTTTTGGGGTTGAAA +GTGGTCGGTATGGGTTTGGGAAAGACGATTAACTTTATTCTTACATCCTTTTCATATTCCCTCCTGAACA +TACCGAAAGGAAAGTCGGAGCTTATCTTTACTTTTACCTTTTCGTAGTAACCTCTTTTTTGGAATAAAAA +CTTTATCTTTTCTGAAACCCATTCTCTTGAAACTTTAGGAAATATAACTTCATCAATTTTATTTGAAACT +TTTATTAAAAAGGAGGTATATCGTGCGTTTTTCCTAAGACTAACGGTTGCAAAAGTAGGAGTTTGGGCGA +AAACTTCTTCGGGAAATTTTATCCTCACATCAATATTCTTCAAGTTATAAAGGGAAATTACACCGGAAAT +TAGCATTCCCGCAAGAAGAAAAGAAACCACTATGTAAAGTCCGTTATTTGCAGTGTTTGCTGCAGCAACT +CCTAAGAAAATCGTGAGGAGTATAAGCAATTGTCCCGCTCTATTTACCCTGACTTTCATGCCTTTGCTTC +CTCAAAAGGGCATCTCCAAGTAGGTTGAAGGCGAGTATCGTTAGGAATATGGCAACTCCCGGTGAGGCAA +GCCAGGGGTAAAAGGTTAGTACGCTTACGTTTCTCACCTCAGAGAGCATATTACCCCAGCTCGGAACGGG +CTCCTGTATTCCGAGTCCCAAAAGCGAGAGGGAAGCCTCACCCAGTATGAAGGCAGGTATAGACATGGTA +GCGGAAACTATAAGGTAGAAGTACGTATTCGGTAGAATGTGTTTAAAGATAATCCTTAAAGAAGAAGCTC +CGTAAGTTTTGGCGGCAAGGACGAATTCCTTCTCCCTTATGGACAAAACCATCCCCCTCACCACTCTCGC +AAGCCCGGCCCAACCAAGGAAAGAAAGGATAAACACGATAATCAGAAACACTTCACCACTTGAGAGTTCT +AAGGGAAATACGGAACGGAGTGAAAGTAAAAGGTAAAAGGCAGGTATGGACATTAGAATTTCCACGAGTC +TCATTATCAAAGTATCTACCTTTCCCCCGAAGTAGCCAGAAATCCCTCCGACAAGAGCGCCTATAAAGAA +GGTAGTAAAGGTCCCGATAAGGGCTACTCCCAAGGAGTACCTACCGCCGTAAAGGAGTCTTGAGAATACG +TCCCTTCCAAGCTTGTCCGTTCCCAGAAGGTAAAGATTGCAGGGTTTTCCAACGCTTACGAACTTAAAGC +CGTACTCTGTTTTTGTAAAAAACTTCAGTCTGCAAGAAATGTTCTTATTTTCTCTGTAAACCTTAAAAAG +AGAATCCACGAGCTCGTACTTGTTCACGTAAGGGAATGTTAGTTTTCCGTCCTTAAAGAAGTGTATCCTC +GTGGGAGGGTGGTAAGGTGCATTTCTGTTCTGGAGTTCATAAGGATACGGAGCGAAGAAATCCGCAAAAG +TGATTAAGAAGAGTATCAGCCCAATTAAAGAGAGGGAAAACTTTACAGCGAACATCAGTCCCAGTAACCT +AATTTTAAGGAAAGTTCAAGGGCAACTTCTTGCAAGGTGGGTTTTATTTCTTTCTCCACTCTGTCAAAAG +GCATCCTGTAAATGGGGGCTATTATCTCAACCGCACCGATGGGTCTTCCCCTGTAGTCCCTTACAACGCA +AGCCCCGCCCGCTATTTCCGTCTGGGTGTTGTACTCGTAATCAAATACAAAACCTTTCTCTCCGAGGACC +GCCTTTCTGAGGGCTTTAGCGGAAGCGGTGTAGGCGTCAAGGTCAAATCTCATCCCGAGACGGGATTTCA +CCTTTACGGGTTTTATCGTTTCTTCTTCTATGACGTAAACCACGTACTTTTTCTGGTCGTCAAGGACTGT +TAAGTTTACCGTCTCAAGGAGCTTAAAGCGGAGATTTTTAAAAACGGGTTCGGAAAGTTTTATAAGGGGG +TTTTTCTGTATGTAGCCGTATCCCAGTCTTACGGAATTCACTCCGAGTTTGTACTTTTCGGTTTCGGGGT +CCTTTTCAACAAGTCCGTGCTCTTCAAAGGTAATGAGTGCCCTGAAGACGTTGTTTTTACTGAGGTTTAA +GTGTTCGCTTATCTCAGTTACACCCGCCTCCCCCTTCTCCATCAGGTACTCAAGAACTGAAAAGGCTTTC +TCTAGGGTTTTCATACTTAAAGATTTTACCTCTAGAGATTTATAACAAAAATCAAAAAGTGTTTTAAATT +AACTTGACACACTTCTTCAAAATGAATAAAATTACACTCTACTTTCGGAGGAGAGCGATGAATAAAACAA +CGTTTGAAAATGTTTACTACTGGGAAGGAAAGGCACAAATCCCCCAGGAAGGGCAGTTTATAAAGCTCAA +AGAAGATAAAACCTTAGAAGTTCCAGACAACCCGATAATTCCCTTCATAGAGGGAGATGGGATAGGTCCT +GAAATAACGCAGGCTATGCTCCTTATTATCAACACAGCGGTTGAAAAAACTTACAACGGAAGCAAGAAGA +TTTACTGGGTAGAACTCCTCGCGGGGGATAAGGCGGAAGAAAAGACTGGAGAGAGGCTTCCTCAGGAAAC +CCTGGACGTTTTAAAAGAATCAATAGTAGGTATAAAAGGACCCCTCGGAACGCCCGTAGGAAAAGGTGTC +CGCTCCATAAACTCCGCCCTCAGGAGGGCATTTGATTACTACTCTGCGGTAAGACCCGTTTACTGGATGG +GCCAGGCAACTCCGATTCCAAATCCTGAGAGGGTTGACCTCGTAGTTTTCAGAGAAAACACCGACGACGT +CTACGCGGGAGTGGAGTTCTTTGCGGGAACGCCCGAAGCCAAAAAGGTAAGAGAATTCCTCATAAAGGAG +ATGGGGGCAAAAGAGGAAGGCTTCCCCGAAGATGTGGGAATAACGGTAAAGCCCATGAGCGAGTTCAAGA +CAAAGAGACACGTGAGGAAAGCACTCAGATACGCCCTTGAAAACAACAAGAAGAACGTCGCGGTAATAGG +AAAAGGAAACATAATGAAGGCAACGGAAGGGGCCTTCATAAACTGGGCTTTTGAGGTAGCAGAAGAGCCC +GAATTCAAAGGAAAGGTAGTAACGGACCCGGAAGCAGAGCCCGGCGAAGGACAGGTAAAACTCACAAAAG +TGATAACCGACCAGATGCTTATGCAACTTGTCCTCAAGCCCGAAGCTTGGGACGTGATAATCGCTCAGAA +CTTGAACGGTGACTACGTTTCCGACCTTGCAGCTTCTCTGATAGGAGGTCCAGGATTTGTTCCGAGCGGA +AACATAGGGGACGGATATGCCCTCTTTGAAAGCACCCACGGAACAGCTTGGGACATAGCAGGCAAGGGAA +TAGCAAATCCCCTTTCCCTTACACTATCTGGCGCGATGATGCTTGAATACATAGGCTGGAAAGAAGCAGC +TCAAAAGGTCTACGACGCAGTAAGAAGAACCCTTGCGGAACATATAGGAACGCCCGATATCGCAAGCGGA +TTCCAGAAACAGGGAATAGAAGCTAAAGCAGTAGGCACGATGGAGTTCGCCGAAGAAATTTCCAAGAGGA +TTGAGTAATTATTCCCTAACAAGGAGGTCATAAATGAAGGTTAAAGTCAAGCAAAAGGAAGACTTTCACT +TCATCGGTGTTGGACCTGCGGGCAGAGAAGTGCCTATAGACGCCGCGGATTACGTTGGAGGGAAAGGAAG +AGGTATAAGACCCCCAGAACTTCTCTTCCACTCAGTAGCGGGATGCGTAGGAATACACCTGTATGAGGCA +CTCCATAAGGAAGGAAAACACGTTGAAGACATAGAGATAGAAACGGATGCGGAAAGAATTACCGACAGGT +ATCCCAAAGTGTTCACCAAAATCTACCTTTTCGTGAAGGTAAAAGGTGATGTTTCAGAAGAAGAGGTGAA +AAATGCTCTTGATAAGGTAATCTACAACCCCGGCACTTGTTCCATAGCTTACATGGTTAACCAAGTAGCT +CCCATAGAGTACAAAGTTGAGATCCTGTAAGGAGGTGCTCGTGTCTTTCTTTCGGACTCTTTTTGTTTTA +TAAGCTCGGAGACCTGAGATGGTAACAGAAGTAAAGAAAAAGCTTTCTAAAGAGGAAAAGAAGAGACTCC +TGAAACTCCTGACCTATGAAAAAGTGAACGGGAAACCAATATACTACAGGGATTACAGAAAGGTTCTTAG +AGGGGAGCTACCACCAGGGGCGGTAATGGGAAGTAGCGGATTGCAGGCTTTCTTAATAATACTTTTAATC +AAGTTTTTATTAAATAAACTCGACGATAAAAAATTTATACTTCTTTCAAACGAACTCAGCTTCTTATACA +AAAAAGGTTCTTGGAGGAACTTAGACATAGCGATATTTGAAAAAACTCAGGAATTATTGGACACAGGAGT +AGAAAAAGTAATATGGATTTTCACAAAACCTAAAAAAGTAATGATTGTAGAAAAGGGAAAAAAGTGGATA +ATTCAGGATTGGAATGAAGAATTTGAAGTAATGGAAGGAATAAAAATAAACCTAAATGAAATTTTAAAGG +AATACAATAAGGAGGTCTCGTAGTGTTCAATAAAGTTCTCGTGGCAAACAGAGGAGAAATAGCGGTAAGG +ATAATAAGGGCTTGTAAGGAACTCGGTATTCCGACGGTGGCAATATACAACGAGGTTGAATCCACCGCAA +GGCACGTAAAGCTCGCGGATGAAGCCTACATGATAGGGACGGACCCGTTAGACACTTACCTCAACAAACA +GAGGATTATAAACCTTGCCCTTGAAGTTGGAGCGGACGCAATTCACCCGGGATACGGATTTTTGGCAGAA +AATGCAGAATTCGCCAAAATGTGCGAGGAAGCCGGGATAACCTTCATAGGTCCCCACTGGAAAGTAATAG +AACTTATGGGAGACAAAGCCCGCTCAAAGGAAGTTATGAAAAAAGCGGGTGTCCCGGTAGTCCCCGGCTC +AGACGGAGTTTTAAAGAGCCTAGAAGAGGCAAAAGCTTTAGCGAGGGAAATCGGATATCCCGTTCTCCTC +AAGGCAACCGCGGGCGGTGGTGGTAGAGGAATAAGGATATGTAGAAACGAGGAAGAACTCGTCAAAAACT +ACGAGCAGGCGTCAAGGGAGGCGGAAAAAGCCTTCGGAAGGGGAGACCTTTTACTCGAAAAGTTCATAGA +AAACCCAAAGCACATAGAGTATCAGGTTCTTGGAGACAAGCACGGGAACGTAATACACCTCGGTGAAAGA +GATTGTTCAATACAGAGGAGAAATCAAAAGCTCGTAGAAATAGCACCCTCTCTTATCCTTACTCCAGAAA +AGAGGGAGTACTACGGAAACATAGTCACGAAAGCCGCAAAGGAAATAGGCTACTACAACGCAGGAACTAT +GGAGTTCATAGCGGATCAGGAAGGAAACCTTTACTTCATAGAGATGAACACGAGAATACAGGTTGAGCAC +CCCGTAAGCGAAATGGTTACGGGCATAGACATAGTAAAGTGGCAGATAAAGATAGCAGCCGGAGAACCTC +TTACCATTAAACAAGAAGACGTTAAGTTCAACGGATACGCCATAGAGTGCAGAATAAACGCCGAGGACCC +CAAAAAGAACTTTGCCCCCTCCACGGGAGTAATTGAAAGGTACTACGTTCCCGGAGGTTTCGGAATAAGA +GTTGAACATGCTGCTGCAAGAGGTTTTGAAGTTACCCCCTACTACGACTCCATGATTGCAAAACTTATAA +CCTGGGCACCCACTTGGGATGAAGCGGTAGAGAGAATGAGAGCAGTTCTTGAGACTTATGAAATAACCGG +CGTAAAAACGACTATACCTCTACTCATAAACATAATGAAAGAAAAGGACTTCAAAGCCGGAAAGTTTACG +ACAAAGTATTTAGAAGAACACCCTGAAGTATTTGAGTACGAAGAACACAAGGACAAGGAGGATTTTGCGG +CACTAATTTCTGCGGCTATAGCCGCTTACCACGGTTTATAAAAACTTTAAAGGAGGTAATATAGATGGTA +GTAAACCCGGAGGTTATAGAAGAAGTCAAGGAGAAAATTAAGGAAGTTAAGAATAAGGGCTTTAAGAAGA +AGATATTAATTACCGACCTCACGCCAAGAGACGGACAGCAGTGCAAACTCGCTACCCGTGTGAGAACCGA +GGACCTCCTCCCCTTATGCGAAGCCTTAGACAAGTGCGGATTTTACGCGGTAGAAGTCTGGGGAGGAGCT +ACGTACGACGTTTGCCTGAGATACCTCAAAGAGGACCCATGGGAAAGGCTAAGGAGAATAAAGGAAGTAA +TGCCCAACACCAAACTCCAGATGCTCTTCAGGGGACAGAACATAGTCGGTTACAAACCCAGAAGCGACTA +TGTAGTTAAGAAGTTCGTTGAAAAGGCTATAGAAAATGGAATAACCGTTTTCAGAGTGTTTGACTCTCTC +AACGACAACAGGAATATAGAAACCGCTGTTAAAGCTATAAAGGAATTCGGCGGAGAAGTTCACGCTGAAA +TCTCCTACACCAGAAGTCCCATACACACTTACGAGCTCTGGATGAGGTATGCTCAGGAACTGGCGGAAAT +GGAACCCGACTGGATATCCTTTAAGGATGCAACGGGGATAATGCAACCCTTTGAATGTTACCAGATAATC +AAGGGAATAAAGGAAGTAACGGGAGGAAAGATACCAGTTCTCCTTCACAACCACGACATGAGCGGAATGG +CGACCATGAACCACATAATGGCTGTTCTCGCAGGCGTCGATATGCTGGACACAGTACTTTCACCCTTAGC +GTTCGGTTCATCTCACCCTGCAACCGAGACCATAATCGCAGCGCTTGAAGGAACACCTTACGACACGGGA +CTTGACCTTCAAAAGGTTTCGGAAGCTGCGGAAATAGCTAAGAAGATTAAGAAGAAGTACAAGAAGTATG +AAACGGAATACGCGGGAGTTAACGCAAAAGTTCTCATACACAAGATACCCGGTGGAATGATATCCAACAT +GGTTGCACAACTGATGGAGGCAAACGCACTCGACAAGATAGAAGAAGCACTAGAAGAAGTTCCGAGAGTA +GAAAAAGACCTTGGATACCCACCGTTGCTAACACCTTCTTCACAAATAGTCGGTGTTCAGGCGGTTCTGA +ACGTAATCACGGGAGAAAGGTACAAAGTAATCACAAAAGAAGTGAGAGATTACGTAGAAGGAAAGTATGG +AAGACCGCCCGGACCAATATCCAAGGAACTCGTTGAAAAGATACTCGGTCCCGGAAAAGAACCGGACTTC +TCCAAGAGGGCTGCCGACTACGCCGATCCCCACGAATGGGACAAGGCTAAGAAGGAACTCGAAGAGCTCT +TCAAAAGAGAACCCACAGACGAAGAAGTACTCCTCTACATACTCTTCCCCATGCAGGCAAAAGAGTTCTT +TGAACTCAGGGAAAAGGGAGAACTCCATCCAGAACCCGTGGAAGCGGAACTCCCGGAAGTTGCAGAAACG +AAGCCCGGAGAAGTTCCCGGCGCTGCACCCGTAGAGTTTGAACTCACATACCACGGTGAGAAGTTCAAGG +TAAGGATAGAAGGCGTTTCCGTGGACGCAGAAAGCGGAAAACCCAGGAAGTACTACGTAAGGATAAACAA +CAGACTTGAAGAAATACAGTTAAAGCCTTTTAAGGAAGCGATACCCCAGGGTGGCGGTGCCCAAACAGTT +CAGAGTGCGGAAGAAGAAGAGGGAATTCCCAAGGCTACGGAACCCGGAGACGTTACACCGCCCATGCCCG +GTAAGGTTGTGAAGATACTCGTAAAAGAAGGAGAACCTGTTCAGCAGGGACAAACCGTTGCAACCGTTGA +AGCAATGAAGATGGAAAACGAAGTCCATGCACCCATAGACGGAATAGTTAAGAAGATATTCGCAAAACCC +GGAGACCAAGTTAACCCAGATCAAGCGATAATGAGAATAGTCCCCCACAAAGAAGATAAGAGCTATCAAT +AAGCTTTCCTTTTTCCCTTCTTTTTCTTTTAAAATTTTTAAAATGGAGTATTGCAGAGATTTATCTGAAA +AACTCAGGGAAGTTATTAGAAAGGAAACTGTAAAGCTTCCTATACAACCTATCCAAATAATAAGCATAGA +AAGGCACGAGTTTAAGGTTCTCTTAAACAAAAAAGGAATTAAAATTGTAAACCCGCCAAACCTAACCAAA +AACCTCGGAGTTTACCTAATACTCTCTTTCAGACTTAAAGAAAAGATACGGGAAATTCTCGGCGAGAAAT +TTGAGCATTTAATAAAAGTTTTAGGGGATATAATTTCCGATAATACACTTGAAACACCTTTAATAACACT +CGGTGAAGGTAAAAACCTCAAGAAAAAGTTTAACGAGGAATTCATAGAAACCCTTGAGAATGCTTCCTAT +TCAAACGAGGAGGCCGGAAAATTAAGGGAATTTTTAAAGACACTTTACGCTTTGGCACTCTGTAATAGTA +GGGAAGAAATCACTCTGGACCTTTGTGTAATATTACTCCACTCCGAACAGCACGCAACTTTAGAAAAACA +ACTCCTTTCTCTCGTACAACCGCTACTAAAAATTGATAAAAAACCGAAGAAAGAACTGAACCTATAGTCC +GCGAAGTTGCAAAGGTTATAAACGAAACCTGTTTAAATTAAATTTGTATGGAAAAAGTTTTTTTGGAAAA +ACTCCAGAAAACCTTGCACATACCCGGAGGACTCCTTTTTTACGGCAAAGAAGGAAGCGGAAAGACGAAA +ACAGCTTTTGAATTTGCAAAAGGTATTTTATGTAAGGAAAACGTACCGTGGGGATGCGGAAGTTGTCCCT +CCTGCAAACACGTAAACGAGCTGGAGGAAGCCTTCTTTAAAGGAGAAATAGAAGACTTTAAAGTTTATAA +AGACAAGGACGGTAAAAAGCACTTCGTTTACCTTATGGGCGAACATCCCGACTTTGTGGTAATAATCCCG +AGCGGACATTACATAAAGATAGAACAGATAAGGGAAGTTAAGAACTTTGCCTATGTGAAGCCCGCACTAA +GCAGGAGAAAAGTAATTATAATAGACGACGCCCACGCGATGACCTCTCAGGCGGCAAACGCTCTTTTAAA +GGTATTGGAAGAGCCACCTGCGGACACCACCTTTATCTTGACCACGAACAGGCGTTCTGCAATCCTGCCG +ACTATCCTCTCCAGAACTTTTCAAGTGGAGTTCAAGGGCTTTTCAGTAAAAGAGGTTATGGAAATAGCGA +AAGTAGACGAGGAAATAGCGAAACTCTCTGGAGGCAGTCTAAAAAGGGCTATCTTACTAAAGGAAAACAA +AGATATCCTAAACAAAGTAAAGGAATTCTTGGAAAACGAGCCGTTAAAAGTTTACAAGCTTGCAAGTGAA +TTCGAAAAGTGGGAACCTGAAAAGCAAAAACTCTTCCTTGAAATTATGGAAGAATTGGTATCTCAAAAAT +TGACCGAAGAGAAAAAAGACAATTACACCTACCTTCTTGATACGATCAGACTCTTTAAAGACGGACTCGC +AAGGGGTGTAAACGAACCTCTGTGGCTGTTTACGTTAGCCGTTCAGGCGGATTAATAAACCGTTATTGAT +TCCGTAACATTTAAACCTTAATCTAAATTATGAGAGCCTTTGAAGGAGGTCTGGTATGGAAAATTTGAAG +ATTAGATATATAGATACGAGGAAGATAGGAACCGTGAGCGGTGTAAAAGTTCCGGTAAAAAAGGGCTACA +AAATAGTCGTGGAAGACGAGGAAAAGGGGGAGGACATAGTTGAGGTTCTGGGCTATTCAAGGGAAGAATC +CAAGAACGGAATTCAGCCGAGGTTTGTTAGGGTTGCAAACAAAAGAGATCTGGAGATCTTCAAGAAGAAC +ATGAGGGAAAGCGAGAGGGCTTTTGAGATATGTAAAGAGAAGATAAAAGAACACGGACTGGATATGCACC +TGCTTAAGGCCTACATACCTCTAAATAGAAAAAAAGTCTTCTTCTACTATCTGGCGGAAGAGAGGGTGGA +CTTTAGAAATCTCGTGAGAGACCTTGCGAAGATATTCAAGAGAAGGATTGAGATGAGACAGATAGGGGTG +AGGGACGCTGTTCAGATGAAAGGGTGGATAGGCAGGTGTATGAGGGAAACCTGTTGTTCCCAGTTTATGG +AAAACTTTCAGTCCATATCGCTCAGGGATATAACCGAGCAAAACTTGCCCCTCTCTCCTTCCAAGTTCAC +GGGTCCATGCGGAAGGCTCGTATGCTGTATGGCTTTCGAGCGGGAAAATTACCTCCTCAAAATCCTTTTC +CCAGAACCCGGAACAAAGCTCTGCTACAACAAACAGGAGGTTACCCTTCTTGAAGTTGATCCTCTCAGGG +AGACGGTTGTACTTCAGTACGATGAGCTCGGAAAGAAGGTAGAGCTGGGAGTAAGAGACATGCTACCTAA +GGGGTACGAGAAAGCTTTAGAGCACTGCCGTTCCTGTCAATTTTGTTGCAGAAGGGTGTACGAAGAGGCT +ACGGAACATGAGATTGTCAAAAGTTCTGCGGAGTGATCTAAATACGCTCTTCTTATTTGAGCTGGAAGAC +GGCTATACCGTGGAGTCCGTATTCTACAGGGGGGACACTCTCTGTGTTTCTACGCAGGTCGGGTGTCCCG +TTCGGTGTACTTTCTGTGCTTCCGGAAAGAACGGGCTCTTTAGAAACCTGAGTGCGGAGGAGATATACAA +CCAGTACGAATTACTCAAGGATAGGTATCCGATAAAGAGGATTGCGGTAGCGGGTATAGGTGAACCCCTT +TCCAACTGGAGGAACGTAAAGGAAGCCTTTGAAAAGTTTAAAAAAGAAGGTCTTAAAGTATCTTTCTACA +CTACGGGTTTTCCTACAAAGCACTTGAGAGAACTTCTACATTTGCCCCATTCCGGAGTTACGATTTCCCT +TCACTCTCTGAACGATGAAACGAGGAAGTACCTAATGCCTCATGCGGGAAAGCTGGAAGAGGTTATAAAG +GTTCTTGAAGAAGAACTCCCTAAACTTTCCTCCAAAAAGAGGAAGAAGGTAAGTCTTGCCTACATCTTAC +TGAAGGATGTTAACGACTCGCAGGAAGAACTCGAAAAATTAGCGGAGCTCGCCAAAAGGTTGGGCGTCAG +CATCACTCTCCTTTACTACAACAAAACTTTTGAATTTGAGCCCGTAAGCGAAAAGGAATACGAGGAAGCC +TTCCTCTTCCTGCGTTCAAAAGGGGTAAGGGTTACACTTTCTACACGTTTCAGAAAGGACAAACTCGGAG +GGTGCGGAACGCTCGTTGTAAACAGAAATAAAGAACTAACGAAAGTATGATAAAGGTAGAAGGAAAAGTC +TTAAAGGTGGAGGGAGAACTCACCGCGGAAAATATAAAAAGTTTAAAAATCCCCAAAAATATTGAAAAGA +TAGACCTTTCAGACTTGAAAAAACTCGACACTTTCGGAGCTACTTTTTTAGCTCTCCTGATAAAGGAAAA +TAATATCCCTCTGGAAAGAGTTGAAGGCGGTGAAAAGCATGTGGAATTGATAAAACTTGTGCTTGATAAC +TTAAAATTACCCAAAGAAATTCCTGAAAAGAAAGTGTCCTTCTCACTAAAAAATCTCTTTTCCTTTCCGG +AATTCCTGGGACTTTTCTTAATTCACTCTTTCAAATACATAAAACAGTTCGAATTTTCGGCTTTTTTTAA +GGAACTGCAAACCTCCGGACTCGGGAGTGTCCTGATACTTGTTTCCCTTTCCTTTTTAATAGGGGTTGTT +ATCGCTTACCAGAGTGCGGTTCAGCTGAGAGCTTTCGGAGCTGGGATCTTTATAGTGGATCTTGTAGGCA +TTTCAACCTTCAGAGAACTTGCCCCGCTTCTTACGGGCATAATCCTCGCGGGAAGGGTGAGCAGCGGTTA +CACCGCAAACGTGGGACTGAGGAAGATAAACGAGGAAATTGACGCCCTGAGGGTTATGGGACTTTCACCC +GTGGTTCTTTTAGTCCTTCCGAGGGTTCTCGCTTCCTTGATTTACACTCCATTACTCACCTCACTTTCCG +CTGTCGCTATGCTCCTCGGTGGGGCTATAATAGCTCAAGTATTTCTTGGTATAGGAGTTGAAGAGTTCTT +TAAGAAACTGCCCGAAGCCGTTGCGAAAGAAGATCTGTTTGCGGGGTACGTCAAGACGCCCTTCTTCGGT +GTTGCCATTGCTTTGAACGGCGTGTATTACGGATTTCTCACCGATCCCAAACCTGAAAGCCTTGGTTATT +CAGTAATGAGAAGCGTCGTTACAGGAATATCCGTTATAATCTTGCTCGACGCCGTATTCTCAATAATCTT +CCTGAGACTGGGGATATGATAGTAGAGTTTGAAGAAGTTTACTCGGGATACGGGAACACAGTAGTTCACA +AGGGGATAAGTTTTAAGGTGGAATCCTCGCAAATAGTCGCAATAGTGGGTGGAAGCGGTGCGGGAAAGAC +GACACTTCTGAGACTTATCCTAGGACTTCTGAAGCCTTTAAAGGGTGAAGTAAGGCTATTTGGGAAGTCC +ATAAAAAACTTAAGTGAAGAGGAACTCCAGAAGTTGAGGGATAGAATGGGAGTAGTATTCCAGTTTTCCG +CACTCTTCGGCTCAATGACAGTCCTTGAAAACGTTATGTACCCGGTTATCAAAAAAAGGAAACTGGATCG +TTCAATAGTAGAGATGAACGCCTGCTTTAAGCTTTCCGTGTGCGGACTCAAACCCGAAGACTTTTACAAG +TATCCCCAGGAACTCTCGGGTGGAATGAAGAAAAAGACAGCCCTTGCTCGGGCTCTCTCCTTAGACCCAG +AACTCCTGATACTGGACGAACCCACCTCGGGTCTTGATCCGATAAGTGCTGAAGAGTTTGATAACTTGAT +AAAAACCGTGAGGGACACTTTCGGAACTACGGTAATTATGGTTACCCACGACTTGCCTTCTTTGAGGATA +TGTGATAAAGTCCTTGCCCTAAGGGAAGGAAAAATAGTATTCGACGGAAAGCCTCAGGAACTTTTTGAAA +GTGAAGACCCTTGGATTAAGGAACTTGTAAAGACCTCAAGGGGGAAGTGCATACTGTGATAGAAGGAAGG +GTGAATTACATTCTTGTAGGCTTGTTTATACTGCTCGGTTTGGGAGTTACACTCTTCGTACTTTTTTTGA +TGACGGACATTATGGAAAGGGAAAAGTTCAGACCTTACCTCATTTACACAACCCAGTCGGTAGAGGGTTT +AAACACCGGAGCAGCTGTTTACTACAAGGGTGTACAGGTGGGAAAGGTCAAGGAAATTAAAATTGCAAAA +AATCAGGAGCTTATAAAGATAAAAGTATTGATAGATAAAGACTTTAAAGTTAGGGATGGATTGGTTGCGA +CCCTCGGCGTTCAGGGTATTACGGGACTTGCTTACATAAACCTAGAGTACAAAGAAGGCTACAAACTCGG +AAGAGACCCCGAGGAAAACCTTCCCGTCATACCTATGGAACCTTCCGAACTTCAAAAGTTAACTCAATCC +CTTCCCGAACTTTTGAGCAAAACAGATGAACTCCTCACAAACTTAGGAAAGTTTTTCTCCGAGGAAAACG +CAGAGGAAATCTCTAAAGTGCTGAAGAATACCAACAAAACCCTCAAATCTTTTGAAGAATTATCTGGAAA +ACTTGAGAATATCTCCCTAAGAGTTGAAAAACTGGTCGCTAATGCGGACAAGAAACTCGGAGAGCTGGAA +GTAAAGAAATTAAACGAGGTTCTGGAAGAGTATAAAAACTTGGCGGTTGAGGTGGAAAAGTTTGTGAAAA +ACCTATCAAACCTCTCTGAAAAGGTGGACAGGGAAACCTTAAGAAAGTTTGAAGAATTGATAAATTCTTT +GGAAAAAACCTCTGAAGAAGTTCAAAAACTCGTAAGAAAGCTTAAGAATAACCCTTCACAAATGCTTGAA +ATAAAGACGATAAAACCTCACGAGGTGGAGGAATGGTAAGGCTCTTATTGATTTTTGTACTCATACTCTC +CTGCGTCCCTAAGCAGGAACACCCTTTAATGCACAACTTGGAACCGAGCGGAGAGGCTGATTTTAAGGTG +ATTGAACTCCGTGTTCCCGAGTATCTGGATACGGAAAGGATAATGTATAAAACTGACAAAGGATTTTACT +ACTTTGCAAAGAATGTATGGGTTTGTGAACTCTCCTGTGTTCTTGAAAACTACTTCAAAAAAGCCCAAGG +TGGAGAAGAAAAGGTTTACCTTGAGGTTCTGGACTTTTACCCTGTGTTTACGGGAAAGAAAGAAGGGTAC +GTTTACCTGAGGGCTAGAGTTGACCGAAAAAAAGAGTACGTCTACAAAATTCCCTTTAAAGTAAGGAGTT +TTGAAGAAATTATTTTAAAGATGAACGAGGCTGTGAACAGACTTCTGGAGGATGTAAACAAATACGTTCA +GATAACCACGAGTTCTAAATCTATTTCGGATAGCGGCTTACCAACTCCTCCCTGAACAGCAACTATATTT +TCCAACCTCACCCCAAACTTACCGGGAAGGTATATCCCCGGCTCTATCGTAAAGACCATTCCCTCCTCTA +TGGGCGTTTTTGCGTCGTCTCCCTTGTAGTAAACTCTCGGAAACTCGTGTATCTCCACACCTACACCGTG +ACCCGTAGAGTGGGTAAAGAACTGCCCGTATCCCTTCTTCTCTATATACTCCCTTGCGGCCCTGTCAACG +TCTCCAACAGTATTCCCAACTTTTGCCTTCTCAAGAGCTCTCAGGTGTGCTTCCTTCACTATTTCGTAAA +CCTTTCTGAACTCTTCGGAAGGCTTTCCTATGTGAAAAGTTCTAGTGAAGTCCGTGCAATACCCCTCCCA +GAGAAGACCCATGTCTATCAAGAGTGGAGCGTTCTCCTTTATTTTTTCCCTTGAGCTTTCCCAGTGGGGA +ACCGCTGAGTGTTCACCGCTTGCGACTATCGCCGGGAAGCTTTCACCTTCTCCGTTTTTCTCAAAAATCT +TACTAACTATAAATCCCCTGACCTGGAGTTCCGTCATTCCCGGCTTTACGAAATTTAAAAGTTCCCTGTA +AATCTTATCGCTTTTCCTTACACCCTCCTTCATTATGCTTATCTCTTCTTTAGTTTTCAAAACCCTTACG +TTCTTCAGGAAGTTTGAGAAACCCACCCACCTTATGTGCTTGGATTTCAGGTGTTTCTTGAAAGTGCAGC +TTACCCTGTCCTCTTCGTAGCCCACGTATTTTAGTCCCTTCTCCCTTAGAAAATTCTTTACGGACTTAAA +GAGGTTTCCCTTTATGAGTACAACTTCCCAGTCTTTTAATTGATTTTTCGCCCTTTCGTAGTACCTTGCG +TCAGTGAGGAGGTACTTCTCCTGCGGGGTAATTACAGCGTACGCGTTTGTGGAGCGAAAACGTGAAAGGT +AGAAAACGTTGGGTTGAGAGGAGAACATGAAGGCGTCGAGATTTTTTTCCTTTATGAGTTCTTGGACCTC +CTTTACCTTCATTTTAGAACTCCACTACTTTTAAGATATCCTCCCAGAACTCGGGGTAAGACACGGTAAC +GCATTCGGGGTGGTCTATTATAACTTCCTCTTCAACGACCAATCCGAGCACTGCAAAAGCCATCGCTATC +CTGTGATCTTTGAAGGTTTCTATCACTCCTCCCTTTATCTCTTTAGTCCCGTGAATTGCAAAGCCGTCCT +CAAATTCCTCAACCTGTACTCCGAGCTTCCTTAGGTTTGTGACTATAGCCTTTATCCTGTCACTTTCCTT +GTACCTGAGTTCCTTCGCTCCCTTTACCTCCGATACTCCGTCTGCAAAAGCCATAAGAACCGCAAGGATG +GGAATCTCGTCTATTAAAGTAGGTACTTCTTCAGGAGAAACCTTTACGGGTTTTAAGTTATCAACGGGTC +TTACTACAAGATCAGCCATAGGTTCGTTGGAAAGTTCCCTGTAGTTTTCAAAGGAAATATCCCCTCCCAT +TTCTATGAGTTTTCTGTAAAATCCGTCACGGGTAGGATTCAGGAGAACTTCTTTTAGTCTTATCTCCCCT +TCAGGAGCGAGCGTAGCGAGTGCCGCAAAGTACGCCGCAGAGGAGGGATCCGCAGGACAGTAAACTTCCG +TTCCCTGAAGTTCCTGTCCTCCTTTTATTTTTACTATGTGTCCCCTTTCTTCAGGAATAGTTATCACTTC +TGCTCCGAAGAGCTTTAACATTCTCTCTGTGTGATCACGAGAAAGGTAAGGTTCTACAACTTCGGTCATA +CCTTCGGCTCTCAGCCCCGCAAGCAGGAGGGCACTCTTTACTTGAGCTGAGGACTTTTTATTGAAGTAGG +AAATTCCCTTTAAGTTTCCTCCCCTTATGGCTATCGGTAATTTATTCCCCTCCTCCCTTCCATCTATCTT +AGCCCCCATCTCTCTCAAGGGCTCCACCACTCTCAGCATCGGTCTGTTTTTCAGGCTTTCGTCCCCCGTA +AGGACGCTGAAGAAGGGCTGTGTAGAAAGTACACCGCTCATAATCCTCGCCGTAGTCCCAGAGTTTTTAG +CGTCGAGTACGTCATGAGGTTCTAAAAAGGTGTAATTCCTTCCCTCAATTAAGACTTCTTCTTTTCCTTC +CCTTACTTTTGTTCTGATGGCTTTCAGGATTTCTAAAGTGGCCAGTGTGTCTCCAGAGATTAGAGGTTTC +CTTACTAGAGTTTCACCGCTTGCGAGTGCCCCCAGTATAAAAGCCCTGTGGGTTATGGACTTGTCGGAGG +GAACTCTGAGTTCTCCTTTAACTCTCTTTATTTTCTCGATTTTTTTCATAGAAAAGATTTTACTCTTTCT +CCGACTTCGAGTAATTTCACCTCTGTTCCTTTACCACCTCTTTTATCTTTACGCCTATCTTCCCGTCTAT +TATCACGAGTTCGCCCTTCGCTATCAACTTTCCGTTTACCTTTATGTCCACCAAGTCCTTTGGTTCCCTA +TCTATCTCTATCACAGAACCTATGCCCATGGCGAGGAGTTCCCCCAGGGTCTTGTTTGCCCTTCCCACTA +CAACTTCAACTTCAACGGGAATGTCTGAAAAGTGCTGGATTAACTCTATAACGCTTACTTTTTTTTCCTC +TTTCTTCTCTTCCCTTACTTCTTCCTGAGGCGTTTCCTTTTTCTCTTCCTGTATTTCTTTAGTTTGTTCC +TCCATCCTTTTCCATATTTTGTATTTCCTTTAATAGTTCGTCAACCATTTCGGACTCGTCAACCTTCTTT +ATTGGTTTCCCGTGTTTAAAGAGCCAAGCAAACCCCCTTCCGCAGGCAAGCCCTATATCCGCTTCCCTCG +CTTCCCCTATTGCGTTCACCACACAACCCATAACCGCAACCTTCAAAGGAGTTTTAACGCCGGACAATTT +TTCCTGAACTTCTTTCACCACTTTGGGAAGGTCAACCTCAATCCTTCCGCACGTAGGACAAGCGACTATT +TCTACCCCCCTCCTTCTTAAACCCAGAGATTTCAGTATCTCGTAAGCGGTTTCCACCTCCACCACTGGGT +CGTCCGTTAAGGAAACCCTGACCGTATCACCTATACCCATGTAAAGGAGTATGCCTATGCCAACGGAAGA +TTTTATTATCCCCTTTGTTCCCATTCCTGCTTCTGTTATACCAATGTGGAGGGGAACGTCCGTTCTTTCC +GCAAATATCAGGTTAGCCCTTACGTTTTGAAGGACGTCAGAACCCTTTATGGAAACCTTGTAATTCGTAA +AGCCCCACTTCTCAAACTTTTCGGACCACCTGAGAGCACTTTCCGCAAGCGCTTCCGCAGAAGGGTAGCC +ATACTTTTCAAGCAAATCCTTCTCAAGAGAACCCGAGTTCACACCTATCCTTACAGCCACTCCTCTCCTC +TTTGCCTCTTCCACTATTTCCCTGACTATTTCTTCCTTGCCTATATTTCCGGGATTTATCCTTATTCCGT +GAACACCTTTTTCCATGGAAAGGAAAGCGTAGGAGGGAGCAAAGTGTATATCCGCAATAACGGGCATGGG +ACTCTTTTTCACAATTTCTTCAAGGGCTTCCACGTCTTCCTTGTGAGGCACAGCTACCCTCACAATTTCG +CAACCAGCCTCGTAAAGTCTCTTTATTTGATTGAGTGTTGCCTCAACGTCGTGGGTTTTCGTAGAAGTCA +TGGATTGGACAACTATTGGAGCGTCTCCGCCTATCTTTACGTTTCCTACCCTTATCTGCCTCGTTTTGCG +TTTTTGTATCATAAGTTTTAATATTATTTGAACCTGGAAAGGGGAAACATGCTTGAACTCAGGAGAAAGC +TCTTTCACTTTTTGTCTATACTCCTCCTTATTATTCCCGTAAAGTTCTTCCCTTTCTGGCTAAACGTTTT +TCTATTTTTATCAGCCATACTTTTAAACCTTCTGATAATTTTCAGAGTATCTCCCTTTTACAATATCTTT +GAAGTTTTTATAAAACTTTTTGAAAGGGAGAAAAATCTGGAAACTCCAGGAATTCAGTCCCTGTGGGCAA +TTCTCGGAGTATTTATTTCTTACTTACTTTTTGGAGAAAATGCGGTTGTAGGAATTGTGGTTCTCGCCCT +GGGAGACGGTTTTTCTGGACTTGTTGGATATTACTTTGGCAGAAGAAAGCTCTTTTACAACCCAAAAAAG +AGTTTAGAGGGAACCTTAGCCTTTTTCACGGCGTCCTTTTTGGGACTTTTGCTTTTTACCGACTTTTGTG +AAGCCTTTGTTATTTCTCTTATATGTGCAGTTCTTGAAAGTCTCCCTCTCAAACTCGACGACAACTTTTA +CATTCCCGTCTTGGCGAGCTTTCTCGGAGAGGTGTTATGAAGAAGGCGTTAATAGTGAGGCTTTCCTCCT +TAGGAGACGTAGTTTTAACGTCTGTGGTATTTGACCCTTTGTTAAAGGCAGGTTATAAACCCTACCTTCT +TACATTTAAGCCCTACGATGAAGTATTTCAGGATGACGACAGAGTAGAGGTAATACCCGTAAGTAAAGAA +AACTTTTTTAAAGAAATTGAAAAAATCCCGAAGGACTTTGACCTGAAGGTGGATCTCCACGGAAACTTAA +AGACCTTCTTCCTCAGACTCTTCCTCGGAGGAAAGTGGAGGAAGTATAAAAAAGAAAGCATAAGGAGGAG +ACTTTCCGTTTACTTTAAACACTTCAGAAAACCCTTTTTCGTCCCCGAGGCTTACGTGAAGAGCTTACAA +GGGATAATTGAGGTAAAAAATCCGAGACCCTTTATAAAAGTTTCCGAAGAAAGGATAAGAGAATTTAAGG +ATTTATACGGAAAATACGTGGTTATAGCCCCGGGAGCGAGGTACAAAAAGAAACGTTATCCTTACTTCAA +AGAACTTTCTGAACTCTTCATAAAAGAAGGGATAAACGTAGTTATAGTGGGAGACGAAAAGGATCGGGAA +ATCAGCAAGGATTTTCCGGGCGTAAACCTGTGCGGAAAGCTTTCTTTGATAGATGTTCTTGGAGTAATTG +GAGGAGCGGAACTCTTTGTGGGAAACGACAGCGGACTCCTTCACTGTGCTAGGGCGGTAAAGACAAAGGC +TATTCAGATTTACGGAGGGACTCACCCTACTCTGGGCTTTTCCCTTTACCCCGATGAGGGGAAGGTTGTC +TGCAAGTGTCTTGATTGCCAGCCGTGTGATGTGCACGGTAAAGGAGTGTGTAAAATAGGGAATTACGAAT +GTCTTAATATTCCTCCTATAAAAATTTTTGAGTATGCTATAAACATTTTGAATACCAAGCCGTAAAATTA +GGAAGAAATTTATAAATAAAAGGAGGTGGGAGACATGGGAATTCTGGAAACACTTGTTTTAAAAGAAAAA +ATAAACGGAACGGAGAAGGCGGTAATCTTCAGGGAGCTCATAAAGAAAGAAATGGAGCTTTTAAACGATT +ACTGCGCTAAAAATCACCTGTTCCCCAAGGATTACAGGATTGAGTTCTGTCACCTGCACAACATAAAAAA +GGTAAACATAGCGAGGCTCCTCACTATTTTAAAGTACTACGACCCGAGGTTTATAGAAATACTAATGTCA +ACGGACCCGAAAGTCAGAACCTTCATTCAGTACTTTATGGAATTCCTAGAAAAACACCCATACTTTGAGG +ATGTCCTTGAGCCCCAGAACCTCTTTGGAAACTGGGACTACATAAGGTATAAGTTAAAGATACTCTTCCC +GCAACTTACCTTTGAGGAAATAGACAGGTTTAAGTTCAAAAGGAAAGAGTTTATAAACTACGTTAAGGAA +AAACTGGGAGAACCTGAGGAATTAATAGAGGATAAACTGAACCTGGCAACCTGGTACGAAAGTGTACCTT +ACCTGGAGCTTGAAAGTGAAATGACTCCCGGTGTGCATCCCGACCCCGTAATGACTCCTGAGGAGTGGAG +CTTTATCAAGAGACACATAAAGGGAAGGAAAAACATAATAATAAGGGACCCCGACACGGGCAAAGAAAAG +CTCGTTTACGTAGAAGTGGATATACCCGACGAAGAGCTAGACAAGTACTACAAAAACAGGGAAGGTTTGA +AGAAACTTCTCATGGAAAGGTACAACATAGACGAGTCCGGAGCGGAGCAGATACTAAGAAAAGCTGGTTG +GGAAGCTACTGGATGGCACATAGTTCCACCCGTCCACACTGACGTTGAAGTAGTTTACCCAGAAGAAGAA +AAGAAAGAAGAGAAAAAGGTTGAAGTAAAAAGAGAACCCTTTGACATAATGGAGCTTGCTAAACACATAA +GGTACCTCGGCGGAAGGGAACTAGAAATGCTCAACTACTACGAACTCGTTCACGACAAGGTTCCCGAAAT +TCACGAGAAACTCCACATGTTCATGAGGACAAAGAGAAGACTTCTCGGAAAGCTGTTCGGAATATACTAC +ACGGTGGACCCCGTAATGGCGGAAGCCATACTCATAAACGACCCCGAAAACATAGAACTGCTAAAAAGCC +TTACTATTTCAACCGGTCTCAGGGACAAGAAGTTCTCAATCTACGACAGCAGTAAGGTCTGGAACGAAAT +AAAGAGAAGGGTAAGATTCATATTCCCAGAGGTAAGCGAAGAAGAAATAGAGAAGTTCAAAGGAAAGAGA +AGCGAGTTCGTGACTTACCTCGCCCAAAAACTCGGAAAACCCGAGGAGTACATAGACGAAAGACTCGAAA +GAGCAGGTTGGCTAAGGAGTGAAGAAATTCCCGCCTTCATCAGACACGTGGGACCTTAAGAGAGTTCAGC +TTTTAGTATGTCGTGCATGTGCAATATGCCTATGGGCTCGTTCTCTTCGTTTACAACTATTAAAACGGTT +ATGTTGTGATCTTCCATCTTCCTCAGTGCTTTTAACGCCAGTTCATCCGGCTTTATCGTTTTTGGGTTTT +TTGTCATAACGTCTTTTGCCCTTGTGTTTTCAAAACTCCCTCCCCTGTTTACAAACCTTCTTAAATCCCC +ATCCGTTATTATCCCGACGAGTTTTCCCTCTTCATTCACAACCGCAGTAGCTCCGAACCCTTTTGCTGTC +ATCTCTATTATCGCTTCCTTCATGGATGTGTCTTCCTTTACTATTGGAACCTCTTCACCTGTGTGATATA +AATCCTTCACAAGTCTGAGCTTCCTTCCGAGAGCGCCCGCCGGGTGTCTCTTTGCAAAGTCCTCCTGAGA +GAAACCCTTTAACTTCATAAGGGTCATCGCAATGGCGTCTCCGAGTGCAAGGGTGACAGTGGAACTCACA +GTAGGTGCGAGGTTAAAAGGGCACGCTTCCCTGTCAACGGGAATTTTCAAAACTACGTCGCTGTATTTTG +CCAGTGAAGATTTCTCATTTCCCGTGATACCGATAACCGGGATGTTTAACGCCTTTGCGTACTGGAGAAC +GTAAAGTACCTCTGTACTTTCCCCGCTGTTTGATATTGCTATAAGGGCGTCCTTTGAGTCTAGGAGTCCC +ATGTCGCCGTGGAGGGCTTCCGCGGGGTGGAGGAAAACAGAAGGTGTTCCCGTACTTGAAAGCGTAGAGG +ATATCTTTCTCGCTATATGACCGGACTTTCCTATTCCCGTAAGAATAACTTTACCTTCACAATTCCTTAA +AATCTCTACAGCTTTTGAAAAATTTTCGTCAAGGGAAGAGAGGAGCCTTTCAAGTCCCTTTATCTCTTCC +CTTATAACTTCCCTTGCAAACTCCAATAAGTCTTTTTCTTCCATTTACCCCTCTTTATTTTTCTTGTAAT +TTTCAATCCCTTTCTTTATCTCCTCTATGGCATCCTGAAGTCCTTTCCAGTTTTCCACTTTTACCCACTT +TCCGGGTTCGAGTTCCTTGTAGTGTTCAAAGAAGTGTTTTATCTTCTCTCTGACTATTTCGGGGAGGTTA +TCCACTGTCTTAATGTTTGAGTAGGAGGGATCCAGTTTTTCGTGAGGAACCGCTATTACCTTCGTGTCTA +TACCCGCCTCGTCCCTCATCTCGAGCATACCTATGGGTCTACACCTCATAACTGCTCCGGGAACTACGGG +TTCTCTTGATATGACAAGAACGTCAACGGGGTCTCCGTCGTCGGCAAGCGTCTGGGGAACGAAACCGTAA +TTAAAGGGATAGTACATCGCCGTAAACAGGAAACGATCAACGAAAATAACTCCCGTATCTTTGTCAAGTT +CGTACTTAACCGCACTTCCCTGAGGAATTTCAATTACGACGTAAATGTCTTCGGGCGGATTTTTCCCCGG +CGGCAGCTGGTCGTAGCCCATCCTTTCACCTCCTTGCAACAGTTAAAAATTTTACAATCAAACTATACCA +AATAAAGTGTATAAACTTGCGAATTTCTCTTTTGAAAGAGACAGCAGGTAGTAAATCCTGTTCCATTTTC +GGGACTCTCTGCAGAAACTGTATCACCTTTGCCTACTTTTGCTTGCTTCTGATGCAGCCTTGTGAGTCTG +CTTATTTAAAGATATTCTCATTCTCTTAATCCTTCCTTGAGTTCCTTCACCAAGTTTCCTAAATCCTCTA +TTTTCTTTTGTCCTGCTAATTTTACGAGAGCACTTCCCACGACCACTCCGTCAGCAAAGGAACCTATTTC +TCTGGCATGTTCTTTTTTAGAAACTCCAAAGCCCACCACCACAGGCTTATCGCACAACTCCCTGTACTCC +TCTACCTTTTTCTTTATCCTTTCGTATGGGAGTTTTTCCCTTGCCCCTGTGGTTCCAGTAACGGAAACAA +AGTAGGTCATCTCATCCGCAGCTTCGCATATTAGCTTTATACGCTTTCGGGTACTCGTGGGAGCACCCAA +GGGAACGAAGGAGAGTACGTACTTCTTCATCACCGCTTTTAGTTCTTCCGCTTCTTCTGGCGGTAGATCG +GGAACAATAAAACCGTCTATTCCCTTTTCCCTTGAAAGCCTGCAGAACTTTTCAAGCCCTATCCTGAATA +TAGGGTTGTAGTAAGTCATCAATAGAAAGGGAATGTCCGGAAATTCTTTTCTCAGTGTTTCGGAGAGTTC +CAGAACGTCTTCAAATCGTATCCCGTTTTTGAGGGCAACCTCATGGGCTACCTGAATTGTAGGGCCGTCC +GCCACAGGATCCGAAAAGGGAAATCCTATTTCCAGTATGTCCGTTCCGTTTTTTAAAACTTCTTTGAAGG +CCTTAAGAGAAGTTTCGTAGTCTGGATAACCCACCATGAGGTAAGAAACAAGGGCTTTTTCTCTTTTTTC +CTTTAATTCTGTAAACTTATCGCTTATTCTTCCCATTTCACTTCCCAAGAAATTTTTAAGTTTGTAGAAG +GTTTTACCATGGCAAGGACGCTGCAGTACTTTTCCGTTGAAAGTTTTACCGCTTGCTCAAGGGCTTTTTC +TTCAACTTTTCCGACTGCTACGTACTTTATTTCAATTTCTTCATAGATTTTTGGATGTTTTTCTCTTCTT +TTTCCTTTTAAAAATATCTTTATGTCTTTTACTTCCTGCCTTTTTTTCTTTAAAATGTGGTAAACGTCAA +CACCGGAACAACTGCCGATGGAAACGAGGAGGAGTTCCATAGGGTTTAAACCTTTTTCTCCTGCGGTTAT +TTCCCCTATTGAGGTTTTTGAAAGGAATGTAGCTTCGCTGGAAAGTTCAAGTTCTACTTCTTTTACTTCC +ATAAAGAGGATTATACCCGCCCGAAGGCGGGTGAAAGGAATTATTTGTGAGAAAGGATAAAATCAGCTAG +AGCCTTGAGTTCTGCGTCGGAGAGACCCTTTAACATGGTGAGCTGGGGCTTCATTATGGCTTCTTTTGCA +GGGTCAACTATAGCGGGAGCTTCACCTTTTAAGAACTTGATGAGTTGATCTTCTTTTCCAGCGTAAGCTT +GAGCTATCTTCTTGAGAGAGGGCCCTACGGTATCAACGTTTGCTTGGTGGCAGGAACCACATCCCTTTTG +CTGGAAGATTGCTTTTCCGTCAGCTGCGAAGGTAAGTCCTGCTACCGCAAGTCCTGCGAGAAGGAGCTTC +TTCATGATACCACCTCCTTAACAAACTTTCTTATAAAAGAATATTATAATTTTTCAATCTCCGTAAACTT +CCTTTTTGATCTCCTCTTCTCTTCCAAAAACGCCCATTATGTGGTATCCGTTGTCCACGTGAACGACTTC +TCCCGTTATAGCCCTTGCCCAATCACTACACAGGAAAACCGCCGTATCTCCCACGTCTTCAATAGTTATA +GGTTTTCCGAAGGGATTTACCTTAGTGGTGTGTTCCATTAGGAGGTGAAAACCCGTAATACTGTAAGCGG +CAAGTGTTTTCACAGGTCCCGCGGATATTGCGTTTATCCTGTGACCGTGCTTTGCTATGTCATAGGCGAG +GTACCTCACGGTGCTTTCAAGGGCGGCTTTTGCTATTCCCATAACGTTGTAGTGGGGAACTACCTTTTCA +GCCCCGTAGTAAGAGAGTGTAACTATAGCTCCGTTCCTACCTTCCATAAGGGGAAGGAGTTCCCTCGTGA +GGGCAATCAGAGAGTAAACCGAGATGTCCATCGCTATCTTGAAACCTTCCCTTGAGGTGTCTATCACTCC +TCCTTTGAATTCTTCTTTAGGGGCGTAAGCTATAGAGTGCACTATTATGTCTAAACTTCCCCAGTTTTCC +TCCAAGAACTTTTTCAGATTTTTAATGTCTTCGTCGAGTGAAACGTCACACTTTACTACTAAATCGCTTC +CGAATCCTTTAGCTATTTCCCTTACCCTCTTTTCGAGCTTTGGGGTAGCGTAAGTAAAGGCGAGCTGTGC +TCCTTCCCTGTGAAAGGATTTCGCTATACCGTAGGCTATGCTTCTTTCGTTCGCAACCCCGGTTATTAAA +GCCCTTTTTCCTTCAAGCAGTCCCATAAACACCTCCCCTTTATTTGAGAATTTCGAAAGCTTCCTCAACA +CTTTTTCCTTCGTGGACGATAAGGGACATAGCCCTTACCATCTTTGCAGGGTCTTTTGCCTGGAATATGT +TCCTTCCTATGGAGAGACCTGCGGCTCCTGCCTGCATAGCCCCCTGCACCATCTCAAGGACTTCCCTTTC +GGACTTCATCTTCGGTCCGCCTGCGATTACCACGGGAATGGGAGAGCCTTCAATTGCGAGCTTAAAGGTT +TCAGGGTCTCCCGTGTATGGAACCTTTACTATATCAGCTCCGAGCTCGGCTCCGACCCTTGCACAGTGTG +CTACGACCTTTGGATCGTACTGGTTTTCTATCTTCGGACCCCTGCCGTACACCATGGCAAGTAATGGCAT +CTGCCACTCTTCACAAACCTTAGAAACGTAACCGAAGTCTTTTAACATTTCCCTTTCGCCTTCAGCCCCT +ATGTTCACGTGTATGGAAACGGCATCCGCTCCAAGTCTGATAGCCTCTTCTACGGTACAAACAAGGACCT +TATCGTTCTTTCTGGGCGACAGATCTGTGGATGCGGAGAGGTGAACTATTAAACCTATATCCCTGCCCCT +GCCTCTGTGTCCCGCTCTGACCATACCCTTGTGGAGGACTACCGCGTTTGCACCGCCTTCAGCTACCTTT +TCAACGGCTTCCCTTATGTTTACTATTCCCTCTATGGGACCCGAACTGACACCGTGATCCATGGGAACTA +TGATCGTTTTTCTCGTTTCCCTGTTCATTATCCTTTCGAGTCTTATCTCTTTTCCTATTCCCATTTTCTA +CCTCCGAGACCTTTAAAATAGTATCATACCGCCCTTTGTCGTTAAAATCATGTTTAATGTGGGTTTTGGG +TGAACACGACGAGCCTTACAGAAAAGCGCGTGAAACAATACTAAAACTCGTAGGAAACACACCCCTCGTA +AGAGTAAAAAAGTGTCTTCCAGAAGATATACCCGAGGACGTAGAAATCTGGGCAAAGTTAGAGAGTTTCA +ATCCCGGCGGTTCGGTAAAGGACAGACCTGCTCTCAGTATGTTTCTGGACGCCTTAAAAAGGGGGCTTAT +TAAAGAGGGAAAAGTTGTAATAGACGCAACTTCCGGAAATACGGGAATAGCCCTCGCCATGGTTGGTGCA +GCTCTCGGCGTTCCCGTGGAACTTGCCATGCCAGCAAACGTAAGTGAAGAGAGGAAGAAGATAATAAAAG +CCTTCGGAGCGAAACTTTACCTTACCGATCCCCTTGAGGGTACCGATGGAGCTATCCTCTTTGTAAGGGA +ACTTGTTCAGAAGTACCCTGAAAAGTACGTGTACCTCGACCAATACAACAATCCAGCAAACTGGAAAGCT +CACTTTTACTCTACCGGTATAGAGATATGGAATCAAACTAAGGGGAGGATAACTCACTTCGTCGCAGGGA +TAGGAACAGGCGGAACGATAATGGGAACGGGAAGGAGACTAAAGATTTACAACCCGAATATTCAAGTAAT +AGGAGTCCAGCCTGCGTATCCTTTTCACGGAATAGAAGGTTTAAAACACATAGAGAGTTCAATAAAGCCG +GGAATATTTGACGAGACCTTTCTGGACAGGACTATCTTCGTAGAGACGGAAGACGCCTACTACTGGGCAA +GGGAGCTTGCAAAAAAGGACGCTATATTCGTAGGACAGTCATCGGGAGCGGCTCTCTGGGCATGCATTCA +ACTCGCAAGGGAACTTGCGAAAAAAGGTGAAAAGGGCGTAATAGTTACCGTTTTTCCGGACGGAGGGGAG +AAGTACCTCACCACGGCTCTTTTCTCTGACAAGGATTAATAAGTTTTTATTAGAATATCCTACATTATGG +GGATAATAAAACTTCTCTTCGGATTCCTGTTCCTGATCTTCGCGGTAGCCTTCACTTACTACAACCTTCA +CATGACGGAAGTAAAGTTCTACAATTTCTCCCTCAAACTTCCCATGTTTATATTCTTTTTCCTAAGTGTT +GGCATAGGGTTCTCCATACCTACAGCTTACTTTTTACTCCGTGAAAAGGCTCTGAAGAAGAGAGAAGAAA +AGATTCTCCAGCTCCTTAATTTCTTCTGGAGGGATTACTTAGGGAAAGCCTTTGACCTATTGAGGAAGTT +TCTCCTTATTGAAGAATTCATGCCCTTTTACATAAGGACGAAAAAGGAATTCGGTGAAAGTCTGGACGTT +CAACTCGACCTCTACAACAAGGGTATAGCGGAGACCGCTCTCGCGGAACTCACCTTCAGGAAGGATCTGG +ACGAGGCGAGAATTTTACTCGAAAACGCCCTCGGTAAGAACCAGAAAAACCAGAGGGCAAGGAAAATGCT +GAGAAGCATCTACATGGTTCTGGAGGACTACGACAAGGCGGAGGAACTCCAGAGACAGATCCTGAAGGAA +ATCGAAAAAGAAAGAAAAGTTGAGGAACAAAGGGTTCTCGCTTCTATATTGGCTGAAAAGTACTCCAGAG +AAAATGAAGAAGTTATTCTGAAAGAACTCTGGAGCCTCCCCGTATCCAAGACTTCGGGAGCTCTACTTTC +AAGCATGGTAAACGGCGGTGAGGTTTTTGAAGCTGCCTTTAACCTTGGAATACTTCCCGAAGTTATAAAG +ATCATGGAGGAGAGAAATCTTCTCCAGCCCGAGCTCCTTAACTTAATTGAAAACAACTACAGGAGTGCCG +TTCCCGACTACGTTCTTTATTACGTTTACTTAAAACTCAACATGAAGGAGAAACTAAAGGAATTGAACGT +AACGCTTCCAGAGCTCAAACTCGTTAAAGACAAGTCTCCCGAACTTCTTGAACTTGTTGATATCTGGGAG +TGTGAAGAGTGCGGAAAAGAGTACAATAAATACACGAGCGTTTGCAGGAATTGTTTGGGGGTGAATACCT +TAAAAATTAAGAGGGTGGAGGAATATGATAATAGACCACTTTAAAAAGACCGTTAAGTTCAAGATCGTTT +ACCACGGGCCCGCCCTCGCGGGCAAAACCACAAACGTCTCCCAGATAGCCAAGCTAAAGGGGGAGGACAT +CCTATCTTTTAACACGAAAGAGGAGAGAACCCTTGTTTTCGACATGACAAAGGAAGAGAGGAATGTCGGA +GATTTTAAAGCTTCCTTCCTCATATACACAGTTCCCGGACAGCACATCTACTCGGACATAAGGAAGATGG +TAATGAGGGGCGTCGACGGTGTAGTTTTCGTAGTGGACTCTTCTGAAGGAAGACTGAAAGAAAATAAAGA +GTTCATAGAAGTTTTGAGCGAAGATCTGAAACTCTACGGAAAGGAAATTGAAAGTACCCCAATTTTGCTC +CAGTACAACAAGAGGGATCTTCCCCAAGCTCTGCCCGTTGAAGTTCTTCAGAAGGAGTTAAATCCTTTTA +ATTTTCCTTATACCGAAGCTGTAGCCTTGGAAGGCAAGGGCGTACAGGAGACCCTTGAAGAGATTATAAA +CCTAGTACTGGAGAACTTCGGGAGATTAATCAAATGATAAGCGGGGATTTAAAAGGTCCGGGAGACTTGC +TAGAAATACTGTCCGGTTTCCCCGCATCCAAAAGCGGTTACCTGAACCTGATAAGCAGGAACCTTTTTCT +CTCTCTAAAACTCGAAAAAAGTAAGGTTAAGGGATTTTTCACAAATTACGAGGTTAAGAGTACAAAGAAT +CCTTTAAACGCATTAACCTTCGTACTTTCCGAAATGCTCTCCGACACGGAAGGTTACTTCTCCTTCGAGG +AAAACACGGCGATAAGCGAATTCATTCCCGTGGACGAAGAACTCGAATCTCTGGTAATAAAAGCGACTAT +CGTAAGGAAGGAAATAGAGGAAATACTCCCCCTGATAATAACTAGCAGTGCGGTTTTCACTTCGAAAAAC +GCGGAGTACAAAGATAGATCCCTCTTTGAAATCCTTTCAAACGCAGAAGATCCAATAGAAAAACTAAGGG +AATTAAAGAATCTTCTTGAAAACGGAGAAGTAGAGGTAAAGGAACTTAAGGAAACGAGCAGTCTGGAAGA +GCTGGGACTGGATTACATCCTTGAGTCCGTAGAGTACAAAAAGGTAAACCTCTTAAAGATACTGGAAGCT +CTCAGAAACATGAAATTTACTGGATTTCTTGAAATAGAGGGTGACAGGAAAACGCTGTACACCTTCTTCA +AGAAGGGAGAGATATTCGGTATTCATCCCGTGTCCGTGGAGATATTCGACTACCTCATGGAGTACTACAG +TGAGTTTAAAGCGAGTATAGTTAAGTTAAAAGAGGAATTTGTAGAGACCTTTGCACAGGCTTTCATAGGA +AAGCCCGTAATAGCCTCCGAGAGCAAGTACATATCCCTTGGAAAGTTGTTTTTAACTTTTTTGAGCTTGA +GGGAAGAAGGCGTTTTAAAGATAATAAAAAATGGAGAAAGTTACATATTTATTTTCAGGAACGGAAAGCT +CTTTTCCGCCAGAAAGACAAAGAGGTGGGAGGAAAACTGGAAGGTATTACTTCCCGACAGCCAATATACC +TTTTTATACAGGGAAATATACTCTACTAACGTAAATTACCTCTTCTACGTATTTCTCTGGAATAAAATAC +TAAATGTAATAAAGAAACATTCCCTGAGGGATTCGGAAAACTTAGTGGTGAGAAAAACCGCCGAAATACC +CTTTATTTACATGAAGAACGGCAGGATAGAAGTTTTAAAGAACTTGAACAAAAAAGAAGAAGGAGAAATT +CTCAAATTCCTTCTGTTTATTACGGAAAAGGTTGTGAGCGAGATAGGAAGGGAAAAGTTTGAAAAGGAAA +TTGAAGAAGAACTCAAACCTTACACCGAAATCCTCAGAGTCCTGAACCTATCAACCGAGATAAGTGCGGT +AGAAGAAGCCCTATGAATAATTACAGATGGCTCTATAACCTATCTAAACCTTACATTCTCTTATTCTTAC +TCTCGCTCCTCGGATCCCTTATTCAGTCCTCTGGAGCCACGGCTTTAGCCCTGCTGGTCAAGCAGGTTGT +GGATAACGTATTAATCCTCAAAAATCAGGAAGAGCTTTTAAAGTACGTTCTCCTCTTGTTCTCAAGTGCC +CTAATAATACAGGTGGGCTTCTTTATCTCCTCCTTTACGCTATCTTACATATCCGAAAAGGTAATATACT +CCCTCAGAAACGAGATTTACGAAAAGCTCCTGTACGCACCCATAAACTACGTTCTCTACACGCCTTCGGG +GGAGCTCATAAGCAGGATAGTGAGTGACTTAGAACAGTTAAGGCAGGTTTTTGCAGATTACATACCGAAG +CTACTGAGAGAACCTTTAGTAGTTCTCGCGCTCTTCGGTGTCCTCCTCTACAGGGACCTATTCCTCACCC +TTTTAATCCTCCTCTTATTTCCCGTAATGGCTCTATTTACTAAGTACTTTTCTGAGAAAAAGAAGAAACA +CCTCTCAAGACAGAGGGAAAAGGTTGCACTCCTGACAAGTATACTCTCGGAAACCTTGAGAGGATTTGAG +AACATAAAACTCTTCCTTGCGGAAAATAGATTTATAAAGGACTTCAAAGAACTGTCTTTCAGGATTTTCA +GATCCTCTGTGAAGATAAACCTTTATGTGGTGGGAAATACGGTCATTAATTACACCTTTGGTTACGCCGT +AGTTTCCTTGATCCTCTTTGCTGGCGGTTACAGAATAGTAAAGGGAGACATAACCACTGGAGACTTTATT +TCCTTCCTGACAGCACTCTTTATGATTCAAAAACCCTTAATGGAAACTCAGAAGGCGATAATGAACCTGA +GGGGCTCAGCACCTATTTTTGAAAGGATAAGGAATCTCTTGAACGTTCCAGAAGAAAAGGACGGAAGTGA +AGAGTTTGAAGGTTTGAAGGAAAGGATTGAGTTCAGAGACGTGAGCGTAAAGATTAACAGAAAGGAAATT +CTCAAAAACGTAAATCTTTCAGTTTACAGAGGTTCAAAAGTCGGGATTAAAGGGCACACGGGGAGCGGAA +AAAGTACTTTCGTTAAATTAATTCCAAGACTCCTTGAGTACGAAGGGGAGATTTTTGTGGACCACACGGA +GCTGAGGGAGTTTAAACTCAAGAGTTTGAGGGAAAAAATAGGATTTTTGAGTCAGGAAGTTATGGTATTT +CGCGGAAGCGTCAGGGAGAACCTGCTCATAGCGAAACCAGACGCTACGGAAGAAGAAATGTTAAAGGCTC +TAGAGCTTGCAAAGTGTGACTTTGTTCTCAATTCACCTGAAGGGCTTGACAAGTTCTTAGAAGAGGGTGG +GAAGAACCTTTCTGGCGGGGAAAAACAGAGGCTTGCCCTTGCGAGGATATTCCTCAAAAACCCGGAGATA +GTTATCTTGGACGAGGCTACATCCGCATTGGACCCGAAAACGGAAGAAGAAGTTATATACAACCTTTATA +AATTTTTAAAAGAGAAAACAATTTTCGCGGTTGCACACAGGCCCTTTATTTTTAACTTCTGCGACGTGAT +ACTTGAGTTTGAAGGGGGGAGACTTAAAGAGTTTTCCACTTCTAAAGAAAATTCTATTAAATTATAAATA +CTCTCAAAACTCTTAAGGGGTGGCAGAATGTGGCAGGAATACGATAGCTGCGGTGTAGGGTTCGTTTGTG +ATATATACGGAAGGAAGAGCCACGATATCTTAAAAAAAGGTATCCAGGCGGTTAAGAACTTAACTCACAG +GGGTGCTATCGGAGGGGATGGAAAAACCGGAGACGGAGCGGGAATACTCACTGAAATCCCGGTAAAGTTC +TTTATGAAAGAGTTTAAAAAGCTAGGGTACGAAGTTTCTTCTCCCGAAAACCTCGCGGTGGGAATGTTCT +TCTTATACGAGCCAGTTGAAGACAAGGTAGAGGAAGCCTTCATAAGTGAAGGAATAAAGGTAATAGGCTG +GAGGGAAGTTCCCGTAAACACGGACGCGGTCGGAAAGGTAGCCCTCAAGGTAATGCCTCAAATCAAACAG +CTATTTCTCGATATGAAGAACATCCCCGAAGAGGAAAGGGAATTAAGACTCTTCTTCGCAAGGAGGAAAA +TAGAGAAGAAGTACGAGGATAAGGTATACATCCCCTCCCTTTCTACGAGAACTATCGTTTACAAGGGAAT +GCTCGTAGCTCCCCAGCTTGATAACTTTTACCAGGACCTCTTAGATGAAGACTACGAGACTTCCTTTGTT +CTCTTTCACCAGAGGTACTCAACAAACACCCTTCCCAACTGGAGACTTGCCCAGCCCCTGAGGTACCTCG +CACACAACGGTGAAATAAACACTATACAGGGCAACAGGAACTGGATGCTCACACTCCAGCACGAGCTTGA +ACACGAAATTCTAAAGGGAAGAGAAGACTTAATAAAGCCTTTAGTTTCCCACGAAGAGAGCGACTCCGCC +TCTTTAGATAGAGTTTTTGAACTCCTCTGCCTCGTGGGCTACAAACCCGAACATGCCATGTACATGCTAA +TTCCCCCCGCGTGGGAGGCCATTCCCGACCTTCCAGAAGAGGTCAGGGCTTTCCTCGAGTACGAGTCCTT +ACTTATGAAGCCCTGGGACGGTCCCGCGGCGATAGCCTTCACGGACGGTAAAGTAATAGGTGCACACCTC +GACAGGAACGGTCTCAGACCCGCAAGGTACGTGATAACTGAAGAGGGTTTTATGGTTCTCGGCTCAGAAG +TTGGAATGGTGGACCTCGATGATCAAAGGGTAAAGGAAAAGGGAAGACTCGGCCCTGGAGACACTATTCT +CATAGAACTCGGAAAGGGAGTAATTAAGAAATCCGAAGAGATATTAAAGGAACTCGCAAATTCAAAACCC +TACAAGGAGTGGCTTGACAAACATCTCCTCAGATTATCCGAAATAGAAAACGATTACAAACTTGAAAAGC +CAAAAGAAGATCCTGACAGAATAAGAAAGCTCGTAGCCTTTGGCTGGAGCGAGGAGGAGATAAAGAACCC +TATCAAATACATGGCTGAAACCGGAAATGAAATGACCTGGGCTATGGGTGACGACACGCCCCTGCCACCC +CTCTCCGAAAAGCCCCAGCTCCTCTACAGGTACTTCAAACAGAGGTTTGCACAGGTTACAAACCCCCCCA +TAGACCCCATAAGAGAAAGGGCGGTAATGTCCCTCCGTATGAACCTCGGCTACAAGAGGAACTTTCTCAA +AGAAACGGAAGAGCACGCAAAGAGGCTTCAGATAGACTCTCCTATACTCCTTGACTACCAGTTAAAAGCA +ATAGAAAACCAGAAGGAGTTTAAAGTCGTAAGGATACCCATAGCCTACCCGAAAGAGAGGAGTTACAACA +TAGTTGAACTTCAGGACATGGCGGGAGAGAGGAGGATATCCGAACTCATAATGGACGCCCTCTACGAGGA +AATTCCCATAAATGACATGAGACTCGGTATAGAAACGCTTCAAAGGAGGGTGGAAGAAGCAGTAAGGGAA +GGGGCGGACATAATAATCCTCTCCGACAGGTATATAAGCAAGTACAGGGTTGCCATTCCCGCACTCCTTG +CACTTTCTGCGTGTGTGAAGCACCTCGCAAAACAGGGACTCGCTCATAAGGTGTCCTTTATAGTTGAGAC +AGGTGAGGCAAGGGACAGCCACCAGATAGCCTGCCTTATAGGTTACGGAGCGAGTGCGGTTTATCCTTAT +CTTGCTTACGAGGTGATTTACGAACTCTGCGAAAAGGGAGAGATAGAACTTCCATATGAAGAAGCGGTAT +TCAAATACAAGGAAGCACTGGAAAAGGGACTTCTCAAGATAATGTCCAAGATGGGAATATCCACCCTCAA +CTCTTATCAGGGTGCTCAAATATTTGACAGCGTATGCCTCAATAAGGACTTTGTTGAAGAGTTCTTCACC +GGAACTCCTGTAACCTTGGAAGCGGACGGACTGGAGGAGATAGAAGCCTCAACCCTTGCAAGGCACAACG +CGGCATACGAAGTGGAAGAGCCAAAGCTTGACATCGGCGGACACATGAAGGCGAGAAAGGGCGGAGAGTT +CCACGCCTGGTCCCCCGAAGTTGTTCGTGCCCTTCACAAGTTCCTGAAGACTAAGGACTATAAGGATTAC +AAGGAATTTTCCAGACTCGCAAACTCTCAGCACCCCACCTTCATAAGACACCTCCTTACCTACAAGAAAG +GAAATCCCATACCCATAGAGGAAGTTGAACCAGTTGAAAGTATCCTCAGGCGTTTCGTGACTGGCGGTAT +GTCCCTGGGAGCTCTCTCCCCCGAAGCCCACGAGACTATAGCGGAAGCCTGCAACAGGCTCGGAATGAAG +TCAAATTCCGGAGAGGGAGGGGAGGACCCGGAAAGATACTGGACAATAAAGAATTCAGCAATAAAGCAAG +TTGCGAGCGGAAGGTTCGGAGTAACACCAACCTACCTCGCTTCCGCAAAGGACCTTGAAATCAAGATAGC +CCAAGGTGCAAAGCCCGGAGAAGGCGGACAGCTTCCGGGACATAAGGTAAACGAGTACATAGCGAAACTC +AGACACTCCCAGCCCGGAGTTACCCTGATATCACCACCACCTCACCACGACATATACTCCATAGAGGATT +TAGCTCAGCTCATTCACGACCTCAAGCAGGCTAACCCCTTTGCTAGAGTGTGCGTGAAACTCGTTGCTGA +AAGGGGGGTTGGAACGATAGCCGCGGGAGTTGCAAAGGCTTACGCGGACGTAGTTCAAATAAGCGGTGCG +GAAGGCGGCACGGGAGCCTCTCCTTACTCGTCTATTAAGAACGCGGGTAATTACTGGGAAATCGGACTAA +CTGAAACCCAGAGAGTTTTAATGGAAAACCACCTGAGGGACAAGATAAGGGTAAGGGTGGACGGCGGCTT +CAGAACCGGAAAAGACGTCGTAATAGCAGCACTCATGGGAGCTGAGGAGTTTGGTTTTGGAACAGCGGCT +ATGATAGCGGAAGGTTGCGTAATGGCAAGGATTTGCCACACGAACAGGTGTCCCACCGGAGTGGCAACTC +AGGACCCCAACTACAGGAAAAAGTTTAAGGGCAAAGTTGAAAACGTTATGGCTTACTTCAAAGCAGTGGC +ACAGGAAGTGAGAGAAATCCTAGCGGAAATGGGATACAGAAGCCTTGACGAAATAATCGGAAGAACGGAC +CTCCTTGAAGTAGTAAGGTATGACGAGTTCCCCGGTTCCAAGAGGATAAAAGTCGAAGCTCTCCTTGAAA +AGTATCCCGAAAACGAACCCAGAAGGTGCATGGTGGAGAAAAACGACAATCCCGCTCCAAACTTCAACGA +CAAGATACTTGAGGATCTTCTCCCTTACATAGAAGAAGGAATTCCCGTGGAAAAGGAGTACACCATAAGG +AACGTGGACAGAACGATACCTACGAAGATAAACTACTTCATCTCCCTCTTCTACGGAGATAGGGGACTAC +CGGAGGACACTATAAAACTCACCTTCAGGGGAACCGCAGGACAGAGCTTCGGAGCCTTCAACCACAGGGG +TGTGAGCCTTACGCTTATCGGAGACGCAAACGACTACGTAGGAAAAGGAATGTACGGCGGGAGGATTGTG +ATAATTCCCGACGGCGTAAAAGAAACGGATAAAAACGTTATTATGGGCAATACATGCCTTTACGGAGCCA +CGGGAGGAGAACTATTCGCTGCAGGTGTTGCGGGTGAGAGGTTCGCGGTAAGAAATAGCGGTGCAACGGC +GGTAATAGAGGGTGCGGGTCTTCACTGCTGTGAATACATGACGGGAGGTGTTGTAGTAGTTCTCGGAAAA +GTGGGCTTTAACCTCGGAGCGGGAATGACCGGCGGACACGCCTACGTCCTTGACGATGAACTCGATAAAA +AGCTCAACTACGCCTATGTTTACGCAAGAAGATTGGTGGGAGAAGAAGAAATTAAGGAGCTCAGAGAGTT +AATTGAAAAACACTACGAGTACACAAAGAGCCCGAAGGCTAAGGAAATTCTGGAAAACTGGGAAGAATAC +GTGAAGAAGTTCTGGAAGGTCATTCCCTTGGAGCAGTGTTCCAGAGACCCCTACGGTGATTCCGACGCTT +GCGAAGTAGAGTTCCTCGGAAGGAAATAAAGTCCTTAGCCTTTGCCCTTTACGACACCGGGGAGACCATC +CTCGGTGCCCTCGTTGTTTCTACCTTCTTTCCCTTATTTATCACAAAACACATAGACGTTAAAATCTACA +GCCTGAGCTATGGAATTTCCTTACTCGCTTCCTTTGCACTTGCCATATTTTTGGGCAAGCTTGCCGACGA +AAATGCACTCAGGAAAAAGTTCTTTACCCTGTTTTCCCTTCTGACTTCCCTATTTTTGAGCTCCATAGCC +CTTTTATACGGAACGCCCTATCTCGCACTCCTTTCCTTCCTACTTATGCTCATCTCGCACCAGCAGGCGA +TGGTCTTTTACAACTCCCTTCTTCTGAACTTTGAAAACAAAGGCTTTGCTTCGGGACTCGGAGTATCCTT +CGGATACGTAGGCTCTGCGATAGCCCTTATATTTCTAGCAGACAAACTAAAAGAGCCAGAAGTTTACGCA +GTGGTAGGATTGATATTCCTGATTTTGGCTGTGCCTTCGATAATTACCTTGGAAAATCCTGAAATCTCTG +CAAAGATTTCCCTGAAAGAAATTTTCGGAGACAGAACCTTTCTCCTCTTTTTACTCTCTCTTTTAACTTT +AACGGAGGTTGCAAACACCTTAATCGCTATGATGGGGGTTTATCTCAGGGAAGTTTACTCTTTGGAGAGT +GTAGAAATTTACAGAATTATCGGGTTTTCAGCTCTGGGAGGGGTTTTAGGGGGCATCTTCTGGGGCGTTT +TGACAGATAAACTAAATGTAAACAGGGTATTCCCTTTAGGTTTTTTCCTCTGGTCTTTCTTCTTTATACT +TCTGTTTTTTGCAAAGAAAGATTACCTGATTTTCGTTGGGCTTTTGGCGGGTTTTTCACTAGCACACCTC +TGGAGCACTTCACGGGTTTACATCCTTGAGAACTTTCCAAAAGAGAGCGTTTCTGTGAGGATGTCCTTCC +TCTCTTTAACTGAACGTGTAGCTTCAAGCTTCGGGCTCTTTTTGTGGAGTTTTTTCCTGTTTATTACGCA +GGACAACTTCAGACTCTCAGCTCTTCTTATGGGAACTTTGCCTTTAATTGGTTTTTTCATTTACTTAAAA +ACGAAGTTAGATTAAAAAAAAATGCAATCACTAAAACTTTTCTCACTAATATTTATAATATGGGCTACAA +GGAACTACTTCTGGAATGCCAGAAACTCCTGAACGAAGGAGACTTTGAGGGAATGATAAAAAAACTTGAA +GAACTCTCAAAGATGGAACCCTCTTCAAAAGAGGAAGCTGAAGAAAGCTTAAAACTTCTGGACTTCCTTA +TAGAAGAAGTGAAGAAGAGACAAGAAGAGATATTCAACAAGATGGTAAATTACCAGAAGTTTAAAAATTA +CCTGAGGTAAGAGGATGTACTTTTACGATATCAACAACGAGAAGAGACTCTGGCTTCACCTTCACGGACT +TGCGACAAACGTCCTCGGAAGGAAGATAGAGTTTTTGAGGAATTACTTTAAGGAAAAGAAGCTTTATTCG +TTTTTTGCGAATGATATGGACTACGAAAAGCACACAACTACAAACACCTTGGATTTTTTGGAAGTTCTCG +TCAGAGGATTTTCCCAGAAGTTTGAAGAAATTACCCTTTGCGGGAGTTCCCACGGCGGTTACATAGCGAT +GAACTATGTAAGGAAAAGGCCTCTCTTTAATGTAAAGAGACTCGTCTTACTCGCACCCTCATACAACACA +CTATCCCTGATAATTAAAGAGCTCGGAGAAGATAAGGTAAAGCCATGGCTTGAGGGAAAGGAAGAACTCA +CCATACTTGAAGAGGACAGGGAAGTGACCTTTATAAAGGATTGGGCAAAGGACATAATACAGAACGACTA +CGAGATTATAAAAGACGGAAGGGTGGATTTCCCCGAAGAGCCTCCCGTGGAAATAGTGATAATGCACGGG +ATAAGGGACGATATAGTGCCAATCCATTATTCCGAGACCTTTGCAAAGAGCGTAAAGGTGAAAAAATTCC +TCAAAGTGGACGACGACCACCAGCTAAACGAAAGTCTGCAGAAGTATATAGAAGAACTCCTTTAGATTTT +GCTGAGGACGAACTCTCCAATAGGATTTTTAAACTCTTCGTCTCCGAGGTGGTATGCGGTCCAGAGGTGC +AGACACCTAACTTTAAAGGGCTTCGTTCTGAAGTTTCTAATTCCCCCTATGCCTATGTTTTTGTCGAGCA +ATACCTTTTTGCACACCATGTCCCACTTTCCTTGACCATGGTAAATTTCGGGAAAGTCACGCTTCAGGAT +TTCTTCCCGTTTCTTTACCTCCTTCTCGTGAAGGGAGACGAAGAAGTTAAAGAGTTCCTCGTCCTTAGTG +ATTTCTTCAGATAGTTTTTTTATATAGCCTTCTGACTCAAGCTTAGAAACCGCTTTCTTTAACTCTGGCT +CCAATATCCAGAACCTTGTGGGCTCTGGTCTGTAAATGCCGTTCTCAAATACAACTATCGGATTTTCTAC +TACTTCAATCTTCATATATTATATAAATATGGCAGGACACAGCCACTGGGCGCAGATTAAGCACAAGAAG +GCAAAGGTAGACGCACAAAGAGGTAAACTCTTCAGCAAGTTAATAAGAGAAATTATAGTAGCTACGAGAC +TCGGAGGACCAAATCCCGAGTTCAACCCGAGACTAAGGACCGCAATAGAGCAGGCTAAAAAGGCTAATAT +GCCCTGGGAAAACATAGAAAGGGCTATAAAGAAAGGAGCCGGTGAACTTGAAGGAGAGCAGTTTGAAGAG +GTTATATACGAGGGATACGCCCCGGGCGGAGTTGCGGTAATGGTTCTCGCAACCACGGACAACAGGAACA +GGACCACCTCGGAAGTGAGACACGTATTTACGAAGCACGGAGGAAACTTGGGAGCTTCGGGATGCGTTTC +TTACCTTTTTGAAAGAAAGGGATACATAGAAGTTCCCGCAAAAGAAGTATCCGAGGAAGAACTCCTTGAA +AAGGCGATAGAGGTCGGTGCGGAAGATGTCCAGCCAGGCGAAGAGGTACACATAATATACACCGTTCCCG +AAGAACTCTACGAAGTGAAGGAAAATCTCGAAAAACTCGGCGTTCCTATTGAAAAGGCTCAGATTACGTG +GAAGCCCATATCAACAGTTCAAATAAACGACGAGGAAACCGCCCAAAAGGTAATTAAACTCTTAAACGCT +CTTGAAGAACTTGACGACGTCCAGCAAGTAATAGCCAATTTTGAAATACCCGAAGAAATACTTCAGAAGG +TTGGCTAATCCCTCTCTTTTCCTTAAATTTTCCTTATCCGATGTTTGTAAAGTTACTTCCTCCTGAAGTA +AGAAAGGTAATAGCGGCCGGAGAAGTTATAGAATCTCCTGTTGACGTCGTAAAGGAACTCGTTGAGAATT +CTCTGGACGCAAAGGCGACAAAAGTAGAGGTAGAAATCGTAAAAGGCGGGAAGAGGCTAATAAGGGTCAA +AGACAACGGTACAGGAATACACCCCGAAGATGTTGAAAAGGTGGTCCTGCAGGGAGCGACGAGTAAGATA +GAGACCGAAAAGGATTTGATGAACATAAGCACTTACGGATTTCGCGGTGAGGCCCTTTACTCCATATCAA +GCGTAAGCAAGTTTAAACTCCGTTCCCGTTTTTTCCAAGAAAAGGAAGGAAAGGAAATAGAAGTAGAAGC +GGGAAACATACTCGGGACGAGAAGAGTGGGAATGCCCGTGGGAACGGAAGTTGAGGTGAGGGATCTCTTT +TTCAATCTCCCCGTCAGGAGAAAGTTCTTAAAAAAGGAGGATACCGAAAGGAGAAAGGTACTGGAACTTA +TCAAGGAGTACGCCCTCACAAATCCAGAAGTTGAGTTCACACTCTTTTCCGAAGGCAGGGAAACCCTGAA +ACTGAAAAAGTCAAGTTTAAAGGAAAGAGTTGAGGAAGTTTTCCAGACAAAAACAGAGGAACTTTACGCA +GAGAGAGAAGGAATAACGCTCAGGGCTTTTGTTTCAAGAAACCAAAGACAGGGAAAGTATTATGTCTTTA +TAAACAAAAGACCTATTCAGAATAAGAACTTAAAGGAGTTCCTGAGGAAGGTTTTCGGTTACAAAACTCT +AGTAGTTCTTTACGCAGAGCTCCCTCCCTTTATGGTTGACTTCAACGTCCACCCCAAGAAAAAGGAAGTG +AACATACTGAAGGAGAGAAAGTTCCTTGAACTTGTAAGAGAACTCGCGGGAAAAGAGAAACCTATCGTAG +ATATTCCCCTCTCTCAACCTGTGAAAACTTACAAGCCCACATACGAGATACTCGGGCAGATGGACGAGAC +CTTTATCCTCGTGAAGGATTCCGAATACCTGTACTTCGTGGACCAGCACCTCCTTGAAGAGAGGATAAAC +TACGAAAAACTGAAGGACGAAAACTTAGCCTGCAGGATTTCCGTAAAGGCGGGACAAAAGCTCTCGGAAG +AGAAAATCAGAGAACTCATTAAAACCTGGAGAAACTTGGAAAATCCCCACGTTTGCCCCCACGGAAGACC +CATATACTACAAAATACCCCTGAGGGAAATATACGAAAAAGTAGGCAGGAATTACTGAAGGTGGTAAATT +AATCCTTGATGAGGATACAAAACTTTTTCTCTCCCAACATTCCCCTGAAAACCACGAGGAAAGAGCACAT +AAGGGGGGATTTTTACTCGGAACTTAAAAGCTTTAAGCCCGTAATTGAAAGAAATACAATATCCTTGCAA +AATCCCTACTCCTCTCCAATAAAATCTCAGATAAACAAGGAGTATATAAAGGAACTTGCGAGAAAGAAGG +CGCAGAAATACGGCGTCCCCCTAAATATAGTCCTCGCAATTATAGAAAAGGAAAGCTCTTTTAACCCTAA +GGCTTACAACAAAAACAAGGACGGGACAGAAGACGTAGGCCTAATGCAGATAAACTTCCAGCACAACAAA +AGACTCATGAGGGAGTACGGCGTAAACTCACCCGAGGAGCTTTACGACCCGGAACTGAACCTTGAACTCG +GTGTGAGAATACTTTACGAAAACTACAAAAGGTACGGTTCGTGGGAGCTTGCCGTAAAGGCTTACAACGG +GATAAGGGCGGATAACTGGGATTACGTAAAAAATGTTATGGAAAGGGCTAAAAAGTACGTAAACTTATAG +AAATGGCAAGAATTTGTGTTGCTCTGGACGTCCCCTGGGAAAGGGCTATAAAGATAGTAAAAGACCTTTA +CGACTTCTTTGAAACATATCCCCTTATCTTAAAAATCGGACACAAGATTTACCTTGAAAAGGGCGGAGAC +GCTGTAAAGGAACTCAAGGAGGACTTTCCTTACGAGGTGTTCCTCGATTTAAAACTCCATGACATCCCTT +CGGTTGTAGGACTTGCCGTTGAAAAGATCAGTGAACTGGGAACGGATTACACCACGGTTCATCTGCTCGG +CGGTCCGGAAATGGTAAAGGAAGCGGTAAAGAACAAGGGAAGCATGAAAATCCTCGGTGTTACTATACTC +ACCTCGCACGACGAGAACTACATAAAGTTTTTAAAAAGCAACTTTGAAGATATAAAGAACTTCACCCTTT +ACCTCGCAAGAGTTGGTATAGAAAACGGCGTTGACGGAGTTGTTTGCTCAGGTGAAGAAGTTGAGTTCTT +AAAGAAGAACATAGAAAAGGACTTCATAGCGGTAGTTCCGGGAATAAGGATTAAAAAGGAAAAGAGGCAC +GACCAGAAGAGGGTTCTCACACCCGCGGAGGCAAAGAAAAGGGGAGCAGACGTTATAGTAATCGGAAGGG +AAATTACAGAGAGCAAGAATCCCGTCTACGTGGTAGAAAGGGCTCTAAAGATGATGGGAGAGATATGAAA +AAGCTTTTAATTTTATTAACCTTTGTCTCCTTTGTCTTTTCTAAGACCTTTTACTACGACGTTTACGTCT +TCTTTTTCAGAGTTGGAGAGATAAAAATTCAAATTGACAAAGAAAAAAGTTACGCCGAGGGAAAAACACT +TGAAAGTATGAAGTGGCTTTACTCTTACGATTTTAGATTTTACGAGGAAAAAGGAGACATGAAACTCTAT +GAGAGAGAAAAGGAAAAAGTGAGAGTTTTCGGAAAGGATAAGATTTACGAAAAGAAGCCGTGGATACCCT +TACTGGTGGATTACTTAAAGACGGGAAAGGTGAAGGAAAATAACCTCTTTAAAGTTAAAAAAGAAGGGAA +TAAATTTATCGTTATTCCGCTGAAAAGCAAAAGAGTAAAAAAAATTATCCTTAAGGACGGAAAAGTTCCT +AAAGAAATAGTAATTCACGGGAAGGTTAAGATAAAGTTAAAACTCAGAAAGGCGGAAGATGATAAGGGAA +CTGTTTGAAAAGGAAGGATTTACTCTGGACGAAGAACAGGAAAGAAAGTTCTCAATTTACCTGCAAGAAC +TCCTGAGGTGGAACAAAGTTCACAACTTAACATCTATAAAAAAACCCGAAGAAATCGTGAGGAGGCACTT +TATAGACAGCGTGAGCGTCGTGAGGTGCTTTGAAAGAATAGGACTTGACTTGAGGGGAAAGCACTTTGCG +GACGTAGGGAGCGGAGCGGGATTTCCCGGCGTTCCTCTAAAGATTTACCTCAAAGACATAAAACTCACCC +TAATAGAGTCTGTTTCCAAGAAGTGTTCTTTTCTGGAGTACCTGAAGATTAAACTAAATGAAGATTACAG +GGTTCTCTGCACTAGGGCGGAAAAGGTTGAAGAAAAGTTTGACGTGGTACTCGCAAGGGCACTGGGAGAG +TTTGAAGAGGTAAAAGAAATTTTAGAAAAATTGAGCATAGGGTACGTATTCGTGTACAAGGGAAGCAAGT +TGAAAGAGGAGTGGCTAAAGGATTACAAACTTTGTGAATTGTCACTGAGTTTTATGCCAAAATCCTATAT +ACTGTGGAAGAAGGTATAAAGATGGGAACTAAACTCACTTCTCTCTTCAAGGAGGGTGAAAAGTACCAGA +TTAACACAAAGTACAAGGAATTACCTATAAAGACGAACCTCAAACTCCTCTGGATAGATGAAAATATGAA +ACTCCTCGGCTTTTCAATAGGAGCCTGTGTCTTTAAAGGGGCTTTCACTCCGGGAACTGAAGTTTACATA +AAGATAAACGGCAAGTATGCGTACGGAAAAGTGTTCTCCTGTAGTAATGAGCTGGTTATTGAGTTCAAAG +AAATTAGGAAAGAACCCGAATTTATCAGAAGGAGAACCGTAAGGGTTGAACCTGATCCAGCAAACCCCGT +TGTAGTTGAACTGAAAGTTGACAGTTACTCCATAAAGACAAAGGCAAAGGATATAAGCGAAACAGGTGTG +GGAGTGATACTGGAAAAAGACAAGCCCGAAAGTGCGGAGGTAATAGACATAATCCAGAAGAACCCGAATT +CCTGGTTTGACCTCTACGTTCACCTTCCCAAACACGGAACCGCACACGCAAAGGGAAGAGTCAGGAACCT +GAGTATAGAGGAGGAAGGAATATACATAAGAATAGGTTTTGAAGCGGAGTACTCAAAGGAGGACAGGGAA +AAGGTAAGAAGGTACGTATTTGAAAGACAGCAGGAGATAATAAAATCCCTGAAAATGTTATGAGCCTTTA +CCTGAAAGTAGTCTTAAGGTACCTATTTCACGCAAAGGGAAGTTCCCTTTTTATGACCTTCATGTCTTTC +TTCGGTATTTTCCTGAGCGTAAACGCCATAATCCTTACCTTAGGTGTATTTTCCGGATTTCAGGACGAAC +TCAAGAATAAAATCCTTTCAAAAACTCCACACCTCGTGATAACACTCTATTCCGATTACGAAAGGGAAAG +AATAAAGGAAGTCTTAGAAAAGGAAAAAGAAGTTGAGTACTTCTTGAGTTTCGTGGTTTACAACGCTTTC +CTTTCAAGTGGCGAAGTTATCCAAAGCGTGAGCGTAAAGGCTATAGATTACAAAGACGGGGAATTTCAGA +AATTCATAAAGAGATTTTTAACGGAAGGAGGTACGAAAGGTCTCATACTCGGAAAAGGGATTGCAGAGGT +TTTCGGACTTTTGGTAGGCGATGAGGTAAGCCTCATATCCCCTTTCGGTATCAGGACACCTACGGGAGTA +ATACCGAAGGTAAAGAAGTTCAGAGTTGGAGGGATTTTTTACACGGGTTCCTACGATAAGGACTACGCGG +TAGTTTACATGAACCTGAAAGACGCCAAAGAGTTCTTCAAAAGGGATTACGGAGTTAACTTTACGGAAGT +TTACATAAAAGACCCCTACAGAGCGGATATCGTAAAAGAAAAGGTGAAAAAAGAACTCGGTGAGCGCGTA +GTCGTCCGCTCTTGGATAGACCTGAACAAACCCCTCTTCAATGCCCTTGAACTTGAAAAGCTCGGACTTT +TCTTTATCCTCCTCCTGATGGTTGTAGTTGCCTCTTTTAACATAACGAGTCTCCTCTTCGTAAAGGTAAA +GGAAAAAGTAAGGGATATCGCGGTATTTAAAACCTTCGGAATGAAAAAGAGACAGGTTTTAATGATATTC +CTCTCCTTAGGGCTCTTTATCGGCACGGTGGGAGCAATTTCGGGCGTAATCAGTGCCTACGTACTCGCCT +ACTTCATAAACGAGTACAAACTCATAAGAGTGTCTGAAGAGGTCTACATGATGAGTTACATCCCCGCTCA +CATAAAGTTGAAGGACGTCCTTGCTACGCTCCTCGGAGCACTCTTGCTTTCTTTTATATCCTCACTCATT +CCGGCTCTCAGGGCTTCCAAGGAGAAGGTTATAGAAGTTTTGAGAAAAGAGTAAGGTATTGCTATAATTG +TTTAGCGGAGGAGAAGAATGGACATAGGAGTAATGCCTAATGCAACAATCCTCGTTCAATTGTTCATCTT +CGTAATATTCCTAATGATAATCACTAACATCTACGTAAAGCCCTACACCGCGGTGATAGAATCCAGAGAA +GAACTCATTAAGAAGAACCTCTCTGAAGCACAAAAGTTAAGGGAAGAAACTCAAACCTACCTCACTCAGG +CCAAAGAAGTTCTCGAAGATGCGAAGAAGAGGGCGGATCAAATAATTGAAAACGCAAGAAGGGAGGCGGA +AGCTCAGGCGAGAAGCATAATCGAGCAGACGGAAAAACAAACCGAAGAAGAGATTAAGAAAGCAGTGGAG +GAAATCAGAACCTCCTTAGAAGAAGAGAAGAAGAAGCTCGAAAAGTCCGTAAAGGAAATAGCTCAGGAAA +TTGTAAAGAAAATTTTGAGAGAGGCGGCGTGATGGTGAGGTTGATAAGTTTCTTAACTCTGGCTTCTACT +TTTGCTTACGCGGGTGAAGGACATTTGGGACACTCCCCCGGAGCGCTGATCTGGAAAGGGCTCAACATAC +TCGCGTTCCTCGGAATAGTTTACTACTTTGGAAAAAAACCCATAAGCGAAGCCTTTAACAAGTTCTACAA +CTCAATAGTGGAGAGCCTCGTAAACGCAGAAAGAGAGTTCATGATGGCAAGGGAGGAACTTTCAAAAGCT +AAAGAGGAACTCGAAAATGCGAAGAAAAAGGCACAGGAATACGAGAAACTCGCAATAGAAACCGCGGAAA +CGGAAAAGAAAAAGATACTCCAGCACGCCCAGGAAGTTTCCGAAAGGATAAAGGAAAAGGCTAAGGAGAC +GATAGAGATTGAACTGAATAAAGCTAAGAAAGAACTCGCCCTTTACGGAATACAGAAGGCTGAAGAAATA +GCAAAGGATCTTCTCCAAAAAGAATTCAAGAAGTCCAAAGTTCAGGAAAAGTACATAGAGGCTCAGTTAA +AGCTCCTGGAGGAGAGGAAGAATGCTTAAGAGGAAAGAACTCGCAAGGAAGGCTGTAAGGCTCATAGTAA +AGAAGGTTCCAAAGGAAAAGGAAAGCATCTTAAAGGTTGACGAGTTCTTAGGAACCCTTTCCACAGCTTA +CAGGAAGGACAAACTCCTGAGAAACTTCTTCCTGTCGCCCCAAATAGACAGAAACGCAAAGGTAAAAGCC +CTCGAGTCACTTGCGAAGAAGTACGACGTTCCGAAGGAAGTTCTCGAAGTTCTCGAGTACCTCATAGATA +TAAACGCCATGGCTCTTATTCCGGAGATAAAGAGACTATACGAATTAGAACTCGAAAAGCTCATGGGAAT +GCTTAAAGGGGAACTCATACTTGCAAAGAAACCCAGTAAAAAACTCCTAGAAAAGATTACAAAGACCATA +AACGATATCCTAAACAGACAGATAGAAATTGAAGTAAAGGAGGACCCTTCCCTTATAGGTGGTTTTGTCT +TCAAGACGCAGGCTTTCGTTCTGGACACTTCTGTTAAAACCCAGCTTGAAAAACTCGCAAGAGTTGGAGG +TGTTTAAATGGCCGTAGAGAGGACACTCATAATAGTGAAACCCGACGCTATGGAAAAGGGAGCTCTCGGC +AAGATCCTGGACCGCTTCATTCAGGAGGGATTCCAGATAAAAGCTTTAAAGATGTTCAGGTTTACCCCCG +AAAAGGCGGGAGAATTTTACTACGTCCACAGGGAAAGACCCTTCTTCCAGGAACTCGTTGAGTTCATGTC +TTCTGGTCCCGTGGTTGCAGCTGTACTGGAAGGTGAAGACGCAATAAAGAGAGTAAGGGAAATAATAGGT +CCTACGGACAGCGAAGAGGCGAGAAAGGTAGCTCCCAACTCCATAAGGGCTCAGTTCGGCACGGACAAGG +GTAAAAACGCCATACACGCCTCAGACTCACCCGAGAGTGCACAGTACGAGATCTGTTTCATATTCTCCGG +TCTTGAGATAGTATGAAGCTTTTTAACTTCAAAGGGGAAAGGGTATTCACGCCAGGTCCAGTAGAGATAC +CCGACAGAATAAGGGAAGTTTTAGGCAGACAGATAATACACCACAGAACTAAGGAGTTTACGGAAGCCTT +TTTAGAAACGAGGGAGCTCTTTAAAAGACTCGTTGATTGCACTTCCGAAAACTTTGTGTTTTTTGCATCC +TCGGGCACGGGGGCTATGGAAGCTTCCGTTCAGAACTTCTTTAATCCCGGAGAGAAAGTTCTTGCCGTAG +TAGGCGGAAAGTTCGGAGAAAGGTGGGCAGAGCTCGGAAGAACCTGGGGCCTTGAGGTAGTAGAACTTCA +GGTAGAGTGGGGAAAGAGCGTAGACCCCGATCAGGTGGAAGATATCCTGAATAAAAATCCCGAGATAAAA +GGTGTTCTGGTTCAGATGTCCGAAAGTTCCACGGGAGCCTACCACGACGTAAAAACCCTTGCCAAGATAA +CAAAAGACAGGGATACACTCCTCGTAGTTGATGCGATAACGGCTCTCGGTGTGTACAATATGAAGCCCCA +CGAATGGGGACTTGACGTAGTGGTGGGAGGTTCTCAAAAAGCTTTCATGCTTCCACCCGGGCTTTCAATG +CTCTGTTCTCCGAAAAGGCGGAAAAAAGGCTAAACGACAGGGCTTATTACTTTTCCGTAAAGAAAGAAGT +TGAAAAGCAAAGGGAGGGACAAACCGCTTACACTCCCGCAATAACCCTTATCCTTGCCCTGAGGGAAGCC +TTAGAAATGCTGCTGGAAGTGGGAATGGAAAACGTTGAGAAAAAGTACAGCGCGATGGCCAAAGGAACGA +GAAAGGCACTCGAAAGTATAGGTTGCAGAGTTTTTCCCGAATATCCTGTAATCTCCTTGAGTACATTTCT +TCCCCCCGAAGGCGTTGGAGCAGATGAACTCAGAAAAAAACTCCTCTCCTTCGGTGTCAGAGTTGCGGGT +GGACAGGGTAAGTTAAAAGGAAAAATTTTCAGGATTTCCCACATGGGTATGGATGTTCTGGATATGGTTC +ACGCAATATCCGCTGTGGAACTCGCCCTCGGAAAGAGGGGAGCCGTAGATATTTACCTTGACACCGTTTC +GGAAAAACTTTCATGATACTTTAAAATTTTCACTATGAACGAGTTCAAGGCTTTCCTCGAAGTTGTAAGC +AAATTCACGGATCTCAAGTGGGGAGATGTACGCGACGACCTGATTTCAAGGAGTATAAAAGTTCTGAGAA +AGTACAGGGAAGGAAAAACACCTGAAGATCTAAAAAATTCTAAACTTATTTTAGGGATTGAAGATTTTTA +CGAAAAACTTTACGAAATTTACAAGGAAAACCCACAAAGCATTGAAAAATTAACGGAGGCTCTAAGTTCC +TTCATAAAAGCTCCCGTTCCCTGCAAACTGAAAATAATAAACATAGTAGAAACATTACTTAAGGAGTGAG +TAAATTTCGTCAAGAGCCTTTAAGCTTTCTTCAAAATTCACCTTCTCTTCTGGTTTTTGTTTAAAAAAGC +TTTCCACTTTTTCTAAGTTATTTATAACTTTGTCTACCAGAGGATTTGAACCGCCCTTGTAAAGTCCTAT +CCTCACAAGCTCCTCCACATCTTCAAACTTACTCAGAACTTCCTTAAAGAAGTTTGCCTTCATGAAGTGC +TCTTCACTTACAAGCTTTGGCATTAGACGGGAAAGACTCCTTACTGGATCAACCGCCGGGAAAAGTCCCC +TTACGGCTCTCTTTCTGGAAAGTATTATGTGACCGTCGAGGACTCCCATAAGCGAGTCGGCTATTGGATC +TAAAGATATATCGTCTCCCTCTACCAGAACTGTGAATATTCCCGTTATACTTCCCTTCTTGAAAGCTCCG +CAACTTTCCGCTATCCTCGTGAGGAGCTGAAAAACAGAAGGAGTAAAGCCCTTCAGGGTAGGAGGTTCTC +CCGCGGCAAGTCCTATTTCCCTCTGGGCTAAGGCGAGCCTTGTAATAGAGTCCATCAAAAGCAGAACGTC +CTTCCCTTGAGATGCAAAGTGGTGGGCGTGAACAACAGCACTGATAGCCCCTTTTACCTTCAAAATAGGG +GATTGATCCGCGGTAGAAACCACCACGACGCTCTTTTTTAAGCCCTCTTCTCCCAGAACCTCCTCTAAAA +ACTCCTTTACCTCCCTTCCTCTTTCTCCGATAAGGGCGAGGACCACAACGTCCGCTTTTGAGTGCCTCGT +TATCATTCCGAGGAGCGTACTCTTTCCCACTCCTGCTCCTGCAAAAATCCCTATCTTCTGCCCTTTTCCT +AAGGTAAACAGGGCGTTTACGCTCCTAACGCCCGTATCAAAAACTTCTCTAATCCTTTCCCTATATAACG +GGTTTATCTGGGGCAGTTCTAAGCCCTTTTCCTCAACAAATCCTATAAAACCACCGTCCAGAGGATTTCC +GAAGGGATCAACCACTTTTCCTACTACGCCGTTTCCCGTCTTGGTGGAAACGAGCTCGTTCTTAAGCAGG +ACTTTATCCCCTTTTCTGAGTCCAAAGACTGGTTCGTAGGGCATTACGAGGACTTTATCACCGCTAAAGC +CTATTACTTCCCCCCTTATCCTCCTGCTGTTGCTCTGTATTTCCACTTCGTTTCCTATGTTCGCAAAGGG +GAGTATGGCTTCCAGGTATATTCCTTTCGCGGAAACGATTTCTCCAGAAACTTTAAGCCCTCTTAAATAC +ATCTCCGAACACCTTTTCAAATACGATTTTTGCAAATTCCTTCGGATCCCTTTCAACGGTAAAATGTTCT +CCCTTTATCCTAAAACTTCCCTTCTCAAGGTCTTTGTCCTCCAAAACTTGAAGGTTTATGCCCTCCGCTT +TTAAGTTTTCCTTCAGGGATTTGAGTTCGTCGTTTAGATACCTGAGATCCTCCGGGTTTATGTAAAGCTT +TAAGTTAGTTTTAAACTTTATAAGTTCGTCTATTATGTTCCTGAGGTCTTCCTTTAAAACTTTTACCTGA +GGAACGTAGTAAGAAAACTCAAGAAGAAAAGTCTTTAGGAACTCCTCTACCTTTTCCCTGTACTCTTCCT +TCAAGTTTGATAGGTATTCTTCAATACTTTTCGAAAGACTTAAAGAAATACTCCCCTTTTCTGAAAGCTC +GTTCAGTCTTTGTTCAAGTTCTTTTATCTTCTCCTCTCTGTTTTTTATTTCAAAATACATTTTTTGTTTT +TCCTCTTCAAAGCTGTCCAATTTTTCTTCGTAAGACCTAATGGTTTCTAATAGCTTTTCCCTCTCTTCAA +GTAATTCTTTTATTACCTTTGAGCAATCCTCTTCGTCCTTTTCTTTCTTCTGGTTTTCTTTTTTTAAGAA +GTCCTCCCAGAGGGGTTTGAAATCCTCACCGCTCACAAGTATAAATAATAAAGTTATGTTTCAGTGTTTT +CTATTCTTCTTAGCAGGTTTTGCATTCGGATTTCTCTTAGCTGTAGCCCTAATAGTGGGAATTACCTTAA +TTCCCTTCATACTCCTCGGAGTCCTTATCTTTATGGCGTACGCTTACTACAAGTACAGAAAGGAACAAAA +GCGAAGGGAAGAGATACTCAGAAGGTATTACGAGGACCTTTGGGAAGAATAAACTAATTACTATGAACTT +CAAAAAGGGAGAGGTAATTCTCGCACCTATGGCCTCTTACACCCACTCCGCATTCAGGAGACTTTGCAGG +AGACTGGGAGCGGATAGAACTTACACGGAACTTATAAGTGCGGTCGGTGTCCTCAGAAACGGAATTCCCA +TGAAGCTCGCTTACTTTACAGAAGAAGAAAGACCAATACATATTCAGGTTTTCGGAAGCAATCCGGAAGA +AATAGCACAAGCAAGCGTTGTAATAGCGAAAGAATTAAAGCCCGACTTTATAGACATAAACTTCGGATGT +TCTGTTCCCAAGGTTCTGAGAAACAAAGCTGCCGGTTACATGCTCCAGTGTCCACCTCTCATGGGAGAAG +TGGTAAAGGAGACTGTAGAGGCGTTGAAGCCCTACGGTATTCCCGTTTCTGCAAAAATCAGACTTGGTTT +TGAAAAGGACGAGGTGGAGAGGATAGTAGAGGAACTCCAGAAAGCGGGAGTCTCTTTAATAGCTATTCAC +GCGAGAACCGCAAAGCAGGGATTTAGCGGGAAAGCCCTCTGGCACAGGATAAAGGAAGCCAAAAAGGTTG +CAAGCGTACCCATAATAGGGAGTGGAGACGTAAAGAGCTGGAGGGATATCGAGAGAATGTTTGAAGAAAC +GGAGTGCGACGGTGTTATGGTGGGGCGTGCAGCCCTTTCAAACCCGTGGATATTTAAAGAGTTCAAAGAA +AAAAGGGACATAGAGGTAGGTCTAAAAGAGAGAATGGACTTTATCCTTGAAGAGCTTTCTATGATGACGG +AGTATATGAGCAGGGAAAAAGCGTGTGCGGAAATAAAATCTCAAATAGTTCAAATACTCAAAGGTGTTCC +CAATTCAAGGGAATTGAAGACCTACATAGTGCATGCGGAAAACTGCAAGGAACTTGTAAAAAGGATAGAG +GAGGCGAAGGAGAGGGAATTACTTTATGCCTAAGGTAGTCTTGGGAGTTACGTAGTCTGCAAGTGCCGCT +ATACCACCTTTCAGAGCGTAAACGTTGTCAAAGCCCGCACTTCTGAGGGCAAAGGTTGCTGCTATTGCCC +TTGCACCTGAGCGGCATATTACTATAACCTTTTTATCCCTCGGTATTTTCTTAAGATTTTCAGGTTTAAA +GAGCTTGTCCATAGGGATGTGCAGGCTATTTTTGTAGGTAAGTCCCACGATGGATTGTTCCGCTTCCGTT +CTTATGTCGAGGAGAACTACGTCCTCACCTTTCTTTATCATTTCTACGACTTGCTTGGGTGTTACCCTGC +AGGGAGACTTTGCGAGAGTTTCCTGAGTCATCTGGCTGAACATCTTGTCGTACTTCTTGATAAGAGCCTC +GTCAACTCCGAAGGAAAGTCCTCCGAAGCTAACAACTGCAAGTGCAACTGCCAAGTACTTTTTCATCTTA +CCCACCTCCTTTATAAAGATTTTCGAATATTATTATACACTGATAATGTAAGTTAGAATTTGCTCCTTAA +ACACTATTCCGATAAAAGCTCCAAGGGAAAGGAAAGGCCCGAAAGGCAGGGCAAAGTTCATACTTTTGTG +CCTGATTATCATGGGAAGAGCGTAAAGAAGTCCCAGAAAACTCCCTATAAAAAGGGCTGAAAACACTCCG +TAAACTCCGCTCACAGAACCTATAAAGCCAAGGAGTATGACATCCCCGAAGCCCAGTCCTTCTATTTTCC +TGAACTTCACGTAGTAAAGGTATATAACGAATGGGATAAGTACTCCTACAACCGCTCCTATAATGCTCTC +TTTTGGTGTTATATCTTGCCTGAACGGGGAAACAAGAATACCTAAAACCAGACCTCCTATGTTTATCCCG +GGCGGGAGTATGAAGTAGTACCAGTCTATTATGGACATAACGAGGAGTGCGGAAAAGAAGAAGTAGTAAA +CGACTCCGTCAACGGAAAGTCCCCACTTGTAATAGGAAAGCACCGCTAAAAAACCCGAAGCGAGCTCCAC +TAAAGGATAACGAGGAGGTATTTTTTCCCCGCAGTGTCTGCACCTTCCCTTTAAGATCACGTAAGAAATT +AAAGGAATGTTGTCGTACCACTTTATAGGTGTTTTACACTCCGGACAGTGAGAAGAGGGAAAAACTATAG +ATATATTTCTCGGAAGTCTGTATATAAGGACGTTGTAAAAACTCCCCAGAATTAAGCCGAAAAGGAAAAC +AGCCAAGTAGGGCCAAAATTCCTTCAAGCGGTTTGCACCTCTCCTCTTTTAAAGAGTTTTTGCATATCCA +GAACAAATGCTGAAGCCACAAACACGGAGGAGTAAGTTCCCACTACAACGCCCACAACGAAGGCAAACAT +TATGTTAGAAAGGGCGTATCCGCCGAGGATAAAGAGCGTTAACGCCGTTACCAGAGTGGTAAGAGAGGTC +ATTATAGTTCTGGAAAGGGTTTGGTTTATGGAAAGATCCATTATCTCTTCAAGGGTAAAGCCTTTCTTCT +TTCTTAGGTTTTCCCTTATCCTGTCAAAAATAACGACTGTGTCGGCAACGGAATATCCTGCAACCACGAG +AATTGCGGAAACTACTTCGAGGTTTACCTCACGCTGAGTAATGGAGTAAGCTCCGAGAACAGTGATAACG +TCGTGGGCGAGGGCGAGGATCGCGCCAAATCCCCAAACTGGTTGAAATCGCACTCCTAAGTAAAGGAGTA +TTCCTCCGAGGGCCGTGAGTATGGCAAACACCGCTTTTTTCTGAAGCTCTTCACTCACCACCCCACTTAT +TGTTTCCTTCCTGATTAACTCGTACTTTCCGAATTTCTTAAGAACATCCTCCAGTTTTTCTACAGGCTCT +CCCGTCTTTACTTTTATAACGAAAGTACCTTCCTTCGTTTCCTGAATTAAAAATCCCTTTATCCCCGCGG +AAGAAATTGTTTTTCTGAGTTTACCTATGTCCACACTCTTTTCAAATTTAACTTCGTAAAGAGTTCCTCC +CGTAAAGTCCAGACCTAAGTTAAGTCCACGAAAGAGAAGAGAAAGGAGACTTATTAAAATTAGGAGGGCG +GAAACCCCGTAAGCTGCCTTCCTTAACCTTAAGAACTTTATTTGTTTCACAGGTACTTACACCCCGTAGA +AAGGAGTCCGTAATTTCCACCTCTCTTTCTGTAGAGAATTTTGAGCTGCCCGTCTGCTATGTCCACGAAG +GGTATGAAGTACGCGTGTGTTTCTTCAAGTTCCGCCTTTGCGTCTTCCACGCTCATGGGTTTATCAACAA +CGAGTTCTTCTTCCACTATTTCGGGCCTTTCTCTCTCTTCGGGAGCGAGTTCTGCCTCGTGTAGTTTTTC +TTTAAACTTCCTCGCTTCCCTGATGTACTCATGTCTCCTTTCCTTGAGTTTTACGAGTTGTTTTTCAAGC +TCGTCAAGGGCCTTGTCTATGGCTGTAAAAACGTCTGTATCCTCTTCCCATGCGTGTATTGCTCCGTGGG +GAACGTTCTTCAGATAAAGATGAAGGTCTACCCTGTAAAAGGTCGGGAGGCTATCACCTGCGTAGTCTTT +CTGCCTTGACCTCGTGGAGGATATAGCTACAACCGCTTCAACTTCGTCTTCTCCGACTTCCTTCAAATAT +CTCTTGAACCTGTTTAACTTACTTTCAATAACGGCTTTCATCGCTTCACTTATGTTTACGTCAACGCCTC +TGTACTCAATATTCATCTCTTTCCTCCGTAATTTTGTACTTTTTCCAGACTCTATTATTAAGTATAACCT +CAACTTCCCTAACGTCCTTCTCTACTTTTACCTTTTCCTTAACTATAACCTGCGGACACAGTTTACCTTT +TTCTCTGCCGAGAAATACTTTGACTTTTTCGTTTTCTCTGGAAATCTTTTCCACGTAGTGACAGGGACTT +GGCTTTTCTATTGTAAGAGTTTTATAAGCTCCCGAACACGCCATAACGCTTGATAAAAATAAAAGCCCTA +ATTTATCCATAGGTTTATTTTAGAATTTTCTTTAAGGATTAACATTTCCTGATTAAGGTCATAAAATAAT +TTCAGGAATTGTGATATTCATCTTTTTCAAGGGCTTAGAGAAAGGCCCTTATGGCTCCTTGGCAATTGAA +TAGGGCTTATGGGTCTTAATAAGTGATGCTTTAATGGTGTGATGAATTGATATCATTATGCAATAAAGCT +AAAGGGATTGAAAATTAAGGGCGAAAACTTTATAAAGGTATACTCAAGTTTGCAGAACCTCAGGTTAGCG +GAAATTAACATTCATTTCGTGAAGGTTAGAAGTTTAATAAGTTATTGATAAAGCGTTATTTTTTAGACAC +AGGCGCGCAGGGTTTCTAATGTACCGTGTGGAGTTGAAACAAAAACGGAGGAGAGAAATGAGCTACAGAA +TAGACATGTTCCTAATGGACGGATGTGGATGTGTTACTTTTGTAAATAGTAGTAATAAATCACTTATTTG +ATAACTTTTTTAATGCTTCCCTCAATTCTCTCGTAAGTTCTTCGTCAACTTTAAAAACCTTTCCCTCTAT +CTCCGAGACTGGAACGACGAGAAGGAGTGAGTTCAGGATAAATACGCTCTCACACGAACTCAAAAAATCT +AGTTTTATTTTCTCTTCTCTCACTTCAAGCTCTTCACAAAGAATATCCAGAGTAGTTCCCCACAGGAGTC +CGCTCTCACGGGCAGGAGTGTAAAATCTCCCGTCTTTGTAAAGAAGTAAGTTCGCGGAGCTCGTTTCAGT +TATGTATTCCTTTTCGTTTAAAATTACCGCGTCGTAGAATCCTTTAGCTTTTGCTTCTCTCTTTGTGTAA +GTGTTTAAAAAGAAACTCGTGGTTTTGTGGTAGATTAAAGGATTTTTTGAATGTTTCCTCACTTCGGAAA +TACAAAGTTTGACACTTTTGGGAATTTTTGGAAGTTCCCTTGTGTAGACTTTTATCTCATACTCTTCGGG +AAGGTCGCCGTAGTAATCGCTTCCTCTGTAAGCCACTAAAAACTTCACGTAAAGCCCTTTTTTACCTTTG +GTAGCCTCTTGTATTTCCCCTAAAAACTCCTTATAAGAGGGATAGGGAAATCCGAAAAAGTTTGCGGAGT +TTTTTAACCTCTCGTAGTGTTTTCTTAGTTTATAATTCTCGCCTTCCCATAGTATAGTTTCAAAGAGTCC +TTCTCCGTATTGCAATGTTCTATTCACTTTTTAGCTCCTCATCCATGTGTATGCGGGAAGGAACCACTCC +CTTTTGTCCCTTGTACTTTCCGCTGTAAACTCGCTCAGGCGGACGGTCAAGCCTTGCAAAAACGAGCTGG +CATATCCTCATACCTCTGTAAAGTCTTATAGGTCTGTCGTTTGCGTTAAAGAGTTCTAAAGTAATCTGCC +CTTCAAATCCAGCGTCAACCCAGCCCGCGTTCTCAATAAAGAGTCCGAGTCTTCCGAGAGAAGAACGTCC +TTCAACGAAGGCGGTAACGTAAGGTGGAAGGCTTATATACTCAAGTGTGGTAGCAAGCAAAAACTGCTTT +GGCATTATGTCAAAATACTCTTCAAACTCCAGTATCCTTACACCTTTTGTTCCTTTTTTTACGTCTATAA +CCCCCTCTCCTTCGTAAAGGGCTATCTGATTTCCGAGCCTTAAATCCAAGGAGGAACACTGAACGTGCGA +AGGTTCGTAAGGTTCAACCTTTAATTCCCCTTTCTCTATCAGTTCCCTTATACTCCTGTCTGAGAGAATC +ATATTAATACAATTATTATGAGAGTAAAGTTCAGAATTGGCATAGAAAAGGAAGGGAAAAGACTCAAAAA +GAAGGACCTTCAGGGAGTAAGAGATCCCCTCTACATAGGAATGAGGTATATTACCGAGTTCAAGTATCTG +GAGGCAACGAAGTGGCTGCTTCTTGCGAAGGACTCTTACGAAAAGTATAAACTCCTTGCCCTTATAAATG +AGGCTCTGGGACAAAATGAACAGGCAAGGGAATTTGAGGAGTTATCGGGGAAGTTTCCGAGAGTTACGGA +TCTTTCTTTCGTTATAGAAATTCCTGAAAAGAACTTCATTCAAAAGGTTTAAGGAACCTCGTAGCCGTAC +TTTCTCAGAACTTCTTTCGCAAAAGGAGAACTCAGGAACTTTATAAACTCCCACGAGACTTTTTTATCTT +TCCCGTGCTCCGTTATTACCGCGACGTTGTTTATTGGGGAGTAGAGCTTTGGATCAATCACGAGGTAATT +TCCCTTCCCGTAAGGGATGACTAAAGATAGGGCTACAATCCCTATATCCGCTCCTTTGCTCACTACGTAC +TGAAAAGCTTGTGAAACGTTAGAACCGTAAACGAGTTTTTTGAGGACCTTTTTATAAAGTCCCGTGTTTT +TTAGAAATTCCATCGCAGCTCTACCGTATGGAGCGTGTTTCGGGTTTGCAATAGCCACAGTCTTTACACG +AGGTGAGAGTAAAACCTTGTAATCTTTTAGTTCTATATTTTTCATAGTAAAGAGTGTCAGTTTTCCCCTT +GCAAAAATCGTGTAAGATGCTTTAACCGCCTTTTTACTTTCTATAAGCTTTTTTGGGTAAATCTCGTTTG +CGGATATGAAAATGTCGTAAGGTGCCCCGTTTTTTATCTGTATAAAGAAATGCCCCGAAGCCCCGTAAGA +GACTAAAACCCTGTTTCCCGTCCTTTTTTCAAACTCCTTTATTATAGGATTTAGGGCAAAGCGAAAACTT +GAAGCACTTGCAACCCTTATGGTTTCGGAAAAGGAAAAGGCAACTATCAGGAGTAGTAAAAGTAATGTCA +TAAAACACCTTCCTCCCTGAAGGAGAAGTACCTTCCTTCGGAGAGTATAAGGTGGTCAAGGAGTTCAAAA +CCGAGCAGTTCGCAGGCTTTTTTAAGTCTTTCCGTGAAGTTCAGATCCTCGTTTGAAGGACTTGGTTCAC +CTTGAGGGTGGTTGTGGGCTATTATTATACCGTTTGCGGAGAGTTTTACCGCTTTAAAGAGTATGTCTTT +TGGCTTAGAAAATACCGTGTTTACGTTTCCTATTGCCACCACTTCCCAGTCAAGGAGTCTGTTGCTGAGA +TCCAGATAAAGAGCTATTAAACTCTCCCTCCTTTCGTCAAACTTGTCCTTGAGGAATTCAAAAGCTTCCT +GCGGGTTCCTTATGGAAATTCTTGATTTCCCTCCCTTGAAACGTTTTGAAAGTTCTACGAGAGCCTTTAC +CTGCAGGGCTTTTACGAGTCCCAGCCCCCTCACTTTCAACAATTCTTCAACGCTCTTTTTCTCAAGTTCT +TCCCAGCCCATCTTTATCAACTCCTTTGAGAGACTAAGCACGTCCGCACCCTTGGAGCCCGAACCGAGGA +TTACGGCAAGGAGCTCCTCGTCCGATAAATTTTCGGGACCGAGTTTTAAAAGTTTTTCTCTCGGTCTTAA +TTCCTCGGGAATTTCTTTTAACCTTTTGAAAGAGTAATTTACTCTATCCCTAGCCTGTCCCATATCTCGT +CTATCCTCTTTTTAACTTCGGGAGACATCTCTATTACCTCGGGCCACTCCCTCGTGTAGCCTTCCTCCTT +CCACTTGGTCGTGGCGTCAATAATCATTTTACCCCCGAAGCCAACTTCGTTAGTGGCGTGGTCAAGGACG +TCTATGGGACCTTTTAGGATGAGGACGTCCCTTTGTGGATCAACGTTGTTCCCCCAAGCCCAGAGAACCT +CTCCTATGTCCTGAACGTTTATCCAGTCGTCAAAAACGACTATGTGTTTTTCCAGGGACATAAGTCCGAG +TCCGAGAAGTGCGTAGGCTACCTTAAAGGCGTGCCCGGGATAGCGTTTCTTAATTGAGACAAAACAGAAG +TTATGAAAGCACCCTTCGGCGGGAAGGTGATAATCCACAACTTCTGGAAGATTGAACTTTATTAAGGGGA +GGAAAATCCTTTCCGTAGCCCAGCCCAAGTATTTATCTTCCTGAGGAGGTCTCCCGACTATAGTGGTGAG +GTATATAGGGTCCTTTCTCATCACTATTGCGGTCACGTGCATTTGGGGATACTTGTCAACGGGGGTGTAA +AAGCCCGTGTGGTCCCCGAAAGGTCCTTCATCAACCAAAGGTTCTTCAGGGTCAACGTATCCCTCTATCG +CTATTTCCGCGTTTGCGGGATACTCAAGGTCAACGGTGAGCCCCTTCACGAGTTCCACGGGTCTTTCCAT +AATAATTCCTGCAAATAGGTACTCGTCCACTTCGGGAGGAAGCGGTGCGGAAGCCACGTAAGGGAGTGGG +GGTTCTCCGCCTATCGCTATAGCAACTTCCAGCTTTTTCCCGAGCCTCTTTGCCTTCCAGTAGTGGTGGT +TTCCGTCCTTGTGTATCTGCCAGTGAACCGCGAGTTTGTCCTTGTCCAAAACCTGAAGCCTGTAGAGTCC +CACGTTCCTTATACCGCTTTCGGGATCCTTGGTTATCACTTGCCCGAAGGTTATGTACCTACCTCCGTCC +TTTGGCCAGCACTTGAGAATGGGAAGATCCTCTAAGTTTATATCTCCCATTATTACTTCTTCCTGAACCT +TTCCCCTTTTAACTACTTTGGGTATGGCGTCGTTTAGTTTTTTGAGTTCTGGAAGTTTTTTTATCTTTTC +GAGGAAGGTTTTTGGAACTTCGGGTTTTAAAATTCTGTAGAGTTTCCAGCCTATGTCCTCGAGGTTCTCG +TAACCCAAAGCCTTTTTAATTCTTTTCTCCGAACCGTAGAGGTTCGTAAGAACCGGGATTCTGTAGCCTT +TTGGATTTTCAAAGAGGAGGGCTTTCCCGCCCCCTGGCATTTTGCAGACGCGGTCCGTGACTTCCGTGAT +CTCAAGTATGGGAGACAGGGGCTCTTTTATCCTTACTAGTTCTCCTTCCTTTTCAAGATCCTTGATAAAG +TCATGAAGATCCCTGTACTTGTAGCCCATCTTTATTATGTTGCACGAGCCTTGAGAGGAATTCCATGATC +TGCCCGTTCTTTATCCTGAAGCTGTCCTTGTTTGCTATGAGCCACGCGGTAGATTTTCCAACTTCTTCTA +TCACGATAAGACCGTTTTCTTTCAATGTCCTTCCCGTTTGAACGAGGTCCAGAATAAAGTCGGAAAGTCC +TACAAGAGGAGCGAGCTCAACGGAGCCGTTTAGGTAGTATATGTCCGCCTTGACGCCTTTCTTTTTAAAA +AACTCGTAAGCTATGTTCGGATACTTCGTCGCTACGCTGATGTGTGTGGAACTGAAGTACTTTTCTTCGC +TTTCGGGCTTTCCCGCAACTGCTATTCTGCAAAAACCTATTCCGAGGTCCATCAACCTGTAAACGCTCGG +TTTCTTTTCAAGGTAAACGTCGTAACCGCACACACCTAAATCCGATACACCGCTTTCCACGTAAACGGGA +ACATCCGAGGGTTTTACGAGAAAGAAGGTAATCCCTCCCTCTTCAAGTATGAGTTTTCTTCCCTCTTCTA +TTCTCTTTTCTATAATTCCCCTTTTTAATAAGAGATCTACCGTTTCTTCAAAGAGCCTCCCCTTGGGAAG +TGCAACCTTTATCATTTCCTTTTACCGCGTTTGGGTTTAATCCTTATGAGCACTTCGTCGGGGTTTACTG +TTTCTCCTACTCTTACGAATATCTCCTCTACTATTCCGTCAACGGGACTATGGATTTCATTTTCCATCTT +CATGGCTTCTACGACTAAAAGGACGTCTCCCTCTTTTACTTCGTCTCCCACGTTTACTTTTATGTTTACC +ACTTTACCGGTTATGGGTGAGGTAACGTCTCCGATACCTTTGGGCTTTGGTCTCTTGCTTATTACCGTAC +CGCCTTCCGTTGCTTCGGTCGCAAAGGCTTCCTTTACACTTACTTCTCTTATGGGCTGGAGCTGAACTTC +CTGGAGTTGTCCGTCCAGTCTTATGAAGAAGGTTCTCCTCGTCGGGTCCTCTTCGCCTTTACCCGCTATC +TGGACGTGATACTGTTCTCCGTGAACGGTAACGTAGAACTCTACGGGAGCCTTGCACTCCGTAGTTTCTT +CCACCGTTTCTTCCATGGGAACGGGCGGAAGTTCTCCTTTTTCTACTTTTTCCCTCCACTCAAAGAACTC +TTTGGCGACTACCGGGAAGAGTGCGTAAGAGAGTATATCTTCTTCGCTCCTTGCACCCGCTTCTATTGCC +TCATCTCTTATCTTGTCAAGTTCCGGCTCAAGCAGGTCCGCGGGTCTTATGTCGTATATGGGCTTTTCGT +CTCCGAGTATCTTTCTGATAATTTCCTCCTTTATGGGGGCGGGAGGTCTTCCGTAGAGTCCCTTAACGTA +GTCCTTCGTTTCCTTGGTAACTACTTTGTAACGCTCTCCGTGGAGGACGTTTAAAAAGGCTTGAGTTCCC +ACTATCTGGCTGGTTGGCGTCACTAAGGGCGGGTATCCGAGGTCTTCCCTGACTCTTTTTACTTCTTCAA +GAACTTCTTCTAGTTTATCCTCCAGATTTTGCTCCCTTAATTGGGATATGAAGTTTGATATCATACCGCC +GGGTATCTGGTGTATTAGGACTGAAACGTCGGGGTAAGGAGGAAGGACGTCGTATTTTTTATACTTCTTC +CTTACTTCTCTCATTATGTCTCCCGCTTTTTTATAGAGCTCCGTGTTTACTTTTACCTCGTAGCCGAACT +CCCTGAGGACGTATATCATCGTTTCTCCCGGAGGGTGGGAGGTTTGTCCCGAAAGTGAATAACACGCGGT +ATCTATCATATCCGCTCCCGCTTCAATCCCTTTGAGTTGTGCCATCTCCGCAAGGTCCGCGGTAGTCTGG +GTGTGAAGGTGCACGGGATAATTGGGAAATTCGGACTTCAAAGCGGAAACGAGCTCGTAACAAACTTTGG +GTGAGAGTATTCCCGCCTGATCCTTTATGGATATTATGTCTATTCCCATATCAACGAGTTCTCTTGCTAC +TTTTACGTAGTACTCTATGGTGTGAACGGGACTTATGGTGTAGGAGAGAACGCCCTTTACTATGGCTCCG +AGCTTTTTGGCAGTTTCAATAGACTTTCTCATATTTCTCGTGTCGTTCAGGGCGTCGAAAATCCTGAAAA +CTTCTATTCCGTTGTCGTAAGCCTTCTTTACAAATTCCTCAACCACATCGTCGGGATAGTGCCTGTATCC +AACAACGTTCTGTCCCCTCAGGAGCATCTCAAGCTTTGTGTTCTTCGCCCTCTCCTTGAACTTCCTGAGT +CTTTCCCAGGGATCCTCTTTGAGGTACCTCAGACACACGTCAAAAGTAGCTCCACCCCACACTTCCAGAG +ACCAGAATCCGCACTTGTCTAGTATTTCTATTACATCAAGCATGTCTTCTGTTCTTACCCTTGTAGCGAG +TAGACTCTGAATGCCGTCTCTGAGCGAGACATCCGTAACTTTGATTTCCCTCATGCTATCACCTCACCAG +CTTTAAAAACTAATAATATAATACGAGGTGGATTTTTTAAGAAAATTGCCCCTCGGGCTTACAATACACC +TATCACTTTTCCTGCTATCCCTTTTATACGCACTGAATGCCGGAAGACTCCCCGAACTAAAGGACTACAT +AATCTACTTTAAGGTTCGTTTAGAAGGTCAGTGGGAGCTCTCCGAAGATGGAGTATCCGCTCCAGTGTTT +GTTGAGGAGTCGGAAATAGAGTTCTTAAAAGGGAGGAAAGCTTTTTTATTCGTGAAGAAAGCAAGATATA +TCCCGAAAGGAAGCAGGTTTGAGCTTTTCGGAAACGTAAGAGTAAAGAAAAACAGGGTGTTTATAAGCGC +CTACATCTGGGATTTAGAAAGACTTCCTGAAAAGAAAAACATCAGGGATTTCTTAATGGAGAAGTTTAAA +GAAAAGGTAAAAGACGAGCACCTGAGAGCTATAGGGCTTGCCTTTTTGTTCGGGGAGAGTAAGAGAAACC +TCCCCGCTGAAGTGGAAAGGGTTTTCCTACACACGGGACTTATACACGTCCTCGTAGTATCCGGACTTCA +CGTAGGACTCGTTTTCTTAATCCTTTCCCGCCTCCTTCCGAGGTTCTACGGTGAAGTTCTGGGATTAGTA +GGCGTTCTCTTTTACTCCGCCTTTTTGGTTCCACACAACCCGCCGGTCATAAGAGCTACGTCCATGCTCT +TCCTGTGGGTGCTTTCCTTTCTTTCCTTCAGGCGCTACTGCTCCCTCTGCGTTCTCTTCTTTACCGGGAC +TTTAATGCTTTTCTTCTTTCCCCACTTTTCTTACTCTTACTCCTTCTGGCTTTCCTTCTTTGCGGTTTTA +TACATTCTTCTCGTTTTGAAGGACTTTGAAGGTGGAAACACCTCAAAAGCCCTTATGGTTTCACTCGGTG +CCTTTACAGGAACCGCACCCTTGATAGCGAGTTTTTCCTTTGTAACTCCCCTTTCTGTCCTACTCACACC +TGTTCTCTCTCCTTTGATTTTCGCGTACGCCCTTTTCGGAGTTTTGTCCCTCCTTACGCTCTTTTCCTTT +CCCCCTTCTTTAATCCTTATGAACCTGAGCGGAGAGCTTATCTTCAGAGTCCTTGAATTTTTCTCTGACT +TTTCGCCCAAAATTCTCAGTAATGTAAAACCAGAAGAGGCTTTTATTCTTCTAATACTGGGAGCTATCGG +ACTTTACGTCACAAAAGGTTATTCCAAACTTCTTCCTTTGGGTGTTGTAAACCTATATCTAATCTTTAAA +ATAAATTAAAACATTTTTTTACTTTCGGAGGTGGATGTATGAAGCTCCACGAACATCAGGCAAAGGAGAT +ATTTGCAAAATACGGAATTCCCGTTCCGGAAGGCAAGGTGGCATTTTCCCTGAAGGAAGCAAAAGAAGTC +GCAGAAGAACTCGGAGAATTTCCTCTCGTTGTAAAGGCTCAGATTCACTGCGGTGGTAGGGGTAAAGCAG +GCGGAGTGAAGATAGTCAAGGACATGGACGAGCTGGAAAAGGCAGTTGAATCACTCCTCGGTAAGGTTCT +AAAAACCTTTCAGTGTCCCGACGGAAAACCCGTAAACAGGGTACTCATAGAAAAGGCTACGAACATAGAC +AAGGAGTACTATCTTGCTATAACTTTGGACCGTTCAAAGTCCAAGCCCGTTATAATGGCTTCCGCAGCGG +GCGGTATGGAAATTGAAGAAATAGTCAAAGAAAATCCAGAGGCGATAATAATCGAAACAATAGACCCAGA +ACTGGGACTTATGCCCTATCAGGCGAGGGAGCTTGCCTTTAAGTTGAACCTGCCCGTAAAGGAATTCGCA +AGCATAGCCCTGAAACTTTACCAGATATATTCCGACCTTGACGCTTCACTCGTTGAGATAAATCCCCTCG +TTCTCACAAAGGAAGGAAACCTTATAGCCCTTGACGCAAAACTCGACATAGACGACAACGCCCTCTTCAG +GCACAAGGACCTTGAAGAGATGGAAGACGAAACACAACTTCCACAACTTGAGGTGGAAGCCAAGAAGTAC +GGCCTTAACTACATAAAACTCAATGGAAATATAGGTTGTATGGTTAACGGTGCGGGGCTCGCTATGGCGA +CTATGGACATAATCAAGCTCGCGGGAGGAGAACCCGCGAACTTCCTTGACGTGGGTGGTGGCGCGAACGT +AGAGCAAATCGCGAACGCCTTCAGAATACTCATGGCGGACCCGGACGTGAAGGCGGTCTTCATAAATATA +TTCGGTGGAATACTGAGGGTGGACAGGCTGGCTCAGGGACTCATAGAAGCCTCCAAAATGGTAGAACTCA +GAGTTCCCATTGTTGCGAGACTTGAAGGAACGAACGTTGAAGAAGGAAAGAGGATGCTCCAAGAGAGTGG +ACTCAACTTCATAATAGCGGAAGACATGTGGGACGGAGCGAAAAAGGCTGTGGAAATAGCGAATAAACAA +AGCTAAGGAGGTTAAAAATGGCTATTTTGGTAAACAAAGATACCAAGGTGGTAGTTCAAGGTATAACGGG +TAAAGAAGGTTCTTTCCACGCAAAGCAATGCAAAGAATACGGAACTCAGGTTGTCGCAGGAGTAACCCCC +GGCAAGGGAGGAATGGAGGTAGAGGGAATTCCCGTATTCAACACTGTGAAGGAAGCGGTAAAAGAGACAG +GTGCAAACTGTTCACTCATATTCGTTCCAGCCCCCTTTGCGGCGGACGCTATAGTGGAAGCTCTGGACGC +GGGGATAGAACTCGTGGTGTGTATAACGGAAGGAATTCCCGTAAAAGACATGATGATGGTAAAGGACTAC +ATGCTCAAGAACTATCCGAACGCTAAACTCGTAGGTCCCAACTGCCCCGGAGTGATTACCCCCGGAGAGG +CGAAGGTGGGCATAATGCCCGGACACATATTCAAAAGAGGTAAAATAGGCATAGTTTCGAGGAGCGGAAC +CCTCACGTACGAGGCGGCTTATCAGCTCACGAAGTACGGACTCGGGCAGTCCACTGCTGTTGGTATAGGC +GGTGACCCCGTCCACGGACTCACACACAGGGATGTTATAGAGATGTTCAACAAGGACCCCGAAACGGAAG +CCATTTTAATGATCGGAGAAATCGGTGGAACGGAAGAAGAGGAAGCTGCGGAGTACATAGAGAAGGAAGT +TGACAAGCCCGTATTTGCCTACATAGCCGGAATCACCGCGCCTCCCGGAAAGAGGATGGGACACGCGGGA +GCTATCATCATGGGCGGAAAGGGAACGGCTAAGGCCAAGATGGAAGCCCTTGAAAAGGCGGGAGCTTACG +TCATAGAGAATCCCGCAAAGATAGGTGAGACAGTGGCGAAAATACTGAAGGTTATAGAACTGGAAGAAGA +AGAAAGGACTTCCGATGCTGAGTAAGATTATATTAATATTTTTCTATTCGCATTATTTTTATGAAAAACC +CTAAAGGAGGTAAGTGCTATGGGACTTAAAGTTAGAGTAGATCAGGACACCTGCACCGCTTGCGAGCTCT +GCTACGATAGAATCCCCGAAGTCTTCAAGAACGCGGGAGACGGAATAGCGGACGTAGTCAAGTGCGACAT +CGAAGACGACGAAGGATGCTGGATGATCGTTCCCGAAGGACTCGAAGAGGAAGTACAGGAAGTTGCAGAC +GAGTGCCCCAGCGGATCCATAATCGTAGAGGAAGAATAATCTTTTCCTTCCCCTCTTTTTCATAAATCTT +TTTTCTTTTTCAAAGGAGGTCTGAGCCATGGCAAAATTAAAGACCATGGTTGACCAGGAAACCTGTACGG +CTTGCGAGCTGTGTTACGATAGAGTTCCCGAGGTTTACAAGAACAGGGGAGACGGAATAGCGGATGTTGT +CAAGTGTGACATAAAAGACGAGGAAGATCACTGCTGGATGATAGTCCCGGAAGGACTGGAAGACGAAGTC +AGAGAAGTAGAAGAAGAGTGCCCCAGCGGTTCTATTATCGTTGAAGAACTCGAAGAGTGAAAGTAATATT +CCTAGGAACAGCGGGCGGAAGAGTTGTAACCTTCAACTTAATAAGGCGTTCTGGAGGTTTCCTTTTAGAG +GAAAACAGCAGTTACCTTCACGTTGACCCCGGTCCCGGAGCTTTCGTTTACCTTCATCAGCTCGGTATAG +ATTACAAAAAAATAGATTTAATAGTCCTCTCCCACCTCCACTTGGACCACTCAGCCGATGTGAATACGCT +TATAGAGGCTGCCACAAACGGCGGTAAGTACAGAAACCTCTCTCTCTTTGCTCCCAAAAGTGCCCTTGAA +GGAGCAGACCGAGTAGTTTTTCCCTACAACAGGCGAAGACTTGTCAAAGAAGAAACTTTCAGCGAAGGCT +CGGAGCACCATTACAAAAACTGGAAAGTTAAGGCGGTAATAAAACACAAACACCACAGGACGGAAACTTA +CGGACTTTTTCTTCAAAACAAAGTGGTTTACGTTTCCTGCGCGGGATTCGAAGAAAGGATGCTCACGCTT +TACCCCAAAAACGCGGACTTGATGATAATAAATACAACCTTTTACAGGAAAAGACCCAACGTTGAACACC +TTTCGGCGGAAGATGCAAAGGTTTTAATCTCTCACCTGAAACCTAAAAAAGCCGTAATAACACACTACTC +CATGGAGATGCTACAGATAGGCCCCGATAAAGTTGCTGAGGAGATAACAAAAGAAACGGGAATTGAAACG +ATAGCGGCGAAAGACAACATGATTCTTGAGATATAATTCAGTAAATGCCTGCGATATTCACCCATGAAGG +AAAGGTAGAAGGCGTTCCAGGAAATTACCCCTTAACTGCCGAAAACCTCTTCAGAATAGGTCTTGCCCTC +TGTACACTCTGGATTTTAGACAAAGAGATTGAAGAACCGACTCTTTCTATTCCCGAAACAAACTTCGTTA +CCTTAGCACTTTCCGTAGGTTTTATGAATGCAGGCGGAAGCGTAAACGTGGGAAAAGGAGGTGATATAAA +GTTATTTTTACAAAAGGGAGAAATATACGTCCTCGAGTTTCAACCTCTTTCCGAGACAGACATTAAAAAG +CTCGAGAGTATACTATTTGGAAGAGCCCCGATTCCCAAAAAAACGGGGGAAGATATAGGAAGCTTTAAGT +GTTAAATTAAAAATTTCATGAAAACCCTCTACATTTTGGACGGCTCTTCATTCGTTTACAGAAGTTTCTT +CGCACTCCCTCCCCTCAGTACAAGTAAAGGTTTTCCCACGAACGCTATATACGGTTTCTTGAGGATGTTA +TTTTCCCTTATTAAGAAAGAAAGACCTCAGTACTTGGTCGTGGTCTTTGATGCTCCCGCAAAGACAAAAA +GGGAAAAAATATACGCAGACTATAAAAAACAAAGACCGAAAGCCCCGGATCCACTAAAGGTTCAAATTCC +CGTAATAAAGGAAATACTAAAACTCGCCGGTATACCCCTTTTAGAACTTCCCGGATACGAAGCAGACGAC +GTTATAGCTTACTTGGCAGAAAAATTTTCCCAAAAAGGTTTTAAAGTAAAGATTTACTCCCCGGACAAAG +ACCTTTTACAGCTCGTGTCCGAAAACGTTCTGGTCATAAACCCTATGAACGATGAAGTGTTCACAAAAGA +AAGAGTAATAAAGAAGTTCGGAGTAGAACCCCAAAAAATACCAGACTACCTCGCACTCGTAGGAGATAAA +GTGGACAACGTCCCCGGAATAGAAGGCGTAGGACCAAAAACGGCTATAAACATACTTAAAAAGTACGGCA +GTGTGGAAAATATCTTAAAAAACTGGGAAAAGTTTCAAAGAGAGTTTCCAAGGGCAAAAAAAGAAGACTT +AGAACTCTCCTACAAGCTCGTAAAACTCTACACGGATTTAGATATTGAACTCTCCGAAGAAGATTTAAAG +ATAAAACGACCTGATCTGAATAAACTAAAACAAAAACTTCAAGAACTTGAGATGAAGAGCCTTTTAAAAG +AAGTGGATAAGATTTTCAGACAGGCTTCTCAGAGATCGTTGTTTTGATATATCTCCCTCAGAACACTCAA +ATTCACCGGATCCATGTTATTCTCTTTGGGAGTTTCTATGTAGTAGGGAAGTGTTGAAAAGTACTCATCC +TTCAGAAGATTTTTAAACCCTTCAAGACCTATATACCCCTTTCCTATGTGCTCGTGACGATCCTTTCTGC +CCCCTAAGGGAACTTTACTGTCGTTAGCATGAACTGCCTTTACACTCTCGAGTCCTACCATTTTTTCAAT +TTCCCTTTTAAAGTTCTCAAATCCCTCTTTAGTGTTTATCTCGTACCCGTAGGCAAAGGCGTGGCAGGTG +TCCAGACAAACGCCAAGTTTAATTCCCCTGAAAACGTTCATGATTTCCTTCAACTCTTTAAAGTTCTTTC +CGAGATCTCCCCTTTCTCCTGCGGTGTTTTCCAGTAAAACGGTTGTAAACTTCGGCGTGTATTCCGAAAA +AACTTCTTCCAAAGATTTTATTACGTTTCTTAAACCTTCTTCGTCGCTTATTCCCTTGGCCGTTCCAGGG +TGAAAGTTGTAAAAGTGTATCCCGACCTCGTCGCAAAACTTTAACTCTTCAAGGAAAACCTTTACGGATT +TTTCCCTCAGTTCTTCGTTCGGAGAGGCGAGGTTGAGAAGATAAGGAGCGTGAACCATTACGGGGTTTTT +AAAGTCCTTAAGCTTTTCTATAAAAGCCTGTTTGGTTTCTTTATCTACACCCTTCCAGTACCAGGCCCTT +GGACTCCTTAAGAAAAATTGAAAGACTTCCGCTCCGATATCCTTTGCCCTTTTAAAAGTTTTTAAGATGG +AACCGGCAGAGGAAACGTGGGCACCGAAGAGAGCCATTAAGCGTAAACCTTTTCCAGTTTCAGTTCTTCT +TTTATTGCTTCAAGGAGTTTCTTTAAAGCTTCCTCGTAAGAATTCGTCTTTATCTTTGCTCCTGAGGCGT +ACTTGTGACCTCCACCGCCCAGCCTTTCCGCTATCTTCCCAACGTTTACGTTGCCTTTCGCCCTTAGAGA +CACCTTCCACACGCCTTCTTCCGGCTTTTCTATTAGTGCGTAAGCCACCTTCACACCTTCAATGGAACGG +GGGTAATTAACTAGTCCTTCCGTGTCCTCGTAAGTGGTTCCCGTCTCGTCTAAGAATTTCTTGAACACAG +TTATACCCGCAACTTTTCCGTCTTCGTGGAGTTGAAGGGTTTCCAGAACTTTAGCTATTAGCTTCATCTT +GTTTACCTTTTCCCTTTCCATTACCATTGTGTACACGTAGTATGGATCCGCCCCGTAAGACACGAGTTCC +TTTGCAAGTTCAAAAGTCTTTTCATTTGTATTTGAGTATCTGAAGAATCCCGTATCCGTGGCAAGTCCCG +TGTATATACACGTTGCTATGTCTTTATCTATAGCGGTCTCGTCCCAGTTCTTTATTATCTCATACACTAG +TGCTGCAGTTGCGGGAGCGGTCGGGTCTATGTAGTCGTGCATCCCGTAGAACTCACCGCCCACGTGATGA +TCTATCCTTATCCTCTTGCCCACTTTCACTTCTTTTCCGACTCTGTAAAAACCAGAAGCATCAACTACTA +TACCAACGTCGTAAAACTTACCGTCGGGATTTATCACATCCTCAACACCGGGTAAAAAGTCCAGAAAGTG +AGGAACTCCGTCTTTAGAACCTATGTAAACTTCCTTTCCTTTCTTCTTTAAAAACTTGTAAAGTGCCAAA +CCGCTTCCAAGGGAATCCCCGTCCGGATTTTCGTGCGTGAGGATCAGTATGGAACCTTTTACGTTCTTCA +AGAAGTCCACAATGGGAATGTTTTCCTTCGTCATTTCTTCAACCCTCCAAGCTTTTTAATCTACTGAAAA +TTTTTATCAAATAATATGATTTTTTACAAATAAACTCAGGATTCCCTTTCAAGGATTCTCTCCCCCATCT +TCAGGGAAATCTCAAGGGATTGAGCAAGTTCCTCTAAACTCCTTATTATCTCTCTGGAGGAAGAAAGTTC +CAGTTTCTCTATGGCGTTTTCAATTTCCGCCATAACGTCTTCAAGTTTTTCGAGTATGGGTTTCCTCTCC +ACCTTCATACTCTCAAGGAAAAAGGGGGCGTACTTCTCTATTGCAGGAAGAAGGAGAGAAATCAGGGATA +AACTCTCGGAAGAAAGGATTAAAGCCTCTTCTTTTATGTCCCTTTCCTGAACCTCCTCCAGCTCCCCGAG +TATAAGGGAAACGAGTTTCAGGTCCGCACTTATTCTTCTGAGTGTTTCGCTAACAGTCCCGATAACTTCG +GGGGAGTACTTGGGGGGACTTACCAGGTAAGTGGTTGCCATCTTCTGTTGAAAGGCTATTTCTTCTTCCA +GTTTGGACAAAAGGATGTGTATGGGATAAAACTCCATAATGAATTTAAATTATACCTTTCAAAAGAAGGG +AAAAGAAAAAGGGAAAATTTCAGGAAACGCCGGAGAGTGAGGATTTGTATTCTGCGACGAGCTCGGTATA +ATCGTCAAACCAGTGAGCTTCTGGATTTCTCTTGAATACCATGAATTTACCCCTGTTTTCAGGGTCCGCA +GCCCTGTGATACCTGAAGAATATATGCTCATCGGTCTTTCCGAGGATTTCTATCTTTCCAGTTTCGTGGG +ACATGACGTACCTTACCCTTGCAGCAAGTCCTGACACCTCTGCCCTTACAGCTTCAACCAAGTCTATTGT +TTCCTCTATCGGAGTTGAATAAGCTTTATTACCCGCGGTAGGTCTGCACTGGAACACGTAGTAAGGGGGT +ACTCCTATGAAGGAGAGTTCTTCAAGGAGCGTCTTTAGAGTTTCAAAGTCGTCGTTAATTCCCTTGAGTA +TAGGAGTCTGATTAGTAAGGGTGGTTCCCGTCTTTTGAACGAGTTCTACAGCCTTTCTTGCCTCTTTAGT +TAACTCCCTTGGGTGGTTGAAGTGGTTCATGAGGTAAAGCTTTTTACCAGTTTCCGTGTTGAACCATTCA +AAGAGTTCAAGGAGTTTGGGGTCGTCGAGAACTCTGAAGGGATTTACCGCGAGCATCTTAGAACCTATTC +TTACTATCCTTACGTGGGGTATTTCAGCAAGAGCCTTTAATATCTTCTCAAGTTTAAAGGTGGCAAGGAT +TAGCGGGTCTCCTCCGGTAAGGAGGACGTTGTTTATCTCAGGATGGTTCCTTATGTATTCAAGTCCTTCG +GATACATCCCTTGCAACCTCGTCATTGTCGTTCATAAAGAGCCTCTTTCTGAAACAGAACCTGCAGTATA +TACCGCAAACGTCTGTCACGAGGAGCAGAGCCGTGTCGGGGTACTTGTGCTCAAGCCCGTGTACTTTCAT +GTACTTGCTCTCGTTTGAAGCGTCAAGCTTTCCCCACACTTCAAGCTCTTCCGTAGTGGGGATTACGATC +CTCCTTATCGGGTCGTTCGGGTTGTCCCAGTTTATGAGGGAGTTGTAATAGGTGTTCGTCCTGAAGGCAA +ACTTTTCCGTAACCTTTTCAAGTTCCCTCCTCTCCTCCTCCGGAATTTCCTCTATGAATTTGAGGTCAAT +AATGTATTTAAGCTTCTTTCCCATACTTCACCTCCTTTTAGGGATTTTTTTAAAAGAAAGTGTTAAGAAT +TTTTTAAGAAACCGATTAATATAAGACGTGCTGTCTAAAAATATACACGCTGAAGTTGAAAATTTCAACC +TGCCCCTTATAATTTAGAATTCATGAGATTTTTTATACTGGGTGCGGGAAGGTGGGGAACACCCTCGCCA +CGCACCTTGACAGGAAAGGACACGAAGTTCTGCTCTACGACATAAACGAAGAAGTGGTAAAGAAGATTAA +CGAAGGAATACATCCCTACGTTGAAGGAATTAGGTTTAAAAATGTAAAAGCCACTACGGATTTAAATCAA +ATAAATGAGTTTAAAAATCTAATTTGTGCACTTCCAGTTCAGGTAATTCCAAAAGTAATCACGAAAGTAA +ACCTGAAGGGAAAGAACTTTATTTCTGCTTCAAAAGGAATAATCCATGAAAATTTAAAGAGAATTTCACA +GCTCGTTAAAGAAATCGAACCTAAACTTAAATTTTTTGTTCTTTCTGGACCTTCCTTTGCGGAAGAGGTT +TCAAAGGGACTTCCCACGGCCATAGTGCTGGCTTACGAGGACAAAGAAGAGGCAATGAAACTCCAGGACG +CACTTGATTCTGAAAACTTCAACGTTTACTTGAACGACGATATAACAGGAGTTGAACTGGGAGGTGCTTT +AAAAAACGTCATAGCGATTGCGGTGGGACTTTCGGACGGAATGGGCTACGGCTACAACGCAAGGAGTGCA +ATCATAACCAGAGGTTTGCACGAAATGGCAAATGTAGGTGAGAAGTTCGGGGCAAGGAGGGAAACGTTTT +TCGGACTTTCAGGAGCGGGAGACCTTATACTGACTTCAACCTCTGACCTTTCAAGAAACAGGACCTTTGG +AAAACTCCTTGGACAGGGATACAGCGTTGAGGAAGCCCTAAAGAAGATAAACCAAACCGTGGAGGGTGTA +AAAACCGCAGAAGCACTATACGAAATTATCAAAAGGGAAAACATTTTCGCACCAATATGCGAAGGAGTTT +ACAGGATAATCAAGGGTGAGGATCCTAAGAAGGTTTATCCTCACTTTCTTTCGAATCATCTAAGGGAGGA +ATTTCAGAGATAACCTCTTCCTCAGAAATTAACTCTCCGTAGTAGTAGTACTCTTTGCACTTTTCACAGT +ACCAGATTCCCCCTCCGCAACACTCAACTATCACGAGAAGATTTCCGCATTTAGGACAAAGTTCCTTCAT +AACCTCAGGTAAAGAGGGAACTTACAGAAGTTCCCTCCTGTATCCTTCTTATGGCTTCTCCTATCAGGGG +TGCGATGGAAACAACTTCCAGTTTACCGAACTTCTTTTCGTAAACGGGAAGCGTGTTCGTCACGATAACC +TTTTCAATAGGGGAGTTTGTAAGCCTTTCTACCGCAGGACCGGAGAATATACCGTGCGTAGCGCAGGCTA +TAACCCTTTTAACACCTTTATTCACAAGAAGGTTTGCCGCAGCAACGAGCGTTCCGGCGGTGTCTATTAT +GTCGTCAACGATTATAGCCTCTTTACCTTCTATGTCTCCTACAACGTCCATAACTTCCGCTTTGTTCGGT +TCGGGTCTCCTTTTGAGTATTACTCCTATGCCACACCCTAGTTTGTTGGCAAGATCCCTCGCCCGCTTTA +CACCTCCGGCGTCCGGGGAAACGACTATTGGATTTTCTAAAACTACGTTCTTCCTGATGTAGTCGTAGAG +CACGGGGATTGCGGTTAAATGCTCAACGGGTATGTCAAAAAAGCCCTGTATTTGCGGGGAGTGAAGGTCA +ACAACTATTACCCTGTTCGCCCCTGCCTTCTGGATAAGGTCTGCAACGAGCTTCGCGCTTATCGGAGTTC +TGGGCTTGTCCTGCCTGTCCTGCCTCCCGTAGGCGTAATACGGAACTACCGCGGTAATTTCCTTGGGAGA +GGAACGCTTTACAGCGTCGAGGGTAAGCAGGAGTTCCATTAAGTTATGGTTGACGGGGTTTGAGAGGGAA +GTTATTACGTATACGTGATAGCCCCTGATACTTTCGTTTATTTGAACCCTTATCTCTCCGTCGGAGAAGG +TGGTTATTAACGCGTCGGTAAGTCTCAGACCTAAGTATCCCGCTATCTCTTCGGAAAGGGTTTTATTGGA +AGTTCCCGCAATTATTTTCACACCGTTCATGGAGGATTAAATGGCTGGGGCGCCAGGACTCGAACCTGGA +ACCCCCGGATCCAAAGTCCGGTGCTCTGCCAGTTGAGCTACGCCCCAAGCCTTCCAGAAATAATATTATA +TACAATCCTCTCCTGTGTTCAAGCCATCTCGTAGAACATTTCCAGCTTCTTTGAGTTTACCCCCGCAAGG +GAAACGTCCGCATCGGGGTGTCCGTAGAGGGTGCAGAGAGTGACTATTTTTGTATCCGTGTACTTCTTGA +GCATCCTTATGGTGAAGTCCGTTCTGTAGCAGTGTACTCCTATCATGAGGGTAAGGTCGTGCTCGCCGTA +CAACACGGAAAGGTGAGGATTGGGTGGGTCCACTTCTCTTGAGAAGTCCACTTTCTTGTTTTTCGGCTTG +TAATCGGGTAGTAGGTGGATATTCAGGTTTGGATACTTTTCCTTCAGTCTCTTTATTATCTCACCTTTCT +TTTTAGCCTCTTCGTTCCATGCCCAGAGCACCAGAGGTCCGACGATTAGAGTAGGTCTTTTTGCTTTGCT +TAGAAGCTCTACGGCCACTTGAAGTGCCTCTTCAAAGGATACCTTTTGACCGTTTATGAAGCCTATTTCC +GTGGAAGTTTCCCTGACTATGGGAAGCCTGCTCATGTCTTCCTGAGGACCCGGGGCGACCTTCGGAACTT +TGTAGTTTTGTGGGATAAATTCTTTTAGGTTTTCGTTGGGAACAGGTTTTTGGGCACTTTGTCTCTTCTG +AACTCTGGAAGTCTTTTCCTTGAGTGAAAGGAGTTTTTCACTGTCCTCCACGTAAAGGTCAAGTTCCACC +TGAAACTCACCGTGGTAAGCTTTTTCCTCCTCTTCAACTCCGAGGGAGTAGCACGTAACTCCTTCTATAT +CTAAAAAAACTCCGTTCGCTCCCCACTCCTTCGCCTTTTTGAATATCTCGTACCTCTTTTCGTAGAACTC +GTAACAGCAGTGTCCTATGTAGGTGTAGCCGTTTTCCCCGCACCACTGGAGGACGTCCCTCAGCATCTCA +AAGCTCGTAATGGTTATGGGTATCATTCCCCTCTCGTAAGCCATTCTGTAAAGGTCTCCTACCGTACACC +CTCCGCACTCTCCGCAGTCGTCCGTATGCCTGTAATCGCACCACGTGGGCTTTGCACAGTAGGGAAGGAG +CATAACCTTAGCCTTTTTTATGTTCTCCTTCAGCCCTCCTCCTATACTGCCTATTACCCTATTGAGTTTT +TTTTTATCAATTCCTAAATCCTGAGCCTCCAACTTCCTCAAGGGAAACATTACGGCTTCCACAAAATCGT +CCACCGTGAGGTTCACGCTTTCAAATTCTCTTTCCTTGAAGAACTCCCTTATCCTCTTTTCAACTTCCTG +AACGGGAGTATGCTTGAGATAAGCTTCCAAGTCGTATATAAGTCTTTTGGGATTTATGAAGAAATCCCCG +TTAATTATCACCTGTTGAAGAACCTTAGTTTGGGGGTCCACTTTTGCGGAAACCCTGAAAGTTCCTCCAG +GACACCTGTATATACCGTAGAGTATCTCGTCTCCCGTAATAGCCTTCTTCACGTGGTAAATCCATTCATC +ACTCTTGAAGTAGTCTTTCTTTTCTTCAAAGAGTTCCAGCTCTTCCTTTGTTAGTTCTCCCCAGTAAGGT +TCTATACCGAGTTCTTCCTTCAGGGCTTCAAGAATTGCGTTAAATACTTCTTCTTTTTCAGGCAGTCTTC +CGATTTCCCTCTTTACCCACGTTATCCTGTCTTCCGCGGACTTTATCCCCTTGGAAGTTAGCTTCTCAAC +AGGTATCTGTAAGGATTTAAGCATTCTTTCCAAGTTCACGTCCATGAGGATAGTTCCCTGGTAGAGGAAT +GCGTTCCCCTCAAACACTCCACCCGTTCCCGAAATCTTCTTTCCCTCAACTTCTATGTCGTTCCTCGGTC +TGAACTGGGCATTTACACCGAGTTTTCTGAGTGCTTTTGCCACGGTTTCGCATATGGTTCTCGTTATCTT +CTCGTAGGATTTATTTCCAAAGCTTTCCCTGTCCGCTATTATTTCCCACCCTATCTGGAGCTCGTCAAAG +TATATAGCTCCTCCTCCCGTAATCCTTCTGTTTACCTCTATTCCTTCTCTCTGAACGTACTCAAGTCTTA +CCTCTTGTTCAACAGCTTGGTGATAACCTATCAGGACGCATTCTGGTTTGAACTGTAAAAATCTTATAGT +GTTTGGTATTTTCCCTTCGGACTTTAATTCTAAAAGAACGCTATCAAGTGCCATGTTTTCGTGGGCAGGT +CTCTGCCCGGTGTATATTACTCTCCACATACTTTCACTCCTTAAGAAGTTTTCTTTAAAATCTCTATGAG +ATATACACTCCTTTCTATAAGAAATTTTTATCATAGAATAAGCTATACCTAACCCTAAAATCATGAGTAT +GGAAAAATTCGAGTTTCCCATAGACCTTGCCGAGAAATGCGTAAAGTGCGGACTCTGTAAATCGGTGTGC +CCCACTTACCCCTTCAAAGAGGAAGAAGGAGCCTTTGCAAGGGGAAGACTCGCCCTTGCGGAAATGGTTG +TAAAAGGCGAACTCCCTTTAACCAAGGAAGTCGTAGCCCAGTGGAATGAGTGTGCAATGTGTAGAAGGTG +TGAGTGGATATGTCCAAACGACGTTCAGTACAAGGAGATAATGGTTCACGCAAGAGAAATCCAAAGGAAG +GAAACGGAAAGGGATTTCATATCGGAGGCCGGATTAAAAAGTCTGGAATTTATGCAGTCAAAACCAGGAA +GAGTTGCGTTAAAAATTGCGGGAATACTTTCTAAACCTCTTCCCAAAGAGATAAAAGTTCCTCTCCCCAC +GGGAGGAGTTAAGTTCTTTCCCAAACCCTATGGAAAGCCTTTCGGTATAAGGGGAAAGACTTTTAGAGCC +AAGAATGAGAAGATGAAGCTCCTCTTCTTTACGGGATGTATGATAGACGTCTTTTACGGAAAGACGGGAG +AGAACGTAATAAAGGTTTTGAATAAACTCGGTTATACGGTAATTGTTCCAAAGGACATAAAGTGCTGTGG +TGCACCCCACCTTTACCACGGAAACACGGAGGCTTTTGAGAAGTTAAAGGAACACAACTTAAAGGAAATT +GAGAAGTACGAGTACGACGCTCTTGTTGTTGCGTGCCCAACCTGCGGAGGAGCTCTGAAGGAAGACTACG +GAAAGGACTGGAAGGTTTTCAGCTTTACTGAGATAATAGCGAATGAAGACATTGAGTTTAAAGGAAAAGG +TGAGAAAGTTACCGTTCACGTTCCCTGCCACTACTACACTGCCATGAAGTTAAATCCGAACAACTTCTAC +AAAGCCCTCGGAAAGGTAAAAAACGCGGAGACGGTTAAAGCGGAAAAGGCTCAGAGTTGTTGCGGATTTG +CAGGACTCTTCTCAATAAAGAACCCTGAGCTCTCGGAAGAAATCCAAAGGGAAAAGATGCTTGACTTTAA +AAAGACTGAGGCGGACTACGTAGTTACGGAGTGCCCGGGATGCGTTCTACAACTGAGAGACGGCGTGAAG +AAGTTCAAAAACCAACAGGAAGTAAAGCACATAGCTGATTACCTGGGTGAGAGGATTTAGTAGACTTTTA +TCATATGAAGATACTCTTCTACGCACCGAACTTTACACGCCCTCTGAAAAATGGTACAGCTTCTACAATT +TTAGCATCAATGTGGGCTAACTATTTACACCGCAAGGGGAACGAAATTCTCCTTGTTAGTCAATACCCGG +TGAGCCTGTTGAAAAAATCGTCATGACTTAGAGAATAAAGCGAGAGGAAGCCCATGTAATCCTCAAAAGG +TTAAGACACAATAAAAGGAGCTTCAGAAGAAGGATCAAGTTGTAAAGAACAAACCTCCCTAGAACATACA +AACTCGCAATCTCAAAGTCATAAACATTGTCCCTGTCCCCAAACCTGTTCTTAACTATCCCTATCACCTG +CTCAACCCTGTACCTGTTCTTTCTATAAACCTTCCTCCTTATCTCATAATTCCTCTTAGCCCATAGCCTA +TACATGTTCCTAACTCTTGTATGTGCAGTATCCCTCACCGGAACTATAGACTCCATCCGTAGCTTCTTTA +TTTCCTCTAAAACTCCTGCAGACTTCCCATAGTAGGCATCCCCAAGAAAATACCTCGCTCTAAAGCCAAG +TTCTTTGAGCATGGATCTTAGCAGCATATTCTCATCTGCATAGGATTTGCCTGTGTTTATATCCACTACT +ATAGCTTTGTTTCTTACAACTCCTACAAGAACTTCTGTTTTCACATGAGATTTTACATTCCTAAGTTCCT +TTCCCTTCTTCCACTTGAGTTCATATGCCTGTGCATATCCAAATCCGGTTCCGTCAGCAATAAGGCAGTA +AAACTCTTTTGCCTGAAGCTTTTCCATTATCTCCTTTGCGGTCCTGTGTATTAGCTCTTTGAGATAGCCC +CGGTTTAGTTTTCTGAACCTGTAGTGGAGAGTGGTAAAGTCAGGTACTTTGGGGAATAGGTCTTTTAGTC +TTTCTTCTAAATCTCGGAGGGAGAGGTTTTCTAAGATCTTAATCAGTAGTGCTGCTACTATGAGGTGATC +TTCGTAAACTCTGGGTCTTCCTCTTTTGTTGTACTGACTTGGTCTAATGGTATTGCATATTTCCCTGCTT +TTGGTTAATATCAGTTTTATCAATTGCTTGTTATTTCTTGTTCTCATTCCCTTCCTTCTACTTCTTCTCT +TCCACTGTGTCAAGATTTTTTAAACGGGCTTATACCCGGTAGTTGAAGAAGAAGGATTGATTCACTTTCC +TCATATTTCCTTGAAAAGAAATAAATTGAACGGGGACATATTTTATGCAAAACGTTTAAGTGAAGTTATA +AAATCAGAAAAGCCAGATATAGTTTATGCTTTCTTCAGATCTATGAGTACAATTCTTGGTTTATCAACGT +TTTTTGGTAAAGAAACAGGCACTATTTATCTTGGAAGTGTTCATAATACTGATAATTACATTAAATACGG +TTCCCTTAAACATATACCTTACAGAGTGATGATTAAGGTTTTACTGGAAAAACTTGATGGAATTGTATGC +GTATCAAACACAGTAAAAAGAGACTTAAAACAAACTTTTTGGATTAAGGACGATAAACTTAAGGTTGTCT +ATAATTTAATTGACATAGATAAAATAAGAAAACAGGCAGACGAGTCAATTAATGTGGACTTTGATTATAT +AATAGCAGTAGGAAGGTTAGAAGATCAAAAAGGTTATCCTTATATGCTCAGAGCCTTTAAATTGATTTCC +GAAAAATTTAAAGATTTACACTTACTAATAATAGGAGAAGGATCAAAGAAGAATCAAGTTGAAAAATTGA +TTGAAGAGTTAGGTTTGAAAAATAAAGTGCACTTACTCGGTTATCAATTAAACCCCTACAAGTACATAAA +GAGAGCAAAAGCTTACCTAATGACCTCTATTTATGAAGGGTTTGGATTAGTTTTAGTGGAAGCTATGGCG +TTAGGTATTCCTGTAATTGCTTTTGATATACCTGCTGTTAGAGAAGTGTTAAATGATGGTAAAGCAGGAG +TTTTAGTACCTTTTGGAGATATAAATGCATTTGCAAAAGGATTGGAAAAATTACTTACAGATAGGAACTT +AAGGGAGTATTACATAAAGAACGGACTTATTAGGGCAAAGGATTTTGATATAAGTAAACTTGATAAGATT +TTTTCAAAAGATTTCTGGGAAAAATAACTTTTTCTTTTGGTGGAGGCGGCGGGAATCGAACCCGCGTCCG +AGGACGGCGGCCACATCCGAGGCTCTACAGGCTTAGCCCGTGTTCAGGATTTCCCCTCGGGTCGCCCACG +GGCAAGCTCCCCGAGGGTAGCACGGGTTAGGTGTCAGCTACTCAGCCCCGTGCGACCGAGTAGCCCGAGC +GGGTGTCTCTGACGCCCTCCGGTAGGCCACCCGCAAACCTACCGGGGACGCGCTGCCGTTTAATTAGGCA +GCGAGAGCGAGTTCAGCTTCGGGAGCTGTTTTAGCGGCTGTTACGGGAGCCACCCGGCCTGCTCCTCGGG +GACCGCCTGTCCCCGTCGAATCCTTTCCGCCCCCTTACCTTGACGAAATATAAAATTATAACCCAAAAGA +AAGGTTGTCAAGAGGAGGGAAAATTAGGGGAGTATGTCTTTTATCTCTATTTCAGTATAGGGCTGTCTAT +GACCCTTCCACCTTTTGTAGTTTTTCTTAGGTCTGTACTTAAAAACTATTAATTTTTTTCCTCTGCCGTG +AGCCTTTACTTCCGCAATAACCTTTCCTTTATTGAACTCTATGCTTCCGTCGTCTTTCCTAAGCATAAGG +GCTTCAAACTCAACAGTCTGCCCAACTTCGTAAGGGAGCTTTTCTACCTTTAACTTCATTCCCTTTTCAA +CCTTGTACTGCTTTCCTCCTGTTTTTATTACCGCGTACATCTCTTACCTCCTCAGGATATGATTTCCCAC +TTACCGCCCGCCTTTTCTATCTTTTCCTTCGCGGATTTGGAGAAGGCGTGAGCCTTTATAACGAACTTCT +TTGTAAGCTCACCGTCTCCGAGAATCTTAACCCTGTCCTTTTCGTCGCAGAGTCCCTTGCTTGCAAGAAC +TTCGGGAGTGATTTCCATTCCATCTTCAAAGAGCTTATCTATAACGCCGACGTTTACGGGAGTGTACTCC +TTGCGAGTGGGGTTCTTAAATCCCCTCTTAGGGATTCTCATATAGAGAGGAGTTTGTCCGCCTTCAAAGT +ATGGAGGCATTTTCCTGTCTCCGGAACGGGACTTCTGTCCTTTGTGTCCCCTTCCTGCAGTCTTTCCGTG +ACCCGAACCTATACCTCTACCTACTCTTTTCTTTTCCTTCGTTGCTCCCCAGTGTGGTTGTAGGTCGTGA +AGCTCAACCATTTCTCAACCTCCTTAAAGCTCTACTTCTTCTCCTTTCCAGTTCTTGTACTTTTTGTAGC +CTTTCTTCCTCAGGAAGTCCTCAAGATCCGTTATCCTGGAAAAGTAGTAAACGCCTTTTCCGTTAGTGTA +AACTCCATTCTTGTTTATAACCGTGTAATCCGGCTTTTCCGATAAATCCCTTTCTACGGTAGGAATATCA +CCGGAAAAATCTATTCTGTACGCCACACCAACAAGGTGGAACGCCTTCCTTATGTTTCCCCAAACGAGCG +GGTTGTCTTCGAGTATCCTCTCCTGTCCTCTTTTTTTAAGACCTAAGGACTTTACCGCCTGGATATGTCT +TTCGCTTTCTCCCGCAAGTCCCCTGAGGAGTTTCACCTTAAGTTTGCTCATAGATACCCCTCCAAGGGTA +GTAGTGCTTTATGTTCATCTTGGGAAGGGCGTACCTTCTGTACCTTCTCAGGATTTCCTCTACGGGCAGT +CCTCTTTCTTCTGCTATCTGCTCGGGAGTCTTTAATTGAAGGAGTGCGTCGAACACCGCCCTTACGACGT +TGTCGGGATTTGTGCTCCCTATTATCTTCGTGAGAACGTCCGTGTACCCTGCGAGTTCAAATACGGGTTT +TGCTGCACCACCTGCAACAACACCGGTTCCCCTTCTTGCGGGGAGAACGATTATCTTAGTCGCTCCGAAA +GTTCCTATAACGTCGTGGGGGACTGTTCCGTCTACTATGGGAACTCTGATTACGTTTTTCTTCGCCTTTT +CAATACCTTTTGCTATGGCGAGGGTTACTTCTTTCGCTTTACCGTGTCCAAAACCGACGTGTCCCTTTCT +GTCTCCTACAACCACCAGAGTACTGAAGGAGAACCTCCTTCCACCCTTTGTAACTCTCGCCGTTCTGTTT +GCGTATATGAGCCTCTCTTCAAGCTGAAGTTCGGGAAGTATTTCTTCTATGTTCTGCTGTTTCCTCCTCT +CTTCTATAAGCCTGTCTATGTCTTTACCGCCCATAACAACCTCCTTTAGAATTCAAGTCCCATTTCTCTG +CATTTATCCGCAAAAGCCTTTATTTTACCGTGGTACTTAAATCCGCCTCTGTCAAAAACTACTTTTTTTA +TGCCCTTTTCAAGTGCCCTTCTTGCAATTATTTCCGCAACTACTTCCGCGTCCTTTATTGACTTTCCGCC +CCTTTTGCCCGTTATCTTTTCAAACTCAGGATCCAAGGTAGAAGCACTCACCAAGGTGTGTCCTATGGTG +TCGTCGATAATCTGGGCATAAAAGTGCTTTAAACTCCTGTACACGCAGAGTCTCGGTCTTTCAGGAGTTC +CGAATACTTTTTTCCTTATCCTCTTGTGCCTTCTTAATCTTTTTTCCCTTCTCGTTTTCAGCCTCGGCAT +CTAATTACCTCCTTACTTCTTACCAACAGCTTTACCGGGTTTGAGTTTGAGCTGTTCGCCTTTATACCTA +ATACCTTTACCCTTGTAAGGATCGGGTTTCCTGAAGCTCCTAATCTCCGCTGCGACCTGTCCCACTCTCT +GTTTGTCTATACCGTGGATGTGTATCTCGTTTCCTTTAACTTCTATCTTCACATCGGGCGGGATTGGGTA +TATATCTGGGTGAGATTTTCCGAGGTGAAGTTCTAAAACGTTTCCCTTGAGCTGTGCCCTGTATCCAAGT +CCGTGTATTTCGAGAACTTCCGTAAATCCTTCCGTAACGCCTTTGATCATATTCTTTACGAGGGCTGCCA +TAGTTCCGTGTATAGCCTTGTGGAAGCTCCTGTCGGTGGGACGATCCAGCTTTATCCACCTTTCCTGTTG +GTTTACCGTAACCTTTATATCGGGGTGGACGTTCAGTTCAAGCTTTCCTTTAGGGCCTTCAACTACGATT +TTGTGTTCCTTTTCTACGTAATTCACTTTTACGTTTTCGGGGTACGGAATGGGTTTTTTAGCCAATCTGG +ACATTTCTCCTCCTCCTTACCACACGAAGGCTATAACTTCTCCGCCCTTTCTCATTCTTCTGGCTTCGTG +ATCGGTCATGACTCCCGCGTCCGTGGAAACTATGGCTATTCCAAGTCCCCTCTTAACGTAAGGCATGGTT +CTGACACCTGCGTACACCCTTCTTCCGCCCTTTGAGACTTTGACGATGTTCGTTATGGCGCTCTTCCTCT +TCTTGGGGTCCAGGTATTTGAGGTATATCTTTATGGGGTACTGCGTTCCCTTGTTATACTCCTCAAGCTG +CTTTAGGTATCTCTTCATTTTGGGATTGGGTGACTTTTCAGCGAGTTCCTTCATCTTCTTGTACTCTTCT +TCGTACTTTTCCCCTTTTAACGCTTCCCAGTCCTGAATGAAACCCTCTTTCTTTAGGACGTCGAGTATTC +TCTCCTTTAACTTGGAAGACGGGACGTAGAGGAAGTCGTCTCTTCTCATAATAGCGTTCTTGATCGCGGA +GAACATATCCGCTATTGGGTCAACGGCACTCATTACAAACCTCCTTCAAGCCGGCAGTTGGGCTTTAAAC +CCCTTACCAGCTTGCTTTTCTAACACCAGGTAGATCGCCCCTGAGGGCGTGTTCCCTGAAGCAAATTCTG +CACATGTTAAAGTATCTGATAAAAGCCCTAGGTCTTCCGCATATGGGGCATCTATTCTTTTTCCTGCTCT +TCCACTTCGGGTAATACATGAGATCTTTAGCTACCTTAGCCTTTCTAGGCATACCTAACTTTACCTCCTG +AAGCTAAGTATTTTATCACATAGACCTTATGGGCAGTCCTAGGAGTGAAAGTAGCCAGAAAGCTTCTTCG +TCCGTTTCCGCGGTCGTGTTTATGATTATGTCCATACCCCTTATACGATCCACTTTGTCGTAGTCTATTT +CGGGAAAGACTATCTGTTCCGCTATACCGAAGGCGTAATTCCCTCTTCCGTCAAAAGAACGAGGACTCAA +ACCTTTGAAGTCCTTAACTCTGGGAAGTGCCACTGAGATAAGCTTGTCAAGGAAGTCCCACATCCTTTCT +TTTCTGAGGGTTACCTTGCAGCCTATGGGCATTCCTTTCCTGAGTTTGAATCCAGCTTCGGATTTTCTCG +CTCTGGTAATTACAGGTTGCTGTCCCGTTATGGCTCTGAGGTCCTCTACCGCCCTTTCAAGCTGTCTTAT +ATCCTGAACGGCTTCACCTACACCCATGTTTACGACTATCTTCTGGAGTCTGGGAATTTGCATAGGGCTT +TTGTAATTGAACTTCTTCTGAAGTATGGGAACTACTTCTTCCTTGTACTTTTTGTAAAGTCTCGGGACGT +ACTTCGTTTCAGTTGCACTCATATCAGCCTCCCTTTATTACCTTTTCACTAACGAGGTCTATGTTTTCGT +TACACTTCTTACAGTACCTGTACTTTCTCCTGACATTCCCTTCCTCTACTATCCTGAAACCTACCCTTGT +GGGCTTGTTGCAGTTTGGGCATATTAACATAACGTTGCTGATGTCTATCGGTCCTTCCGTTTCTATAATT +CCGCCTTCCCTTACGCCTTCTATGGGCTTTACGTGTTTCTTTATAAGCCTCACGCCTTCCACTATTACGA +AGTGCCTAACATAAACGGGATTTCCCTGCTTGTCCCTTCTCTTAACCCTTTCGTAAACCTTTAGAACCTT +TCCCTGCTTTCCTTTTTCCTTACCTCTTACCACTAGAACCGTATCGCCCTTTTTGATCTTTGCTGCAGCC +ATTACACTACCTCCGGAGCAAGTGAAGCTATCTTGGTAAAGCCTTTATTCCTCACCTCTCTCGCTATAGG +TCCCAGAACACGAGTTCCCAAAGGTTCTCCGTACTGGTTCAGGAGAACGCAGGCGTTGTCGTCAAACTTT +ATGTAGCTTCCATCAGGTCTCCTGACCTCTTTAGCGGTTCTTACGATAATAGCCCTGTAAATCTTTCCTT +TCTTTGCGTTTCCCTGAGGCAGGGCTTCCTTTACGGTTACCGTAACAACGTCTCCTAGCGTTGCGTACTT +CCTCGGAGCATAAGGTATACCTATAACCTGAACCTTTTTCGCACCGGAGTTGTCCGCTACATTTAAGTAA +GTTTGCCTCTGTATCATGGCTTTTCACCCCTTTAATTAGAGTAAGGCAAATTGATATTATAACAAATTTA +TGTTAGAAACGCGAAGGTTTTTACAGCTCACTTTAGCCCACCGCAAACTATAATAAATTAACACTTCTTT +AAGCCAGTATTGATAATTCTTATTGTTAAGTTATTGGACACAGGGTAAATTTTTTATTTGCAGAGGTCAG +GGAATGGTAGGAATTAAGGATCAAATTAAAGCTCTCACGGAAGCTATAGAAAGGGAAAGTGTTCTTATTC +ATAGGGACGCTTTAATCGGTGCTTACAGGGATTTAAAGAAAGTCGCAAAGTTTGGGCTTGATAAGTTGAT +TAAGAAGGCTGCTGAATACGGGGGGAGAAAGGGAGCAAAAACACTAAAGGAAAAGTACGCCATTTACACG +GATCGCTTGGACGAAGCGATGGACGTGCTCTCCATAATAGCCGAATCTTCAAGGATGATAGGATACTTTG +ATTACGATCCAAAGGCTATGGAAATAAAGATAGAGGGTTCTATTCTTGTTGAAGCTATTCCAAAGAGTGA +TAAACCCGTTTGCGAACCGATGGCAGGATTTTTCAAGGGATTTCTAAGTGAATTTCTGGAAAAGGACTAC +GAGGTTAAAGAGGTTCAGTGTCAGGCTCAAGGGTACGAGCAGTGTGTGTTCAGGATAAGACAAAAGGGTG +CTAAGAAGTAGCCTACTTCCCTTTTCGTACTTATACGAAAAAATTATTAACTTCAGAAACACACTTTACG +ATAAGGGATTTTTAAAGATAAAAAAACTTCCCGTTCCCGTGATTTCTGTAGGAAACCTCTCGGTGGGCGG +AAGTGGAAAGACCTCCTTCGTTATGTACCTTGCCGACTTGTTGAAGGATAAAAGGGTTTGTATACTGTCC +CGGGGCTACAAGAGAAAGAGTAAAGGTACCCTAATCGTTTCGGAGTACGGGAATTTAAAGGTTTCCTGGG +AAGAGGCAGGGGACGAGCCCTACCTTATGGCCAAGTTGCTACCACATGTGAGCGTCGTGGCATCGGAGGA +CAGGTATAAGGGAGGACTCTTAGCTCTGGAAAAGTTATCTCCCGAGGTTTTTATTCTTGACGACGGATTT +CAACACAGGAAACTCCACAGGGACCTTAATATCTTACTTTTAAAGAAAAAGGATTTGAAGGACAGGCTTC +TCCCCGCCGGAAATCTGAGGGAACCTCTAAAGGAAATAAGGAGGGCAGACGCTTTAGTTCTTACCTACCA +GGAAGTTGAGCCTTTTGAGTTCTTTACGGGAAAACCCACTTTCAAGATGTTCAGGGAGTTTTGCTGTTTG +CTGAACTCAGACTTTGAAGAAGTGCCTTTTGATATTCTAAAGGAGAGAGAGGTTATAGCTTTCAGCGGAC +TCGGGGACAACGGACAATTCAGGAAAGTTTTGAAAAATTTAGGGATAAAGGTAAAAGAATTTATGTCCTT +CCCCGATCACTACGATTACTCGGATTTCACACCAGAGGAGGGAGAAATTTACTTAACCACTCCAAAGGAT +CTAATAAAACTGCAGGGTTATGAGAACGTTTTTGCCCTGAACTTCAAAGTTAAGTTGGAAAGGGAAGAAA +AGCTGAAAAAGCTCATTTATAGAATTTTTTACTGATTTGGGCTCTCTCTTCACCGCAGTTCACGTCTTCC +CTTTCAATGTATTCTTTTAGTTTTTGAACAGCTTCTTCTCCAGTAACGAGGTCCTGAAGATCCCTTTCCA +AGTTTGCAGGCTTTAATTTTGCTATCCACCCTTCGCCGTAAGGATCTTCGTTTATGAGGTCAGGCTTGTC +AAAGAGTTTTTCGTTCCTCTCAACAACTTCCCCTTCTATGTCCGCGGGAACGGGTCCAGCCCACTTTCCG +CTTTCAAGGCTTGCCACGGGTTTTCCCTTCTTTACGTACTTTCCGGGTGGTTTAATACGTATGTTTATTA +TCTTTCCCGCCCTTGCCTGTCCGATGTCTGTAACTCCAACGGTTACGGTGCCGTCTTCGTTTACCTTAAA +CCAGACCTGATTTTCTATATCGTAGTAAAGGTCCTTCGGAATAACACAACCCCTGTATTCTTCAACCTTT +TCCGCCATACTCAACCCCCAAAAGAATTTTACAAGAATTTTCCAAAACCGAAGTAATCTCGTAAGCCCTT +ATTAAGTTCTCCGCCCCTGCAAAAACACCGTGACCTTTAATTACCGCAATACTTTTTTCTTTTAATTCTT +CCGCCAGGTTCTGCGCCAGCTCTTCACTCGCAGACGAATTTTCAAGTTCAAGAACGTTTACCTTTCCCAG +AATAGCCTTACCTTCACTATCTAAGGGAGTTATCTCTTTGGTTTTGAGTGAGCACATAACGGCGTAAACA +GGATGGGTGTGGAGAAGTGCTTTATGTTCTGTTTCTCTTAAAACTCTTCTATGAACTATAAGTTCCGAGG +AAGCTCTCTCTTCTAGAATGCTTTCCCCTTCAAGGGGCAGTTCCAGTATGTCTCCTTCACTCAGGTTTCT +GAAGTTCGCACCCGTTCTCGTTATGTAGAGTTTCCCGCTAAAAATTCTACTCATGTTTCCCGTGTAGGAA +TAAGTCAGGTTTTCCTGAGATACGAGCTCAGCGCACTTTAAGAACTCTTTGAGTATAAACTCCACAAGTT +TTTAGGATATCACTCAGGTCCTTACAAACCTTTAAAGATTTTCTTATAACTCAATTAGAACTACTTTTTG +GGTGAGGCACTCAATTATCTCACTTAACTCTTTCCTGCTTACGAAGTAAACCCTTCCGCCCAAAGGATCT +CCCTTTTCCTTCAAGGGAGTTATCCTGACGTATCCTATTTCCTTTCCCGAAACGTATCCCGTGACGTAAT +CGGGATCATCACTCCAGCAAAGCTCCGCCACAACACCGCAAAACAAGTTCTTAAAGGTCAGAGCCAGAGC +GTCAACAGTTCTTAGGGTGTAGCCTTCCTTCAGGAGTTTTTCAGTTACTTTTTTCCTGTCCTTCCAGTCA +AAGTGAATGGTTCTTACTCCCCTTTCCTTGTCCTCTTCAAGCCTCTCCCCTGTTTCTATATCCATAAGAA +CCGCACCTCTCATATTTCCGCCTTTGGGGTTTGCTCCCTTTGACAGGATTTCCACAGCCTTTTTTGCCAC +TTCCTCTTTTATACCTTCCTGGGTGAGTTTTTTTACTGCAAACTCCCTCGCTTCCTCCGGACTTTTGAAA +CTGTATGTGGATATTTTCAGGTTAAACTTCACAACTTCAAAATCCTTTACCTTTTCAACTTTTACGTTCA +TAAAGTCAAATTCCTTCGGTCTGTTAAGGAGTTCTTTGACTGCGGTTTCCAGTTCCTCTTTTTTTACTAT +CCTTTCCGCTCCCGAGACGTGCTTTCCGTTTTTCTGTGCCCGCATTCTTACACTGAAAAGATCCATAATT +TTAAATATGGCGATAATTAAACCCTACAAAGGGAAGTACCCTAAAATACACGAAAGTGTTTACCTTTCCG +AGAACGTCGTAGTAATTGGAGACGTGGAGATAGGAGAGGACTCAAGTATCTGGTTCGGGAGCGTGGTTCG +GGGAGACGTCAATTACATAAGGATAGGGAAAAGGACGAACATTCAGGACAACTGCGTGGTTCACGTGACT +CACGACACACACCCTACGATAATAGGAGACAACGTCACGATAGGACACAGAGTAGTTCTACACGGTTGCG +TACTTCACAACAACATACTCGTGGGAATGGGAGCGGTTGTTATGGACGGTGTAGAGATAGAAGATTACGT +AATTGTGGGAGCGGGAGCACTCGTCACTCCAAATAAAAAAATACCTTCCGGCGTTCTCGTTGCAGGTGTT +CCTGCAAAGATAGTGAGGGATTTGAGAGAAGAGGAGATAAAACTCATAGAAGAGTCCGCCCAGAACTACG +TGAATTACAAGAATGAGTACTTAAGAAGTGCTTAAGGTTCTTTTCCTTTCCTTTATCACGTCCTCGTAAG +CCCACTTCTTGAGTATCTTTTGAATTTCTTCTTCCGAAAGGGAAGGCCTTGAGTACATACCCTTTTCTTC +CCTCTGCCTCTGGGCTTCGTAGAGTATTATCCCGGTGGCTACCGATACGTTCAGACTCTGGGCCATTCCG +TACATGGGTATTACTATTTTCTTGTCTGCAATTTCTACTATTTCGGGGGAAACCCCTTGAAGTTCGTTTC +CAACTACGAGAACGGTGGGTTTAGTGTAGTCCACTTCCCTGAAGTTTACCGACTCCTTTGAGAGCCAGGT +GGCAACTATCTGAAAACCTCTATTTTTGAATTCAAGAAGTTTTTGGACGGGGTTGTCTACCTTTTCTATA +AACACCCACTTGTGGGAACCCTGAGTTATTCCCTCGTTTATCTTTGCTTTTTTCCCTTCTGCGTGGTAGT +AGTAAAGGTAAAGAACACCAACAGCATCGCAGGTTCTTACAATCGCGGAAAAGTTGTGCTCGTTTTTCAC +GTTGTCCGCAAAAACTATTAAATCTTTCTGTCTTTTCTCAAGCACTTCCCTTAGGCGCTTTAAGCGTTTT +TCAAGAACGAGATATTCCATTACCATTAATTAAAATTACCCCTGAAAGTTCCGATTTAATAAATTAAATG +AAACTGGTGGAGAAACTCAGGGAAGTAAAGGAAAAAATCAAAAACCCTTTCAATTATGAGGGACTGGAAA +AGGACTTTATGGAAATAGAAGAACTCCTTGAAAAAGCCTCAAAAGAAGAAGTGGAAAAAGCTTACAAGGA +GTACGAAGAGGTAAAAAGGCTTTTCTGGAGAAACGTTGAAATTCTTAGGAAACTTTACGAGGTGGGCTAA +ATGTTCGGAGCGAGCTTTAACATAATCTCTCAGGCACTTGAAGTTTACAAGAAGATGATAGACGTCAAAA +ACAGGAATATCGCAAACGCTCAGGAGGAAAACTACGTAGCGGAAGAACCCGTAGTTCAGAGCGACCTTTA +TTCGGGAATAACTTTTCAGGAAGTCAGGAGAATACAGAACTTTAACTTTATAAACACGAGAAACGAAAAA +CTCTCTTACGTAAGCTATCTGGAAGAGAGGAGGGATTATCTTTCAAAGCTTGAAAGTGTTTTTCAGGAAC +TCTCTCAGGGAAATGGATTAATAGATTACGTGAACAGGTTTTTCCAGTCCTATCAAGAACTCATGAAAGA +ACCGACAAACGAGGGGGCAAAGAGCCAGTTTCTGGAAAGTGCTAAAATGCTTGTAAAAACGATTAAATCA +AGATACGGCGAACTGACGCGGAGTTACAACGAGATTGACTACACGATAAACGATTACGTCAGAAAAGTAA +ACGAACTGGTCAAAAAGATTTACAAAATTAACAAGGAAATTTTCTTCAAGTACGCTCAAACGAAAGTCCG +CGGAGAGGACTACAAAACCCTTTTAGACCAGAGGGATAAATACTTAAAAGAACTTTCTCAGTACATAAAC +GTAAGGGCTCAGGAAGACGAGCTCGGGAGGATAAAAGTTTACACGTCAAAGGGCTTTGTGCTCGTAGACT +TTTCGGAAAATTTCTTCACCTTGAAGTACGAAGGCGGAAAATTAATATACGAAAAGGACGAGAGTGATAT +AACGAACGTCGTGGAAAGCGGACAAATCAAAGGCTTGATTGACGCAAAAGGAGACATAGAAAACTTGATA +AACAAGTTAGACAATTTGAGAGATTACTTGGTAAACAACGTAAAAATTCCCGTAAATGGTGGCGGTGAGG +CAAGTGTCTTTAGTGGAGCAAGTATAAACGATTTTGAGGTAGATGCTAACCTTGAGACAAACTTAGGAAA +CCTTGACTTTTCAAGGACTCAGGATTACGCCCAAAACGCTTTAACGTGGTGGGAAGAGGCAAAAGGCAGA +ACGAAGGATATAACCAATTACGTGGCTACACAGAAAAACGCTTTAGACTCGGAGTACGAAGTGGAAAAGG +CACTTTACGACTCTTTAGAAAAGAAAATCCTTGAAAGGCAAGGTGTATCCATAGATCAGGAATTTATGGA +GATAATGCAGATTCAGAAAAATTACGAGGCAGTAGCGAAAATTCTTCCGAGAATAGATGAGATGTTCAGG +ACGCTTTTGAACATGGTGTGAGGTAGTGAGATGAGAGTTCCTGACCTGATTTTTTACCTCTTTTTCGAAA +AGGAAAATAACAAAATTAGGAAAAATGTTGAAGATAAGTACCTAGAAATAGTGAGCGGTAAAAAAATTCA +AAACCCTTCCGATGATCCCGCATCCACAAATCAAATACTGAACTTAAAAACAGAACTCAGTAAACTATCT +CAGTTTTCAAGGAACAGGTTGTTTGCGGATACTGTCCTCTCGTATGCGGACACACTTCTTGCGGGAATAG +AAGACCGCTTAAAGAGTCTTTACTCAAAAGTTATTCAGTTGTCAAATCAAGTTCACACTCCAGACCAGTT +AAAAGCCGCAGCGAAGGAGTTTGAAGAAGCCCTGAAGCTTCTCCTGAACACCGCAAACGAGAAGGTAGGG +AATAACTACATATTTTCTGGAAATGCACTGACCACAAAACCCTTTGACGAAAACACTTTAACTTACAACG +GCGGGAACGCAGAATTTGAGATTTTGATAGATGAGGGTTATAAATCTCCCGTTATCTTGAATGGAGGAAA +TATTTTTGACGGTATAGGAGGAATAGGTGAAACTTACACCGTGTATGAAATTGAAATAACAGGGTTTGAT +GATACTCCTGATAACGACGATACAGGTTTTAGAGTAGACAGTATAGAAATACGAGGTGATAATTTAGATG +AAATTATTCAGAAGTTAAAAGAAAATTTCGGAGATTCCATGAACATATACCTTTACGAGAAGAGTGATGG +AACACCCATCATACGCCTTGAAGCAAATAGGGATTTTACTGTGACGAATATCAACAATACAAACCCACGA +GAGATAGACACAAATAGTCTCCTTATAAATAGATGGAATGCGACCAGAAATATTTTTGAAACTATAAAAT +TTATTGCCGATGAACTGAGCGAAGGTAGATTGTTATTCAGTGGTCCTCTTATTTCTGAGGACTCAAACGA +TTACTTTAGTAATAATAGACCTGATTACCAAGTAATCAGTAAACCCTTTAATAAGTCAACGGAAGTAAAG +TTAATGGAACAAAGTGTAGAAAGAATTATAAACTTCAGAGCAAAGATTGGAAGCATTCTCAAGGAACTAA +GAAATGAACAAAACTATCAGGAAGATAGAAAACTCGTCCTTGAAAAGCAAAAATCCGAGGCTGAAGACGC +GGACCTTGCAAAGTCTATTTCCGAGTACGAACGCTACAGACTCGCTTACGATGCAATTATGAAACTCTTT +GTAAACCACAAGAACATGAGCATACTCGATTACATTTAAACCATTATCCTTTCCACAAAGGTTATGTCGT +GCTTTCCTTCTATAAACTCTTTCTGATCAAGTACCCTAAGGTGAAATTCCGTGTTGACCTTTAATCCCTT +TCCTTCAATCTTTAGTTCTCCGAGAGCCCTTTTTCCTCTCGCTATCGCTTCCTGACGCGTATTTCCCCAT +ACAATTATCTTTGCAAGCAGGGAGTCGTAATAGGGCGGAACTGTGTAGCCTTGGTACAGGTGAGTGTCTA +CTCTGACTCCCGGACCTCCGGGAAGGATTAATTTTTCCACCTGCCCGGGAGAGGGAATAAAAGTTACTGG +ATCTTCAGCGTTTATCCTGAACTCTATAGCAAAACCATTAGTTTCCACTTTTTCAAGTTTTATCTCCTCT +CCCATGGCTGCTATTAACTGGAGCTTTACTATGTCCACACCCGTTACCATCTCCGTTACCGGGTGTTCAA +CCTGTATCCTTCCGTTCATTTCCATAAAGTAAAAGTTCCCCTCTTCGTCCATCAGGAACTCAACCGTCCC +CGCGGAAGTGTAACCGAGTCTTTTACAAAATTCCGCTACCTTTTCGGAGATTTCCTTTCTTTTCTCTTCA +CTCACGGAAACACTCGGAGCTTCTTCTATTAACTTCTGGTGTCTTCTCTGAATAGAGCATTCCCTTTCTC +CGAGAACGTACACGTTTCCGTGTTCGTCCGCAATTACCTGAAACTCTATGTGTTTGGGATTTATCACGTA +CTTTTCTATGTAAAGCCTACCATCTCCGAAAGCACTTTCCGCCTCTTTCTTCGCTAAGGGAAACTTTTCC +CTCAGTTCTTTTTCATCCCTTATTATTCTTATTCCCCTTCCTCCGCCTCCGGCCGCAGCCTTTATAACAA +CGGGATAACCTATCTTTGAAGCGAGTTTCACAGCTTCAGAAAACTCAAGGGGCTCATCGCTTCCGGGAAC +TAAAGGGAGTCCTACTTCCTTTGCAACCTTCTTTGCCAGAACTTTATCCCCAATCTTCGCCAGAACCTCG +GAGCGTGGTCCTATAAACTTCGCCCCGCTCTTTTCTACGATTTCCGCGAATTTTGGGTTCTCGGATAAAA +ATCCGTAGCCGGGATACACCGCATCAGCTTTACTCACTTCCAGTGCGGACATTATCCTCGGAATATCGAG +ATAACTCTTTGAAGGGTCGGGAGGACCTATGCATATAGCTTCGTCTGCGAGTTCTACATGGAGGCTGTTT +TTGTCAGCCTCCGAGTAAATCGCCACAGTTTTCAATCCCAGTTCCCTACACGCCCTTATAGCCCTTACTG +CGATTTCTCCCCTGTTGGCTATTAAAACCCTTTTGAACATTAAGAATACATTTTAAAGCTCATTCAGGAG +TTTATCCGCTAAGCTTACCATTTCTTTTAAAGTTTTTGCAGAACGCAGAAGTTCTCTCTTTTCGTAACCG +CTCAGGTTTACAAGCTCAAAGTCTTCAACTCCCTTCTTTCCGAGAACTACGGGCAGTCCTATGCACACTC +CTTCTATTTCGTAGTGCTTTGCAGCTTCCCCTTCAACGTAAACGGAGCAAGGCATTACCCTTTTCCTGTC +GTTGATTATAGACTCAACCATTATCACAACCGAGGCGGCGGGTGCATAGTAGGCAGAAGTGCCCATAAGG +GATACTATCTGCGCTCCACCTTTTCTGGTCTTTTCTATGAGTTCATCTATCTCGCTTGCACTGAAAACTT +CCTCTATCGGTTTGTCTCCTATAAAGCTGTGCGAGGTTACTGGCACCATTAAATCCCCGTGAGTTCCCAG +AACCAGAGTCCTTATATCAGCGTTTGATATACCTATCTTTTCCTTTACGAAGTTTTTAAACCTTGCGGAA +TCGAGAACTCCGGCCATTCCGATAACCCTTCTCGGTTCAAATCCCGTCAACTTTATGGTGGCGTAAGTGA +GCGTATCCACAGGATTTGAAACCACTATAATTATTGAATCCTTCGCGTATTCCTTTATCGCATCCGTGAA +CTTTTTCAAGATTTTTAAGTTTTCGTAGAGTAAATCCTCCCTGCTCATCCCCTCCCTTCGAGGTATTCCC +GCGGTAATTACCACGATGTCTGAACCCTTTAGTTCTTCAAAACCCTCTTTGTCGTAGGAAATCCCTTTAA +CGTTTATATCTATGTCCATTAAAACAGCCATTTGTTTTAGATCAAGAGCCTTAGCTTTCGCAGGTTCTAA +ACCTTTTTTATACCTCGCAAATAGGTAAACGTCTCCGAGGCCGAGGATCGTGAGGAGGTAGGCTACATTT +TCCCCTACCTTTCCCGCACCTATTACACTAATTTTTGGCTTTTTCATAAGAAATGAGTTTATCAATTTCC +CTTTCACTTATAGGCTTATAATCATTCCACTCAACGTTTGCGTTTATACATTCTATTCTGTAATCCTTAC +AAGCACACTTTATTCCCTCTCTGTTCCAGTGGACGTGTCCGTGTATTAGGAGGTCGCAATTTTCTTTAAA +GTAAATTTCTCTTACCATTTCCTGTCTGTCGGGATACCTTTCGGTTATGGGATCCTTTGCGGGGTAGTGG +GAAAGGAGTATTCTCTTTCCTTTGTGTTCAATTATCTTGTAAAAGTCGTAAATTTCGTCAAAGTACTCTT +TCAGGGATTCTTTGTCTTTGTCGTGGTTCCCCATAACGAGGATTTTTCTCCCCGGAAGGGCTTTCCATAT +TCTTAAATACTCGTTCTTGTCGTTAAAGTGCCAAGTAAAATCTCCGAGGTGATACAAAGTGTCTTCGGGC +TTTAAAACTTTCAGGAGGTTAGTAAGGATTACTATTTCAAAACCTTTGAACCTTACTTCTGGATTGAGAT +TTATTATGTTTTCGTGGTAGAAGTGTGTGTCGGAGATAAAGTACATCATCGCTATTTATTTTAGAAAGGG +CCTCCCGGGCGGGAGGCCAAAAATCGGTGGAGGGAGGTGGGGGGAGGGAGGGGCTTTCTCACCTCTCTAC +TATTAAATTTATGCAATTGAAATTTTTTTGCAAGTTCTCCTAACTTCTTCATTCTCCGTAGTTTTCAAAC +CATTGACAGTTATAATAATATTACAATAAAATATAACTTGTTTATGACTACTATCATAAGAGGATTAATA +AAAGCGGGAAAAGAGGGGAGATTACTCTTTATTTTTTATCTTTTCTTTAATCCAGTCAAGGAATTTATTA +AGTTCCATACTGCCGAGATTTCCTTCCTTTTTGGTTCTCACGGATACCGTATTGTTCTGAGCTTCCCTAT +CACCTACGACCAAGATAACCGGTATTTTCTTCAGTTCTGCGTCCCTTATCTTCGCATTCATTCTCTCTTC +TCTTAAGTCCATTTCGGCCCTTATGCCGTTTTCCTTCAGGAACTCGTAGACTTTCTTAGCGTACTCGTGG +TGACGATCCGCTATGGGGATAATCATTACCTGCGTTGGTGAGAGCCATATGGGAAGGAGTCCCGCGTAGT +GTTCAAGGAGGATTCCCGTAAACCTCTCTATGGAACCGAGGAGTGCCCTGTGTATCATGTAAGGTCTGTG +TTTCTTGTTGTCGGGCCCAACGTAAGTCATGTCAAACCTTTCGGGAAGGTTGAAGTCAAACTGTATGGTG +GAGAGTTGCCACATCCTGCCTATGGCGTCCCTTATCTTTACGTCTATCTTCGGACCGTAGAAGGCTCCGC +CTCCTTCGTCTATCTCGTACTCGTAGCCTAAATCTTCTATCGCCTTTTTAAGGGCGTTCTGAGAAACTTC +CCACTGCTCGTCGGAACCTATTGAGTACTCGGGTCTCGTGGAGAGGTAAATCTTGAACTCGTTAAATCCG +AAGTCTTTTAAGGTACTCAGGGCGAAGTCCAGAGTTTCCCTTATCACATCATTAACCTGCTCGGGTGTGC +AGACTATGTGAGCGTCGTCCTGCGTAAAGCCCCTAACTCTGAGTAGTCCGTGGAGAACTCCAGAGAGCTC +GTACCTGTAAACCGTTCCAAGTTCAAAGAGTTTTAGAGGTAGTTCCTTGTAGCTCCTTGTCCTGCTCTTG +TATATTGCTATGTGGAAGGGGCAATTCATGGGCTTTACGTAGTACTCCTCTTCGTCTATCTTCATGGAAG +GAAACATGTTCTGTTTGTAGCACTCAAGGTGTCCGCTCGTTTCCCAGAGCTTGGATTTTCCTACGTGGGG +AGTGTAAACGAGCTGGTATCCTCTCTTTAGGTGTTCTTCCCTTAAATAGTCTTCCAGAACCTTTCTGTAT +ATTGCTCCCCTCGGAAGCCACAGAATTAATCCAGCTCCCACGTTGTCGTCTATCGTGAAGAACTCCAGTT +CCTTTCCGAGTCTCCTGTGATCCCTCTTCTTTACTTCCTCGTAGAACTTTAGCCTTTCCTTTACTTCTTT +GTCGCTCCAGTAAGCTATACCGTAAATCCTTGTGAGCTGAGGCTGATCACTCCTTCCCTTCCAGTAAGCC +CCTGAAATTGAAGTGAGTTTAAAGGCTCCTGCCTTCCCCGTTGAAGGGAGGTGAGGTCCTTTGCAGAGGT +CTATAAAGTCCCCCTGTTCGTAAACGGAAATGACTTCCTCTTCTGGTATCTCCTTTATTATGTCTATCTT +GTACTTTTCCTTTAATTTGTCAAAGAGTTTTATCGCCTCCTCCCTTGAGAGCTCCCTCCTCAGAATGGGA +TAATCCCTCTCTATTATCTCCTTCATCTTTTGTTCTATTTTGGGAAGATCCTCTTCAGTTATCTTGTGTC +CTTCTACTTCAACGTCGTAGTAAAAGCCCTCCTCGGTGGTTGGCCCAACTCCTAGGTGAACCTTTTTAGC +CCCGTAGAGTTCCTTTAAGGCTTGTGCCATTATGTGTGCGAGGGAGTGCCTCATTATCTCAAGGCTTTCC +TTTGATCCCCTATATACGGGCTTTATCTCACCCGATTCCCTTACGGGTGTTTGCAGATCTATGATCTTTC +CGTTTATTACTCCGCCGAGGGCGTCTTTTATACCTGCAAGCTCAAATATCTTTCCGAGAGGCGTTCCCTT +CTCTACCTCGTACTCCTTTCCCTTAATCTTTACCTTAATCTTTTCCATAGAGATTTATTTTAGGCTTAGC +TTATCTTTTTCAATATGAAGAAATCTCCCAAAATCAGTTTAATACTTGAAGCTTTCCAGAACCTTGAAAA +GGCTTACGTTGACCTCAAAAAGAACCTTGAAATTCCAAAGGAGGAATTTGTTAAGAATAAACTTGTTCAG +GACAGGGTGAGGATAGACTTTAACCTCGCCTTTGAGAGTACAATGAGGGTGTGCAGGCACCTCTCCGCTG +TTTACGGCGTAAAAACCTCTTCAAGGGACTGCCTTCCTAAAATTGCCGAGCATATAGGTCTTCCCTTTGC +GGACAGGTTAAAGAAATTTTCCGAATTTTACTTCCGCTACAGGGACTTAAAAGACACCGTTTCTCCAGAA +GAACTCTATGACTTTTTAAAGGAAAACCTCGTCCTTTTTAAAGAGTTTGCGAGGGGTGTTGTAGAGTACA +TAAAGAAGACCACGGGCAATTACCTGTTGATAGACTTTGACCTTCTGAACGAAAAAGCGAAGTTCATAAA +GGATTCCGTGAAGAAGATAGACTTCGTCCTGTCTCAGGGAGAAGAAGAGTTCAAGAAAACGCCTATGTAC +TACGACAGGGTGAAGTACTTCTATCAGGTGGCTTACGACTCGCTGTTTGACATATGCAAGCACCTCGCTC +CAAAGTTCGGCATAAAGAAGTTCGGGGATGATTGCCTAACGAAAATGGTGGAAAAGGGGGTAATCCCTCC +TGAATATTACGAAACTGTTCTGAAAATGACGCTCCTTAAGAACAAGCTCATAAGCACGTGGGAGGTGAGT +CCGGAAGAGCTTTACAGAAGTCTTAAAGAGCTAAATGACAAGTTCATCCCCGTTCTCAGGGAAATATCAA +AGAGTTTAAAATTATTACTTGAGAAAAAAGCAAAGGAAGTGGGGAAAGAAGCATGAGGGTTTTAAAGATA +CTGCTTTTTATAATCTTCTTCTCTTTCGGTGTTGAGGCTGTTCCCTTTGAGAAAATCTCATTCCTGAACT +TAAAAGAGGATCTGGAGGAGGCTAAAAAGGAAGGGAAGTACTTATTCATAATGTTTGAACAGGAAGAATG +CCCTTTCTGCGATAAGATGAAGAGGGTTACCTTTCAGGATCCCCGCGTTAGAGAGTACTTCACGAAACAC +TTCTACATGGTGAGGATAGATATAAAAGGTTCTAATCCCGTTGTGTACTTTGACGGGACGGAAATGACTG +AAAAGGAACTCGCCCACAAGTTCAGGGTTAGGGCAACGCCTCACTTTGTTTTCTTTGACCACGAAGGTAA +AAAGATACTCTCTATCCCCGGATACATACCGCCCGAGGAATTTCTACTAATCGGTAAGTACGTAGCCGAA +GGTTACTACAAAAAGATGAGTTACTTTAAGTTTAAGAGAATGATAAAAAAGGATTAATGTGGTTTTTAAT +CCTCCTCGTAGGTTTCAGTTTTTCCCTCCAGATATCCCTCAAGGATGCCTTAGAACTCGCCCTTAAGAAC +AACAGAACCTTGAAAAAACTTGAAAGAGAACTCAGTTCTGCGGTCTACAGGGAAAAGTTGAGCCTGTGGG +AGAGGTTTTCCCCCGAAACGGACGTAAGGGTTTCAAGGGACAGGCTAGAGCTTGTGGCGAGGGTTTTGCT +CCTTGAGTTCGGAAGGAGAACGAAAAACATAAAAGCGGAGGAACACAGGAAGAAGATAGCGGAGTTAACC +CTTCTGGAGTTCAAAAATAGGCTCAAAATTGAAGTCACGGATCTTTACATAAAACTCCTACTTTACGACG +TTATGGCACAGGAGAAAAGGGAGTTTATGGCGGTTGCCTTCGTGAGGTTTGACAGGGAAAGGGAGAAAAT +GAAACTCGGACTTTCGGATAGGGTAAAGGTCTCGGAACTTGAAAAAGTTTACAGAAAGTACAGAAAAGAA +CTCTTTGAAGTTCAGAGGAAGTACAACGAAACCCTTTACAGGTTAAAACGCTACCTCGGTCTGAAAATGG +AAGAAGATCTGGAAATAAAGCCTCTTAAATTCAGGATACCCTTCGAAAAAAACTTTAAGGAGAAAGTTTT +ACTGGATAAAGTGAAAAATAATTACAAATTAAAGATAAAAAATCAGGAAATCGCTTACTACAGGGAACTG +GAGAAGGGTGAAAGAACGCTTTTCAAACCCGAGGTGGTGCTGGAGGGAAGGTTCGGAAGGGATTTTGATG +AAAAGGATTACTATACTAAGTTCAACACGTACATTAACATTCCCATTCTGGATCCGAGACCTGAACTGAG +GAGAAAAACTTTAAAAGAAAAGAGGCTGGCTTTGATGAGGGAGTACAGAGAACTGGAAGAGGAAGTAAAA +GAGAGGGTTTACACCTTTCCCTATATATGGGACGAAATAAGGGAAAACTACAAGTACGCGAAAACTTACT +TCAACTGGGCTGAGAATAACCTCGAGAAGAAGCGTTCGGAGTACGAACTTCAACTCGCCTTTGATCTCGG +GTACGCAATGGCACACTACACGGAAGCGGAAAGAAAACTCTTAGAAGTGAACAGAAGGGCACTCCTCTTT +CTGATGGAGGTTTACCATACCGTGGGAGAAGATCCGGTGAAGGCTCTGGGAAATAAACATCCGTTCCTCG +AGTAAAATGAACTTATGGAAGTGAAAGCTACAACTATACTCGCGGTGAGGAGAGACGGAAAGACGGCTGT +AGGCGGAGACGGTCAGGTAACTCTGGGAAGTTCTGTGATAAAACACACCGCGAGGAAGATAAGGAAACTT +TACAAAGGGCAGGTGATAGTAGGCTTTGCGGGAAGTGCAGCGGACGGACTGGCCCTGATGGAAAGGCTGG +AAGCAAAACTCGAAGAGTACAGGGGAAACTTGCTAAAGGCTTCCGTTCAGCTTGCAAAGGATTGGAGGAT +GGACAAGTACCTCAGAAGGCTGGAAGCACTACTCTTGGCGGTGGACAGGGAACACATGCTCCTTATATCT +GGAAACGGGGACATAATAGAGCCGGATGAGCCCGTTCTCGCCATAGGTTCTGGGGGAGATTACGCAAGGG +CTGCAGCTCTTGCCCTTTACAGGAATACGGATCTTTCCGCCAGAGAGATAGTGGAGAAGTCTTTAAAGAT +AGCCTCGGAGATATGTATATACACGAACGATAAATTCGTAATTGAAGAGATTTAATTTTATCGGGGCGAC +CGGACTCGAACCGGCGACCTCTGGCTCCCGAAGCCAGCGCGCTACCACCTGCGCTACGCCCCGTTGAGTA +TAAAAAATTATAAAAAAGAAAAAGGAGAAGGTTTAGGATTCCTTCTTCTCTTCGGAGGATGCGGAAACCT +CAGCTTTCTGTTTTTCGTACTCTTCCTTAGGAATAAAGACGAACTCCCCGTCTTTGTAGTCCACAACTAC +CGTCATTCCGTCCTTGATTTCTCCTCTTATTATCTTGTCCGCGAGGGGTGTTTCCACGTACTTCTGAATT +GTTCTCTTTAGAGGTCTCGCTCCGAATGCCGGGTCGTATCCTCTCCTTACGAGTTCTTTCTTTGCCTCTT +CCGTGAGTTCTATCTTTATGTTCCTTTCAGCGAGTCTCTTGTTCACGTTTGCGATAAGGAGGTCTATTAT +CTTGGAGAGTTCTCTCATGGTGAGCGGTTTGAACACGATTATCTCGTCTATTCTGTTGATGAATTCAGGT +CTCATGTAGAGCTTGAGCTCTTCAAGAACCTTTTCCTTAGCCTTTTCGAATTCCCTATTGAGAGTTTCCT +CATCCGCATCCACGGGAATGTTCAGGAGATACTGAGAACCTATGTTTGAGGTCATTATTATCACGGTGTT +TCTAAAGTCTACCGTCCTTCCGTGGGAGTCCGTGAGTCTTCCATCGTCAAGCACTTGCAAGAAGAGGTCA +AGAACTCTGGGGTGTGCCTTTTCTATTTCGTCAAGGAGTATTACTGAGTATGGTTTTCTCCTTACCGCTT +CGGTGAGTTTTCCGCCCTCCTCGTATCCTACGTATCCCGGAGGTGCACCGATTAGCTTTGCCACGGAGTG +CTCTTCCTTGAACTCGGACATATCAAGCCTGATTAGAGCGTCTTCATCTCCGAAGAGGAGTTCCGCAAGT +GCCTTTGAGAGTTCCGTTTTACCTACACCCGTTGGTCCGAGGAACAGAAAGCTCGCTATGGGTCTCTTGG +GATCCTTTAGTCCTGCTCTTGCCCTTCTGATTGCTTCCGCTACAGCTTTTACAGCGTGTTCTTGGTCAAC +GACTCTCTTGTGAAGTTCGTCTTCAAGTTTGAGAAGTTTTTGCATTTCCTCTTCTTTTAGTCTGGATACG +GGTATTCCGGTCCACTCCGAAACTACTTCCGCAACGTCGTCCCACGTGACCACGAGTTCCTTGGACTTTT +CCTGTTCTAACTTCTTGAGTTCCTTTTCTAGCTTAGCCTTTTCTATCTTGAGCTCAGCTTCCTTCTCATA +ATCGCCCTTTTCCGCGGCTTCCTTTATCTTCTCGTCAAGTTCCTCAATCTTCTTCTTGAGCTCGGCGATC +TTAGCTTCTACTCCTCCTACCTTGCCGAGGAGTTCCTGCTTTTCCTTCTCAAGTTTAGCTTTCTCTATCT +TGAGCTGTGCTTCTTTTTCGTAGTCGCCTTTTAGGTTAGCCTCTATTATCTGCTCTTCCAGAGCTTTTAT +CTTCCTCTCTATTTCCTGTATTTCGGGGGGAGTTCCTATAACTTTTAGCTTTTTCCTTGCGGCAGCCTGG +TCGAGGGCGTCTATCGCCTTGTCGGGAAGTCTCCTGAAGGTTACGTACCTCTTCGTGAGCTTTACAGCCG +CTTCTATTGCTTCGTCGGAAATCTTTACCTTGTGGAACTGCTCAAGTCTTGGTCTCAGACCTTTTAGGAT +TTCTATCGTCTGCTCTTCGGTTGGCTCGTCCACGAATACGGGCTGGAACCTTCTTTCAAGTGCCGGGTCC +TTTTCTATGTACTTTCTGTACTCGTCAACGGTTGTAGCTCCGATTACCCTGATTTCTCCTCTAGCGAGTG +CGGGCTTCATTATGTTTGCCGCGTCAACTGCACCTTCCGCAGCTCCCGCTCCCACTACGGTGTGTATTTC +GTCTATGAAGAGTATTACGTTTCCTTTTTCCTTTACCTCGTCAAGGAGAGCTTTTAGTCTCTCTTCAAAC +TCACCCCTGTACTTAGAACCTGCGAGGAGTGATGCCATATCTATGGACCATATTTCCTTGTCCTGTAATT +CTGGGGGGACTTCCTTGTTCACTATCCTTTGGGCGAGTCCTTCCACTATTGCGGTCTTACCGACTCCGGG +GTCTCCCACGAGTACGGGGTTGTTTTTAGTTCTCCTTAGGAGTATTTCTATAACTTGGTTTATTTCCCTT +TCCCTTCCTATTACAGGGTCCAGTTTACCCTGCCTTGCGAGTTCGTTTAAGTTAACGCCGAAGCGCTCAA +GGGGAGACTTTTCTTCTTCTTTGAGTTCTTGAGTGACGTCCTTCTTCATCTCTTTTTCACCTCCTAAAAC +TTGATTTATTAACTTACCACCTATGGTATCTTTTGCCTCAATTAAAGCCGCGGAAATGTGAGAAGGTTGA +ACCTGAGCCTCTCCCTCGGATACAGCCTTGTCCTGAGCCTTTTCAAGAACCTGAGTCAGGTACTGACTGT +AATCAAAGGTGGGTTTCTTTCCGAAAACCTTTTCCGCTACCTTGTCTATTATCCTGTCCGGAGAAATTCC +AAGTTCCTTTACTTGTTCAATTAAGGGAGACTTTTCAAGGGCTTTTCTTATTAGACCATCTATGGAGAGT +TTATTTTCAAGGAATGCCTTTACATCCTCGGGTGCAAATACGGTGGATAAGCTCTTTTCCACCTGCTCCA +GTTGTCTCCTTATACTTTGTTCCGTTGCTTCGAGTTGTCTGAGTTCAAGTTCCAGAGTTTCAGCGGTCCA +CCAATCTCCGTATCTCCTTGCGTACTCAAGTTCCCTGAGTATCCTCTCCTTTGCCTTCCTTATTTTGGAG +AGTTCCGTCTGGACGTTTCCTATGTTGGATTTTACTTCCATTATCTGGGTTCTCAGGTTTATTAGGTTCT +GGGCTTCCGCTTCTATAGCCTTTTCAAGTTGCTTGTTGAGGTTTTCAAGGTATTCGCTCACCCTCTTTAA +AAACTCCTTCCTGTCTATTCCCCTTTTCTCTATATATTTAGAAAGAGGAGATTTTTCGTCGAGGAGCAGG +GCTATTAGAAGGTGATCCGTGTCCACCTTAGTGTCCTTGTTTTCCCTTGCTATTTCTTTCGCCTTTTCCA +GATACTCAAGGGATTTGGCGGAAAACAGGTTTTCGCTTATCATACTTTTACCTCCCGTTTAATTTTCCTT +TAATAATATTTCTTGAGTATAATTGTGTCAACCTTTTATACCTTTCGTGCACACTCCCTCCACTATAATT +AATTTCTATGCTCACAGAGTACGGAGACTTCAAAAGAACCAAGTACTGCGGAGAGGTAAGCGAAGAAGAC +ATCGGAAAGGAAGTCAAGCTCGCGGGTTGGGTTCACAGAAAGAGACACCACGGCGGAGTAATATTCATAG +ACCTGAGGGACAGGGAGGGAATAGTTCAGGTAGTAGTAGAAGAAAAGACAAATCCCGAGGCTTATGAGGT +TGCGGACAAATTGAAGTCAGAGTACGTTATCGGAGTCGTAGGAAAGGTGAGAAAAAGACCGGAAGGAACG +GAAAATCCCAAGCTAAAAACAGGATACGTTGAAGTGGTTGCGGATAGAATTCTCGTCTTCAACACGAGCG +AAGCCCTACCCTTCCCAGTAGAAGAAGAAACACATGTATCAGAAGAGACGAAGTTAAAGTACAGGTACAT +AGACCTTAGAAGGGAGAGTATGAAGAACAACCTCATATTCAGACACAGGGTTTACCAGATAACTAGAAAC +TTCTTCACAAAAGAGGGTTTTATAGAAATAGAAACTCCCTTCCTTACAAAGTCAACTCCCGAAGGAGCGA +GGGACTTTTTAGTTCCTTCAAGGCTACACCCGGGCAAGTTTTACGCCCTTCCTCAATCTCCTCAGCTATT +TAAACAAATACTAATGATTGCAGGGTTTGACAGGTACTTCCAGATAGTAAAGTGTTTCAGGGACGAGGAC +CTGAGGGCGGACAGACAGCCCGAATTTACCCAGATAGATTACGAGATGTCCTTCGTGAGCGAAGAAGAGG +TAATGGATGTTGCGGAAAGACTTATCGCCACCCTCTTTAAAGAACTCCTCGGAGTAGAACTAAAAACACC +CTTTGAGAGGATTTCTTACAGGGAAGCTATGGAGAAGTACGGGACGGATAAGCCAGACAGGAGGTTCGGA +CTAGAACTTATAGAACTCACGGACATATTCAAAAACACAGCCTTTAAGGTGTTTAAAAGCGTCGTTGAAG +CGGGAGGGATAATAAAGGCTATAAACTTCAAAGGCTCAAATCTCTCAAGGAAGGAGATAGACGAACTCAC +AAAGTTCGTGCAAAGTCTCGGTGCAAAGGGACTTGCGTGGATAAAGGTAGAAAAGGACAAACTCACATCA +CCGATAGTGAAGTTCTTCACCGAAGAAGAAACTCAGAAACTCCTTGAAAGGACGAAAGCAGAACCCGGAG +ATGTGATACTCTTTTCCGCGGACAAAAAGGAAATGGTTTACAAAATCCTCGGAAACCTGAGACTCCACCT +CGGAAAGAAGTACAAGCTTATAGACGAGAGCAAGTGGGACGTTTTCTGGATAGTTGATTTCCCTCTTATG +GAGTGGGACGAAGAGGAAGAGAGGTTCGTATCACTTCACCACCCCTTCACCATGCCAAGGGAAGAGAACA +TTCCAAAACTAAAGGAAGCCTTGGAAGAGGAAGATTTAGAAAAGAAAAAGGAAATTGTTCACTCGGTAAG +GGCGAGGGCTTACGACATGGTCCTGAACGGAGAGGAAATAGGCGGAGGTTCTATACGTATCCACAGAAGG +GATATTCAGGAAGTTGTTTTCAAACTCCTCGGTATAGGTGAGGTGGAAGCTCAGGAGAAGTTCGGCTTCC +TTCTGGAAGCCCTCAAATACGGAGCACCTCCCCACGGTGGACTTGCCTTCGGGCTTGATAGGGTAGTGGC +TTTGATGCTCGGACTTGATTCTATAAGGGACACGATAGCCTTCCCGAAGACTCAAAGAGGTATATGTCCT +CTTACGGGAGCGCCCGATTACGTGGACCCCAAACAACTCAAGGAACTTCACATAAAAGTTTTAGAATAAA +AGTATGGAGAAGAGAATTACGACACCTCTTACGGACGAAGTTGTGAAGTCCTTAAGGGCGGGAGACAAGG +TTCTCATAACGGGCTACATTTATACCGCAAGGGACGCAGCCCACAAGAGAATGGTTGAAGCTATACAGAG +GGGAGAAAAACCGCCGATAGACTTAAAAGGTCAAATAATCTACTACGTAGGCCCAACTCCACCAAAGCCC +GGACAGGTTATAGGCTCTGCCGGACCTACCACAGCGATAAGAATGGACAAGTACGTGGAACCCCTCCTAA +AGCTCGGACTGAAGGGAATGATAGGAAAAGGTTACAGAAGCCCGCAAGTTAAAGAACTGCTGAAAAAGTA +CAAGGCTGTTTACTTTGCGGCGGTTGGAGGAGTAGCGACCCTTCTCCAGAAGCACATAAAGAGTTCCGAG +CTTATAGCTTATGAGGACTTAGGAACGGAAGCCATAAGAAGACTTTACGTTGAGGATTTTCCCGTTATCG +TTGCAAACGACGCCTTCGGAGGCGACGTATTCGAAGAGGGCAGGAAGAAGTACGCGAAAATAGATGTTTA +AAAGGATAAGGGAAATAAAGGAAAAGGAACAGGAAGAATTAGTAAGGAAAATATCGGAACTACTAGCGCT +CGAAAGAGAACTCGAAAGGAAACTTGAAGAACTCCTAAGAGAATACGACAGAAAAAGCCAGAGTGTAAAT +ACCTTGAACGAAATCTTCAAGTTAAAGGCCATAACTAGAAAAATAGAGGAAACCGTAGACTACTTGGAGG +AATTGAACGTCAAAAAAGAGGAGCTAAAAGAAAAGTATCTGGAGTTAAAAGGTGAGATAAAGTCAATAGA +GATACTGGAGGAGAGGAAAAAGAGGGAAAAAATCAAAAAGGAAATAGCGGTAAGCCTTCAAGAACTTGGA +TTTATGCATCTCGTAAAGAAGATAATTCCCGTTTTTTTTATGTTTTTCTCCTTCCTCTTTTCTGAAAGTG +CCACACAAAAAGCATTAAAAGATAGCATTAACTTAAAAGAGGATTACAAGGTTCTCCTGAAGTTGATAGA +GGAAAAGCTAAAAAAACTGGAAGAGGAGAGGAAAAAGCTCGAAGCCCTGCAAAAAACACCCTTGACGGAG +GAGGAAAAGAAGAAACTGGAAAAGCTGATTAAATCCGTGGAGAAAGCCCCGGCGGACGAGATAGCTCCCG +CTATAGAAAACCTTCCGCCCAAGTTAGCGGCGGAGATACTTCTGAGGATTAAGGAGAGGAAAGCAGGTCA +GATACTCGCAAATATGAACCCTCAGAAGGCTTCAGAAATTATGAAGTACATACTTGAAAGAAATCCCAGC +TTCAACGCTCAGGTAGATTGAAGTACTTTAAGATAGCCCTGTAAATCGCGTAAGCGAACTTTTTCTGGAA +GTGTCTGCTCCTTAACTTTCTAGCTTCGTAAGGGTTCGTTATAAATCCGGCTTCTATTAAGACTGAGGGT +ATTCCAGGCGTCTTGAGGACTGCAAAGTTTGCCCTCTTTATCCCCTTAAAGCGGACGCTCCTTCTCATAG +TTCTCTTTATCTCCCTTGCTAGTATCTTTGCAAAGTCAACGCTGTCCTCCAAAGTTACCCTGAAAGCGAG +GTCTGAGATGATCAGCCTCAATTGTCTGTTCCTCGGATCTCCTCCCCTTATTATCTGCCCGGCGTAACTC +AGGTCACTCAGGAGCTTGCTCTTCTTCTGTTTTGCACCTCTGTAAGAAAGGGCGAATATCTGAGTGCCCC +TCGCGTAGGGTCTTCTCTTAGGTGCCGCGTCCGCGTGAATGCTTACAAAGAGGTGTGCCCTGTTCCTTAT +AGCTATCTGTGCCCTTTTCTCTAAAGGAACGAAGTAATCCCCCTTCCTCGTCATAATTACTCTAAACCTT +CCGTCCCTTTTGAGGTAGTAAGCGAGATACTTCGCTATTTGAAAGTTTACCCACTTCTCTTTTATTCCCC +TCCAGCCTATGGCTCCGGGATCCTTCCCGCCGTGTCCCGCATCCACGACAACCGTAAACTTTCTCGGCTT +TACTCTTATCCTTTTTTCCTTTATAAGATCAACAACGAGTCTGTCTGGATTCTTCAAGGTAAAGGCCCTT +ACTGAGTACTGTTTTTCCGGTTTTAAAACCACCCTCCTTCCCCACGGGTGCTTACCGAGTTTGTAAGAAA +TGCCCTTCGGCAGGCGAACTCTCTTTATCCTCACGTCCTTACCGAGAAGGTCTATTACTATCCTGTATGG +TCTCTTTAAGACGAATATCCTGTACTTCGTCTCCTTTGATAGGTCAAAAACTACCCTTACCTTGTCTTTA +TGAATTCCGTGCCTTATTTTGACGAGATTCAGAGGGAAGGTAAAGCTTACAAAAAGTAAAAACAGTAAGA +CCTTAAAACTGGTCGAACTCCTTAGGAGCACTGACTTCCTCCTCCACCTCTTCCTTCTTAGTAGCCCACG +GAGCCAAAGGAAACTTTATCATCACGGGGTTGGGAATGTCTGGCTGGTAGAGTATCATCGTCCCCTTCTT +TAGCATTATAGCCCTCTGTCTAAAGTTTCCGGTCAGGAACTCGTACTCTTTGCTGAGGACTTCACTGCTG +TCAAGCCTTCCCGTTACCTTTACCGCTGCGTTAGCTACTATCCTCTTCTCAATTTCACTTGCAGTTTGCT +GTGCTCCTATTAGTATAACTCCTAAACTCCTTCCTCTTTCCGCGATGTCGAGCAAGATTTCTTTTATGGG +ACTCCACTTGTCCTTAGGTGCGTATTTATTTAATTCGTCCAGAACGACGAAAATTTTAGGGTAGGGATTT +CCCGTCTCTTCTTTTTCTCTGAATATCTTCTTGAGTATTGAACCAACAACGAACATTTTGGCTATACCGT +GGAGATCCGATATGTCTATTACGTTGAGCTGGTGGGAGCGCCAATCTATGTGCCTGGATTTATTTCCGTG +AACGAGGTGCTTGCAGTGGGAAGCGGCGTGGTGAAACCTCCTCAAAAAGGCGTATGCGGTTGCGGTTGCA +GCCGTTCCGAACCACTCCCTGTAGCGGTCGGGATCTCTCTTCGTTTCCCTGTCTTCTATAACCTCGTGCA +GGAGCTTTAAAAGATCCCCGAGAGAGTTTATCTCCTGACCGTTTTCGTCAAGTAGCACGTCTCCCGGGCT +TTCCTTTGCAAGTTGCTGGAGTTTTTCTGAAACCCTGTCTATTACGTAGTGGAGTGAAGTCGCCCCTTCG +TCTCCTTCCGCAAAGAGAAACCTCAGTAATCCTTCCTGTGCAAAGTCCTTCATGGACCACTTGTAGGGAA +ATACCCCTTCCAGTCTCTCCCCCGAGGATGGGATCTCGCTCCACTCCTGTTCGGGAGGTGCCCAGAATGC +AACGTTCTTGAAAGGTTCTGGCGGAAGACCCAGTTTTTCAAAAGCCTCTCTGTGTTCCTTAGTAAACCTC +TTGTTCTTCTTGTCTATCCACAAAAGATCTTTTCCTTTTACGTTGAATATTATCCCGTGAATCTTTGTCC +TGTCGTCCGCCTTCTGGAATATAGAGTATAGAAGGAATAGGGCGTAAGAAGTTTTTGTAGCAACTCCGGA +CATACCAGAAATTGATATGTGAGCCCCTTCCCTTCCGTTTATAAAGTCGTAATTGAGGTAAACAACCTCT +CCGTTTCTCGTAAGCCCTGCGGGAATCTTCCTTTTCATATTGTCGTAGTAGAGGGCTTTTTCAAAGTCTA +TTCCCTCGGCTTTAAAGACGTAATCACCGGGTGTAGGAGGTATGAACACTTCTGGTTCTATACGGGTGAC +GGAAACCCTAGCCATGTAAGCCAAGTTTGCAGGAACGACCCCGCTATTTACAAGCTGGGCGTCATATACA +AGTTCAACACCTTCCAGGTACTTTATAACTTCCTGAACGATCCCGTAGAACTTTATCTCCTCATTAGTTC +CGTCTATTTTTGAATTAACTACTACGACGTCGTCAAGTTGAAGGAATTTTCCCTTTTCTACCCCTACCCA +GAACTCAAGGGGGTTTGAAGGCTTTGTTCCTAAAACTATTCCCACTTTCATGTTTTGCCCCTCTTTCAGA +TAAACTTACTCCTAAAGAGGATTTTAACACCTAATTCAGTATTATTTTTGTGTTTAAAACTTTATTTTCC +TCCCCGTCGGGTGGTGCCCAATGCGCATCCGGAGGCGTTTTTTCCACGGGAGACCACGGGTGTCCTTTCG +GGATTATTATTTCCGAATCTTTTACAGTGTTAAACCTTGAATAACCGCCGTGGAAGTTTACATCAACGAA +AAAAGTGCAGTTTTTCACCACATTTCTCGAAGAAGCCCACTGAATTACAAAGTGCCTCACACCTTTTACG +TAACACTTTACAAACACTATTCTGTGGGACTTGTAAATCCTGACGTATCCGTTTCCCCCTTTCCCTTTAT +TCCAGCTCCCGAAAGCTTTAAAGTTTTTAACTTTAACACCGTAGCTGTTTTCAAGGCTAAGAGGATGACT +ACCTGCCATAAGCACCTTTACGTTTATAAGGGAACTCTCCGATACCCACCTGAGCCTAATTCCATCAACT +TTATACCCGGGAAACAAATTCTCGTAAACGTACTCAACTTCGCGCGGGTCGTGGTCAGGGACTTCCTGAT +AAAGTGTCAGGTTTTCTATCCTGACGTTCTTTACAAACTCAGGAGCGTAAACCACGCTGTTAGGAGGGTA +ATCTATCTCCACGGGTTCTGACAGAATAATCCTATTTCTGCGAACTTCCTCAACTCTGTAAATTCCCTGT +CTCAAAAAAGGCTTTTCCTTTTTCCAGACCCTTGAGCCTATACTCTTCAAAAACTCCTCCGTATTAGGAG +CACCTATCCAGACGTAATTGAGTTTTCCTTTTACTTCTCTGTCCAGAAGTAATTCACTTTCACCTTTTCT +CACACCCTTTAACGTATAACCTAGCTTTTTTCCTTTACTCCCGGAAACCTCTATAACGCTTTTGTCTTCG +CCCTTTATCTTTGAAATTATCAGAACCTTTCCTTTTCCTTTCAGCGTGATATTTGAAGTATTTATCTTTA +CGGGTCTGTAAACGCAGTAAGTTCCCTGTTCTATGTAAATTTCATTTACTCCGCGTTTTAGTGCCATTTC +AATTTTACTTTCCAGTCCTTCCTTGCAATCTTTTATTTCTGCAGAAAAGGCAAGTCCGGGCAAGGGCAGC +GGACCGAACCTCGGGAGCTTGAAAACACCCACGTACAGCCCTACGAAGTATACGTAAAGAGTTATGTAAA +GAACTATTAATCCGTACCTCAGCATAGTCCTGAGAGTTTTGAAACTGTGAATTTTTGCCTGTATTTCCTG +TTTTGCGTGTTTAGCCCAACTCTGTTTTGCTAAGTTTGATGAAGCGTAAATCTTCACTACTGAACCTACC +CACTTGTCGTAAACTTGGAGAAGTAGGTGTAGTATGTGAGGTGTGAGGCGTGAAATAAAAAACAACCACG +TCAATTGAAGCGTTCTTATCCATATTACCCATACCGCGTAAAAGACCCAGTAAAAGGGAGATATAAAGAG +GGAGAGAAGGGTTGCACCTGTGGGCCCAACTAAACTCGTCCACATGGAAATCCTTTGATCCACTATAGCC +CACCATATGAACCAGCTTCCTATTTTCTTCGGACCTAGCTTAATAGCCCTCCAGTTATTCCTGAGCATAT +TCCCGTACCACCTGAACATGAGGGATATAGAAATCTTAAAGAAGTTTCCGCTCCTTTCCTCCACAGACCA +TGTGAGTGCGTCCGGAGCATAAAGCATATCCCAGCCGTTTTTCAGAAGGTAAAACCACGTACTTTTGTCG +TCTCCCATCAAGAACCTGAACTTACCGAACAGGTAATGCTCAAGTTTATCTGCTTCAACAAACCTTATGA +ATTCTTCATTCAATACTACATGAGCCCTGAATACGGAAAACCTCCCTGTTAAAGTCAGAACTTTCCTGTA +AAGGCTGTGGGACATCATCATCATGTGTCTTCTTGCGAACTTTAACCTGTACCAGAGCAGTAAGAGGAAG +TTCTTTCCGATGTAGTGAACCTCTTCATCGGTCGTTACCGCCGCTATTTTCGGAGAAAGTTTAAAGAGCG +GAAGCGTTTTTTTGAGGACGTCCTTTCCCAAAACAGTATCCCCGTCCATGAACACTATAAGGTCATCCTT +GTAATCCCTGTGGAAGTAAAGAGGGTGCGTAAAGTGTCTGGAAATGGCACGGAGGGTGTGTCCCATAGCT +ACCCTTTTACCGAGCTCCTGATACAGAAATATGAGCTTTATCTTTTCCTTGTAGTCGTAAGCTCTAACTA +CCTGCTCAATGAAGTCCGCTTCCTTTTTAGACCCAACTGCTACGAATACGTAAACCTCAGATGGAATTTT +GTAGCATTCCTGAACAAGGGACATGAAAACGATTTCCGAAACCCTTGGACTCTCTTTATAGGAGGGAATC +ATGAAGTATAGCCTTCTGGGATAGGGATTTTTAACCTTCTTTAATATTCTCCTGTACTTGGGATACACGT +AGAAGTTGTATATAAGGGCGTTTAGAGCGTTAATTGCAAACCACGTGTACCTCCATACACCTATCGCTGC +TATGGCTAAAAAACCGTGAAACTTCAGGTCCCACGCTCTTCCCGGAAGTAAGGCGAGTATTATGAAGGAA +ATCCCAAGCCAGAAGAACAGAAATAAAAGAAATTGGGGCCAAGATTTTGGAAAATCTTCTCTGGAGGAAT +AAGCGAGATTTGGTTTCATCAGAAGAACCTCTTTATATATCTGATAATATAGGGCTCGTAATGCTTCGGT +GTTATCTCCACCTCCGCTTTTATCCCGTGGTGTAGCTCCTGAGGATACTCGAAAAGTTCTATCTTCACGG +GAACGTCCGGAAGGGCGTACTCTTCACTTTCCGATATCATACTCTCGTCTCCCAGAGCCTTCTTACCTAT +GGCAATTACTTTGCCTTCCACGGTCTTTTCTATACTCGGGAAGTAGACACGAGCTTTATCCCCTACGTTT +ATGTAAAGTACATCCCTCTTTTTAAACCTCGCAATTACGTAGCCCTTTTTCTCTAAACTCTCTATCACCA +TAACGGGCATACCCGGTGTGAGAATCTGTCCTTCCAAGTAGTAAACCGAAAGCACTATCCCGTCAAAGGG +AGCCCTGTAAATCTCAAAGTTGTCCTCTTCATCCCCTCCTCCGCCACCCGCGTAAAAGCTGCCCAGCTCC +TTAAGGAGTGTGTATAAGAAAGCCAGATACCTCTCGTCGGCACTCTTTTCTTTTTCCAACTCCCTTAAGG +ACAGGAGAAGCTCTTTATACTCATTTTCTTTATCTTCGTACACACTCCTGCTTATGTACCCGAGCTCAAA +GGCGCTTTTTGCTTTTTCAAGTTCTACTTTTAAACTTCTTAGGCGGAATCTAGTGGCTTTTATCCTTTCA +TCAAGCAGGGCTATCTTATTCTTAGTCTTCTCAATTTCCCTTAGTATGGCAGCCCTGTCTCTCAGTATCC +TAACACCAACACCCCCGTATCCGTCCTTTTCATCCTCTATCCTTGAGGTCTTAAAAAGTACTTGATTTTT +CCTTACTTCGTCCCCTTCCTTCACGTAAACCTTTTCGAGGATTGCCTCCCAAGGCGTGATTAGAGAAACT +ACGTTTCCCGAATAAAACGCATCAACACTGTAAGCTTTCGGCGTAGCCCAGAATACGAGGTAAAGCCCGA +AAGCAAGGGCTAAGGCTATTAAAAGGTATACAAGTATCGCTATAAATAACTTCCTGTTTAGCCTTCTTTC +CTCTTCTTCCGTTAAAGGTTCCTCTATAGGCGGTGGGACCATAAGGCGTTCAGCGGTACTCAGGAATTCA +CCGAATTCTTCCAACCTCCCCTCTATGTAAGCCTGTACATACTTCTTTAAAATCTCTTTGGCTTCATCGG +GCAGTTCCTTAAACTCAAAACCAGCCTGATCTTCACTGCTCCACTTGTTTATAGCTTCAGCATTTATGGC +AACGTTGAAACTTGCAAAGGGAAGTATGAACTTTACTTTGTAAACTTTGTCTTTTTCAAATACATCCTCC +TTACTTTTCTCTATCCTGAAACCTTCGTAGGACCAGTCGAGGACTTTGTACTCCTTTCCGTCAATTGAGA +CTTTTGCAGGTATTTTTAATCTGTAAGTTTTTCGGAGGTGGGCGTCCTCAAATTCAGCCATCCAAAATCC +TCCTTATTATTTCTTCTTCTTTTATGTCCATAAAGTAGATTAACTTCTGTATATAGACGTAGTTTATGTA +CTTGAGGTAAATTAATTGTTCAAGCCTGTGGTATGTATCGAGTAAGTTCCTGAGTATAAGCGTGTAATTT +GCCTCTCTCAAGCCGTTTTTCCAGAAGTAAATTTCCCTTTCTATCTCTAAAAAATTCACGTTTATCTGCT +CAAGATGGTTAACTATATTTGAATAATTCCTGTTTATTCTTGAAATATAATCGAAAAGGAAGGAATAAGT +CGTGGCATACGAAAGACGAGCACGCTCTTTAAAGGAAAGAATTTCTAGTTTATCAACCTTACCCAGGTCC +GTAATTATATAAGGAATAGGCAGTTCAAACCTGAGTCCTAATGCCCAGAAATCTCTGGTGTTTCCGTCCT +TTCCAGCGAAGTAGTACCTTGCAAATACATCAAGGTCCGTGTGTCTGAGGTAAAACCACTTATCCGTGGT +CTTTATTTCAAACTTTTTCAGATACTCCTCCACATCCTTTTTCCTTTTTTCGTAGTACTTCATAAATTCC +TCTACGTTTATCTTCATTGGCTTTAAAAAGAAGCCGTTACTTACACTCTCTATTCCCTCTAATTCCTCCT +TTTTTATCAGTTCTCTGTAAGGAAATCCCAAACTTTTATCGTAGCTTTCCGTAAATTTCACCCAGTCCTT +TAATAAACTTAAGGTTTTATTCTTTTCACTTTCTACAACTCCCAGTTCGTACTTCAGTCCTTTTAAAAAT +ACCTCTTCCTGACTCTGAAAAGCCAGTAAGTAGGTGTACTCCTTTTGTATGTCAAATTCGGAAAATAGTT +TTGCAAACTTTGCTCTTTCCTTTTCGTACTTAAAGTCTGCAAATCCCCTCCTGAAGAAGGAAAGTTTAAG +TCCCAAATAACTGTACCACTTGTCCCCCAGGAGATTTTCCCCCGTTAAAGCCTTTCCCCTGTACCTGAAC +TCTCCGTTTATATACAGAGGAAAGGCTCTCTTGTAACTCTTTTCTTTCTGTTTGTACATCTCTACAACGG +TGCTCTCTAACTTTTCAAAGGGCTTAACTTTTGTGGTGTTCCCTCTTGCAATAATTTCAGTTAATTTCTT +CAGCTCCTCTATATTCTTTTCAAGAAGCATTAAGAAGTTTTCCTTTGTAGTTTTACTTTCTTCAATTTCC +TGTTGCTCGAGGGTTATCACCTTTTCAGGCTTGGGAAATACAACCCTACTTAGGTCATATTCGCACACTC +TTACAAAAGCATCTCTATATTTCTCCTTTATTTCGGGCAAAATTTTTAAAACGTCACTCTTATTTAAGTA +AAACCCTATTCTGAGGGTGTAAAATCCACCTATTTTTTCAATTCTTACGTTGTCCATGTTTTTAAATTTT +TCAAACAAAGGTATTAGATCTTCTAATTTTTCGGAAGAAGCTACTTGAACGCAGTAGTAATTTTCTGATC +TTGCAACGGATATGGTTATTAACAAAAGTAATAGAGAAAGAAGCACCCTTTTTCTCATAACCCCCACCTG +ATTGTATTAATCTTAATACTATGCTCAAGGTAAAAAAAGAAGTCCTTGAGAAAATGATAAAGCAGGCGGA +AAGGGATTACCCTTACGAGACGTGCGGGTTGCTGATAGGAAAGTCAGAAGGAGGTATAAGGATAGCTTAC +GAGGCTTTTGAAACCCCTAATGCGAACCCCGATAGAAAACACGACAGGTACGAAATAGCTCCAAAGGACT +ACATGAGGGCGGAAGATTACGCAATTTCAAAAGGTATGGAAATAGTAGGTGTTTATCACTCTCATCCGGA +CCACCCCGACAGACCTTCTCAGTTTGATCTGCAAAGGGCATTTCCCGACCTGTCCTACATAATTTTCTCA +GTCCAGAAGGGAAAAGTAGCCTCTTACAGGAGCTGGGAACTGAAAGGTGATAAGTTCGAGGAAGAAGAGG +TAGAGGTTTTCGAGTAATGGGACTGAAGGAAACGATAAAAGCCCTGGAAAGCATAGGGATAACGGAAATA +TACTTAAACAGGAAAATGGAAGAAAAGAAAGAGGATAAGTTTATCCTTCTAAAAAACCTCTACGAAGAGT +GGAAAGACTGCACGAGGTGTGACCTTCACAAGAGCAGAACAAGAGTAGTTCCCGGAGACGGGAATCCTTA +CAGTCTTCTAGTCTTTGTGGGAGAGGCACCTGGTGAGGAAGAAGACAGACAGGGAAAACCTTTTGTAGGG +AGAGCCGGGCAACTTTTGAATAGACTCATAGAGGAAGTTCTTGGAATGAAAAGGGAAGATGTTTACATAA +CGAATGTGTGCAAGTGCAGACCTCCCCAAAACAGAAAGCCAACGCCTATAGAAATGAGGGCATGTTTCCC +TTACTTAAAAAAGGAAATTGAAATAATACAGCCTAAAGTTATTTGCTGTCTCGGAGCTACAGCAGGTGAA +GGAATTCTAGGAAAGAGCTTAAGAATTACTAAAGTGAGAGGGCAGGTATTCCCTTATCCATACAATCCGA +GGATAAAAGTCTTCTTAACTTACCACCCTGCCTACGTCCTTAGAAATCCGAAGGAAGAAACCACGATAAT +AAAGGACTTTGAAAAACTCAAAGAACTCCTCACTCAAGAATAGTTATTACCGAGTTCTTCTTCAGTTCCT +TTAATAACTTTTCATACTCCTCCTGGAATTTTTTGGCGAGGATTTTCCTCTTGAGTTCCTCCTCGTTTAC +TCCTGAAACTTCCGTTAAAATTTTTCCCACTTTAACCACGTATATCTGATCTTTATCCTCAGCAAATATT +ACATCACCTTCCTTCGATTTCCAGACCTGTTCATCAAGCTCCTTAATAAGGTCTCCCTTTTCCACTTCCA +GAGATTGGTACTCACCACCGAGCTTTTCAGCGAGTTCCTTTAAGTTAAGATTTCCGCTTTCTATCTCTCT +TAACAGCTCCTTTCCCTTGTCCTTCAGGATTGTTACAAGTTCTATCCTCTTCTTAGTCTTTACTTTTCCC +TCCTTGAGCTTTGCAAGTTCGAGTTCTATTTCCGAAAGCTCCACTTTTCTCCTCAAGTACTCCCTCAGCC +CCTCTGTTGCTATGAGTTCTTTCTTTACGAATTCCCTGAAGTCCTGCAGGGTCAAACCATACTTCGAAAG +TTCCCGGGCTAGTTCCTGAGGCGTCATACCGTTTGCCTTCGCTATCTGCTGTACTATTTCGTCAACCTTT +TCGTCTGGAATGTCTATTCCCTTCTGTACCAAGAACTGATAAATCAGGTTTATTTCTATTAGTCGGTTCA +GGAGTTCTTTTCTATCCTTAACCCCGTAATAAAGCTCTGCCATCTTGAGATCACTTTCAAGAATAGGTTC +CCTGTTAACCGAAGCTACAACCTTGTCTATTAACTTTCCGAAAGAAAAAGCGAGAAATAAAAGTATTACA +AGTTTTCCCAGTAGACCTTACTTGGTACTTTTTCAGAACCTCTGAAAGCCATTTCTTAAAAACCTCCTTA +CGTTTTTCCTTTAAGTACATCTTTTTCACCAAACTTTTTGCCCTTTCAAAGGGAATAAACCCCGCAGGCT +TCTTGTCCAGTATTTTAAAAACCAAGTAACCGTCGTTTATCTTTATAGGTTTTGAGACCTCTCCTACACT +TAAGGTTCTGAAGTTCCTCCTTATATACTTTGGAAGTGTAGGTATAGAATACCACAGCGGTTTAGAAACC +TTAACATCCTCCGTAGAGGGAACCTCACCCTGTTTTAAAATTTGGGAAATTCTTTCAGCTTCTTTTTTAC +TTTTCACATAAATTCCGAGCAGTTTTACACTTGATGGTCTGTAAAACTCCCTTTTGTAAAACTCATAGTA +TGCCCTCAGAATATCTTCACTGGGATTTAGTTCCTGCTCTTTCATAAGTTTATCCACCAGCTTTTCCACT +AAAATTTCGGCTTTCACCGCATTTATAACACTTTTTTCCTTTATTTTTCTACCCACATACTTTCTAATAA +AATCGTTAATTTCCTTTTCAGACACTTCAATTCCCATTTTTTTTGCCTCTTTTAGTATCAAGAGATCTGC +AACGTAATCTATGAGGAAAATTCTCTTGTCTTCCTGTGTAGGTTTTGCAGAGGACAGATGAGTTATCCTT +TTCCAGAAAACATGGAAGAGTGTATCCAGCTCTTCTTTAGTAACTTTATAACCGTCTACTTCCGCGACTA +TTTGGGAAAAGATAAATCCGATAAAAAACAAAATAACAAGAATAGGCTTTTTCATAAGGAAAATTTTACC +TCTTGACTAGGGGTAGGAGTGGATATAGAATAAGGAGATGTCACAGGTGATTAACCTGAAGAAAGGCAGC +TAAAAAGTCTTGACATTTTGTGAAAGATGTTTATAATTAAAATTTCGTGTCCGGGGCAATAACGCCCCAC +CTAGGCTCCTTGGCAACTGAATAGAGGGTGAGCCTCTCCTCCTTTAATCAGTGGGGTCCAGCATCAGGTG +ATCCCAATTTCTGGTTCCCCATAAATCGCTTGCGCCTATTTCCCTGAAGAGTTTGATCCTGGCTCAGCGC +GAACGCTGGCGGCGTGCCTAACACATGCAAGTCGTGCGCAGGGTCGGCCCCTTTTGGGGCCGGCCGCTGA +GCGGCAAACGGGTGAGTAACACGTGGGTAACCTACCCCCAGGAGGGGGATAACCCCGGGAAACCGGGGCT +AATACCCCATAATGCCACCCGCCACTAAGGCGCGGTGGCCAAAGGGGGCCTCTGGCCTTCGGCCACGCTC +CCGCCTGGGGATGGGCCCGCGGCCCATCAGGTAGTTGGTGGGGTAACGGCCCACCAAGCCTATGACGGGT +AGCCGGCCTGAGAGGGTGGCCGGCCACAGCGGGACTGAGACACGGCCCGCACCCCTACGGGGGGCAGCAG +TGGGGAATCGTGGGCAATGGGCGAAAGCCTGACCCCGCGACGCCGCGTGGGGGATGAAGCCCTGCGGGGT +GTAAACCCCTGTCGGGGGGGACGATGCGGACACGGGTTAATAGCCCGTGTCCGTGACGGTACCCCCAGAG +GAAGGGACGGCTAACTACGTGCCAGCAGCCGCGGTAATACGTAGGTCCCAAGCGTTGCGCGAAGTCACTG +GGCGTAAAGCGTCCGCAGCCGGTCGGGTAAGCGGGATGTCAAAGCCCACGGCTCAACCGTGGACCGGCAT +CCCGAACTGCCCGACTTGAGGCACGCCCGGGCAGGCGGAATTCCCGGGGTAGCGGTGAAATGCGTAGATC +TCGGGAGGAACACCGAAGGGGAAGCCAGCCTGCTGGGGCTGTCCTGACGGTCAGGGACGAAAGCCGGGGG +AGCAAACCGGATTAGATACCCGGGTAGTCCCGGCCGTAAACCATGGGCGCTAGGGCTTGTCCCTCTGGGG +CAGGCTCGCAGCTAACGCGTTAAGCGCCCCGCCTGGGGAGTACGGGCGCAAGCCTGAAACTCAAAGGAAT +TGGCGGGGGCCCGCACAACCGGTGGAGCGTCTGGTTCAATTCGATGCTAACCGAAGAACCTTACCCGGGC +TTGACATGCCGGGGAGACTCCGCGAAAGCGGAGTTGTGGAAGTCCCTAGGACTTTCCCCCGGCACAGGTG +GTGCATGGCCGTCGTCAGCTCGTGTCGTGAGATGTTGGGTTAAGTCCCGCAACGAGCGCAACCCCTGCCC +CCAGTTGCTACCCCGTTTGGGGAGCACTCTGGGGGGACCGCCGGCGATAAGCCGGAGGAAGGGGGGGATG +ACGTCAGGTCAGTATGCCCTTTATGCCCGGGGCCACACAGGCGCTACAGTGGCCGGGACAATGGGATGCG +ACCCCGTAAGGGGGAGCTAATCCCTAAACCCGGTCATGGTGCGGATTGGGGGCTGAAACTCGCCCCCATG +AAGCCGGAATCGGTAGTAACGGGGTATCAGCGATGTCCCCGTGAATACGTTCTCGGGCCTTGCACACACC +GCCCGTCACGCCACGGAAGTCGGTCCGGCCGGAAGTCCCCGAGCTAACCGGCTCCTTCGGGAGCCGGAGG +CAGGGGCCGATGGCCGGGCCGGCGACTGGGGCGAAGTCGTAACAAGGTAGCCGTAGGGGAACCTGCGGCT +GGATCACCTCCTTTATAACGGAGACAAAAGCTCCCCACAAAAGGGGAGCTCATCCCTGTCTAGTGCATAT +AAAAGGAGGAGAGGCTCACCCTCTACTCAGTTGCTCCCCTTGCAAAGCAGGGCCTCTAGCTCAGCTGGTT +AGAGCGTGCCCCTGATAAGGGCAAGGTCCCAGGTTCGAGTCCTGGGAGGCCCATATTAGGGGCACCTTCG +GGGGTGTAGCTCAGCTGGGAGAGCGCCTGCTTTGCAAGCAGGAGGTCGTGGGTTCGAGTCCCACCACCTC +CACTTGGCTCCTTGTCAACAGAATAAAGCCTGTACCTCCTCCCGCCGGTGTGCAAGTTAGTAAGGGCCCG +GGGTGGATGCCTCGGCTCCCGGAGCCGATGAAGGGCGTGCAAAGCTGCGATAAGCCGGGTGGAGGCGCAA +GAGCCGTTGAGGCCCGGATGCCCGAATGGGGAAACCCGGCAGGCGACAAGCCTGCCATCCCGCCTTCGGG +CGGGAAGGGAACCGGCCGAAGCAAAACCTTTTAGTAGGCCGAGGAAAGGAAATCAATTGAGACGCCCTGA +GTAGCGGCGAGCGAAAGGGGCTCAGCCCAAACCCTGTGGGTGCCATGGCGGCGGCCTTAGCCCACAGGGG +GTAGCGGGACGTGCCTGGAGGGGTCCGCCGGCCCCTCGGGGAGTTACAAAACCCCACCCTAGCCGAAGTC +CCCTGGAATGGGGCGCCATAGAGGGTGAAAGCCCCGTAGGCGAAAGGGTAGGGGTCTCCCTGAGGCACGC +TCCCAAGTACCGCGGCCCACGTGAAAGGTCGCGGGAATCCGGGGGGACCACCCTCCAAGGCTAAGTACTC +CCGGGAGACCGATAGCGCATAGTACCGTGAGGGAAAGGTGAAAAGAACCCCTGGCGGGGAGTGAAATAGA +ACCTGAAACCCCGGGTCCACAAGCCAGTGGAAGGGGTCCTATGGGCCCCGACTGCGTGCCTTTTGCAGAA +TGAGCCGGGGAGTTGTCCTCAGGGGCGAGGCTAAGCCGTCAGGCGAAGCCGTAGCGAAAGCGAGTCCGAA +TAGGGCGCCAAAGTCCCTGGGGGCAGACGCGAAGCCGGGCGATCTACCCTTGCCCTGGGTGAAGGCCGGG +TAACACCGGCTGGAGGCCCTAAGGGGTCGGTGCTGCAAAACCGTCCCGTGAGGTGAGGGTAGCGGTGAAA +AGCCAATCGCGCCCGGGGATAGCTCGTTCTCCCCGAAATGCATCGAAGTGCAGCGTCGCCCGTTCCTTCC +CGGAGGTAGAGCACTGCTGGGGCTAGGGCCCCGAAAGGGGTACCGAACCCCGGCAAACTCCGAATGCCGG +GAAAGGAAGGGCGGCAGTGAGTCCTCGGGGGATAAGCTCCGAGGACAAGAGGGAAACAGCCCAGACCGCC +GGCTAAGGCCCCAAAGTCCGGGCTAAGTGGTAAAGGAAGTCCCCGTCCTAAGACAGCCGGGAGGTTGGCT +TAGAGGCAGCCATCCTTTAAACAGTGCGTAACAGCTGACCGGTCGAGGGCGGGGGCGCCGAAAATTTAGC +GGGGCTTAAGCCCGGCGCCGAAGCCGCGGGTCACAGGAGTCTCCGGACTCCTGTGGCGGTAGGGGAGCGT +TCCCAGCGCGCTGAAGCCCAAGCCGTGAGGCAGGGTGGAGCGCTGGGAAGTGAGAATCCCGGCATGAGTA +GGAGCGAAGGCAGGTGAGAAACCTGCCCGCCGGAAGCCCAAGGGTTCGGCGGCAATGGAAATCAGCCGCC +GGTTAGCCGGGACCCTAAGGCGAGGCCGATGAGGCGTAGCCGATGGGAAGCGGGTCAACATTCCCGCGCC +AGCTCGGTGGAGCCGGTGTCGTGACGCAGGAGGCTAGGCCGGGCCCGCTATGGAATGCGGGTGCAAGGTA +GTAGGGGGACGGGATAGGCAAATCCGTCCCGTCATACCCCGAGAGCCGATGCCGTAAGCCGGCCGACGCC +ACACTGCCAAGAAACAACGGCGCCGGCTGTGAGGCCGAGCTGCCCGTACCGGAAACCGACACAGGTGGGC +TGGGTTAGGAGCCTAAGGCGTCGGGGGAACTCCCCTCAAGGAACTCGGCAAGTTGGCCCCGTACCTTCGG +AAGAAGGGGTGCCCGCTGGGGTGTAGGCCCACGCGGCCGAAGCCCTGGTGGGTCGCAGTGACAGGGCGGT +GCCGACTGTTTACCAAAAACACAGGACTACGCAAACCCGAAAGGGGATGTATGTGGTCTGAAGCCTGGCC +AGTGCCCGAAGGTGAAGGCCCCCGGTGATGAGCTGGGGGCTGAAGCCCGGGTAAACGCCGGCCGTAACTA +TGACGGTCCTAAGGTAGCGAAATTCCTTGCCGGGTAAGTTCCGGCCTGCATGAATGGCCCAACGAGTGCC +GCACTGTCTCGAGGGGAGTCCCGCCGAAATTGTAATGCCGGTCAAGATGCCGGCTACCCGCGGCAGGACG +GAAAGACCCCGTGAAGCTTCACTGCAGCCTGGCATTGGGCTCTGGCCTGTCCTGCGCAGGATAGGTGGGA +GCCTGGGAAGCCCCCGCTCCGGCGGGGGTGGAGGCGCCGGTGAGATACCACCCTGGACAGGCTGGGGTCC +TAACCCAGCGGGGTGAATCCCCCGCGGGGACAGTGCTAGGTGGGCAGTTTAGCTGGGGCGGCTGCCTCCT +AAAGAGTAACGGAGGCGCCCAAAGGTCCCCTCAGGCGGGTCGGAAATCCGCCGTAGAGTGCAAGGGCATA +AGGGGGCCTGACTGTGAGGCCGACGGGCCGAGCAGCCGCGAAAGCGGGGCCTAGTGACCCACCCGCTCCA +CGTGGGAGGGCGGGTGATCAGCGGATAAAAGCTACTCCGGGGATAACAGGCTAATCGCCCCCGAGAGCCC +ACATCGACGGGGCGGTTTGGTACCTCGATGTCGGCTCCCCCCATCCTGGGGCTGAAGCAGGTCCCAAGGG +TTGGGCTGTTCGCCCATTAAAGGGGGACGCGAGCTGGGTTCAGAACGTCGCGAGACAGTTCGGTCCCTAT +CCGCCGCGGGCGCAGGAGCCTTGAGGGGGTCCGTCCCTAGTACGAGAGGACCGGGACGGGGCAGGCACTG +GTGTACCGGTTGTCCCTGGACTGGGGCAGCGCCGGGTAGCCATCCTGCTACGGGATAAGCGCTGAAAGCA +TCTAAGCGCGAAGCCCACCCCAAGATAAGGGCTCCCTGAAGGGCCCCGGGAGACTACCGGGTTGATAGGC +CGCAGGTGGAAGCCCCGTGAGGGGTGAAGCCGAGCGGTACTAATCGCCCGTTCGACTTGCACGCCGGTGG +GAGGAGGTACAGGCTTTATTCTGTTGACGGATTGCCCCTGGTGGCCATAGCGGGGGGGAAACACCCGGTC +CCATTCCGAACCCGGCAGTTAAGCCCCCCAGCGCCGATGATACTGTGCCGGCAGCGGCACGGGAAAGTAG +GTCGCTGCCAGGGGCTTTTAATTTAATTTATTTAGAAAGGGCCCGTAGCTCAGTTGGATAGAGCAGGGGA +TTTCTAATCCCCAGGTCGGGGGTTCGAGTCCCTCCGGGCCCACCACTGGTTATTCAACTTTTATTAAAAC +TTCCTTTCCCTCAAATTCCAATCCTTCAATCAGTAATTTGTAATTCTTAAAATCCCTTAAATATTTTTTC +TTGGTGATTACGTAATCACCTTTCTTAAATTTATTTTCTTTTGTTATACACCTGTAAAGGTAAGCTACTA +TTGCCGAGTTTTCATGTTTGTAAAAGTACAGTTTTTGAGGTTCGCTGTTTTTCAAGAAGTCTACCGCCTT +AGGTGTAAACCTTTTCTGTTCGTAAATATAAACTCCAAACATCAGTATTAATAATAAGAAACTTCCAACT +ATGTAAGCATATTTTATGTACCTTTTTGTTAAGTAAAAACCAATAATAACGGATAGTGCCGGGTATGAAA +ATAAGATATAATGGTGAAGTTTATTTTTAGAAAGTGAGTAAAACACTAAAACCAAGAGAAACCATCCTGC +GAAAGGAAGAAGTCTTTTATCAAAATCTTTAAGAATTTTTAGAAAAACAGGTAAAAATAAAATAGATGAA +ACTAAAATCACTAAAGGATAAAAGTAAATGGGCATGTTGTGGATTTGATAGGTTCCTGTAAATCTGTAAA +TGTTTTCAAATATGAAAAACTTAAAGAAGAAATTGAAACCAAACTTGTAAATCATTAAAAAGTACCAAGA +AAATCCTATCAAAATAAAAAGCAGTACTCCCTTAAAATTCAAGAACTTTAAATCTCTCCTCCAGAGGAGA +TAAATTCCTATTGGTAGGATAACGCCTACAGGCCCTTTTGTTAAAAACGCTAAGGCCAAGGCTGTCCATC +CGAGAGTGAACCTATCTATTGAAAATAAGTAAACTCCTAAAGTGGAGAAAAATACGAGGGTAAATTCTGG +GACGTAAGCCCTTGACTCTATCCACGTGTGAATAAATAGAGGAAATGTAAGAGCGGAAAGTAAAGCTTTT +TCCCTTGAAACGTGTTTTAAAGTTATGAAATAAATAAGAAGCGTTGTGCCAAAAGCAGAAAGTCCGGAAA +TTAATCTGGCGGAGAATTCAGAAATGCCGAAAATTAAAAAGCTTAAACTTCCCAGCCAGTAAAGCATAGG +AGGCTTTTCAAATCTGTAGTTACAGTTATAGTATGGAACTATGAAATCACCGGTCCTTAACATGTGAAGT +GTGGCGTAAAAGTTTCTCCCTTCGTCAAGGGAAGTCAAGGATAAAATCCAGTTTCCGAAAATGAAGAATA +CAAAAGAAACGAGCGAAATAAGGAAAAGATCCTTTTTCATTTAGCCTTTTCTTTTTTTGGTTCTTCTTTA +ATCAATCCTCTAATAAACTCGATAAGTTCACCGTTTATATCTTCCCTTCTTAAAGCAAAGGATATAACCG +TTTTCAGATAATCTTTAGGATTTCCCGTGTCGTATACCGTGTTATTAACCTTGCAGGCGTATATCGCCTC +CTCCTCAAGTAAGAGTCTCATGGCGTCGGTTAACTGTATCTCTCCTCCTTTACCTGGCTTTGTAACCTTT +AGTTTTTCAAAAATGGTAGGTGTGAATATGTACCTTCCAACTATCGCAAGGTTGGAAGGAGCCTCTTCGG +GAGAGGGTTTTTCGACCAGATCTACAATTATATAAGTTTCTTCGTCCAATTTTTTTACTTTTGCTATACC +GTACTTTGAGACTTCTTCCTTTGGAACTTCCATCAATGCTACGATTGAGTTTCCGAACTTCCTGAACAAA +TGTATCATCTTTTTAAGTTCTTCCTCTTCGTTCTCCACGATTATGTCTCCTAAGGCAACAAAGAAGGGTT +CCTGTGATACGGCTGGTTCAGCCATGAGAACGGCATGTCCGAGTCCTAATTGCTCTTTTTGCCTTACGTA +AATCGGGTTAATAAGGCTCGAAATTTTTACAACTTCTCTCAGTAATTTCTCTTTTCCAGCTTTTTTTAAG +TGCTCTTCCAGCTCGTGGTTGTGGTCAAAGTGATCCTCTATCGCTTTCTTGTGTCTACCTGTGACGAAAA +TGATGTTTTCAATACCTATGTTGATAAAGGATTCGACTATGAACTGGATTATTGGTTTGTCAATTATGGG +GAGCATTTCCTTAGGCATTGCCTTTGTAGCAGGCAAAAACCTCGTTCCCCACCCCGCAACGGGAAGAACA +ACCTTTCTAATTTCTCTCATACACACCTCCCTTGGAATATTTTAAAGAAATAATACCGCAAATAATTCCA +ATCAGAGCTCCTACAAAAACGTCCAGAGGAAAGTGAACACCCGCGTAAATCCTCTCATACCCTATTAGGA +AAGCGTATAAGAAGAGTATTGCCTTTATATGGAGTTTTTCACCATGTGACAGTACAGTTGCTATCGTAAA +AGCCATAGCGGTGTCTCCTGAGGGAAAGGAACGCCAGTGTAAAGGAAAAAGTAAGTTTACATCCTCGAGT +AAAATTGCAGGTCTCGGCTGGTTGAAAAATGTTTTTAGAGAGATCACTAAAACTGTTTCCAAAATTATCG +CTAAAATCAAAGGCTTTACTTTTTCCTTTCTGAAAATAAAAAGAAAGATTAATAAAGGAAACAGTACATA +GCCCGAACCGAGGTAAGCAAAGTGAGTAAAGAAAACGTCCAGAAGTGGATGCCTCGCATTGTTTATCAAA +CGAAAAAGTTCAAGGTTTAGAGCAAAGTCTTCTATTACCATTTTAGGAATTCTTTAAAAATGTCTTCCTT +TTTCTTTAATTTGTTCAGGTAATTTATTACGTACTTTCCGAGAATGTCCGTTTCTACATTCAGAAGATCC +CCAACCTTTTTGAACTGCAGGTTTGTGCTTTTGTAGGTGTGGGGAATGATATTTATGAACACTTTGTTTT +CTTTTACGTAGTTTACGGTGAGGCTTATACCGTCTAAGGCAATTGAACCCTTTTCAACTACGTAGATGCT +CCACTCCTCCGGTATCTCAATTACGAGTTCGTAGTGTTCTCCTAAAAAGTTGAAGGATTTTACAGGAGCT +GTGAAGTCAACGTGTCCCTGGACTATATGGCCGCCGAGTCGCTCTCCTACCCTCAAAGCCCTCTCAAGGT +TTACGTAATCCCCCGTTTTTAATTTTCCTAGGTTTGTCCTTTTCAGCGTTTCGGGAGAAACGTCAAAGGT +TAAGGTAGAGCTTTTAATGTCCACGACGGTGAGGCAAGCTCCGTTTACTGAAACGCTGTCCCCTAACTTT +ACGTCCTCTAATTTAGTCTCAACGCTCAGTTTAGCCCCTTTAGAACTCAAGGTTAAGTTCTTTACCTTCC +CTAAGTCCTCTACTAATCCCGTGAACATCTTATATAGCCAGTCTCGTGTTTAGTTTGTAAGCTTCCCTGT +CTATTGGTTTGTATTCCTGAGCTTTTTCGAAGTCCTCTATGTAAAACTTGCCCTTTTCGTAGGCAACAAA +TCCTGAGCGTTCTCCTGCGATGAGACTCTCATAAGCCACAACTCCGAACTTTGTTCCCATTATCCTGTCA +AAGTGGGTTGGTATTCCTCCTCTCTGGATATGTCCCAGAACGGTTGAGCGTATCTCCCCGTACTTATCAC +CGATCTTTTCCAGAAGGAAGTCTTCCAGTTCCTTTGCACGGCAATATCCTTCTGCGAGGACTATTATGAA +GTGGAGTTTCCCCAGTTTCTTAGCCTTTTCTATCTCCTCGGGGATTTGTTCCCTCGGGAATCTCTCTTCG +GGAATGAGTATGAGTTCAGCACCCGTGGCGAGTCCAGCCTCAACTGCTATAAACCCTCTGTTTCTTCCCA +TAACCTCTACTATGAAAATCCTCTCGTGAGAGCTTGCGGTGTCCCTTATCTTGTCTATCGCGTCAACGGC +GTTCCTGAGGGCTGTGTCGTAGCCTATGCAGTACTCAGTTCCACCAACGTCGTTGTCTATGGTACAGGGA +ACGCCTATTACTGGAATTCCCGTTTCTTCCGCGGTGAGTTTTGCACCCGCAAGTGTTCCCTCACCCCCGA +GAATTATTAAAGCCTCTATACCCTGTTCATTTAGGTTTTTATAAGCCTTCTCCCTGTACTCGAGTTTTTT +GTATCTGGGGTCCCTTGAGGACAGGAGTATTGTTCCTCCCCTGTCCAGAATTCCCCCCACGTCTCTGGAG +GTGAGTTTAATAAAATCTCCTTCTATTAATCCTTTATAGCCTCTCTTTATGCCGATTACTTCGTGTCCTT +CCCTTTCGGCGCTCCTCACAACAGCCCTGATTACGGCATTCATACCGGGGGCGTCACCCCCGGCGGTAAG +AATTCCTATCCTCATACTTTTACACCTACCTCTTCCCTGAGTTCCTTTGCCATGTCAACCATGTTCCTGA +GTGCGGGTATCACTTCTTCCCACCTTCTCGTTTTGAGCCCGCAGTCCGGATTAACCCACAGGAGTTCTTT +AGGAAGTACCTTCATAGCTCTTAGCATTATAGCCTTCATCTCTTCCTTCGTAGGAATAGCGGGTGAGTGA +ATGTCGTAAACACCTATACCTATCTGTCTGTCCCATCCCTTGAACTTTTCAAAGACTTCTATTATTTCAC +CCTTGCTCCTTGACGCCTCTATGGATATGACGTCAAAGTCCATTTGGTATATGTACTCAATTATCTCGTT +AAACTCCGAGTAGCACATGTGGGTGTGTATCTGGGTCTCGGGTTTTGCCCTGGATGCGAGTCTGAAGGCT +TTCACTGCCCAATCAAAGTACTCGGGCCAATCTCTCTTCTTTAAGGGTGCTCCTTCCCTGAAGGCAGGTT +CGTCTATCTGTATGACTTTAATTCCTGCATTTTCAAGGTCCTTGACTTCATCCAGAAGCGCAAGGGCTAT +CTGGTAGGCTATTTCTCTCTTTGGAACGTCTTCACGGTAGTAGCTCCAGTTTAGGATTGTGACGGGACCG +GTCAGCATTCCCTTTACGGGTTTGTTTGTGAGCGATTGGGCGTAGGTTATCTCCTCAAGGGTCATAGGGG +CGGGTCTTGAAACGTCTCCGTATATTATAGGAGGTCTGTAAACTCTGGAGCCGTAGGAGAGAACCCACCC +GTGTTTTGTGGTAGCTATGCCGTCGAGCTTTATGGCGAAGTACTCAACCATGTCTGAACGTTCAAACTCT +CCGTGAACGAGGACGTCAAGCCCTATGTCTTCCTGAACCTCAATAGCGTACTTTATCTTTTGCTTAATGA +AGTTCTTGTACTCCTCTTCCGATATTTTCCCTGTTCTGTAAGCGGTTCTCATCTTCCTTACGTCTTCCGT +CTGTGGGAAAGAACCTATCGTGGTCGTGGGAAAAAGCGGGAGCTTGAGTATATCCCTCTGTATCTTGTCC +CTTTCCTTGTAAGGTAGTTCCCTCTGGAAGTCCTTTTCGCTGAGGCTTGCGAGTCTCCTCCTGACTTCCG +GATTTTGTGCAAAGACAGCGGTCATTACTTTTTCGGAGCTTTCTACTTCCCTTAATGCCTCTTCTTTTCC +TTCAAGGGCTTCTTTTATCAGTCTTATCTCTCTGAGTTTCTCCTTTGCGAAGGAGAGTCTTTCCTTTAGA +CCTTCGGGTAGTTCGTCTTCCGGTTCAACGGTCACCGGAAGGTGGTAAAGGGGACATGAATTTGAAACGA +CTAAGTTCGCTGAAACTTTGAGGAGCTCCTCAAGGAGTTTAACCTTCTCTCTTAAGTTAGCCCTCCAGGG +CTGTCTCCCGTTGATTATCCCAGCTATCAGTTCCTTATCTTCTGGAAAGCCCTTTTCCTTTATGTTCTTT +AAGTTTTCTTCGTTAGAAACGAGGTCAAAGTGAAGGGCTTTCACGGGGAGGTTTACGAATTTATCGTAAT +CAGAAACGCTGTCGTAGTAGGTGAGTATTCCGAGGTCCACTCCCACCTTTGAGAGTTCGGAGTATATCTC +GTTAAGAATTTCCCAGTCGTAGTCCTCTAAATCCGTAACGAGAGCAGGTTCTTCAAAGTGAACCCTGTTT +ACTCCTTCATTTTTTAGGCTTTCAAGGAGTTCTTTGTAAACCGGTAGAAGGGCTTTTGTGAACTTCTCCA +GTCTTTCTTTTGTGTCCAGTTTTTCGAGTATTATTACGGGGAGTCCTTCTTCTTCAACTCTTTTGGGAGC +TTTTGAGAGTTTTAGGAATGTAAAGAGTCCTATCACGTGGGGAACCGTGTTTATACCCTTTTCCTTGAAG +AATTTGTAATCCTCAAGGGGCCTGTTTATTAGAAGCTTAAAATTTTCTCCTTCAAGTTCCGGAACGAGGT +AGTGGTAGTTGGTGTTGAACCACTTTGTGAGCTCAAGGGCGTTTTTGCCCCTTGCCATCTCAAAGTATGT +GTCAAGTCCTCTGTATTCGCCAAAGCGGGAGGGAATAGCTCCGACCATTACGGTGGTGTCAAGCATGAAG +TCGTAGTAAGAGAGCTCGTTTGAGGGAATTATTTCAACGTTTTCCCTGTATAGGTTTGCCCTCCACAGGT +TTAGCTCTTCCATTCCCTTTATTAGTTCTTCTTGGGAGATTTTGCCCTTCCAGTAGTTTTCAAGAAGTCT +TTTAAACTCCCTTTTTTCACCGAGCTTAGGAAAACCAAAAGCGTAGGTTTTTACCATGGATTTCTCCTCC +TTTTAGAACTTCTTATTTTAAAATATCTTTTATGAAAAGGGACTTTGTAGACCTGTGGGATTTAAGTCCC +AAAGAGGCATGGGAGATAGTAAAAAAAACCCTGAAAGTTAAAAAGGGAGAAGAAGAACTTGGAAAACCGC +TTTCCGGGAAAACGATAGCCCTTCTCTTCACAAAGCCCTCAACGAGGACAAGGGTTTCCTTTGAAGTGGG +AATTTATCAGCTCGGCGGGAATTCCTTATTTTTTCAAGAGAAAGAGCTACAAGTTTCCAGGGGGGAGGAC +GTAAGAGATACCGCAAGAACACTGTCAAAATACGTTGACGGGGTGATAGTGAGAAATCACTCCCACACGT +GGTTGAAGGAGTTTGCAAATTTCGCGAGCGTTCCGGTTATAAACGCTTTGACCAACATGTCCCATCCCTG +TCAGATACTGAGTGATGTGTTCACACTTTACGAACACTACGGTGAGGAACTTAAAAACCTAAAGGTAGCC +TACGTGGGGGACGGGAACAACGTGTGCAATACCTTAATGGTCGGGGCGGGGATGTTCGGACTGAAACTCT +TCGTGGCAACCCCTGAAGGTTACGAGCCAAATTCCTATTACTACAAAAAAGCACTTGAGTTTTCAAAGGA +AAACGGCGGGAGCGTGGAACTAACTAACAACCCGGTGGAATCGGTAAAAGATGCGGATGTCGTTTACACG +GACGTTTGGGTAAGCATGGGAGAAGAAAACAAAAACATAGAAGCGTTTTTACCTTATCAGGTAAACGAAA +AACTCCTCTCTTTCGCAAAGAGTTCCGTCAAAGTAATGCACTGCCTCCCTGCAAAGAAAGGGCAGGAGAT +TACCGAAGAGGTTTTTGAGAAGAACGCTGACTTTATATTCACGCAGGCGGAAAACAGACTGCACACACAG +AAGACACTCATGGAGTTCCTATTCAGAGAACCTCAAGCTTAGCCTTCAGGGCTCCCGCCGACTTTATAGC +TTGGAGAACCTGGATTATTTCTCGCGGTGTTGCTCCTATAGAGTTCAGAGCGTCAACGAGTTCGGAAACA +GTAGTTCCCTTTATTTGAACGAGTCTCTTTTTCTCCTCCTTTACTTTTACTTCGGTTCTGGGAACGACCT +TTGTCTCTCCGGGAGAAAGGGGAGGGGGCTGGACGACTTCAGGCCTTTCCTTTATCTCCACAACTAATGA +CCCGACCGCTACGGCAACGGGTTCAATACTAACGTTCCCACCGAGGAGCACTATACCAGAGCGTCCGTCA +ATTACAACTTTGGCTACACTTGACGTGCTAACCTCTAAGTTCTCTACTTTTGCAAGAAAGTCCACGGGAC +TGTAACCCTCGGGAATTTTTACCCTGATTGTGGCACTGTCTACAGCCTTTGCTATGTTCTTTCCAAAAGC +CCTGTTTATTACGTCCTGGACGTTTTTTGCCGTGGTAAAGTCTGGTTCGTCAAGGTATATGTTTACCTCC +TTAAAGTCTGCTGAGAAGGGAAGATCCTTTTCCAGAATCGCACCGTTTGGGATTCTCCCTACGGTAGGCA +CGTTCTTTACCTGAGCGGCTCCCCTCCCTCTTGCCTCATATCCGCCCACTATTACCTGTCCCTGGGCTAT +GGCGTAAACCTTTCCGTCAGGCCCTCTCAAAGGTGTCATTAAAAGAGTTCCACCCTCAAGACTTTTGGCG +TCTCCGATGGAGGAGACCTCAACGTCAAATCTCATCCCCGCCTTTGCGTAGGGAGGAACTTTTGCGGTAA +CCATTACGGCGGCTACGTTTTTGACCGTTATCCTCCTTGGATCTACGGGAATGCCCATTCTCCTGAGCAT +GTTCGCAAGACTCTGAACGGTAAACTGGGTAGCTTTACCGTCCCCCGTGCCCTTAAGCCCTACAACCAGC +CCATAGCCTATGAGGTAGTTATACCTGTTTCCCTCTATAGTCGCTATGTCTTTTATTCTGGCTCCAAAGG +TGAGAGAAACCAATATTAAAAGGGAAACAATATAGCGAATATTTTTGCAAGCCATCCGGGTTCACCCCCT +CTTACGATATAGCCCCTGCCCTCAAAAAATATCTCCATGTCCGCTATCTTGTCGCTCGTTACAGTGTTAT +TAGAGTCTATGTCTTCGGGTCTCACTATTCCCCTCAGGAGGAATTCTCTCTTTACTCCGTTTACCTCTAT +GTACTTTTTCGCCTCCACGAGCATAGTTCCGTTCGGAAATACCTTAACCACCCTCCCAGCTAGAGTAGTT +GTAAGAACTCCAGACTGCTGGAACTTGCTCCCACCTTTAGATGCAAAGGAAGACTTTCCCCCCGCACCCA +AGTTCTTGAGCGTTGCGGGGTGCACTCCAAAGAAGGAAGATATAGCGTTAGAAAAGGAAGTGCTCCTTCC +CACGTTCGTGGATACACTCTCTATGGCGTTTATACTCTCAATCACCCTTATGTAAATTACGTCCCCAACT +TCTGAAGCCCTTACCGAGCCGTAGAGGTAGGCACTTTGCGGGCTTTTAAAAAGGCTTCCCCTTGTAGGCT +TTTCTTCCTTGTAGGTTTTGGGAAAGGAGTAAGTATACTTTTTCTTACTTTCCACTTTTGTGGAACAGGA +AATTATAAATATCAAGGCGAAAAACAGGTATAGCATAGCCCCTCACTAAAAATATAGCAATCTGAGTAAC +TTTTTGCTATAATGACAAAAGCATAATGGAAATAAAACTCCAGGGCAAGGTTTCCCTCGTAACGGGTTCC +ACAAGAGGAATAGGAAGGGCGATAGCGGAAAAACTCGCATCCGCGGGGAGCACCGTCATAATAACGGGTA +CTTCTGGAGAAAGGGCAAAGGCTGTTGCGGAGGAAATCGCAAACAAATACGGAGTGAAGGCTCACGGTGT +TGAGATGAACCTTTTATCAGAAGAAAGCATTAACAAGGCCTTTGAAGAAATTTACAACCTTGTAGACGGT +ATAGATATACTCGTCAACAACGCGGGAATAACGAGGGACAAGCTCTTTTTAAGGATGAGTCTTCTGGACT +GGGAAGAAGTTCTGAAGGTAAACTTAACGGGAACTTTTTTAGTCACACAGAACTCGCTGAGAAAGATGAT +AAAGCAGAGATGGGGAAGGATAGTTAATATTTCTTCCGTTGTAGGTTTTACGGGTAACGTTGGACAGGTA +AATTACTCCACCACAAAAGCTGGGCTGATAGGTTTTACCAAATCCCTTGCAAAGGAACTCGCTCCGAGGA +ACGTTCTTGTGAACGCGGTAGCTCCGGGATTTATAGAAACGGACATGACTGCGGTTTTATCCGAGGAAAT +TAAGCAGAAGTATAAGGAACAAATCCCCCTCGGGCGGTTCGGAAGTCCCGAGGAGGTTGCAAACGTGGTT +TTATTCCTTTGTTCTGAGCTTGCAAGTTATATAACGGGTGAAGTAATTCACGTAAACGGAGGAATGTTTT +AAAGGAGGTAAGGTATGAGTTTAGAAGAGAGGGTCAAGGAAATTATTGCGGAACAACTTGGAGTTGAGAA +GGAAAAGATAACTCCCGAGGCAAAATTCGTTGAGGACCTCGGGGCGGATTCTCTTGACGTCGTTGAACTC +ATAATGGCCTTTGAAGAGGAGTTCGGTATTGAGATCCCTGACGAGGACGCGGAAAAGATACAGACTGTCG +GGGATGTAATAAATTACCTTAAAGAAAAGGTAGGAGGATGAAGAGAAGAGTTGTTATCACCGGCATCGGG +GCGGTTACGCCCCTTGGAACAGGCGTAAAGAAGTTCTGGGAAAACCTTGTAAAGGGTGTAAGCGGTGTTG +ATTACATAAAGAGCTTTAACCCCGACGAATACGGAATACCCGTAAAGATAGCGGCGGAAGTAAAGGACTT +TAATCCAGAAGACTTTATGGATAAAAAAGAGGCGAGAAAAGCCTCCCGCTTTGTCCAGTTTGCAATAGCT +GCGGTAAAGGAAGCCCTTGAAGACAGCGGACTCCTTGAAAGTGAGTACGACCCTTACAGAGTAGGGGTAA +TTATAGGGACAGGAATTGGCGGTCTCAAGGATATAGAAGATCAGACTTTAATCCTTAAAGAAAAGGGAGC +GAGAAGGGTATCTCCCTTTTTCATACCCTACGGCATATCCAACATGGCTTCGGGGCTTGTGGCCATAAAG +TGGGGCTTTAAAGGTCCAAATTACTGCGTGACTTCCGCCTGTGCTACGGGAAACCACGCTATAGGAGACG +CCTTCAGACTCATTCAAAAGGGTGATATAGACATTGCTATAGCGGGAGGAACGGAAGCTGCGATAACCCC +CCTCGGTGTTGCGGGATTTGCATCCATGAAGGCACTCTCTACGAGGAACGACGAGCCCCAGAAAGCTTCA +AGACCCTTTGACAGGGACAGGGACGGCTTCGTAATGGGAGAAGGAGCAGGAATACTGATTTTGGAAGAAT +ACGAGAGGGCAAAGGCAAGGGGTGCGAAGATATACGCTGAACTCGTGGGCTACGGTGCAACCGACGACGC +TTACCACATAACTTCCCCCCACGAGTGCGGTGAGGGAGCTTACGAGTGCATGAGGTTAGCACTGGAAGAC +GCTGGAATTAAACCCGAAGAGGTGGATTACATAAACGCCCACGGAACATCAACACCGCTCAACGACAAAA +CAGAGACGATGGCGATAAAGCAGCTCTTCGGAGAACACGCATACAAACTTAAAATTTCTTCAAACAAGTC +CATGATAGGGCACCTGCTCGGAGCCGCAGCGGCTGTGGAAGCTGTAGCAACGATAAAAACCATAGAAACT +GGAGTGATACCTCCTACCATTAACCTGGAAAACCCCGATCCAGAGTGTGATCTGGACTACGTTCCAAACA +AAGCCGTGGAATACCCCGTAAGGGTTGCACTTTCTAACGCCTTTGGTTTTGGAGGAACTAACGCAACGCT +AGTGTTCAGAAAAATAGAAGAATGAGGGTAATACTCGCATCCACCTCTCCCCGTCGCTCTCAAATCCTTT +CACTTCTGGGTATTGAGTTTGAAGTAATTCCCGCAAAAGTAGAAGAGGAAGTTATTCCTGGAAAGCCCGT +ACTCACTGCGAGAAAACTCGCAAAAGAAAAAGCACTGAGCGTCTGGAGAGAAAACAGGGACGCTGTGGTG +ATAGGGGCGGATACTTTGGTCTTTCTGGGAAATGAAATAATCGGAAAACCTAAGGACGAAAAAGATGCGG +TTAACATACTGAAAAAGCTCTCGGGAAAGTGGCATTCGGTCGTTACGGCTCTCTGCGTTTACTCACCAGA +AAAGGTATTTTTAACTCACGACATAGCAAAGGTAAAGTTCAGGGAACTGAGCAAAGAGGAAATAATTTCT +TACGTGAAGAGCGGAGAGCCCATGGACAAGGCCGGGGCTTACGGAGTTCAGGGCTTTGGTGCGACGATAG +TGGAGAGGATTCACGGGAACTTCTATACGGTTATGGGACTTCCAATAGTTAAACTGTACAAAATCCTGAG +GGAACTCAATCTCCTTGCTGGTACTTTTTCTTAATAGCTTCTTCAAACCTCTTTGCGAACTTTTTGTAAA +TCCAGTTTGAGATAAGGATAATAACAATTAATAGGGGAAAACCAACGATAATTGCAATAATAAAGGCGTA +AATTTCCGCACCTATGAGTATGAGGATCTTTTTTATTGTTTCCCAGAGTTCCATAAAGTTTATTTTAATC +TCCGAGTTGCTGGGCAGTTGTGGAATCCCACCTCGCCACGTGGCTCTTTAGCCAAGGGACGAACTCCTCC +TTCAGAAACCTCACCACTTCCTCGGGGTTCTTTTCTTTTTTCCATTTGTCGTAAACTTCCTTAAAGCGTT +TTCTCATAGTGTCATGCTCCGCCTTGTGCATGGGGTAAGCGAAGAACTCAAACTCCCTCATAAGTTCCTC +TTCGGTGGTAAAATGATCCTCCAGATCCACGAGCAGTTCGTCCATGAGTTGATCCGCCTTTTCCACGTCT +TTCTTCATGAGAGTGTCGTAGAGTTGGTTCAGGAGTCTAATCTCCTCTTCGTGAACAGTATCCATGAACA +GGTTTCCGACTTTTTGAACTTTATTCGGCCTTATGAGCATAAATTAAAATGTAAGTAAAAATTCACATAC +GTCAAGTTGAAAGGAAAAGAAAGAGATTAAAACTTGAAGCCTCCGAAGGAAACCTCGGCATCTTCGGCAT +TTTTGGAATGGCAGGCATACCTCCCGCCTTCTGAAGTTTCCTCATCATCTTCTTCATTTCTTCATACCTC +TTCAGGAGCTTGTTCACGTCGGATACGGTAGTACCGCTACCTCTCGCTATCCTCTTCTTCCTACTCATGT +TTATGATCTTGGGATTTCTCCTCTCCTCAGGAGTCATGGAGTTTATGATTGCCTCTATCTTCTTGAACTG +CTTTTCGTCCACTTTCAGGTGTTTTAACTGGGGTGCAACTCCGGGTATCATGGAAAGGAGTTTGTCAAGG +GGACCCATCTGCTGAATCATCCTGAGCATTTCCCTGAGGTCTTCAAGGTCAAACTCTCCGGTCATTACTT +TGGTGGCCATAACCTGAGCTTTATCCTCGGTTATCACTTCCTGAGCTTTTTCAACGAGGCTTTGTATGTC +ACCAAGTCCCAGAATTCTCTGTGCAATTCTGTCGGGATAGAAGGGCTCTATGTCTTCTATCTTCTCACCT +ACACCTATGAACTTTATGGGAACTCCGAGAACTTCCTTAACCGAAAGGGCAAGTCCTCCCCTCGCGTCAC +CGTCCATCTTCGTGATAACTACTCCCGTAAGTCCGAGTCTTTCGTGGAAGGTTTTTGCGGTCTCTAGTGC +CGTTTGACCCTGCATGGCGTCAGCCACGTACAGGATTTCCGAGGGATTTGTAACTTCCTTAATCTCCTGG +AGCTCTTTCATCAACTCCTCGTCTACGTGAAGCCTTCCCGCGGTGTCAAGAAGCAGGTAATCCACACTTT +CTTCCTTTGCCCTTTTTACAGCCCTTCTTGCTATTTCTACCGCACCAAGTCCTTCCTCAAACTCGTAGTA +AGGCACTCCTACCCTTTCAGCGAGTCTCTGGAGCTGGAGCATTGCGGCGGGTCTCCTCAAGTCCGTGGAA +GAAACCGCAACCTTGTGTCCTCCCTTCTTCAGGAGGTTTGCTATCTTCCCTATGGTTGTGGTTTTACCCG +TACCCTGAAGTCCTACGAAGAGGACAGTTCCTTTCTTTAAATCTGCCTTCTCTCCTCCGAGGATGTCTAC +AAGTTCTTCGTAAACGGTCTTTATAACGAATTCAGCGGGACTTAAGTTTTTGGGTACTTCCTTCCCGACT +ACCTTTTCCCTTATCCTCTTTATGAAGTCCTTGGCAACCTGGTAATCAACGTCCGCCTCCAGAAGTGCTA +GTCTTATCTCCCTGAGTGTCTGGTTTATGTTCTTTTCGGTTATCTTCCTCGCGTTGGTGAGTTTTTCCAG +CGCGTGGCTGAACTTTTCCGTCAGCAGTTCCAGCATAAGAAATAAAATATCACTTCTAAAGAGAAAGTTT +TCAAGCTCACGATTTTACGTCCGAGCAGAAGAGTTTTCTCAGCAAAATCGTCGCATAACTGCCCGGAGGC +AACGTAAAAGAGAGTTTCAGACTGTTTTTTCTTTCTTCAATTACTTTTAGACCTTGAGGTTTGAAGAAGG +CTTTTCTCACACCGTCCGAAAAGAGTTTTATCCCTATCCTTTCCGCCATAAGCATTTTTGGAGTTATCCC +CTCGTCTTGCAGGACTTCCTTCATTACTATCTCGGCTTTTTTGTTCCGAGGTTTGTACTCCACACCCAGA +TAAGGTATTTCTAAATCTTTAATCTCTTCCCATATGACTTCGCTCATATCGTTGAAAAAAGCGAGTTCCC +ACTTGAGAAAGGGTGTTTTGCAGTACTTTAAGTACCTAACCACAAAGGTGTAGAGGTACCTGTTCCACAG +GTAACTCTGGTATGCAAAAACGAACATAAGCCTTATGTTTTTCGGCAGTACCATGAAGGCGTTTTTAAAA +CTCTCTCCCCTTCTCAGGGCTTTTACTACCTCGAGTTCCGGTTTTGCACCTTTTGGCATGAGGCTGAGGA +ATCTGTCCCAGTCCCTCCAAGCTTTTCTCAGAAGCCTCTTTAGTCTTTTATCCCCGAGGGAGGTGAGGTA +CTCCTTCATTGCTTCTTCGTACTCGTGCCTCAGGAGGTACTTGACTATAAACTCCTCCGCGTGTTTTACA +GAACCGAACCTCTGCTCACCGAAGTAGTTCTCACACCCATAGTTTTCAACGAGCTCCTTCATACGAGGAA +AGACTCTTCTGTGGTACTTCGTTACACCTCTCACCACCACCTCGAAGTAATTCCCTTCTATTTCCCCCAG +CTCAAGCCCTTTATCGGAAAAACCGAGGAACTTAAGCTCGAGGTTCTCAGTTCTGTAGCCGTCCATTTTA +CGAATTTTTTCTTCGTTTAAGTCTTTTACAGATATGTACTGCTCTGTTACAGCCTTTTTGTCTTTAAGTC +CGGCAAAACCAATGTTTTTTAAAGGTATTCCGAAGCGATGAGATATGTGCCTTACGGCATCGAGCGTTGT +CATGTCCTTCTTCTTCAGGAGAAAGTACGCGTACTGTCCCTTTTCTTTTAAGTCGAGTTTTTTGATTTCC +TTTACGTAGAATTCCTCGGGTTTTTCCTTTATCCTTATATCCATCACTAAGATTAAAATACCTTTTTTAT +GAAAATTCCCATTATTGGTCTGGAGTTTTCCGAAGAGGAGAAAAAAGCACTGACGGAAATCCTTGAGAGT +AAGCGCATAACGAGAGACGGATGGACGGATACCTTTCAGGAGGCGTTTGCCGAGTTTTTGAACGTTAAAT +ACTGTGCAACAGTCTGTTCTGGGACTGTGGCGCTCTTTATTGGTCTAAAAGCTCTCGGCATCAGGAACGG +AGAGAAGGTTGTAATACCCGCTATGAGCTTTATGGCTACTATTGACGCGGTTCTGCTCGCGGGGGGAATA +CCAGTAGTCGTTGACGTTGACGAGTACTACACTATGGACGTCAACCAGCTGGAAGACGCGGTAAAGAAGT +ACAGACCGAGGGTAGTAATTCCCGTTCACCTTTACGGTCAACCTGCGGACATGGAAAATATTATGTTTTT +AGCGGACAGGTACGGGTTTTTTGTATTAGAGGACTGCGCTCAGGCTCACGGTGCGGAGTTCAAGGGCAAA +AAAGTAGGAGCGTGGGGACACCTTTCTGCCTTCAGCTTTTACGCTTCAAAAAACGTGCCGATGGGAGAGG +GTGGAGCTTTAACAACAAACGACGAAAGCCTTTTTAAAGAAGTTAAGAAGTGGATAGACTTCGGAGAACA +CCCCGCTTTTAACGTGAAAATTACGGAATTTCAGGCAGCCATAGGAACGCTACAACTCCGAAAGTTAAAA +GAGAGAAACGAAAGGAGGAGGAACATAGCAAGGATTTACACGGAAAACCTAAAGGGCTTGTGTGAGGTTC +CGGAAGAAAGGGAAGGTGCTTACCACGTTTACCACCTGTATACTTTAAGACACAAAGAAAGGGATAGATT +GGTTGAGCACTTGAGAAGTAAGGGAATAGACGCGAGGGTTTATTACACTTACCTCCTTCACGAACTCAGG +AACGCGGAAGCTCTTCCCACCCCGAAGGCAGAAAGGTTCAAAAGAGAAGTTTTTTCAATACCAGTTCACC +CTTTCTTGAAGGAGGAAGAAGTTCTCTACATAATAGAGAGTTTGAAAGAGGTTCTGTAAAAAATATCTTT +AATTATCATGGAGCAAAAGAACGTAAGGAATTTCTGCATAATAGCACACGTTGACCACGGAAAGAGCACA +CTCGCGGACAGGCTCCTTGAATACACAGGAGCGATAAGCGAGAGGGAAAAGAGGGAACAGTTACTCGACA +CTTTGGACGTTGAGAGGGAGAGGGGTATCACCGTAAAGATGCAGGCGGTGAGAATGTTTTACAAGGCAAA +GGACGGAAATACTTACAAACTACATCTCATAGACACTCCGGGACACGTTGATTTTTCTTATGAGGTTTCC +AGGGCTCTCGCCGCATGTGAAGGAGCACTCCTTTTAATAGACGCCTCTCAGGGAATAGAGGCGCAGACGG +TTGCAAACTTCTGGAAGGCGGTTGAACAGGATTTGGTGATAATCCCCGTAATAAACAAGATAGACCTCCC +TTCCGCGGACGTAGACAGAGTAAAAAAACAAATAGAGGAGGTTCTCGGACTAGACCCCGAAGAGGCTATA +CTCGCCTCCGCAAAGGAAGGGATAGGTATAGAGGAAATCCTTGAGGCTATTGTGAACAGAATTCCGCCGC +CTAAAGGCGACCCCCAAAAACCCCTAAAGGCTCTGATATTTGACTCTTACTACGACCCTTACAGGGGAGC +GGTGGCCTTTGTTAGGATTTTCGACGGAGAGGTAAAGCCCGGCGACAAGATAATGCTGATGTCCACGGGA +AAGGAGTACGAAGTCACGGAAGTGGGTGCTCAAACACCTAAAATGACGAAGTTTGACAAGCTAAGTGCGG +GGGACGTAGGGTACATAGCCGCTTCCATAAAGGACGTCAGGGATATAAGAATAGGTGACACCATCACCCA +CGCTAAGAACCCGACGAAGGAACCTGTACCCGGATTTCAGCCTGCAAAGCCCATGGTTTACGCGGGAATT +TACCCCGCTGAAGATACAACTTACGAGGAACTCAGGGACGCCCTTGAAAAGTATGCGATTAACGACGCTG +CGATAGTTTACGAACCCGAAAGTTCTCCCGCCCTCGGAATGGGTTTCAGAGTAGGATTTCTGGGACTCCT +GCACATGGAAATAGTTCAGGAGAGACTTGAAAGAGAGTACGGAGTAAAAATCATAACGACGGCTCCCAAC +GTCATTTACAGGGTAAAGAAGAAGTTCACAGACGAAGTTATAGAGGTAAGAAACCCCATGGACTTTCCCG +ACAACGCTGGACTCATAGAGTACGTAGAAGAACCCTTCGTTCTCGTCACGATAATAACTCCCAAGGAATA +CGTGGGACCAATAATACAGCTATGTCAGGAAAAGAGGGGAATTCAGAAGAATATGACTTATCTGGACCCA +AACACCGTTTACCTTGAGTACGAGATGCCCCTATCCGAGATAATCGTTGACTTTCACGACAAGATAAAGT +CCATATCCAGAGGGTTTGCCTCCTACGACTACGAGTTTATAGGATACAGACCTTCGGACCTCATAAAACT +AACGGTTCTTATAAACAAAAAACCCGTGGACGCTCTTTCCTTCATAGTACACGCGGACAGGGCTCAGAAG +TTCGCAAGGAGAGTTGCGGAAAAGCTGAGAGAAACAATCCCGAGACAGCTCTTTGAGGTTCACATCCAGG +TGGCAAAGGGCGGAAAGGTAATAGCCTCGGAGAGGATAAAACCCCTCAGGGCAAACGTTACGGCAAAGTG +CTACGGCGGTGACGTCACGAGGAAGAAGAAACTCCTTGAAAACCAGAAGGAAGGTAAGAAGAGGATGAAA +CAGTTTGGAAAGGTCCAACTCCCCCAGGAAGCCTTCTTAAGTGTCCTTAAGGTTGAATAACTCCTTTGCC +TTTACCATTTTCGTTATAAACTCGTTTGTAGGCGTCGAAACACCATATTTTTTTCCAAGCTCTACTATGG +CTCCATTAAGGGCTTCTATCTCGGTTTTGCCCTTTTTTACGTCTTCAAGCATTGAAGGGTAGTGCTCCGC +AGTGGGAGGGATTAACTTCTCGTAAAAAACCTTCTTGTACTCATCGGCACTTTTCCAGAAACAGGGCAGT +TTAGCCTTTTCTATAACCTGAAAAATTTCATCTATAACCCTGTTCATTAACTCTTTCGTGTGAGGATTTT +CCGCAAGGCTTCCGTAGTTTACTTCAAAAAGCGCACCTAAGGGATTCAGAGCACTGTTGTATATTATCTT +GTCCACCAAGTACTTGTACACGTCTCTCTCGTACCTCGTTGGTATTCCCGCCTCCGTAAAAGTTCGGGCT +AAATTCTTTAGAAACTCTTCATCTATCTTTCCCGAAGGGTCTCCTATTACTACCTCGTCCGCACTCACGG +TTATCCTTATGTGTCCCGGTTTTATAACTTTTGAACCGAATATTATTCTGGAAAGTATTACCTTTCCCTC +GCCGTAAATTTCCACAGCTTTCTCGTAATTTCCGTATCCGTTCTGGGCAATCATTATGAAAGTATTTTCG +CCGACTACGGGCTTTACTTTTTTGAGTGCCTCCTCCGTGTCGTAAGACTTTACTGAGATTATAACTATAT +CGGGAATAAAAGGTACTTCCTCAACTTTTGTAAAAGTTTTTACTGGAATTTCAAACTCTCCCCATATGCC +CTCAACCTTTATCCTGTTTACCGGATTTCTCCTTACGAGTCCCGCCGCTTCGTGTCCCGCTCTCGTTAAA +AAGGCCAGATACGCGCTCCCTATTGCCCCTACGCCCACTATTAGGAACTTCATCACCATACGAAAACGTG +GTCCGCTTCCTGAATGAGCTTCTTCACTTCTTCGGAATTGATTATCTTAACGTTTTCCACCGCGAGGTTT +GACTTTGTTATTCCCCTCTCATGGAGGGACTCTTCTTCGGCAACAAGGGTAAGGTTTATAAACTCTACGG +TTTCCCAGAACTTCTCAAAACTTGCAATTCCGAGCTTTTCGGGTTCCCACTTGGTAAGCGTGTAAACGCC +GTCCCTGATGCAGATAAAGTAAGTCTCGTTACTTATCCCCATAGCTGTTGCAACTCTCAAGGCCTCATGG +GCTTTCCAAGAAAAAGGGTCTCCTTTGAGTATGAATACGATTTTCATGACTTTGCCTTCCCTTCAGGCTT +TTTAACTCCCGAAAGAAGGATATAACTAAGCCCGACTAGAAAGAGAAAGAGAATTATTACTGCTATTACA +AGGTCGTAGTTCATTCTGTAAACCTCCTGCCATATAAGTAAGATAGTATCACCGCAAGCACTGTGAACAT +AAAACCACTCATAAATAAAATCCAACTTTCCGATTTACTTTGGAGCACAAATCCAACAAAAGAAGATACA +TAGCTACCTATAGCAACACCTTTAGTTATGTCAACTAATGCTTTAAAACTTTCCTTTTTACCTTTGTTCA +TTTAACTTCAGTTAAAACATATCGTCTTATCAAAATCCTTCATCATCTGGGAAAGGGAGTAAGTGGAACT +GCTTTCCGCCCATTCGGGAAATTCCTTTACTCCCCTCTGGTGTGCCGCGTGTGAACAGAACATCACTCTA +GCTCCGAAATTTTTAAGCTCTTCCGCATCTGGTCTGAGAAGGTAGTAAACGCCGTTTCCGGAAAGAAAAA +TAGTGACCTCGTGCCCGCTCTCACAGAGGTATTTGGTTAAGTTCCTGATCGTGTTGTAGTCCTTTGCAAA +GGGAACGCTCGTTATGAATAGGAGTATTTTCATTTCACTTTCTTAATTATAATCTCCCAGAGGTTTTCAC +CTATCTGGTTCACCGCTATTACTTCCTGCCCCTCTTCCCTCATGCTTTTGGGAACGCTTTCCGCGGAAGG +GGGGTAATCCACGAGAACCCTCAGGATTTGTCCCGTTTCCATTTCTTCCAAGGCGAGTTTACTCTTCACG +AAGGTAAAGGGGCATACCTCACCCCTTATGTCAAGCTCTTTGTCAACCTTCACGTCCATAACTCTTAAAT +TTAAACCCCTTCGTTTAAAATAATCAATTATGAAAGTTCCCTACTCATGGCTCTCCGAATTCGTAGAACT +CAGCGACGTATCCCCCGAAGAGATAGCCGAAAAACTCTCACTTAGGAGCGTAGAGGCAACGGTTGAAACC +TTCGGGATAGACCTTGACGGTGTGGTTTTCGGAAAGGTGGTTGAGGTAAAGGAACATCCTACCAAAAAAA +AGCTTGCTGTGGTAAAGGTTCAGGTTCAGGAGCACATTTTTATAGACGTCGTTACCGTGGACAAAAGTGT +AAGGGAAGGAGATGGAGTAATTGTAGCCCTTCCAAACGCAAAAGTCGGGAATATGTGCGTTACCGAGAGG +GAGTTTGACGGGGTAGTTTCTAAAGGACTCCTTCTCTCCGCTCAGGAACTCGGACTTGAAGAGAAAAGCG +AAGGTGTTTTAAAAATTCACGAGGACTTCAAGCCCGGAACTGACGCAAATGAAATTCTGGGCTTTGGAGA +AAAAATAATAGAGATAGACATAACGCCAAACAGGGGGGATATGCTCTCGGTGAGGGGAGTGGCAAGGGAC +TTAAGCGCCATATTCAGGCTTCCCAAGAAAAAACCCGAAGAACCGACTTACGAAGAGACGGGGGAGTTCT +TCATAGAGATAGAAGACGAAGATTGCAAACGCTACAGGGGTGTCGTAATAGAAGGTGTTGAGATAAAGGA +ATCCCCGCTTTACATAAAGAAAAGACTCTGGCAGTGCGGTATAAAGAGCATTAACAACGTGGTTGACATA +ACGAATTACGTAATGCTGAGGGACGGACAGCCCTTACATGCCTTTGACCTCTCAAAAGTTGAAGGCGGGA +TAATTGTGAGGAGTGCTAAAAAAGGGGAGAAGATAATAACCCTTGACGGTGAAGAAAGGGAACTGGACGA +GGATATACTTGTAATAGCGGACAGGGAAAAGCCCCTCGCCGTTGCGGGAGTAATAGGAGGGCTTGAGAGC +GGTATTAAGGAAAACACGAAAGACATCCTACTTGAGAGTGCCTACTTCAACCCCTTCAGGGTGAGAAAAG +CCTCTAAGAAACTCGGAATTCAGACAGAAAGCTCTTACAGGTTTGAGAGGAACGTAGATATAGAAAGGGT +AGACAGGGCACAGGATTACGCGGTTTACCTGATACTCAAGCACGCGGGCGGAAAGGTCAAAGTAGTAAAG +GACGTGTACAGGGAAAAGTACAAGCCCAAAAAGGTGTTCCTACCTCAGGGAAAGTACATAAGGTATGCAG +GAGAATCATACAAAAACGAAGAAGTGAAGGAAATCTTAGACGCTTTGGAAATCCCGAACGAGATAATGAG +ATGCGGTGTAGAGGTTTTAGTTCCTTCTCACAGGAGCTTTGACATTCAGAGGGACGTGGACCTCATAGAG +GAAATAATGAGGGTAAAAGGCTACGAACACTACACTTCCGAAACACTCAAACTCCCCTCCATCGCAAACC +TGTGGAAGGATAACTTACTTGAAGTAAAAAAATACCTCAGGGACAAAGGACTAACGGAGGTCATCAACTT +TTCTTTTGAGGACTCAAAACTCTACGAACTCCTGAATCTTCCTCTTCCGGAACTCGAAGTCATAAACCCC +CTCAACCCCACCCAGAGGTACATGAGGAACACACTGATAACCTCACTCCTCAGAACAGCTGTTTACAACG +ACAGGAATTACAACTACGACCAGGCTGTATTTGAACTCGGAAAGGTCTTCTTCAAAGAGGGTGAAGAAAA +CAGGCTCGGAATACTCCTTAAAGGGAACAAGCCCAGAACCTTAAAAGAAGAAAAATGGGAGCCTTACGAC +CTTACGGAAATAATAGCGGGAATTTTTGCATTGTTTGGGCTCGAGCCTGAATTCAGGAATGCAAAAAGGA +ACTTCCTCCACCCTTACGTTCAGGGAGAGGTTTACCTTGAGGGTGAATTCGTAGGGTTCTTCGGAAAGCT +ACACCCCAAAATCGCAAAGGAACTGGAACTAAAAGGCGAGCCCTTTGTAGCGGAAATAGAAATAGAAAGG +GTTCTCTCCAAGAAGAGACTGCCCCACTACAGGGAAGTGGCCAAGTTCCCACCAGTTGTGAGGGATATCG +CCCTCGTAATGGACAAAGAGCTTGATGTGAATAAATTATTAATTGACACGAAATCGCAAATAGGTGAACT +ACTGGAAGAGGTAAGGGTTTTTGACGTTTACACGGGTGAAAAGGTAGGGGAAGGCAAGAAGAGCGTAGCT +GTAAGACTCGTTTTAAGGAGTAAGACGGGTAGTCTCAAAGACGAGGAAGCGAACGAATTGGTGAATAAAC +TTGTTAATTATCTGAAAGAGAAGTACGGAGTTGAGCTTAGAACTTAAGGTCTGCCCTGTTCGTGGTGCGG +GGGTTGTCAATGGGGCCTACACCGTGGGTGTAAGGGAAGTCGACTTCGGGAACTCCGGAAGGATTCCCGA +GGGACTTCCCACCTTAAAGCTCTGAGGCCCACGGCACTTCCTGCACTGCGGCAGGGCGGACACTCTTGCC +TTCCCCTCCTGTAAAAGCAGGAGGCGGAAGAATTGCTAAAAAGCGAATTAAGGAAAAAGGTTTTACATAA +ACGAATAAACTTATCTGAAGAAGAAAGGAGAAGGTTATCGGAAAAAGTAATAAGCAACCTGAAGAGTCTG +CCCGAATTCAAAAAATCAAAGAAAGTAGCCCTCTACTGCCCCATAAAAGGCGAAGTTGACCTGACCCCCC +TCTTTCCCGAAGTTCTCAAAGAAAAGGAGTTAATCCTACCGAAAGTAGAGGGAAACGAGATATCCCTCTA +CAGAGTTCACTCACCAGCGTGTCTCGGTGTTGGAGCTTTCGGAATAATGGAACCGGTTGAGGGAGAAAGA +GTAAATCCCGAAGATGTGGATTTCATAGCCGTTCCCGGTGTTGCCTTTGACCTGGAAGGTTACAGACTAG +GCTTTGGTAAGGGCTACTACGACAGACTTTTAAAAAGAGTAAAAGGCTTGAAGGTAGGCGTCGCCTACTC +TTTTCAGGTATTTGAGCGTCTGCCCAGAGACGCTTGGGACATTCCCGTTGACGTTCTCGTCACAGAAAAA +AACGTAAGGAGGTTGAGAGATGGACGTTCTTAGTATTCTTTTAATCCTTGTTGCAGTTGGAGTAGGCATT +TTTGTAGGAAGACAATTTTTGGGACAAAAACAAGCCCCTGCACCTACATATCAGCCAGTGCCCTCTCCTC +AAATACTGGAAGAAGCCAAAAGTAAGGCGGAAGAGATAATAAAAGAGGCTAAAGAAAAGGCAGAAGTAAT +ACTAAAAGAAGCTAAGGAAAGCGCGGAGAAGATAGTAAGGGAGGCGGAAGAAAAGGCGGAGAAACTCATA +AGGGAAGCTAAGGAAGAAGTTGAAAGGATAAAGGAGGAAGTAGAAAGGAGGAAGAAGGAATTAAAGGAGA +GAGAGGAAAATGTACTCGCAAAAGAAAGACACCTGGACAGGAGATGGGAAGCCCTTGAGAAGAGGGAAGA +GGAACTCCTCCACAGGGAAAGGGAACTTAAGGATTTTGAAAGAAGTCTGGAAAGGTGGAGAGACGAAATA +AGACACAAGGAAGAAGAGCTAAAACACATGAAAGAGGAAGTGGAAGAACTAAAGAAAAAAGAACTTGAAG +AACTCCAGAGGATAGCAAAGCTCACTTTAGAAGAGGCAAGGCAGGAGATAATAAAGAAGGTTGAAGAAGA +GGCGAAGAAGGACGCCGTAAAACTCATGAAAGTCATAGAAGAAGACGCAAAGAGGAGGGCGGAGTTTGAA +GCCAAGAAGATAATAGCGACCGCAACCCAGAGACTCGCTCCCCAGATAGCGGTAAACTACACCACGACCA +CCGTAGAACTCCCCAGCAACGAGTTCAAGGGAAGGATAATAGGTAGGGAAGGAAGGAACATAAGAACCTT +TGAAATACTCACAGGTGTTGACCTCATAATAGACGACACTCCGGACATCGTGACTATATCTTCCTTTGAC +CCCTTAAGGAGAGAAATAGCAAAAGAAGCCCTCCAGAGGCTCATAGCGGACGGGAGAATTCACCCAGCGA +GGATTGAAGAAGTAGTTGATGAAGTAAAGAGGGAGTTTGACGAAAAGATAAGAAAAATTGGTGAAGAGAC +CGTTTACGAGCTTGACCTTCACGACATAAACCCCGGACTCTACTACTACATAGGAAAGCTCTACTTCAGA +ACAAGCTATTCCCAGAACGTCCTCTTACACTCCAAGGAAGTTGCCTATATAGCGGGACTAATGGCAGAAG +AGCTCGGACTTGACGCAAAGCTCGCAAGGAGAGCGGGACTCCTTCACGACATAGGAAAGGCTATTTCTCA +CGAACTCGGAGGTTCTCACACGGACATAGGCGTAGAGCTTGCAAGGAAGTACGGAGAGCCCGACGCAGTA +ATAAACGCCATAAGGGCACACCACGAGGAAGAACCCGTAAGATATCCCGAGGTTGCCCTCGTTTGTGCAG +CGGATGCCCTTTCGGCTGCAAGACCGGGAGCCAGAAGGGAAACCCTTGAAGCTTACATAAGGAGACTTGA +GAAACTCGAAGAAATAGTGAAGTCCTTCAAGGGAGTAGCGAACGCATATGCAGTACAGGCGGGAAGGGAA +GTAAGAGTTATAGTAAATCCCGAGGAGATTTCTGACGAAGAGGCTTACTTGCTCAGTAAAGAAATACCCA +AGAAGATAGAAGAAGAACTGGACTTTCCCGGCCAGATAAAGGTGGTAGTGATAAGGGAGACGAGGCACGT +GGAGTACGCCAAGTAATTTCCTTCCCTGTCGTTTTATACTCTTATAAGTAAGTTTTATTGAAAGATAAAT +TCCCGTGATAGAAATTAAGATCTCTGATGTCACAGGCGGTCAAAGACTACTACGAGATACTCGGCGTAAA +CAGGGACGCTACGAAGGAAGAAATAAAAAAAGCATACAGAAAACTTGTTAGGATATACCACCCCGACATA +AACCCTGACCCGAGCGCTCAGGAGAAATTTAAAGAGATTAACGAAGCTTACCACGTCCTTATAGACGACG +AGAGAAGGAGCGAGTACGACGCAATCCTGAGCAGGAATGACGTAGGTAAGTTCAGGGACTTTCTGGAGTA +CATTCAGGAGTTTGTGGAAAGCATAATTCAGGGAGAAAAGGGAAAGAAGAGAAGACCAAGAAAGGGACAG +GACATAAAGATGAAGCTTCCCCTCACGCTTGAAGAGGCGGGACTCGGGTGCGAAAAGGAAATCATTTACA +GCAGATGGATGGACTGTCCCGTGTGTGAAGGTATGGGAGTAAAGGGAGAGGCGGAAACGGTTGTTTGCCA +CGCATGCAACGGAGAGGGTAGGAGGGTAAGTGGGATATTTAACTTCCCAAGACCCTGCTCAGTTTGCAAA +GGTAAAGGCTTCATCGTTAAAAACCCATGTCCTACCTGCTATGGAAGAGGTAGAGTTTCCGCACAGCACA +AGATAAAAGTTCACATACCTCCCGGAACGGAAGAAGGAGAAGTCTTAAAGGTTCCAGAAAAGGGACATCT +CGGTTACTTTGGTGGAAAGCCGGGAGACCTTTACCTTAAGGTAGTTCTAAAAGAACATCCGATTTTTAAG +AAGGTAGGCAAGGATCTCCACATGGAAAAAGTAGTGAGCTTTCCGCTCGCGGTTCTGGGAGGAACCGTAA +AAGTTCCTACATTGGAGGGCGAAGAAATAGACGTATTCATACAGCCGGGAACTGAGTGCGGTGCAACGAA +AGTGGTAAAGGAAAAAGGGTATCCATACGAAAATGGAAGGGGAGACCTTATAATTCACATAAGGATAGGA +GTTCCCAAAAACCTTTCAAAGTCTGAAAGGAAACTTTTAGAAAAGCTCGCAGAATCTATTAAGGAAGAGG +GGGAAGAGGTTTACAGGGAAGGTGGAAGTCTTGTAGAAAAGTTAAGTTCCCTCTTTAAAAAGAACGCCTG +AAAACTCCCTCTTTATAACAGGGTAGTCGTCCTTTACACCTTTTGAGAGGAGTATCTGAAATACGTAGTT +AGAACCTATCAGGAATGAAACAGCGGAAGCGGTAAGGTAAAGCTCCCACATTCTTATAAACCTGTCGTCA +AACATATTCCTAATTTTGTCTAAGTTCTCGTAAAAGCGTTCCTTCCACTTTTTAAGCGTCCAGTAGTAAT +GCATACGCCAGTTATCAAAGTCAATTAACGTAAAGTCCATATCTCTAAAACTTTCCACAATTTCGGAAAT +GGACGGGAGATATCCGCCGGGGAATATGTACTTCCTTATCCACCTGCTCTGGGTGTCCGGATGGAGCTTG +CCTATAGTGTGAAGTAGGAAAAGTCCTCCTTCCTCCATTACCTTGTAAACGGTATTGAAAAAGGTTTCGT +AATTTTCCTTGCCAACGTGTTCAAACATGCCTACGGAAACCACCTTGTTGAATTTCCTTCCGAGTTTGGG +AAGATCTACATAGTGCAATTTGTAAACCTCGACTTTGTCCTGAAGTCCCCTTTTCTTTATTTCCTCCTTG +ACGTACTCGTACTGGTTGTCCGAAAGGGTAATCCCAACACTCTTTACGTTGTACAGCTCCGCACTCTCGA +GGATTATTGAACCCCAACCACAACCTATGTCCAAGAGCGTGTCTCCTTCTTTTAATTGAAGCTTTTCGTA +AATTATCCTCCTCTTTAAGCTTTGGGCTTCATCTATACTCATGCTAGGATCTTCAAAAAAAGCACAAGAA +TAAGTCATGCTCTTGTCAAGCCAGAGCCTGTAAAAGTCATTTCCAAGGTCGTAGTGGTGCTTTACATTCC +TTTCATCTCTAATAGTCCTGAAAAGGGGAACGTGTCTGAGGATACCAAACAGCTTTTCAAACTTCCTTGT +ATCTTTAAAGAGAGTCATACCCCTCTTTATTACTTCCTCAAGATCACCCTCCACCTCTATATCCCCGTTC +ATATAACCTTCTCCGAAGCCCATTTCAGGATCCTTCAAAACGTAATCCAAGCTCTTCCACGTTTTAAACC +TTATGAGGTGCGACACGGGAAATTCGGGAATCCTTTTTCCACTCGGAAGTTCCACGCCTATTTTTTCTTT +CTGGTTTTCGTTTAACTTGTTTACAATTCTTTCAACGATCGCTTCTTTAATCATAAGAGCACCTCCCTCC +CTTTAAAAATTTAGGCGGATAAATCTCATTGACATTTATGCAGTCTTTGAATATTCTTTAGGCATGGTTG +ACATAATAATCGCAGAACACGCAGGTTTTTGCTTCGGTGTAAAGAGGGCTGTAAAACTCGCAGAAGAAAG +CCTAAAAGAATCCCAAGGAAAGGTTTATACACTCGGTCCTATAATACACAATCCCCAAGAGGTGAATAGA +CTAAAGAATCTCGGCGTTTTTCCAAGTCAAGGGGAGGAGTTTAAAGAAGGGGATACGGTCATAATACGTT +CCCACGGTATCCCTCCGGAAAAGGAAGAAGCTTTAAGGAAGAAGGGTCTTAAAGTAATAGACGCTACCTG +CCCATACGTTAAAGCAGTGCACGAGGCGGTCTGTCAATTGACCAGGGAGGGTTATTTTGTGGTCCTCGTA +GGAGAAAAGAATCACCCCGAGGTTATAGGGACACTCGGGTATTTGAGGGCTTGCAACGGAAAGGGAATAG +TCGTTGAAACTTTAGAGGACATAGGGGAAGCTTTAAAACACGAAAGAGTTGGAATAGTCGCTCAAACAAC +CCAGAACGAGGAGTTCTTTAAGGAAGTAGTCGGCGAGATAGCCCTGTGGGTTAAGGAAGTAAAGGTAATA +AACACCATATGCAACGCTACGTCCTTAAGGCAGGAGAGTGTAAAAAAGCTCGCTCCAGAGGTTGACGTGA +TGATAATAATCGGTGGAAAGAACAGCGGAAACACGAGGAGACTTTATTATATTTCTAAAGAATTAAATCC +GAACACCTACCATATAGAAACCGCTGAAGAACTCCAACCCGAGTGGTTCAGGGGAGTAAAAAGGGTGGGG +ATTTCCGCGGGAGCTTCAACGCCGGACTGGATTATAGAGCAAGTAAAGAGTAGAATACAAGAGATATGCG +AAGGGCAATTGGTTTCCTCCTGATAGTAATAACTTTCACTTTTGCTTCCCTTTACGAAGAATTTGTAAAG +GAACAGGTAAAAGAACTTCCTTTGGACAAGGCTGTGGTAGTCGGAACAGGTAAAAAAGAATTAATAATCT +TCGTAAACCCGGATTGCCCTCACTGCAGGCACGAATGGAAGAGTTTAAGGGAACATCTGGACAAGCTCAA +GATTTACGTCTTCGTGGTTCCTTTCAAAGCGTGGGGTGAGGACAACTTAAAAAAAGCCTACTATATAGTC +TGTTCACAAAACCCCGAAAAAGCTTTAGACGAAGTACTTACCGGAAAAGTGGACGGTAAAAATTTAAATC +CTCCTACATGTGAATTACTGAATTATCACCTGAAAGCCGCAGATATCGTAGGACTAAGGGGTGTTCCGCT +GAACATAATTCCCGACAAAGGAAAAGTTATAGAAGGTGCAAGCCCTAAACTTCTGGAAGAGCTCGGGATA +ACTTCAGCGGGAAGCAGAGACTAAAGCAACTCCCAGAACTATAAGGAGAGCTCCTATAATTTTTTGAAAG +CTTAAGCCTTCTCCTAAAATTAAGTAAGCAAGCAGTGTAGAGAAAAGGGGAGAGCTTGCCGCAACAGGAG +CAACTATTGACACGTCGCCTACTTTTACAGCTTTATAGTACACCCAGAGACCTAAGAAACCCCCGAGTAT +ACCGCCGAGAGCTACACTCAAAATCTCCTTAAGGGGATAGGCAAAAGGGTTTTCTCTCAAAAGGAGTAAA +CCGATAAATGCCAAACTCGTGGCAGTCAAGTTATGAACAAATATCCCGGCTAAAGTGGGCATTTCCCCCT +TCATCCCAAGCTTGAAGAATATTGGAGCAGTCCCCCATATAAACGCAGCAAGCAAAGCCCAAAAAACAGC +CTTTAAGTTTTCCATTTAATGTATAATACTACCTGAAAGGGCTTCTAGCCCCACCTGGCTCCTTGGCAAT +TGAATAGGGTAGGTGGGTCCTAATAAGTGATGCTTTGATGATGTGATGAAATGAAATCATGATGCAATAG +GGTTAAAGGGATTGAAAATCAAGGATGGAAATTTTATAAAGGTATACTCAAGTTTGCAGAACTTCAGGTT +AGCGGAAATTAACATTCATTTCGTGAAGGTATTGTGTCTAATAAGTTGTTGATAAAGCGTTATTTTTTTA +GACACAGACACGCAGGGTTTCTAATGTACCGTAGAGGAGTTGAAACCAGAACAATAAGAGAGCCGATTGA +TGAGAACGCAGACGTTTCTAATGTACCGTAGAGGAGTTGAAACAGATATGATACACCTGAAACATTCTTT +TACATGGACCGTTTCTAATGTACCGTAGAGGAGTTGAAACCCGGCGGATATAAAAATCGCCTACCTATAC +GCCGTAATGGCGTTTCTAATGTACCGTGTGGAGTTAAAACAGTAAAAAATAAAAAAGATTTTGGTTTTAC +CGTAATTTATTTTTTGTAATTTGAAGCTCCTTCAAATAAGCATACTTTGTGAAATTGAAAAAAGCGTAGG +ATGCCGAAATAAGGAAGCCCCTCCATCCGTCCAGAAATCCACGCTTCATTATGAAAAACTTAAAAAAAGT +CCACACAGGTCTTGTGAAAAGTTCGTAATTTTTTACTATCCTTCCATTTTTGTATAAAATTTCTGCGGAA +ATCTTTGAATACTTTAAGTTCTTAGAAAAGAACTCGTCTAAATTTTTGAATGAGTAGTGGTATAAATCTC +CCTTTAACTTCCCTATACTTCCAGAACACTTTACAACTTCGTGCAATTCTCCTTCGTACTTGACTTTATC +CTTTTTAAATACTCTTATTCTCCACTCGGGATAAAGGGTGTGATTTAAAAATTTACCCATAAAGTAAGTT +CTTCTGTTTACCACGTAGCAGTCGTGTTTAGGGAATTTTAAAGTTTCCTTTATACTCCTTTTGAGTTCCT +CAGAGACTTCTTCATCTGCATCAAGGACGAAAACCCATTTATTGTTTGTCTTCGAAATCGCAAAACTGAC +TTGATCGGGATAATTCGTAAAGTCTCTAAATATCACTCTTGCTCCAAGCTCTTTGGCAATTTCCACGGTT +CTGTCCGTTGAGCCGGAATCAATTACCAGTATCTCATCCGCAATTTCTTTTACACTCTTTATAGCTCTTG +CTATGTTTCTCTCTTCATTTTTAGTTAGTATTACCACAGATAGCCTGTCCATTGGTAATATAAAGTACTA +TGAAAAAGAAGCTTATCGGGATTCTATTGGTTTTAGTAGTTATAGTAGCCTTAGGGTTTTACTTCCTCGT +CTTGACCAAACCCAGAGTTTTGAACGTTGAAGAATTCTCATCAATCCCGAGGAAGAAAATTGTAAGACTC +AAGATAGAACACGCTGATAAAGCTCAATTACTACGAGTTTTAATTCTCCAGAACGGGAAAGAGTATGTGG +TATACGAAGGGAAACCTATGCCTGAAGTTCTACTGGAGATACATCCCAAAAAGCTTGGTTTAAAGGAAGG +AGAGGCAGAGGTAGTTATAGAACTCTCAAGATTTTACTTTTTGAAAGAAAAGTATTCAATACGTTCCCAT +ATAGATTACACACCTCCTCTCGTGAACGTAGTATTTTCCCCTTACGCGGTTATGAACGGAGGAAGCGGAG +CTGTTAGAGTAAGTGTAAGTGAAGAATCGGATTTAAAACTGAGCGTTAAGGACTTAATATTTCCTTTTTA +CAAGATAGCTGGAAACACTTACTTTTCTTTATTCGGAGTTCCCATAGATTTTTCTCCTTCAGATTCAATT +AAGATTATCGCTAAAGACAAGGTAGGCAACGAAAGTGTGGTTCTTGTTCCCGTGAGAATAAGACAAAAGC +ACTATCCCGTTTATAAGATTGAACTAAAAGGAAGGGAAAAGGTTTTAATACCTAAACTTTCAAGTTTACT +AGGTGAGGAGATAAATAAAAGTAACTTCATCCAAGCTTTTAAGAAGGTCAATGAAGATTTAAGAAGGGAA +AATGAAGAAAAAATTTCGGAAATTGGAAAGAAATCTGAAGAAAGAATTTACTGGAGCGGCAAGTTTTTGC +AGTTAAAAAACAGCAAGGTAGTTTCCCTTTATGGAGAAAAAAGGATATATACCTACGGGGGAAAGCAAAT +AAGCACGAGCTACCACTGGGGTTACGACTTAGCATCGGTTAAAAATTCACCTGTGGAAGCTTCAAATTCA +GGAAGGGTTGTATTCACAGGATTTTTGGGGATTTACGGCAATACTGTAATAATAGACCACGGGTACGGTC +TCATGAGTATATACTCTCACCTTGCGGAATTTAGAGTAAAGGAAGGTGATATAGTGAAAAAGGGACAGAT +TATAGGCGTAACGGATACCACAGGACTAGCTTTCGGGGATCACCTTCACTTCGGTATTATGATTAACGGA +CTTCCCGTAAATCCGATAGAGTGGTGGGATAAGAAGTGGATAAAGAACAACATACTGCCGGCGATTCAAT +CAAGTACCAGCAGGTGACACGTATCGTTAAGGCTCTTTAAGTAAAACCTTTCTCCATCGTACTCAAGAAG +GGATATTCCCGTGTTGTCCATGTGGATGTGCCACATCTTTTCAAGCCCTATCCCGAGAGCGAGACATAGA +AGTCCGTGGAGCGTCCCGCCGTGCCCTACGACCGCTAAAACCTTCTCTTTTCTACTTTTTAAATCTTCCA +AGAATTCCTTAATCCTCTTTTCAAACTCCTTTATGTCTTCCTGCGTTGGGAGAGGATATTTTACAGGGTC +CTTGAGCCAGTTTATTATCATTTCCTTATTTTCTTCAAACATAGTCCAGAAGTGCCTTCCCTCGAGCACT +CCGAAGGACATCTCCCTAATCCTTTCATCCACGATCAGGTCAATTCCTAGCACGTCGGAGAGGGTGAGAG +CGGTCTTGTAAGCCCTCCTCTGGGGTGAGGTTATTATTACCTCTGGCTTTTCTCTCTCAAATTGTTTTAC +AAGAAGTCTTGACTGAACGAAACCGAGGGGTGTTAAATCACTGTCCAGTCTTCCCTGAAATATTCCCTTT +TCGTTATACTCACTCTGTGCGTGCCTTATGAGATATATCTTCTTCATATCTGCTCGAATAAGACGTCGAG +AACTTGCGGTTGAATATCTATTTCCCACTCCTGATAGTAGTACTCTTTATTTACAACGGTAACTACACCT +AAGTTTTCAAGGTAAAGTAAGACTTTTGCAAGGTTTACAAGTCCACAAATTTGGGCGGATTTTAACTCCT +TTATCTTCACTCTTGGTATAGGGCGGTCTGCGTTTTTGAATATTTCGAGAAGCTCCTGTTTTACATGGTA +GTAAAGTGTTTCAAAGTCACAGGGACCTCCTTTTGGGTTTAATCCTTCCCTATACAACCATCACCTCCGA +GGATTTCTTTAACAACTTGAGCGTCACTGAAAGGATATTTTACACCTTTTATTTCCTGATAGTCCTCGTG +TCCCTTTCCGAGAATGGCTACCATGTCACCTTCTTTTGCCATATCTATAGCCTTTTTTATTGCTTTCCTC +CTGTCCGCTTCAATTATTACTTTGTCCTTTTCACTTATTCCATCAAGGATATCCTCTATAATTTTTTCCG +GCTCTTCATCCCGAGGATTGTCCGAGGTAAGGATTATTAAGTCGCTGTACTTCTCCGCCGCCTTTCCCAT +GAGCGGTCTCTTTTCTCTGTCCCTGTTTCCTCCTGCTCCGAAAACAGATATGAGTTTTCCTTTACTTAAT +TTCCGTGCGGTTCTCAGGACGTTTTCAACGGCGTCGGGCGTGTGAGCGTAATCAATTATGACGGTAAATT +TATCCGAATGTACAACTTCAAACCTTCCGGGAACGTTTACGCACTTTAAGGCTCTTTGAATAAGGTCCGG +TTCTATACCTTTCCACAGGGCGTAAGCTATAGCCGCGGAGAGGTTGTAAGCCTGAAAATCTCCTATTAAG +TTTGTGCTAAATTCGTACTCTTTTCCTTTAAAGGCAATCCTTAACGCACTTCCCCTAAAGTCCGTTCGGA +AGTTCAGAATTTTCAAGTCTCCCTTCTTGCCATAAGTTATAATTTCCCCGTGTGTAATTTTCAGCAATCT +TTTTCCATAGGTGTCATCTGCGTTTATTATCTTTACCTTTGATTCGTACTCCGTAAAGAGCTTTGCCTTC +GACGCAAAGTAATCCTCCATTGTTTTGTGATAATCTAAGTGATCCTGAGAGAGGTTTGTGAAAAGGACCG +CTTCAAACCTTGTGGGATAAACTCTGTACTGATCAAGGGCGTGGGAAGAGATTTCGGCAACTACGTTCTT +TGCCCCGAGTTCGTAAAATTCCTTTAAAGTCCTGTGCCAGGTTATCTGATCAGGAGTAGTTCTGCCGCTT +CCTAAAATTTTTTCTCCGAGCCTGTAATAAATTGTTCCAATCAGTCCTGTCTTTTCTCCTGCTTCCAGAA +GTATTTTCTCTATTAGGTGTGTGGTAGTGGTCTTTCCGTTTGTTCCTGTAATTCCTATTACGTTTAGCCT +TTCGGAGGGTTTACCGAAAAATTCGTGAGCCGATTTGCCGAGGGCTTTTCTCGTATCCTCAACGATTATC +ACAGGAACTTTAGAACTTACAGGTCTTTCAACGACTACCGCGTAAGCCCCTCTTTCTTCCGCTTCCCTTA +TAAAGTTATGACCGTCAAACCTTGTTCCCTTTATGGCGAAGAAAAGGTAACCTTTCTTTACTTCCTTTGA +GTTTAAAGTTATTCCTTTTACACGTTTCAGTATAAAGCTCAGATCCATATAAAGCACACTGGCGGAGGGG +GTGGGATTCGAACCCACGGGCGGGCCTGTAACCCGCCAAGGGATTTCAAATCCCCCGCCTTCGTCCGCTC +GGCCACCCCTCCTTCTAATATATTATCCACCACCGTACTCAGAAGCGTCAATCTCAGACTCAAACTCCTG +AATAAAGAACTCCACTTCCCTTACAATCTCATCGATATCCTTTTTAATAAGGTGTTCAAAGAGCTCTATT +TTTCTTTCGTGAGCATGGTCATCTTCTACGTAGTACCTCACCCTTATGTAGGGGAGTTGCATTTTAGGAT +CGAAATCGGGATCTTCGGGAGTCACAACGTCTACATCTACATTTATCCCTTCCGTTTTATTCTTAAAGAT +TTCCTTCAACTCTAAAATCTTTGTTTTGTACTTTGTCCAGTCGTACTTCACAATAATTTTAATAATATTT +GAGCGATATACCTTATGTCAAGGTAAATAAGCGAAAAGGGAAAGGAAAAAAGATTGACTTAAACGTATAT +CGGTTCTGTGAATTCACTTATACCAGTTTCCAGTCTTGTGAGTATCGCTTTTCCTCTGAGTGAGTTTACA +GGAACCCTTTCTTCTCCGCTTTCTTTAACAATTACTATGTTGTCCTCCTCAATTCTTATTTCCAGAGGAG +GATTTCCAGTGGACTTGTCAAGTATGTTTTTATCCCTTAAAATATCTTGTCCATATACCTTTGCTTCTGC +TACTGCGGGCATGGTTCTCACCTCCTTTGTTTTCTTTTCTCTTTTTTATTTATTCCTTTTTTGTTTCACG +GCTCTGATGGGAATCATGACAAAGGTTAAAATAAGATTAACTTTCCCAGATGTTAAATTAACCTTATGCA +GAGGAAGGAAATTTCTCAAGAAACTGTAAACCTTCTGGTGGACATAATAAAGGAAACAATAGGAGAAGGC +GGACTGAAAAGTATTACGAAAAGACTAGAAGGTAGAGATCTAAAGGGAAGGGAGTTAGTATACGCTTTTG +CGGAAGAGGTAATGAACATCTATGGGCAAAAGGGTTCATACGCTTTAATAAGGCAACTTGGGAGAGACCT +TGCAAATATGTTTCTTTGAGTTTATCAAGTAATTTCCTCTCTTTCTTCTTCGGAAATAAACGTTTCTCTT +TTCTCAGATGGTTTTTCCTGATGAGTCAGTAGCATAGTAAAACAAAAAGTAGAGAGAGAACATATCAAGA +GCCAGGAAAAGAGCATAAAGATAAGGGCTTCTCCTTTCATAGGGATTATTTTAACCGCTAACAACTCTGT +AAAACTTCTTTTTGCCCACTTTTACCTTCAGCTCTCCGTTTATCTCTATTTCCGTGTTTGGATCAGTGAC +CTTTTCTCCGTTTATTTTAAGACCTCCGCCCTGTATTACTCTTCTGGCTTCGTTCTTTGATTTTACCGCT +CCTATTTTTACGAGGAAATCTACGGCTCTTAACTTTTTCTCATTTAGTTTTACAAGAGGTGCGTCTTCTG +GAAACTCCCTCTGAGAGAAGGTCTTTTCCCACCACTCCTTTGCCTTTCTGGCTTCTTCTTCCGAGTGAAA +GCGCTTGACTATAGTAAAGGCGAGGAGTTTTTTTGCCTCCATGGGGTGCATCTCCCTTCTCATTTTCTCT +ATCTCTTCCTTATTGTAATCCGTCAAAAGCAGGAACCAGTCCCACATAATTTCATCGGGAATGGACATTA +TCTTCGCAAACATAGTTTTCGGATCTTCCGTTATTCCCACATAGTTCCCGTAAGATTTTGACATCTTCCT +TACGCCGTCCGTTCCCACGAGCAGTGGAAGCGTTATGCACACCTGAGGCTCCTGCCCGTACTCCCTCTGT +ATGTCTCTACCTATGAGTAGGTTAAACTTTTGATCCGTTCCGCCTATCTCAACGTCAGCCTTTATTGCAA +CAGAGTCGTAAGCCTGAAGGAGCGGATATATAAACTCGTGGATGTATATGGGAATTCCTTCCTTGAAACG +TTTGGAGAAGTCTTCCCTCTCGAGCATTCTCGCCACGGTGTACTTTGCACAGAGTTCTATGAGTCCCTTG +GTTCCCAGTTCCTCCAGCCAAGTGGAGTTAAAAACGACGGTTGTCTTTTCTGGGATTAAAACTTTAAACA +CCTGATGTTCATAGGTCTTTGCGTTTTCAAGAACCTGTTCTCTGGAAAGGGGTGGTCTCGTCTGACTCCT +TCCCGTCGGATCCCCTATCATGGCGGTAAAGTCTCCGATTATGAAGAAAACCTCGTGTCCCAGTTGCTGA +AACTGCCTTAGCTTTTGAAGCAGTACGACGTGCCCCAGGTGAAGGTCCGGAGCGGTGGGGTCAAAGCCCG +CCTTTACCCTCAAAGGTCTTCCTTCTTTTAACTTCTTCAGGAGTTCTTCTTCTTCTATAATTTCTACCGT +GCCTTCCTTTATTATCCTGAGTTGTTCCTCGGGTGTCATAACTAATTATTTATAACATTGATTTATAATC +ATTTAAAATGAGGCTACCAGAGAGGCTTGTGGAAGCTATTGCGGAATCTATAATTCAAAAACTCGGAAAG +GAAGAGGGAATACTGGAGCTCGAAGATCCTGCAACCTTTAAAAAGAAGATAATTTCCCTTTTCAAAGAGG +CGGATAGGGAGGAAAAGGAACTGGAGGAAAAGGCTAAAGCAGTCTTGAGGGAAAATTTAGAGGTTCTTGA +AAGGGAAAACATAGATTACAGAACTGCTTTTCTCGCAGTAAAGAGAAAACTCGCCGAAGAAATGAACATC +AACGTGGATAGAAGGGAAAGGCTGAACCAGATAATCAACAGAATAATGGATTTAATAATGAAAGATGAAA +GCGTTGAGATATACGAGGATCCTCCCGTGATAAGAAAGAAGATTAGAGAAATAGTTCTCGGGGCTCTGAA +GATAGAAGAAGAGATAGAAAAAACTGTAAGACAGAGGATTAAGAAGTACTCAAGAGACTTGCTGGAAGGC +AGTCCTGAGTGGCAGATTTTGTGGAAAAGGATTTACGAGGACGAACTCAAGAAAAGAGGTCTTGCTTAAG +GCAAGTAAAGTATCGGGTTTTGTCTTATGCCATATTTGAGTACTTCGTAGTGTAGATGGGGTCCCGTTGC +CCTTCCCGTGCTCCCTATGTAACCAATAACGCTACCCTTAGCCACTAAATCACCCTTATAACCTTCCCTG +CCCGAGAGGTGAGCGTAAACCGTAGTGTAGCCATATCCGTGGTAAATGACTATTACGTAGCCATACCCCC +TTACCCAGCCACTGAAAATCACAACTCCGTCCGCAGTAGCAACGACAGGTGTTCCCGTGGGAGCTGCTAT +ATCTATACCTGCGTGGAATTCCTTGTACCGCCCTCTCCTTCTCCAGCCATACTGAGAAGTCACTACTCCC +ACTATTGGCCATATACTGGGTCTTGACTCTTCGGGAAGCTTAACATACTTGAGAAAATCAGTCAGTTCTC +TCGGAATTTCTATTTTGGGAGAGATAACTTCTACCTCTTCTTTTTCAAAGATATCCGGCTCTAAGAATAA +GTTGGAGAGTTTTCCGAAAGATAGAGGGAGGAAAAGGAGGAAGAGACTAAGTAGTAGAGCCTTCTTCATC +TAAGTAGAACACCTCATCGGATATAGGTTCGTTCCAGCGTTTGAACCCGGGAAGCGTTTCTATCCTGTAC +CAAGCGGAGCGATACCATATGTCCGTGGGATTCTTCTTTACAGGTGCTATCTGGGCTGCTCTAGTTTCGG +GGTGGTATTCCCAGTTCATGTAATCGTTGAAGTCCTGAATTATGTCGGTTATAACAACTCCGTACTCGTT +AATGAGTATTTCCTGAAACTCCTTCCACCTGAATATGGAACTGTCTCTTAAAGTGAGTCCAAAGTAGCCC +GCACACCCCGCGTCCTTGAGCGTGGCTATTCCCCTTCCTATAAACGCCCTAAACGCTGCGAAAGTTTCGG +GGGGATCTGTTATAAATACGTCAAACTTCCCTAAAAAGTCTTCAGTATAGGGGTTTCTAAGATCCCACAC +CATGGCTTCCGCGTTGTCTATTCCGAGTTCCTTTATAATTCTGTTATCAAAGTCTATCAATCTCTCGTCT +ATGTCTATTATCAGAACCCTTTTTGCCTTTCTCGTGAGGGCTATTGCGAGTCCAGTGAGGTCGTCTTCCG +CTCCCATTACGATAATTTCCTTACCCCTGAGGTCTCCCCTGCTATCTAAAAAGAGTACTCTGGATACAGT +AGTTTCGGGAGTAACGCTTCCCTGGTCGTACTGCTGAACGGGTTTTGGTCTGTCTTTGGCTATCTCAACG +AAAGTTCTGTAAAGTTCTTTATCGTCGTAGAAGGGTATTCCCCTTCCTTCACAAGCCCTGCACTTGTGCT +CTTCAAAGGGTTCAATCCCGAGCTCCTTTACTAAGTCAAGCCCCTTCTGGGTAAAGAGGATGTTTTCGTT +TTCATCAATAAACACAATTCCTTCGTCTAAAAACTTTTTGATAATCCCCGATGCCGCAGGAACAGGCAGG +TCTGAGTAATCAACTATCTTCCAGAAATCTCCCGTCTTTAAAAGTGCCTGAAGAACTCTCTCTACGTTCC +TCGCGTGAAGCCTTACCTTCGTCTCCTCCTGAACTTCCTTGGCTATCCTCTCCAGTATGTTCAATCCTTC +ACCTCCGCAGGGATTTTGCAAAAAGAATATTATAAAAATTTTAAAATCTTTAAGTATGCAAAACGTCCTC +ATAGTAGGCGTGGGCTTTATGGGCGGCTCCTTCGCAAAGTCACTTCGCAGGAGCGGGTTTAAGGGAAAAA +TATACGGGTACGACATAAATCCCGAAAGCATAAGTAAAGCGGTTGACCTCGGAATAATAGACGAGGGAAC +AACGAGTATAGCGAAGGTTGAAGACTTTTCTCCGGATTTTGTGATGCTCTCTAGCCCCGTTAGAACTTTC +AGAGAAATAGCTAAGAAACTGAGTTATATCTTGAGCGAGGACGCTACCGTCACGGATCAGGGAAGCGTTA +AGGGGAAACTCGTTTACGATCTTGAGAACATACTTGGAAAAAGGTTTGTTGGAGGGCACCCGATAGCAGG +AACGGAGAAATCTGGGGTTGAATACAGTTTAGATAACCTTTATGAAGGGAAAAAGGTAATACTCACACCT +ACTAAAAAAACGGATAAAAAGCGTTTAAAACTCGTAAAAAGGGTTTGGGAAGATGTTGGTGGAGTGGTTG +AGTACATGAGTCCTGAACTTCACGACTACGTGTTTGGTGTTGTTTCTCACCTTCCCCATGCCGTTGCCTT +TGCACTCGTTGATACCTTAATCCACATGTCAACGCCGGAAGTTGATTTATTTAAATACCCCGGAGGAGGT +TTTAAGGACTTCACGAGGATTGCAAAGAGCGACCCCATTATGTGGAGAGACATATTTCTGGAAAACAAGG +AGAACGTCATGAAGGCGATAGAGGGTTTTGAAAAATCTTTAAATCACTTAAAGGAACTCATAGTAAGGGA +AGCGGAAGAAGAGCTCGTGGAGTATTTGAAGGAAGTAAAGATTAAGAGAATGGAGATAGATTGATGGAAG +AGATAAAAGAACTTATAGACTATGGGATAATGGGAACGCTCCTTTTTATGAGCTTCGTAGCCCTCGCCGT +GGGAATAGAGAGGTACTTATCTATAAGGTCCACAAAAGTAGAAAACTTCAAAAGTAAGGCTCAGCTTGAA +AAGGAACTTACAAAAAGGCTTTACATTATTGCCACTGTAGCGTCAAACGCCCCTTACGTGGGACTTCTCG +GAACTGTTCTGGGAATCCTTCTTACCTTTTACATCATAGGAGAAAAGGGGATTGTGAACACTAAAGAGAT +AATGGTCGGACTTGCCCTTGCCTTAAAAGCTACGGCTCTTGGACTCATCGTTGCAATTCCATCAACCATT +CTTTACAACTTTCTGGTGAGAAAGGTAAGGGAGAAGCTCCTGGACTGGGAGGCTATTCACGGAGAGTGTT +CTTCAAGCCATGAGTAAACACTTTTGAAGGTTTCGGGCTCTTCTATCTCGAATACCATCCACTCCCCTTT +AGTTGGGTGGTAAAAGCCGAGGTGGTATGCGATAAGCATATTACACTCTCCCATAAGGGAAAGTAGCTCC +TTTGGAACCGAACTACTTTTAAAGCCGTAAGTTCTGTCTCCCAGAACGGGATGTCCTATTGAGGCGAAGT +GAACCCTTATCTGGTGTGTCCTTCCCGTGTGTATTTTTACTTTAAGCAGTGTTATCTCATACTTTTCGTA +CCTTTTCAATACCCAGTACTCTGTAAGGGCTTCCTTTCCCTCTTTCCTCACCCAGAAGCGTTTTCTGTCA +ACGGGGTGACGTGCTATGGGTGTGTCTATCGCTCCGTAGTCCTTTTTCACGAGACCTTTTACGAGAACCT +TGTAAAACTTTTCCGTTTTTCTCTCCTGAAACTGCCTTACGAGATTTCTGTGTGCGGTGTTGTTTTTGGC +GATTACCATTACTCCCGCAGTTTCCTTGTCCAGCCTGTGGACTATTCCGGGTCTTTCAACCCCTCCTATT +GATGAGAGGTCCTTTATGTGGTAAAGGAGGGCGTTAACGAGCGTTCCAGAAGTGTACCCGGGAGAGGGGT +GAACCACCAAACCGCAGGGTTTTTCTACGACCGCTATGTCTTCGTCTTCGTAAATGATGTTTATGGGTAT +GTTTTCGGGTTTTACGTCTAAAGGTTCTGGCTCGGGAACGTGGAGTATTACCCTTTCCCCTTCTCTGAGT +TTTCTCGAGGGTTTTCTTACTTCTTCTCCGTTTACGTAAACGAGTCCTTCCTTTACGAGTTTCTTTATAT +AACTTCGTGAAAAATCGGGATAAGCCCGGGCAAGGAACTTATCCAGTCTCTCTTCCTCACCCTCAACCTT +GAACTCCAGAACCTCAGATATCTTCATAAAAGAAAAAATTAGGAGGAGAAGATGAGGATCGCTTCAGGTC +TCTTTATTCTGGGAACTACCATTTCCATTACGCGGAAGGTGTGGTTCATGTTTGAGGTTTCCACAAAGGC +AACGTTTACGTCAAGTGCGATCGCAAGGTCGAAGTTCGCCGGAGATGCGGATACGAGAAGAACAATATCT +TCGGGAATTATGGGAGTCTGGTAAACTTCCTTTACTACCTTTTTAATTTGTTCAAGCTCTAAAAGTCCCG +TGTTGTCGTGAATTCTGTTGAGGAGGAAGTATCTCTTCGGATTAACGATTAAGTAATAATTGGTGTAAAA +GCCCTTCTCAACGAGTCTTGATATTCCCTTCACGACGTCCTGAAAAGCATTTCCCACTTTTTCCCAGTCG +GAGAGTTCTTCCCTGAGCGTTCCCTTTGCCGTGAGGAATCCCTCTATGCCCATTTCCTGATTTCCGAAGA +GTATGAGCTTGTCTTCCGCTACCGCCAGAGAACTCGCTGCTGCGGCAACGCCCGTCGTGTCCACGGGTAG +GTTAAACTGCCTCCAGTGCTCCAAATCCCTCCAGGAAATGACAAAGTCCTTGTAGAGTGTGGGAACTGGG +ACGTGTTTCCTCTCACCGGTTCTCACGGGTTCGCAAACCTTGTACTCCTGTCCCGGTTTTACTTCGCAAA +CCCCCGGTTCTACCCCGTAAAGGACGTCGTATGACACTACCTGATGTCCCGCTCCAAAGGGACCCACAAC +GGGCATAAACTTTCTGCACACTACGGTGCTTTTGAAGACTTCATAAGCGGTTTTGTCTATCTGTTCCCAC +TCCTCCGCCGTGAGCGGTGCTTGGTCTCTCTGAAGAAATTCCATAATCCACCTCCTCCTTTTATTTTAAA +TTATTCCTAATCAAAAATAATTCTCACATTTTTCATACCCTTCAGTTCTTTTAACTCCTCCGGAAGCCTT +CCCAGTTTAAACTTTAACATATAACGGTAAACTTCTCTAAACTCTTCGTAAACCTTAAAGAAGTTCTCCG +AAACCTTTTCCTTTAAGAACTCGTCAATTTCCTGCTCACTTTCCACAACCACGAGCCTCGAGAAAGGTGG +AAGGAACTCCTCTTTCCTCCTTTTCAGTTCTCTTTCAAAAAGCTCTTCAAAGTTTTTGTTCAGTATAAGG +CTTTTGTCCTCCTCGGAAATCAGTGCACTCTGGATAACGAGGCTATTTTTGGCTACTCTCAGACTTTTCA +AAACAAGGTTTAAGAACCTTTCCCTTGACCTGTAATTGGGGACCGAAAGGAGGGTGTCCGCGTTCAGGAT +AACCACGTTTTCATACTCCTCGAACCACTTCGGATTAGTTGTAAAAGAAAAGTTTTCCCTCTCACTGAAA +AAGTCTTTTATGACTTCCCTCGCCCTTTCCAGTCCAAATCCCATTTCTTGGAGCTCTCCACCGCATGAAG +GACATTCAAAGGCTTTACTCCCGTAGTGTTTCTTTACCCTCGGACAAAAGATTTCCCCTTTTTCCTTACT +GAAAGTTAAAAGAGAACCGCATTCGGGACACTCTGCGAGGGATTCGCACCTCGGACAGTAGGCGTAAGAG +TAGCCCTGCTTTACCACGACGAATAAAGTTCTTTCCTCTACTCTATCGTTAATAAATTTGTATGTCTCCT +CCGTTATTACCTCGCCCTTTCTCTCGTGGATATAGATATTTGCCTTAAAATCCTCTTTTCTGTGTTTAAA +AATTCCCTTCTTTATCAGAAGGAAGCTTTCTAGTCTGGGATAGGGAGAGGTAAAGATTAATTCAGATGCG +TACTTCTGGGAGAGGAGGTATGCGATCCTCCTCAGGTCAACGCCGTTTGCCGGAAACTTTGTGTTCTCCT +GTTCGTTAAAAAGTACCACGCTTTCGAGTTCGGAAAAGGGTAAAAAGACGGACTTAAAGCTTCCCAAAAA +TACAAATCCACTTTCGTGAGCCCTGAACCAGTTCTCGTAAAGTTCCTTTGGTTTTATCCTTGCGGATATC +TCCACAACCTTTTCCCCGAAGTAATTCCTGAGCTCATCAGAAACCCTGTAGAGTTCCTCCTTGCTTGGAA +ACAGAACTAAGGTATTCTTCCCTCCCCCTAAGTTCTGGGCAACCAAGTTTATTAAAAAATCAAGAGCTCT +TTTAAAACTCGTAGAAAGATACTCGTTTCCCTTTTTCCTTTTAACCAGAGGGGGCGCCTGTTTAAGCGGA +ATTTCGGAAAGTGCTTTGGGGTAAAGGATTTCCCTTTTTAATATTCCTCTCTTTAAAAGGTCGTTTATGT +GGGAAGACTTAAAACCCTGTTCCAGGAGTTCCTCTTTTGTAACTTTTTCTCTTTCGTTTATAAACTCTAT +TAATTCCTTCTTTTCTTTTGAACGAACCCTCTTTAGTGCTTCTTCTAGCGGAATGTTTAAGGAGTAAACT +TCCTCTTCAACCCTTGGTATCACCCATTCCGTTTTCTTTAGAATTATCCCGTGGTCCTTGAGCAGGTGAA +TTAACCGATAATCAAACCTCTCCAGAAGTGTTTCGTAAGGTACTTTTCTCCTCTTTTTTATATACTCAAC +AACCTGTAGGGAATTTTTATCCAGATTTTTTAAATTCCTCGGTGCTAAAAGGACGAAATTTTCCTCGTAC +CAGTCAAAGCTTGCGGGTATAAAGCTCCAGAGTATCTTCCAAGGTATATCCAGGTAATAATTCCCGAGGT +CTTTTGCAATTTCTAAAGCTTTTGTGTTTACAAGGGGAAGTTTATCGGGAAGGGAGGAAACCCTCCCTTG +GGCTTTGCCTTCCGAAAGTCCTACGATTATTCCCGTACTCCCCTTTCCGCTCTTTCCCTTAAACAGAACC +CTGTACCCGATTGGGTTTTTAGGGCAATCTTCACACTCCAATAAGTAGGTTCTCCCGCTGGATATGGCAA +CCTTAACGAGCACTAATTTAAATCTATTCCTTTAGGGCTTTTAAGACTTTTGAGTCGAGTTCCGTCATTT +TTAGAACGTTCCCCGTGTGTGCAAAGGGGATAATCCCGGTTATCGTGGCTCCTGGAAAGAGGGAGTTTTC +CACTTCGTCTATTTGAACCTCAAAAACGGACACGGGGAAAGGGACGTCTTCTATCTTTTCCTTGATTTCC +TTTCCGACCCCGTAACAACTGAGTGCTTTGTCGGGAGCGAATATCTGTATCGCTACTTTTGAGTTCTGTC +TTATGTTCTGTGCAGTCTTTGCGTTTGAGCTCACGGCTATCCTTATGGTTCTCTCGTCTGTAGGATAAAC +CCAGGTTATGAAGGCGAGGTGGGGATTTCCTTCACCGTCAACGGTCGACACAACAACGGGAAAAACGTTT +AAATCCCTCATCAAATCTATTAAATCTCTCGGTAACATTTTCCACCTCCTTAAAATTTTGTTTACAGATA +TTTTAATTTGTTTCCCCGACGTTTGCCTTTCTATGAGTTAGGTATATAATTTTATAAAAGAACGATAAAG +CTTCTTAAAAGCTTTATTAGAGAAAACCCAAAAGGGAGGTGTGAGAATGGCAGAAAGAAGGTGAGAGTGG +CTATCGCGGGAGTGGGAAACTGCGCGAGCTCCTTCATACAAGGTATTTACTACTATAAGAAGAAGGGAAC +TGTTGACGTCAGCGGTTTAATGCACGAAGACATAGGCGGATACAAGCCCTGGGACATTGAAATAGTCGCA +GCGTGGGATATTGACGCGAGAAAAGTCGGAAAAGACGTCTCAGAGGCTATATTCGCACCGCCAAACTGTA +CGGCTGTGTTCGAACCGGACGTTCCCCACATGGGCGTTAAGGTAAGGATGGGTAAGGTTCTGGACGGATT +TGCACCGCACATGAAAGAATACCCACCTGAAAGGACTTTCGTACTTGCGGACGAAAAGGAAGACGAACTC +GAAGACGTAGTGGCAGTTTTAAAGGAAACCCAGGCTGACGTTTTAATCAACTACGTTCCCGTGGGAGCGG +AACAGGCTGCAAGGTTTTACGCGGAAGCTTGTCTGAGAGCGGGAGTGTCTTTCATAAACGCGATGCCCAC +ATTCATAGTTTCAGACCCCGAATGGGCTAAGAAATTTGAAGAAGCCGGAATACCCGTTGTGGGGGACGAC +ATAAAGTCTCAGGTGGGAGCTACGATAGTTCACAGAGTGCTCACTCAACTCTTTGTGGACAGAGGTGTTA +AATTAGACAGAACTTATCAGCTCAACTTCGGTGGGAACACGGACTTCCTGAACATGCTCGCAAGGGAAAG +GCTAAAGACCAAGAAGATATCCAAAACTGAAGCGGTAACCTCACTACTCCCCTACGACCTCGGATGGGAA +AACGTACACATAGGACCTTCCGACTGGGTGCCTTGGCTAAACGACAGGAAGATAGCTTACATAAGGATGG +AAGGAAGACTCTTCGGAGACGTACCCATGTACATTGAACTGAAACTCGACGTTGAAGACTCTCCAAACAG +CGCAGGTTCTATGATAGACGCAGTAAGGTGTGCAAAACTTGCAAGAGACAGAGGAGTTGCAGGACCTCTC +TACTCCATAAGTGCATACACCATGAAGCACCCACCCATTCAGTATCCGGACTGGCAGGCTAAGAAGATGG +TAGAAGAATTCATCAGGGGAGAAAGAGAAAGGTAATAAAAACTCCCCTTTTCCTTTTCTTTTGGAATACC +CCCTTTAGGTAAAAATTTTTTTATTTTTAAAAGGATTCTGTTTATAGAAAGGTGGTGGGCTGCCCGGGAC +TCGAACCCGGAACCTGCGGATTAAGAGTCCGCCGCTCTGCCTATTGAGCTAGCAGCCCTCGTCTGAAGAA +TATTATAACACATTGGCCGGGCTGGCGGGAGTCGAACCCGCAACCTCGGGATCCGTAGTCCCGCGCTCTA +TCCAGTTGAGCTACAGCCCGTACCAAGTTAATAATTTTAATCCCTTGCCCTATGGTAGTCCAGCTTGATC +AAATACACTTTTTCATTTTTCATGAAGTCCTTAAAATATTTAAAACTATGCCTCAGCTTTTTAAAACCTC +TAAAAAAATCGACGAGCTGGTTATAAACACTATTCGCTTTTTGAGCGTTGATATGGTCGAAAGGGCAAAA +TCAGGACACCCCGGAATGCCCCTCGGAGCTTCCCACATAGTTTATCTGCTTTACGACAGGATAATGAAGT +ACAACCCTAAAAATCCCAATTGGTTTAACAGGGATAGGTTTATACTCTCTGCGGGCCACGGAAGTGCAAT +GCTCTATGCAGCCTTCTACATGTTCGGATTTGACCTGACTCTTGAGGATCTAAAAGCCTTCAGGCAACTA +AACAGCAAAACTCCGGGACACCCCGAATACGGACTCACTCCCGGCGTTGAGGTGACTACCGGAAACCTCG +GACAGGGATTCGGGAATGCGGTTGGGATGGCGATGGCTGAGAAATTTTTGTCCCACTACTTTAACAGGGA +AGGATACCCCGTTATAGATCACTACACCTACGTCCTTGTATCGGATGGGGACTTAATGGAGGGTGTTTCT +TACGAGGCTGCATCCCTTGCGGGACACTTTAAGTTAAACAAGTTAATAGCAATATGGGACAACAACCACA +TAACTATAGACGGAGACACTAAGCTTACGTGGACGGAAGACGTCTTAAAAAGGTTTGAAGCCCTCGGTTG +GGAAGTGTACCACCTGGAAGACGGGTACAACTTGGATCTTCTGGAAGAAACGATTCTAAAAGCAAAAGAA +AGCGACAAGCCCACCTTTATATCCGTGAGGACGCACATAGGTTACGGAACGCCCCTTCAGGATACACCGG +AAGTCCACGGGAAGCCTATGGGCAAAGAGATAGTGGAGGAAACCAAGAAGAAGTTCGGCTGGCCACTTGA +GGAGTTTTACGTCCCCGAAGAGGCACTCAATTATACGAGAAGGAAAGTTGAAGAGGGGAAAGCTCTCGAA +GAAGAGTGGAACAAACTTTACGCCGAATACAGGGAAAAATACCCCGACCTTGCCCAGACGCTTGAGAAGG +CTCTTAACAAGGAGTGGAGTTTAGACTGGCTTGAAAAAGTAGAGGAATTCAAAGAAGACATGCCTACCAG +AAAAGCCTCGGGGAAAGTGCTCAACGTAATGGCGGATTACATACCCACCATGATTGGCGGTTCGGCGGAC +CTTTCGGAATCCGTGAACACAGTGTTGAAAAAGTACGGAGATTTTGAAGCCGACACACCTACAGGAAGGA +ACGTTCACTACGGTGTCAGGGAACACGCCATGGGAACGATTCTCAACGGCATGGCTTACCACGGAGGAAT +ACTCCCTTACGGCGGTACTTTCCTCATATTCTCGGAGTACATGAGACCCGCTATAAGAACGGCAGCACTC +GCAAACCTACAGGTAATCTTCGTTTACTCTCATGACTCCATAGGTCTGGGAGAGGACGGTCCTACCCACC +AACCCGTTGAACAACTTTGGAGCCTGAGGAGCATACCCAACCTCTGGGTAGTAAGACCCGCCGACGCAAA +CGAGGTGAAGTACGCGTGGGAGATAGCCCTGAAGAGGAAAAACGGCCCCACGGCCATAATACTCACGAGA +CAAAAAGTAAAAACCATAGACAGATCCAAGTACGCCTCTCCGGAAGGCGTAAGGAAAGGGGCTTACGTTA +TAGCTGATACAGAAGGAAAACCGGATGTTGTAATCATCGCAACAGGTTCGGAAGTTCAGGTTGCACTCGG +AGCGAAAGAGATACTGGAACAAAAAGGAATAAAAACGAGAGTGGTTAATATGGCTTGCTGTGAACTCTTC +GAAGAACAGCCCGAAGAGTACAAAAGGGAAGTTCTGCCTCCCGAAGTTACGAAGAGGGTAGCCGTTGAAG +CGGGAAGGGACACGGGCTGGTATAAGTACGTAGGAAGCGACGGACTCGTTATTAGCCTGAACGAGTTCGG +TAAGTCCGCTCCCGGAAGCGTTCTCTTTGAGTATTACGGCTTTACACCGGAAAACGTGGCCAATAAGGTA +ATTGAAAAGTGGTTTTCCTGATTTATAATTATTTATTCGGTAGGAGGGTGTAGCTCAGTTGGTAGAGCGG +GGGACTGTGGATCCCCGTGTCGCGGGTTCGAGTCCCGTCACCCTCCCCATTTGCAGTATCAGGAGGTAAG +GAAATGCCAAACACCAGACAGGCAAAAAAGAGAATGAGGAGAGATGCGAAAAGGAGACTTAGGAACAGGT +ATCACCTCTCAAGGATGAGAACTTATATAAAGAACTTCAGGAGAATGATTGAAAACGGAGAGATTGATAA +GGCTAAAGAGTACATAAACGAAGTTATCAGCGTTATTTATCACACAGCCGCTAAGGGAGTTATTCATAAA +AACGAAGCTGCAAGAAGGGCTTCAAGGGTTTACAAGCTATTAAACAAAGCCCTTCAGCAGCAACAAGCTC +AGGCTTGATCCTTTCCTTTGCCCTCCCTAAAAATTTCCCCTTCAGAAGCTGAAAAGATACAAAACTACCT +TGTTTCATCAGGTTTTAGAAAAATTAATGCACCATATACGTTATGGGCCCTTGAAGGAAACGGTGTAAAG +GTTTATTACTACAAGACTGGAAGTCTTTTAATACAGGGAAAAAATTCCGAAAAAGTTTTAAAAGAAGTTT +TAAATCTACTGGAAAAGAAAAAACTACCGGGGTGTGATGAATCGGGAAAAGGGGATATTTTCGGTTCCTT +AGTTCTTTGCTGTGTTTGCATTCCGGAGGAAAATTACTTAAAAGTATCTTCCCTAAATCCGAGGGATACC +AAAAGGCTATCGGATAAAAGGGTAGAAAGGCTTTATTTAGCCCTGAAACCCCTCGTGAAGGCTTACTGCT +ACGAAATTAAGCCAGAAGAATACAACAAACTCTATAGAAAATTTCGGAACTTAAATAAGATGATGACGCA +CTTTTACAAGCTCCTTATAGAAAGAGTTAAAGAAGAGTGCGGTGTTTCCGAAGTCGTGGTAGACAAGTAT +CAGCCATCAAACCCTTTCGGAGAAGACGTGATATTTGAAACGGAGGCTGAGAGAAACTTGGCTGTTGCGG +TGGCAAGTATATTCGCGAGGTATAAATTTCTCCAATCCTTAAAGGAAGTTGAAAGAGAACTTGGAATAAA +AATCCCTAAAGGAACTTCAAAGGAAGTTAAAGAACTCGCAAAATCGTTAAAAAATCCGGAAAGATTTATA +AAGTTAAACTTTAACGTCTAAAAAGTCCACGTAAGAGTCTTCTATGCCTGCCTCTTCGAGCAGATCTTTT +AAGTTTACCTTAAATTCATAGCAAAAATCGCTTTCTTCTAAGCAGGTATATCCCTTTAAAAGTTCGTAAT +TTTCCAAAAACTCGATAACTTTTTTGCTCATAGTCCTACCTCCTCAGGAAATTTTGAGCTAAATATGAAT +CTATCTTTTAAAAATAATTTGTCAAAAAAGACGATTTTTTTAAAATTTTTAAAAAGATGTTTTAAAAAGA +AAGGGGGTTAGAGTTCAAGGACTTTGCCGGGGTTAAAGAGGTTCTTCGGATCAAACAACTTTTTAATTCC +TTTCAAAAGTTCGTATCCCGTTTCTCCGAACTGCCACTTTAAAAACTTCCTCTTAGTAAGCCCCACACCG +TGTTCTCCCGTTATGGAACCGTTGTAATTGAGTGCCAGTTCAAATACCTCGTCAACCGCCCTTTCCGCCC +TTTCCTCTTCTTCCTTGTTTGACTTGTCATAGAGGAGGTTTACATGTAGATTTCCGTCTCCTATGTGTCC +GAAAACTACCATAGTGAGGTTGTACTTTTTGGCTATTTCCCTTAATTTGGGAAGTGCTTCGTGGAGGTAA +GTCCTCGGGAATACTATGTCTTCGTTTATCTTTCCGGTTTTTAAGTTTCCGAGGGCGGGACCGAGGTTCT +TTCTTGCACTCCAGAGCTTCTGGGCTTCTTCTTCCGATTGAGCCACCTGAACCTTTGCTCCGAGTTCCTC +AAGTATTTTTCCTACTTCCTTTATTTCCTCTTTAACCGTCAGAGGATGCCCGTCCACCTCTATAAGTAGC +AGAGCTTCCACGTCCCTCGGAAGTCCTACGGGTTTGAAGTCTTCAACAGCCCTTATTGCGTCCCTGTCCA +TGAATTCCAGAGCTGAAGGGAATACTCCGGAGGTTAAAATCTTCGTTACCGCTTTTCCTACTGTCTCTAA +ATCATCAAAGAGTGCCAGAGCAGTCATTCTTGCTTTTGGCTTTGGAATGAGTTTTAAAGTTATCTCCGTA +AAGAGCCCCAGCGTTCCCTCCGAGCCGACAAGCAGTTTCGTGAGGTCGTAGCCCGCAACGTCCTTCAGGA +CTGGCCTTCCCGTCCTTATCACCTCTCCGTTTTTTATTACCGTTTCAAGTCCGAGGACGTATTCCCTCGT +CACACCGTACTTGAGACACCTGGGTCCTCCTGCGTTTTCCGCAACATTTCCACCTATAGTTGAGTACTTG +AAAGATGAAGGGTCGGGCGGGTAAAAGAGTCCGAGCTTTTCAACGTACTCCTGAAACTGGTAAGTTATTA +CGCCCGGCTGAACAACCGCTGTTGCGTTATCAACGTCCACGGTGAATTTGTCCATTTTTTCAAAGGAAAC +TACAATTCCCTCCTCAATGGTGGGTACAGCTCCTCCCGTCAATCCTGAACCCGCACCTCTCGGAAATATA +GGAATGTCTTCCTCATAACAAACTTCAACGAGCTTTATAACATCTTCTTTATTTTCAGGAAATACAACCG +CGGAAGGGATAGCCCTCTGAATGGGAATCGGAGTAGCGTCGTAGGCGTAGAGCTTTCTCTCAACTATTGA +GTCCTTTACCTTCTTTTCTCCCAGTGCCTTTTTTAATTTTTCAACTTTTGAGTTAGTCAAGACTTCCATG +GAATTAATATATAGGATGAAAGAAAAAAGCGGGAAATAATTTATCTCATTTAACAACTACGTTTACGAGC +TTGCCTTTAACGTAAATAAACTTCTTTACTTCTTTTCCCTGAACCCACTTCTGAACTCTCTCATCGGAAA +GGACTATATTTTTCACAGTTTCCTCGTCCGCATCTGCGGGGACCTTTACCCTTGCCCTTAACTTGCCGTT +TACCTGAACAGGAATTTCTATCTCTTCCACTTTCAGGGCTTCAGGGTCAGGTTCGGGGATCGGTTGGTTT +ATTATAAAACCTTCATTCCCGAGCATCTCCCAGACTTCTTCCGCTATGTGGGGAGTAATGGGAGAAAGGA +GAAGGGTTATCGTCTCTATTCCCTCTCTCAGAACTTTGTAATCTTGCTCAGTTTGAGGTGAAAAGTCCTG +TAAGGTGTTTAAAAGCTTCATTATCTTTGCAATTGCTGTATTGAATTGATACCTTTCCTCAAAGTCCCTT +CTGTAATCTGCTATCGTCTGGTGAATTTCCCTTCTTACCTCCTTTGCCTTCCCTTGAACGTTTCTGAGTT +CTTCCACTGTGTAAGTTAGGTTCTTTATCTTTTCAAGGTGTTTATTAACAAAGTTCCAGTATCTTTGCAA +AAATCTGTATGCTCCCTGAATTCCCTCGTCTGTCCACTCAAAGTCCTGCTCTGGTGGTGCAGCAAAAAGT +ATGTAGAGCCTCACAGTATCTGCTCCGTACTTTTCTACGGCCTCTTCTGGATCCACTACGTTCGCCTTTG +ACTTTGACATCTTTGCACTTTCGCCTATTTCCCTTTCAAGGAACTTTATGAGGTTTTCATCTTTTATCCC +AAGTTTTTCTAAAAGGAATATAGCGTTATCGCCTACGGATATCTTGTTTTCCTGAAGGAAGTCTTTTATT +TTCATAATTAAAAATTTTATATTGACCCGAAGTTTTTACTTTAGTAAACTTTTAATTGGAGGGCTACAGA +GCCCTACTTTGCTCCTTGGCAACTGAATAGGGTAGGTGGGTCCTAATAAGTGATGTTTCGATGGTGTGAT +GTATTGAAATCATGATGCAACATAGCTAAAAAGATTGAAAATCAAGGATGGAAATTTTATAAAGGTATAC +TCAAGTTTGCAGAACCTCGGGTTAGCGGAAATTAACATTCGTTTCGTGAAGGTTAGGTGTCTAATAAGTT +ATTGATAAAGCGTTATTTTTTGGACACAGGCACACAGGGTTTCTAATGTACCGTGTGGAGTTGAAAGTTG +AAAGAGCTAAAGCAACCGCACCGATGGTTATGAGTTTCTAATGTACCGTGTGGAGTTGAAAGTGGAAAAT +GCTGCAAAAACAAAAAGGAAAAAGCTGAGGTTCCTAATGTACCGTGTGGATGTATATTCATAAGATCATG +AAACTTTCTTACAAAAGAGTTATCCTAACGAGGGAACTTGAGGATATAAAAAAGGATAAACCTCTCTTTG +AAAGAGAAGGCTTTAAAGTTTTGGAGCTTCCCTTAATACAAACAAAAGTTCTTGAGTTTAACCTTCCCGA +TGAAGAATTTGATTACATTGTTTTTCAAAGCAAAAAAGCGGTTAAAATTTTTCTTGGCAAGGTAAATCTT +AAAGGAAACAAAAAAATTGTAGCTGTAGGGAAAAAAACGGCGGAGGAATTGGAAAAATTAGGGTATAAAG +CGGATTTCATTCCGGAAAATGAAAGTGCAAAGGGCTTGATAGAACTCTTTAAAAGATTACCTAAAGGAAA +GGTTCTAATTCCACGTTCTAAAATAGGCAGAACAGAGTTAATAAAGTTTTTAAAGGAAACGAGCTTTGAA +GTTTTTGCGTTGGATGTTTACACAACTGAATACGTTTTTTATACAAGAGAAGAACTCCTGGAAAAACTAA +ACAAAGGAGACTTTATTATCTTTTACAGTCCATCGGCGGTGAAGGCATTTTTTGCAAATTTGCAAATGCA +TAAAATTCCAAAGGATAGTTTGAGCCTTAAATTTGTAGCGATTGGTAAAACTACAAAAGAGGAATTACAG +AAACACTCTGTTAAAAACGTTATTACCTCTGAAAGACCGAGTACTGAGGATATTGTCAAGAAACTAAAAG +AATTGGCACGTGATTTGCAAAAATAATTACGGTATGGGATTAGAAAAGACGGTTAAAGAGAAATTAAGCT +TTGAGGGTGTCGGTATACACACAGGTGAATACTCAAAATTAATCATACATCCCGAAAAAGAAGGAACAGG +AATCAGGTTTTTCAAGAACGGAGTTTACATACCCGCAAGACATGAGTTCGTCGTTCACACAAATCACTCC +ACGGATTTAGGCTTTAAAGGGCAAAGAATAAAAACGGTTGAACACATACTTTCCGTTCTCCACCTACTTG +AGATAACAAACGTGACAATAGAAGTAATAGGGAACGAAATCCCTATACTTGACGGAAGTGGCTGGGAATT +CTACGAAGCCATTAGGAAAAATATTCTCAATCAGAACAGAGAAATAGATTACTTTGTTGTAGAAGAACCC +ATTATCGTGGAAGACGAGGGAAGATTGATAAAGGCAGAACCTTCAGACACGCTTGAGGTCACCTACGAGG +GAGAATTTAAAAATTTCCTGGGAAGGCAGAAGTTTACCTTTGTTGAAGGGAACGAAGAAGAAATAGTCCT +TGCGCGGACTTTTTGCTTTGACTGGGAAATAGAACACATTAAAAAAGTCGGTCTTGGGAAGGGAGGAAGC +CTGAAAAACACCCTCGTTCTCGGAAAGGATAAAGTGTACAACCCTGAAGGGCTAAGATACGAAAACGAAC +CTGTAAGACACAAAGTGTTTGACCTTATAGGAGACCTTTACCTCCTTGGAAGTCCCGTAAAAGGTAAGTT +TTACTCCTTCAGGGGAGGGCACTCGCTCAACGTAAAACTCGTAAAAGAGCTTGCAAAGAAACAAAAACTT +ACTCGTGATTTACCTCACCTTCCTTCCGTCCAAGCTCTCTGAATTCCAGTATCCCGTTTTTCTTACTTAT +ATCCACGACTACTAAGTTAGTGTTCTGCACTCCCCTTACCTTATCAAAGGTATTTCTTATAAGTCTTACA +TAATCCCCGACTTCGTAGCCAAAGGGTTTTAGCTTCTCGTAAAGCCACTTGTTCTGAGGTTTTAACTGAA +AGTACGTAATTTCGTAAGAGACTTCTATCATGTGCTCTACTCCCTCTCCTCCCGCCACTCCTTCTTTCCT +TACCTGCAGTGCTCCTACAAGCCACTTATTTTTCCACTCAACAAGACTCCTCAGGTCCTTTGCTACCTGT +CTCGCCTTCTGTTCGGAAACCGCTCCGGAAATTGAGTCAATGACTATAATTCTCTCTTCCCTTTGGGATA +GTTCTTTGATAAAGTCCTGATCCATGTAGTACTTGAAAACTACTCGGACGTTCTCGTGGTTTGTGTCGTA +CTTTTTGAATATAGCTTTCCACCTGTGGGGTGATTGTTCCGTTAAGACCACGAGTACAGGTTCCCTTTTA +GCTATGTCCGCCATTAACCTCATTAAGGTCTGGGTCTTTCCCGCACCTGCCTCACCGGAAATTCCGATAA +AGGCTTGGGGAAGACCGCCGAAGATGTCAAAAACGGTTTCCTTAAGAATGGGGATTTCGTAATCTCTTAC +CTCGGATAAAGTCTTTACTTTAAGCTCTCTCTTTTCCATAATTGTTTAAAATAATTAAACTTGACACGAA +AGGTTGTCCAGGAATAACTTTTTCTTTTGCAAAGGAGGTGTGAAAGATGGCAAGTAAAGCGAGCGGTGGT +TCAACACGGAACGGTAGAGATAGTATTTCAAAAAGATTAGGTGTAAAGAGGTACGACGGTCAGTTCGTAA +AGGCTGGAAACATTATAGTCAGACAAAGGGGAACGAGAATTTATCCGGGTAAAAACGTAGGAATGGGCTC +AGACTACACTTTATTTGCACTCAAAGACGGTTATGTTTACTTTGAAACGAGGAGGAAGAAGAAGTTCGTA +AGCGTCCTTTCTCCGGAAGAGTGGGAAAAGGTAATGGCTCAAAAGAACGGAAAAGTTCACTGAGCCAGAA +ACTCGTTAAAGACTTCTCTCATCTTTTTCATCTTCTCCTTTATACTTTCTTTCAGTTCCTCGGGTTTCAT +TCCCAGAGATAAAGCTACCTTTGGAATGTCCTGTTCACTCAATACGGAAGTTCCCCTTTCCTTAGAAAGT +CTAAGGTGCGTTTCTACGAGTCTCAGGAACATGAAGCTGTCATAAGCCTCCTTCAACCTCGGGTACTTTT +CCATTAAGACCTCAAAACCTCTTATCATAGAAGTTTCCCTTATTTTTTCTTTGATGAGAAGGTACTGAAC +TAAAAACTCACCGTCCACTATGCCCCCCTCACCGAGTTTGAGGTCCACAACTCCTCTTCCCCTCTTTGCA +ACACTCTGGAGCTTCATCCTCATCTCGTAAACTTCTCTCTTTTCCTTTTCTCCCCAGGGCTTTTCAAACA +GGAAGTTTTCTATCAATCTCTCAAACTCCTCTTTGAACTCTTCATTACCGGTTATGTATCTGGCTCTCGT +CCAGGCGAGTCTTTCCCAGGTTCTCGCTTCCTTTTCAAAGTACTTTTTGTAAAAATCAAAAGTGGGAACG +AGTTCTCCCTTACTGCCCATGGGTCTTAGTCTGAAGTCCACGCTGTAGAGATAACCTTCCGTTGTGTGAG +CGGTTAAAAACCTCACGAGCTCCTTTGCCTTTTCGTGAACCTTTTCCTTTTCTTCCAAGCTCTTTACTGC +GAATACAAGGTCAAGGTCCGAGTTGAAGTTCAGTTCCCTGCTTCCGAGTTTCCCAAGGGCGTAAAGGAGT +GCCGTATTTTCCTCCAGAGTTATATCCTTCCAGAGGTTTGAGAGTATAAAGTCCGCAAGTGTGGAAAGGG +AAATGTACAATTTCTTGAGTTTCTCGTACCTGTCTTCCTCTTTCAGGAGGTAAACGAGCCCTATCCTCAC +TTCCCAGACGGTTTTGAATCTCCTGTAAAGATTCTCAGGGGAGAGGTTTAAGGTTTCCCTGTACTTCTCA +AACTCCCTTTTAAAGTCCTCAAATTTTGGGAAATCCCTGTAAAGAGTAAGGGCGTCTTCAACCAGGTCAG +GATTCCTGGCAACGAGGTGAGACAGGTAATCGGATACGGAAAAAACGGTAAAGAGTTTTTCTAAGAATTC +CTCCCTTTTGTGCTCTGAAAGTATAACTCTTCTTCCCGTAGGGTTAAAGAAGAATTTGAAGAAGTTCTTT +ATGCTCTGGTCAGGGTTTTGAGAAGAAAGTGCAAGGTTCACGAGTTTTGGTATGAGTTTTATGTAGAGTT +TTTTCTCCTTTTCCGTGAAGTGAACGTTCATGGAACCGTACAGGGGCTCGCTGAGGAGGGTGAATATCTG +TCTCGTGCTCTTGAAGCCTTTTTGTTTTAGTATCTGTGTTCCGCTTTCTTCGTCCTCCATAATTACCGCC +TCCTGAAGCTCATCCAGTTCTTCTTCCTCCCTTTCGGGAAGGATTTGAGAGAATACACTTTTTACGAATG +CCCTCGTTTCCTTTAATTTTTCCTCAAACTCTTCCTTGGATTCAAAACCTAAGAACTTGGCAAAGGTTTC +CTTGTCGCTTTCCTTTAAAACTTGCGTCTGGAGACATTCCCTCAGTTGTATCCTGTGTTCCAGTTTCCTG +AGGAATGTGTAGGACTCCTCAAGTTTCTGGGCTTCTTCCGAGGAAAATACGCCTTTTTGCATGAGTTTGT +ATATAGCCCTGTAAGTGTTACTCTCTCTCAAAATCGGAGTTTTAGAACCGAGGAGTATAACCAAGGACTG +GACGCTGAACTCAACCTCCCTTATTCCTCCCTCTCCCGTTTTCACGTTGTAGCCCTTTATAAATTTCTTT +TTGGCTTCCGCTTCTATTCTCTTCTTCATTAACCTTATCTCTTCAACGAGTTTGTAATCCGCCGGACCAA +AGACGAAAGGTCTCACTACTTCTTTCATGAACTTCTGGGCGAGTTCCTCATCTCCCGCACAGTACCGTGC +CCGGAGCAGGGCAAACCTCTCCCATATCCTCCCGTAGCTCTCGTAGTAGAGTTCCGCACTTCTGAGGGGC +ATAGAGAGAGGACCAGACTTTCCGAAAGGTCTCAGGTCAAGATCCACAAAGTAGGGCACACCTTCCGGTG +TTTGAGCGTTTAGGAGCTTTACGACTTTCTGGAATAACCTTTGAAAGAAGTCATTTAAGGAAAGGTTTCC +AGCCTTTCCCTTATCCGTGGAGTGTATGAACATCAAATCCACATCGGAATAATAATTCAGCTCTTCACTT +CCCAGCTTTCCAAGACCTATAACAGTTGCGGTTGCTTCTTTTCCGTTTTCCTCTAGAGGTTTCCCGAACT +TTTCCACAGCTCCTTTAAAGCCTCTCGTAGGTAACTTCCACAAGCGCGTCGGGGAGGTGAGAGTACTCAC +TCAGTATGTCCTCGTATGGGGCTGTTCCGAGGAGCTCCTTTGAGAATATTCTCAAAAGTTCCCTGTGCCT +GTAAAAGGCGAGTTTTTCCGAAAACTTTTCATCCGAATCGCTCTCAGAAATGAGTTCCTTAAGCTCCTTT +ACGTAGTCCTCCTTTTCCTTCCTCAGGTACCAGAGGTTAGGTATTGTGTTCTGAAACTCCGTGGGGTGTT +TTAAGAGAAATTTCCGAAGGCACTGGGACTGCTCAAGTATCATCAAAAGGAGAATGAAACGCCTTTCATT +CAGGTAATCTAAAAGAGTTTTGGGCTTGGGGTGATTCTCAAGGAGCTTTTCAAAGTAAGAGAAGGCTTTC +TCGGGCTCTTTTAAAAACCTTCTTGAGGAAGAAAGCCAGGAGGAGGGAACTGTGGACATTTCATGGTCCT +ATGGTGAGTTTAGTTCCCTTGGAAGGCGGGACGTGTCTCAAAAGGTTGAGGGAAAAGTTTAAGTTGTCAT +AAAGAGTTATTGAGTAGTTATCCCAGAAGACACACGTTCCCGCGAGACAGAAGTATCCGCCGCTCGGGGG +TGCTATCTGCTCCGCTATCAGGAGGGGGTAATTTCCCATGTTTGACTTTGCGGTGTCCTCTCCCCTCGCA +ACTATCTTCGTGTCGGGCATTATGGGTTTTATGGAAGCGGTGCATGCGAGGACTATCTTCTCAACGTTTA +CCTCGTTCTTATCGTTCTTGTTGTATCTCCTTATTTTAGAAGTGACAACGAAGTACTTATCTCCGTTGTG +GTTGTTTACCTCATCCGTAACCTCGTCGGGATTTAGTTCCATACCGAAGGCTCTGGCTAAGGTGTTGCAA +GTGTCCGCTATCCTGTCCTCATTTTTATAGTATCCCGCAAGGATAACTTTCTTTCCGTCCTTCCAGACCC +ACCTTTCCACGTCCTTTACTTCACTTTCAGTAAAAGGTATTTCAGGGTAATTGAAAACTATAACGTCGTA +CTTGTTCAAGCTTTCCCAATCGTTCACTTCGTCTATCTCTATGCCCGCCTTCTCGGCTTCCCTCTGAAGA +ATAGAAAAGTAGTAGTAATCGGTAATGGTAAACTCCTGGTGTGTTATATCCCAGCCTACTTTTACACTCA +TGTGTTTAATTTTACTTTTTTCTCTTGGGTGCTAACACGAATATCATGAAGTTTCCTTCCTTCTTTGGCT +GAACCTCTACCTCCGCTATGTCCGATAACTCGTTTATTATTCGCTCCGCCAGCTTTTTACCTAGTTCGGG +GTATATGTTTTCTCTTCCCCTGAACCTGAGCCACACCTTTACCTTATCCCCCTCTTCTAGGAATTCCCGC +ATGTGTTTGAGTTTCACCTGAAGGTCGTGCTCATCAATTCTCACCTTCATACGAATATCCTTGACCTCAA +TCTGGTGTTCTCTCTGTTTCTTTCTCGCCTCCCTTTCCTTTTTCTTGAGTTCGTACTTGAACTTTCCGTA +ATCCATTATCTTGCAAACGGGAGGTTTTGCCTGAGGTGCTATCTCAACTAGATCCAATCCCTTCTCCTCG +GCTATTTTTAGGGCTTCCTCAATAGGAACTATTCCTATCTGCTGTCCGTTTTCGTCTATAAGCCTGCACT +CCTTTGCCCTTATCTGTCTGTTCACTCTGTACTCTTTCAGCTTACTCATCTAACCTCCTCATAGATTTTT +ATACAAAATCGTTGTTGACAACATAAAGTTTAGGAATAAAACGCTCAAAGACGTGTAAGAAAGCTTCCTG +AACTTTACCCTATCAGGATGATTAAAATCAAGGTTTTCTATGCTCCCCAATTTCCTTTTGAACTCCTTCA +ATTTTTTTGAAATGAATACGTTGACACCCAAGCCTAAAAATAATATAACTCCTTCAAAAAAGTTAAACAA +CAGTCCGTAAAGGAGAAGAACAGGTAAAAATATTCTGTAAAAGTTCCATAAAATTTTTCCGTAAAAGTGT +CCCGCCAAATCCTTATTTTTTTCCGTTCTGAGAAGCACAGGGGAAACAATGAACACGATTGTAAAGAGGG +AACCGGAGTAGAGGGAGAGGATTATCTTGTCCATAACTTCTTTTTTCTTATCTTTGTCATTACCACTCTA +AAGAGAAAACCGCTCAGGAACATAACCGTTATTATACCGATGATTGCAAACAGGAGAAGGTACTTCATAC +AACCCTTTCCGCGTGCCTGTTGGCATGGCACTGAATGTTTACCGCCACCGGTAGTGAGGCTATGTGACAG +GGGTACATCTCAACCTTCACGTCCACGGCAGTAACCGTACCTCCGAAGCCCATGGGTCCCCAGCCTATCT +TGTTTATCTCTTCGAGGAGTTCCTCTTCAACCTTAGCTATAAGCGGGTTTTCGTGTCTCTTTCCGACGGG +TCTCAGGAGTGCCTTCTTTGCGAGGTAAGCACAGTACTCAAAGTTCCCGCCTATTCCTACACCTACCGTA +AAGGGAGGGCATGCGTTAGGACCTGCGAATTTTACGGTTTCAAGGATAAACTTCTTCACCCCTTCCCAAC +CGTCTGCAGGCTTTAGCATCGCAAGCCTTGAAGTGTTTTCGGACCCTGCTCCTTTCGGAGCTACCACTAT +CTTTACCCTGTCTCCGGGAACAACCTCGTAGTGTATTATCGCGGGCGTGTTGTCCTTAGTGTTCTTCCTT +TCAAAAACGGGATCCCAGACCATTGAAGCCCTGAGGTATCCTTCCTCCGTGGCTTCCCTGACCCCTTGAT +TTATGGCGTCTTCCAGAGAGCCTCCTACCACGTGAACGTCCTGTCCGAGGAAAACGAAGATTACGTCAAC +CCCTGTGTCCTGACAGTATGGCATTTTCTCCTTTTGGGCTATTTCCGCGTTTTCAAGTATCTGAGTAAGA +ACCTCCCTTCCTATGGGAGACTCTTCCCTTTTTAAGGCTTCCTGAAAGGCTACTCTTACCTCCCGAGGAA +GGACGCAGTTCGCCTCTATTATAGCTTCCTTGACAGCTTCTTTTATATCATTGACGTGAACTTCCCGCAC +TTAGTATACCCTCCGCAACTTCAACGGTTTTCTTAACAGACTCGACGGAACGTCTCCACATTTCCCTTTC +TTCTTCTATCATAGGCACTTTTATTATTTCTTCAACCCCGTTAGAACCAAGTTTCACGGGAACTCCCACG +CAAAAGCCCTGAACTCCGTAGTACTCACCTGCTTCTCCGTCAAGGTAAACACTGCAGGGGAGTATCCTCT +TGCTGTTCTGGACGAGAGCCTCTATCATGTCCACAATTGCCGCCGCAGGAGCGTAATAAGCGGAAGTTCC +CATGAGGTTTACTATCTCACCGCCACCAAAGCGTGTTCTTTCTATAATCTTTTCAAGCTTTTCCTTTGGA +AGTAAATCCTTTAAAGGTATTCCTCCCACGTTAGAAATTGAAATAAGAGGAACCATCTCATCACCGTGCC +CGCCTATCACGTAAGCGTGGATGTCTTTCGGAGAAACCATGAGTTCTTCGGAAATAAAAGTTTTGAACCT +CGCGGAATCAAGCACTCCCGCCATCCCCATTACGCGGTTCTTAGGAAAGTTAAGGAGCTTGTAGGCTACG +TAGGTCATGACGTCCACGGGATTCGTAACAACAATTACTATTGCGTCTGGTGCGTACCTCTTAATCCTGT +CCGCTATAACCGAGATTATCCTTATGTTTGCCTCAAGAAGGTCCTCTCTGCTCATTCCCGGTCTTCTGGG +AAAACCCGCGGTAATTACCACTATGTCGGAACCTTCTAAGGGTTCGTAGCCTTCGCCCTCAGGTGTCACA +GTATAGCCCTCTACCCTCGCATCTATGTCCATAGCTGCGAGCATCTGCTTCATGTCGAGGGCCTTCCCTT +TAACTGGCTCAAAAACTTTCTCTTCCGTTTTTCTGGGAAGGTCGAACATTTTAACGTTTGCGAGGTTTTT +TAAAAGGATGAGGGAGGCGACGTGCTCCCCCACGTTCCCCGCACCGATTACAGCAACGGTTTTTTTCATT +CTCATGCGGAAACCTCCTTCCTGTGTTTGTTCTTTATGTAGTTGAGTCTTCCGCCGGCTATGAGTATTTC +CTTCTGTACGGGTGTGAGGTTATACGTACACAGGATTTCCTCTCCCGTGGTCTTGTTTATTACGAGTATG +TCTTCACCTTTTTTGAGTCTTTCTATGAGGTTAGGTATTTCTATCTCATCTCCTAGACTGAACTTGTCGT +AATCCTCCTTATTCTTGAACTCTAATGGAACTACTCCGAAGTTTACGAGGTTTGCGTGGTGGATTCTCGC +GAAGGACTTGGCTATAACTGCCCTTACTCCCAAGAATCTGGGTGCTAGTGCTGCGTGCTCTCTGGAGGAA +CCCTGTCCGTAGTTTTCTCCGCCGATAATTATTCCCGCTTTTCCTTTTTCCTTTAATTTCTTCATTCTCG +GGACGAATTCGGGATCAACGTAGTGGTAAACGTACTCGGAAATAGCGTATATGTTGGACCTCAAGGGGAG +TATCTTCGCACCTGCGGGCATTATGTGGTCCGTGGTTATGTTGTCTTCAACGATGAGGGCGACTTCTCCC +TCTATAGTTTCGGGCAGGGGTTCAAATTCGGGGAGAGGTTTTATGTTTGGACCTCTGTATATTTCAACTT +TTTCCCTTTCCTCCTTGGGAAGAGGCGGTATGAAGGCTTCGTCTCCGTATGGGAACTTTTCGGGCATTTC +TACCCTTATCCACTTTACACCTTCCCTTTCAGCGAGCTTTCTCGGGTCTATTATCTCCCCAGCTATTGCC +GCGGCAACACAGGTCTCGGGAGACGCGAGGTAAACTTTTGCGTCAGGCGTTCCAGCCCTTCCCTTGAAGT +TCCTGTTGAAGCTCCTTACGGAAACTCCGTTCGTGGGAGGAGCGAATCCCATTCCTATACAGGGACCGCA +TGCACTCTCCAGAATCCTCGCTCCCGCCTTCAGGAAGTTAAGAAGTGCTCCGTTCTGGGTTATTAATTCT +AGCGCCTGCTTAGAACCGGGTGCTACCGCAAAGACTACGTCCGGGTGAACCCTCCTTCCTTCAAGGAGTT +TAGCAGCTCTCGTTAGGTCAACGAAGGAGGAATTCGTACATGAACCTATCACTACTTGATCCACTTTTAT +TCCTTCTATTTCCCTTACGGGAACAACGTTGTCCGGGGAGTGAGGTTGAGCTATTAGAGGCTCTAATTCG +GAGAGGTTTATCTCTATAACTTCGTCGTACTCGGCGTCAGGATCCGGTAGGAGTTCTACCCAGTCCTCTT +CCCTTCCCTGAGCTCTGAGGTAAGCTCTAGTTATTTCGTCTGAGGGGAATATTGAAGTTGTAGCTCCGAG +TTCCGCTCCCATGTTCGTTATGGTTGCCCTTTCCGGAACGGAGAGTTCCTTTACCCCCTCTCCGAAGTAT +TCAAATATCTTTCCGAGACCGCCTTTTACGGTGAGCCTTCTGAGGAGTTCAAGGATTATGTCCTTTGCGG +TTACCCACTCAGGCATTTTGCCTTTGAGGTGTACACCCACGATCTTGGGCATCTTCAGGTAGAAGGGTTC +TCCCGCCATGGCTGCGGCAACGTCCAATCCGCCCGCACCTATTGCGAGCATTCCCATTCCGCCCGCGGTA +GGTGTGTGGGAGTCCGAACCGAGAAGCGTCTTTCCGGGTTTTGCGAACCTTTCTAAGTGAACTTGGTGAC +ATATGCCGTTTCCGGGCTTTGAGAGCCATATACCGAACTTCTTAGCTACGCTCATCAAGTACTTGTGGTC +GTCCGCGTTCCTGAAGTCCGTCTGGAGCATGTTGTGGTCTATGTAGGACACGGAGAGTTCCGTCTTTACC +TCGGGAACGCCCATCGCTTCGAACTCGAGGTAACACATAGTTCCCGTAGCGTCCTGAGTCAGAGTCTGGT +CAATCTTTATCGCTATCTCCTCACCGGGCTCCATTTTTCCCGAAACAAGGTGGTTTTTAATGATCTTCCA +CGCAACCGTCCCTTTAGCCATACTGACCTCCTTTCAAAACAATTTTAAAACTTCATTTTAAAATTAGAAA +CCTTCAAAAGCCCAGCAACTCTTTTAACTTCCTGTAAGGATTCTCACTCTTCATAAGGGAAGTGCCTATT +AAAAAGCCGTCCACCTGATAATTCATAAGTTCAAGGATCTCCTCCCTTTTGGATATCCCGCTCTCGGAAA +TCACGAACTTCGCCCCGAGATCCTTTATCTTGGGTGCAAGTTCCTTAGTTTTGTTTATATCAACTTTAAA +CGTTTCGAGATCCCTGTTGTTTATACCTATAATTTTTGCTCCGGCGTCGAGTGCCCTCTTTGCCTCGTCC +AAGGTGAATACCTCAACGAGTGGTGAGAGACCGAGCTCCTCGGAAAAATCGAGTAATTCCTTTAACTCCT +TGTCTGAGAGCATTCTCACTATTAAGAGGACTATGTCCGCACCGTATGCCTTTGCTTCCAGTATTTGAAC +TTTGTGAACAGTGAAGTCCTTCCTCAGAAGCGGAAGTTTTACACTTTCCCTTACATTTCTCAAATCCTCT +AAAGAACCTTTGAAGTACTTTTCATCCGTCAGAACGGATATTGCAATCGCCCCAGCTTTTTCGTAGAGTT +TTGCCTGTTCTTCCGGGTTAACCTCCTTTATATTCCCTTCAGAAGGGGAGGCTTTTTTAACTTCTGCGAT +AATTTTAGTCCCGCAACTCGTGAGGGCTTTCTCAAAGTCGTAAAACTCCTTCCTCTCTTCTATTAATTCT +TCAAGTTTCCTGAGGTATTCCGGGGAAGTGTCAATTTGACTCTCTTTGTAAGATCTTACCTCTTCTAAAA +ATCCCATAACTAATTAAGATAGCGAGTTCTTCTCTCAAAATAATAAGAAAGACATAGTAGAACAGGGCGT +AAATGGGGATAAAGGATACGAGGATAAACGGATTTTGAGTCAAAGACTCCGTTAAGTATACTAATCCTCC +CATAAAAGATGAGGCGATAAGGTACTTTATCAGGTTTCCGAAGGGAATACTCACCTTTTGAGGGAGTTTT +TGGTAGAGATATACAAGGACTGAGGAGGAAGAAATCAAAGCGGCGAGGGGAAAGGAGTAAACGCCGAAAT +TAAGCAGAAAGATAAATACTGAACCGAATAAAGCCTCCAGAAAGACGCTCAGGAAGGCACTTTTTGTGGG +TATTTCCACGTTCTTTTTTGAGTAGTAGACGGTCTTTAGTATGTGCTGGAGTGAGTAAAAGGGAACGCTA +AAGGCGTAAAGACTGAGAAGTCCCGATGTGTAGAAAAGGTCTTCCTCCGAAAAATTTCCCCTTTTGTAAA +GTACGCTCACGATTTCCCGCGAAAGAAAGAAAAGTCCGAAGGAAGATGGAATACTCAACATTAAGGTGAG +CTTTAAGGCTGTATCCGTGTCCTTTTCCTTATCTTTTTTTGTGGACACGAGGGCAAGGAGCGTATTGCTC +AAACTTATTGAAAAAAGGCTTATAGGGAGAAGGTAAATCCTAGCAGCGTAGTAAACGTAGGAGATGCTAC +CTACTTTCAGGAAAGATGCGAGAAAGGTATCTACAAATAGGGAAAGCTGGTTCGCGGAAAATCCTCCTAG +CGTAAATAAAAACTTCTTTAAAAAGGTTTTAATCTCTCTATCTAAAGAAAACTTCGGGATTTTCAGGAGT +TTTTCCTTAAAAAGCAAAAAAGTGTTTGGAATTATTTGGAAAAGTCCTCCGATCAAAACCGCGAGTGCGA +GAGAGTAATGTCCCAAGGTGTGGAAAAGAATTACCAAAGAAAGTATAAAACCTAAGTTGAAGAGCGTTTG +AGAGACGGAAGGAACGAAGAACTTTCCCTGAACGAGGAGTATAGCCATACTGTACGCGTAAAAGGAAACT +AGGGGAAGGTACAGAATCGTGAACTTCAGAAACTCAACAGCGTAACTAAAAGTCTCCTTTTCCTTTATAC +CGGGAGAAATTACGGAGATAATTTCCTCGGGAAAGAGCAAACCGATAATAACAACGGAAAGAGAAAAAGT +TATCAGGAGTCCGAAGGTTTTCCTTAAAAATTCCTCTTCCCTGTTTTGCTTTACAGCTTCACCGTAGAAA +GGGATAAATACCGCGTTAAATCCTCCCTCTCCAAAAATCCTCCTGAAGGCGTTCGGTATTCTAAAGGCTA +TGAAGAAGGCGTCGGATACTGCACTCGCACCGAAGTAATAGGCTACCGTTGCGTCCCTGACGTAACCGAA +AATCCTGCTGAGAAGTATTCCTAAGGAAAATAGGAGGGAAGCGCGAAAGAGGGAAGGCAAGTTTTTAGTC +CATATCCTCTTTTTCTATTTTTTGTTCCTCGGATAACTTCTCGACTTCCGTGTCGTAGAACCTGTTTTCG +AGCTTCTTGAGAACTTTCGGGAGCGTTGTATACTCCATCTCTTCCGCAGGGAGTCTGTGAGGTTCGAATA +TTCCCTGTCTCCTGAGTATATCCGCCATATCTTGAGCTACCTGTCTTGCCTTATCAAAGGCAGGATCTTT +GAACATATCAGCAGGTCCAATGAGTTTTCCGTTGGCGAGCTGGTATCCCGCACCTATTACTCTGGGAGGT +CCGTCAAATCTGGAGGGTCTTGCGTCTTCAAAGGAAACGGGCATTAAAGGTCCGTTGTGGGAACCCCTCA +TCCATCCTTCAACTATCCAGGGTCTTGCAAAGGGTTCGAGAATTTCTCCCACTGCGGGAAATCCGCTCTG +AGCCCTCACGATCAGGACGGGGTCGTCCTTTCCTACGTACTGACCCGCTATGAGTGAAAGCCTTTGAGTT +GAAGCCGTTGCGGCAATTTCCCCGTCGTAATTCCTGTAAACGTTCTTAACGACGTACTTTCCGACGGAAC +CTATTAACGCAAGGAGATCGTAGACTTCAGCAGGGGTATTAAGCTTTACCGCCTTTCCCGTGTAAACGTC +CAGAACTTCAAAGGTAAATCCGTCGTGCATTTTGGGGTCTATTACGAGCCCGGCTGTGTTCATGGGATCT +GCGAACATCTCGTAAAGCGGTAAGTTCCAAGCACTCGGAGAAGTTTTGTCCGCAAAGAACACTATTACGG +GTTCAGAGGGTCTTTCTTCAAACTCCATTTCCGCTACGCCCGGACCCATTCCCTTAACGTTTCCGCTGAA +GGTATCCGTGAGGAGGTCCTGTCCCGCTCCGTAGAGTTTTAACTTCTTTGCGACTTCCGTTCCCTTCATA +AAGGCGTCCCAAGCTATCTTGTGAACCAGTTCCGCGTCCACTCCGTGAGTATGAGTCATAACTATCGCTA +TATCGTCACCGCAGGTCAAAATATCACAGTCTATGAGGTTTCCCTTCTCTACTTCTTTTTCAACGTGTTC +TCTTACAGCGTTTACAACATCAGGGTGAGTTGAAGAGTGTCCCACAAACCCCCCTATGTCCGCCTTAATC +ACGCTCAAAGTTACCTTCATAATTTACCTCCCTTAAACTTTTAGCTCTTCAATTTTCTTTTCTATCTCGG +ATAGTTTTTCTTTGAGGGCTTCAACTTCCTTCATTATCTTGGGATTGTAGGCTATTTCACCTTTGGATAT +GTACTTCGCCCTGTTCTTGAGCTCTTTTATCCTTCTCCTGATTCTCCTGTACTCCCTCAGGTAGAACCAC +CTCGCTATTGCGGAAGCGGTTTTTAATATATCCTTGTCGTACCACCTGAGTTCTCTTTTGAACCTCCTCC +TTTCCCTCGGTGGTGCATGCATGCAGAGTATCTGTATTTCCTTTCCCCTGCCGTCTTTTACTAAATTCTC +CATTACGCTCTGGAAGGAACCTTGGTACTTTTTCTTCTCATCGCCTATCTTAACCCACAATTCCATTTCC +GAACCTCCGTTTCGTGTGGTGGACTAATATATTTTATTAAAATTTCTTAAGTTCTATGCCGTACTTCTTT +ATCCTGTAATCCAGCTGCCTTAAGGTGTAGCCGAGGAGTTTTGCCGCACGTGATTTTACGTAACCCGTTT +TCTCCAGAGCTTCTATTATCCTTTTCTTCTCCGTCTCCTCTATAAACTTCGGAAGGTCACCCGTTTTCCT +TTCTCTCTTCCTCAAAAGTTCGGGAAGTTCAGAAGAGGTAACTCTTCCGTTGTTTAAGATGACGACCCTT +TCTAGTATGTTTATCAATTCCCTTATATTACCTGGATAATCGTACTCCAGTAAAACTTCCAAAGCGTCTT +CCGAGAGGTAAACTTCCTTGCCGTACTTCTTATTCAATTCCTTTAAGTAATACTCAATCAATATCGGGAT +GTCTTCCTTCCTTTCCCTGAGGGGCGGAACGTAAAGAGGTACAACGTTTATCCTGTAGTAAAGATCTTCC +CTGAACTTGCCTTCTTTGACTAGTTTTTCAAGGTCTTTGTTCGTTGCCGTTATTATCCTCACGTCCACTT +TTATAGGTTTTTCACTTCCGAGTCTCTCAATCTCCCTTTCCTGAAGGGCTCTCAGGAGTTTTGCCTGGAG +GGAAAGGGGCATGTCCCCTATCTCGTCGAGGAAGATGGTACCCCCGTTTGCCAGTTCAAACTTTCCTTTT +TTAGTCGTATAAGCTCCCGTAAAGGCTCCCTTTTCGTACCCGAAGAGCTCCGACTCCAGAAGAGTTTCCG +GAATGGAGGCACAGTTTACGGTAAGGAAGGGCTTTTCCCTCCTGCTGCTCTCGTAGTGGATTATCCTCGC +AATTAAGCTCTTTCCAGTCCCGCTTTCTCCGAGTATGAGAACGGTGCTGTCGGTTTTCGCCACCTTTTCT +ATAGTGTCTATTAATTCCCTCATAACCTTACTCTTTCCGATGAGACCGTGAAGGGAATACTTTTCGCTCA +GTTCCCTCGTCAGTTCCTTTCTCTGCTCTTCCCAAGCTTTTTTCTCACTCTCAAACTTTTCCCTTAACTT +GAAAAACATACCGAGGAGGTTTCCGATTACGTTAATCGTCTGGTAGAAGTTCTCTAGACTCTCTTTATCA +CTAAACTCCTTGAATATCGTAATAACACCCTTAACCTCTCCACCAACCTTTATGGGAGCTGCTATGAGAG +CGTGTTTTTCCGTGAGAAGCCTGCCTATTCCCGTTTTATTGGCAAAGGCGGAATTGTGTTTTACGTTAGG +TATAACGAGGGGAATCCCCCTCTGGAACACCTTACCCGTTATCCCTTCACCTTTTTTAAATGCCACGTCC +TTATTCAGAAAGTACCCGTAAGAACTAGCAATCCTTAAGGTATTACCCTCCCTTATTGCTATAAAACTGT +GTTCCACACCGAGGTAAGAGTAAAGGACCTTCAAAACTTCCTTTAAGCTCTCTTCAAAGGTATAATCACC +CGTGAGGATTTTCGTTATCTCGTTTACAACGTTTATCTCCTTTAATTTCAGTCTCTCCATTTATTTTTAA +TTTAGCTTTTCAAGAACTTTCTTCGGAACGAAGCGCCTTACCTTTTCACTGTTTAAAACCTTTTTCACAA +AGTTCGGATAGGCTTTGTAAAAGCAAAAGAGCGCAGGAATGAAAAAGGGGCTTGACGGAATTATCGGTAG +TATAAGACCTATAATTCCGAATATTGAAAGGATAACTCCGCAAATCACGTAAAGAAACTTCATTTTCCTT +CCCTTTTCCACAACAAATAACTTACGCTTATAACTCCGAATAAGTATATAAGTAAAGTGTTTGAAAATGC +CACGAAGTAGGTCAGGAAAAAGAGAGGCGGAAATAAATGACTCATAACAAACTGAAACAGGAAGATAAAA +AGGGAAAAGAAACCTATTACAAAAGACGAAAATAGGACTTCTAAGGAAAAGGCGAGTTTCCAGAGGAGCT +TTGAAAAAGGAGCGGTCAAGAATAAAAAGAAAAAGTCCCTAGGCGTTTGCCCTTCTATAACCGTTCTCGC +AAAAAACACGGGATAGGAGGTAATTATCCAGAAGTACAGGATTAAAAGAAGAACTATAAAAATCAAGTAG +GCGATAATAAAGTCCGTTCCGAAAGTAAATACGGTAATCCCTGTTATTAATCCTAATATCAACAGAGAAA +CGAACAACAAAATCAGGTAAGCTACCGTCATGGCATAGGTCGCAAACGTCAGTGTTACGGCGTGCGGAAG +GTAGGTTTTTAAGGCCTGTGCAAGTTTAGTTCTTTCTATTTCCCTTTTATATTCTTCTTCATTTCCTTTC +ACCTTAAGGTAGAGTTTTGAAAAGTAAATAATGAGTGAAAAATTCACAACGTTGTGTATAAAGAAGGCAA +ATACATTCATTACAGGAATTAAAAAGAGAAAGTTCAAAAGTGTAAAAAGGATAATAAGTTCGGCGGTTAA +GCGGAAATTTTGGAAAAGTGTGATGGACCACACATTAAGAGCGTGCTTCCACATTCTAAAATGAGTATAC +ATGAGAATACTTGCCATCGGAGACATCATAGGCAGACCCGGAAGGAAAGCCTTAAGAGAACTCCTGCCGC +AACTCAAGGAAGAGGTAGCCTACGACGTCGTTATAGCAAACGTTGAAAACTCCGCAGGAGGCTTTGGGAT +AACCAAGAAGGTTTACGAGGAGCTCCTTGAGATAGGCATAGATGTAATGACTTCGGGAAATCACATCTGG +GATAAGAAGGAGGTTTACAACTTCATCGGTGAAGCCTACAACCTTCTGAGACCAGCAAATTACCCCGAAG +GCGTTCCCGGGAGGGGTTACGGGATATTCAAGAAAAACGGCGTTGAGTTCGCGGTAATAAACCTTATGGG +AAAGGTTTTCATGGACTGTAACCTAGAAAATCCATTCAAAACCTTTGACAGGATATACGATGAACTGAAG +GACAAGGTAAAGATAATTGTCGTAGACTTTCACGCAGAAGCTACTTCCGAGAAGTGGGCTTTCGGGATTT +ACGTGGACGGGAGGGCTTCCTTTGTGTACGGCACGCACACACACGTCCCCACCGCGGATGAATTTATCCT +GAAAAAGGGAACTGGTTACGTGAGCGATATCGGAATGACTGGTGTATGGTACTCCGCAATAGGAATGAAA +CCAAAGGAGGCGATAGAACGTTTTCTTTTAAGCCTGCCGAGGAGGTTTGAAGTGGAGGATAAAGGAGAGA +TAATGTTCAACGCAGTTCTCGTTGACATAGATGAAGAAACAGGTAAAACTAAGAGTATAGAGAGGATAAA +GAGGTTCCTATGAGGGAGGTAATAACGCTTCTCTTTGCACTCGTTTCGTTTATACACGGAAGCATTTCGG +AGAAGTACGAACTATACAGAGAGTTTTTAGAAACAAAGAATGTAAAACTCGCGGAGAAAATTCTCAGAAA +GTATCCGAACGCACCTTTTAAGAACGAGCTTTATATATTTCTTATTGAGAAGTACTACAGGACGAACCCG +CGTAAGGCGAAAATTTTTATAAAAAAGCTGAACGTAAAAAGAATTCCGTATTACAAGGTAAAGGAATTTG +TAAAGATTTACAAAAAGCTGGGACTTAATTTAAAACCTTTTGTGGTACAATATCCCGAGTTTTTCTTAAA +AGATTTAAGAAAGTTCAAACTTTCCCAGGAGGAAAGGGAAAAAATAGCAAAGAGATTGTACAGATTGAGG +AAGTACAGGTACGTACTGAAATTAACAAAGGACTGTTACCTCAAGGGAAAAACTTATTACAGATTAGAAA +AGTACAAAATAGCGGAAAGGATATTAAAAAACTGTCCAAAGAAAGAGCCCAAAAGTTTTTGATTTACGTT +TACCTAAAGCAACGTGCCTATAAAAAAGCCGAAAAATTTGTAAGGAGTAAGAAAAATCCTGAGCTTTACT +TTATCCTTGGAAGGGAGTTATTAGAAAGGGGACTTGCGAACAGAGCTATTACTTTTCTGAAAAACTCTAT +GAATACGGAAGCGAACTTTTCCCTTGGCTTGGCTTACTACCTGAAAAAAGACTACGAGAAGGCTAAACAC +TACTTTTTGAGCTACCATCCGCCAGACGAACTGGGAAAAGGAAAAAGAGATTTCTGGCTTTTTAAAACGT +ATCTTCAGCTGGGAAACTCCGAGAAAGCTCTTGATTACTTAAAAAAGGCTTCTTCTTACGATAACTTCTA +CGGAGCTGTTTCAAGAAAGTTATTAGGTTTGAGGGTGTATAAACCTGTTCAGTTTTCTTCCGTTGAACCG +CCGAGGTTGTTTCCCGAACTTTACAGAATAAGAGAATTGGGATTTTTGTCTTACATGCGATATGAAGCTT +TCAGGCATGAACACCTGGCTACCACGGGAGATGTCCTTTTGATTTCAAGGATTGATCCGTACACGTCAAT +AAGACTCGCCGTAAAAAAGTACGGTGTGAAGTCGGAAATATACAGGGTGGTTTCTCATCCCACTCCCTAC +GAAAATCTGGTTTTTGAAGCTGCCCAAAAGTTTGAAGTACCGGTTCCCCTTATATACGCAGTTATGAGAC +AGGAAAGTTTATTTGATCCGTACGCTGTTTCCTCTTCAGGAGCAAAGGGGTTGATGCAGTTGATTGATTC +AACTGCGAGGTGGAAGGCGAAAAGGCTCGGTTTAAAGATCAGGAGCGTGTTTGATCCAGAGACGAATATA +ACACTCGGTACAGCTTACCTGGCTTTTTTAATGGATTACTGGAACGGAGATTTAATTAGAGTTATTGCTT +CTTACAACGCCGGACATGGAGCCGTTAGTAGATGGAAGAGGTACGAGGACGACTTCTTATTTATAGAACT +GATTCCCTACAACGAAACGAGGAATTACGTAAAAAGGGTTTTATACAATTACTACGTTTATTCGGAAAAG +TTAGAAAAGGGTCTCTGACTCTTCCAGTTCTTCTACTGGTCTTCTTCCCGCAAAGCCTTCGTTCAATTCG +TGCCAGTACATAATCGTTTCTTCATCTTCCTTCCAGCATAGCCATATGTACCTTCCGTTGTGTTCGGAGA +GGAAATCAACCAGTAAGGGGTCAAGACCTTTTATAACTCCCCCGAGTTCCTCTATACGAGCGAGATGTCT +CTTTATTTGGGCTTCCAGTTCTTTTATTCTCGTCTTTACGTACATTTGTTCCAGTTCGTCTTCCTGAGCG +TTTAACTCTTCGTACAGGTTTCTCAACTCTTCTTTTTTATGTCTTATGTCCTCCGCAATTGGCTTTATCT +TGACAAGCAGGTCTCTTGCCTCTTTTAACGTAAATACCCTCATGCCACAAATATACTAACTTTTCACAGA +CAGATTTATGAGGAAAACCATCACTCTCCCATCAGGATTTCGTTTTCTATTTCAAAGTAAACGTAGTAGG +CGTTTACAGGGTTCACGTTAAAGAATACAGGCACCTGAGCGTAAGAGGGATCTATCTTTATCAACTCCTC +GTTTATCCTCTCCCTTACGCACTCAACGTCACAACCCTCTTCGTAGAGTTTCCTTATAGTTTCCCTCAGA +TCCTTTATGTACTTCCTCGTCCAGCTTACCGCTTCTTTTATCTTTTTCTCACCAATTAAAGCTTCCCCGT +GTCCCGGAAGGAGTATTCTTGGTTTCATCTTAAGAATTTCGTCAAGACAAACAAGCCAAGTTCTTGAGTT +CCCAGAGCCTAAAAAGGGCAGTCTTCCGTCAAATACTATGTCCCCGCTGAAGAGTACCTTTTCGTCGGGT +ATCCATACGACTATATCTCCGTTCGTGTGAGCCCTGCAAAGGTGCAAGACTTCAAACCTTTTGTACTCCT +TTCCCACCTGAAGGTAGACGTTTAAGTTTTTGGTAAGTGTTATAGTTGGAGGAGTTAATTCCGTTCCTTC +CAGATGTTCCTTTAAAATTTTCTTTCTTGCTAAAAAGAAGTTGTAACTCGAAGGTTGGGATATGTAATCG +AATGCCCACTCGTGGGCTATAACTTCAGCTCCAACTTCTCTGAAAGCTTTTGCACCGTAGAAGTGGTCGG +TGTGATAGTGTGTGACGACTAAAAACCTTATGGGTTTATTCGTAACGCTCCTGATGCTTTCTATTAATTC +CTTCCCTAGTTTGTAAGTGCTCAAAGCATCCACAACGAGAACGCCGTCATCGGCTACGTAGAAGTAGGCG +TTGGATATAAAACCCCTGTTTTCGTAAGATACCTGTTCGTAGACTCCGAAAACTCCGTAAATCCTGTCGG +TTATCTTCCTTAACGTTTCCTTTACGTGTTTAGGATACTCACTCGAGAAGGAGAATAAAACCAGGAGAAA +AAAGAAGAGAAAGCCCCCCATAATACTCTCCTGAGTTTCTATTCAGGGTTCTTTTGGCAGGTTTGTTTGT +GAGTACTCGTTCCAAGAACCGTCGTACAACCTCACCTTATCCGTAAGCCCGAGGTAATACTTTATCACAT +AGTAAGTTGCCGCGGACATAAGCCCCTGTCCGCAGTAAAGGATTACTTCCTTTCCTTTTCCTATACCGAG +ACTCTCGTAAAAGAGGCTTATATCTTCCTTCGGTTTTAGTAAGTAGTACTTTTTTCCGTACTTGTTAACG +TGCTCTTCAAAATCTTGTTTCCAGAACCTGTTTACGGCTCCCTTTATGTGTCCCAGCCTCTTCCAGAATC +CGGCCTTTCCTTCGTAAAGTTCCGGTGTCCTGGCATCGAGAAAGACTACGTCTTCTCTGTTTAAAGCTTT +TTTAACGTAATCGAGGTCGGCTCTTATACTTTTGTTTATCGTATACTTTCCGTAACGTTTTTCTTTAACT +TTCGGATAATCCTTTGTCGTAGGTAGATCCTTATCCTTCCAGTGGTTAAATCCTCCGTGAAGGACGTATA +CTTTTTTGTGGTTTATGTAATCAAGTCCCCAAGCTACGTAAAAGGGGATGAAAGTCCCCTCAGCGTCGTA +TAGAACGACGGGAGTGTTCTTATCTATTCCGAGTTTTTCGAGTTTTTTGACGAATATTTCCGTGTGTAAG +AAGAAAGCAGGAGTTCCACCTTTCGGAAATCTGAAGGCTTCAAAGTGCACCCACTGGGCTCCGGGTATGT +GCTCCTTCCAGTATTCCTTTATGCTTTTCCTGAGGTCTATTATGACAAGGTTTTTCTCCTCTTTTATAAG +TTTGTGGAGTTCTTCAGGCGAGATTAAGTAAATCTTTGCAAAGGAAAGTGTAAAAAAGAGTAAAAACAAA +ATTACTCCTCTCATCTCAGAACCCTCCTTTTACCTCTTTAATAGCTTCTTTTATGTCTTTGTCAGCCTGC +AAGAAAACTTCCTGTGCCTGAGGAGTCAGGTACTTTCTGAAACCCTTCACGAGGTTAGGTATATTTATGT +AACCCACCTCAACGCTTCCATCTTCCTTTTCAAGTATATAAATCCTGCAGGGTGCTAGTGCCCCAAATTC +GGGAAAAGTTCTGAGAATTTTTTCACCGTAGGATAAGTTACAGACGTAGAATACTGTCATTCTTGGTTTT +TGAGAGACATCTTGAACAGCCAGAACGTTCATATTCTTACCGTCAAGGGCGGTTTTCAGGAGTATTTTCA +CGTCTTCGTAGGGTATGCCCTCAATCTTTTCCTTATAGAGCATTTTCTCCTGGGCTAAAACCAAGAGAGG +TAATAAAAGAACTATTAAGAACTTCCTCATTTCCTTACCTCGTCAAGGGTTTTTCTCAAGTTTCTGTAAG +TGTTTATTATGAGGTTTGCTTCCTCGTCCTTAAGTTGTTTTGCATACTCTGCAAGGAAAACCATTTCCTT +CATGGTTGTTATTCTTAGAACTTCTTTTGTTTCGTAAACCGCAACGCTACAGGGGATTAAGTTCGTGAGT +GCAGGGTATTTGGGAAGTATATTCTCCTTTCCGGGAACGTCGCAGGCGAGTATTATGGAGTACTTTGGAA +AATCTTTTACTCCTCTTCCTTCAAGAGCCTTTGAAAGGGGAAGGACTCTTACGACTTTCAGTCCGTTTTG +GTTGAGCTTTTCCTCCAAAGTCTTTACAACGTCGTCAAAGCTTTTGTTCTGTACTTCCACGGTGTAGAAG +AGTATCCTGAAGGGATTACCGAAGTAATACCTTATGAAGTAAAAGATTGAAAGGGCGATGACCGCCCCGA +TCAGGAAAGCGATTAAAGCTCTCACTTACCACCTCCGTAGCACTCGTCGTAGGTGTGGTACTCTGCATCG +AGAACCTTTACGTTCGGCTTGGTTCTCACGTTTATGCTTCCCTTCTTCTTAATGTAGTTTATCAGTATCT +CGTAAACGGGTACCGGTTTGTAGCCGGGTTCTACGGCTTCGGGCGGTGGCGGTGGTCCTCCGTAAACCGC +GACGAGGTACTCCTTCTTTGGTTTCAGTTCTTTTCCGCCTATCCACACTCTCTTTATCCTGTTGTACTGG +GGTCCGTTTACCTCTATTTCGTACTCAACGTTCCAGATTCTGGACATGTCACCACCTTGCTGGTAGAAGG +GGTTAGGATTGAACACGTTGTCCGCAACGTCTTCCCATACGGCCTTTAGCTGTTCTCCCGTTCTCTTCAA +GACGTAAACGTTCGGGTAAGTTATAGCCGTAAAGGCGTAAACGTGATCTACAGTTATCTTTTGTCCGGGA +AGGACTACAGTTCCCCACCTGTAACCGGGAGATGTAACTACGTCAAGGTCTCCTCCGTAGTAATCGTTTA +TGGCTTCCCCAACGAGCCAGTCCCATGTGCTGAAGAAAGTGTCACGTTTGTAGAGCATCACCTCGGCGGT +TCCTATTTCTTTGGAAAGTCCCAGTTTTTTATCCACTTCCCTGTAATACTTCTCAACAAGTTTTTCCGCT +TCCTTGTCCGCGGGTATGAGGTTGGAAGCCACGGGATAGAGTTTGTAACTGAAGTCCATTATCTTTCCAT +TTCTGATGTCGAGGTCAAGTCTTCCTACGAATTTACCGTGGGATCCTGCAATTACCACTATAGTATTCGT +TCCAGGAACCTTGTAGGCTTTTGGCACTACGTCGTGGGTGTGTCCCGAAATTATTACGTCTATTCCCTTT +ACCTTCTTTGCAAGGGCAATATCGAGGAGCAATCCGTCGTGGGATAGCAGTATTACAGCGTCAACCTTGT +GCTTTTCCCTGAGTTCGTTTACGTATTCCTGCAGTGTATCTTCTCTTACTCCGAAGCTCCAGCCTTCTAC +GAATTGTCTCGGGTTTGCTATGGGAGTGAAGGGGAAGGAGTTTCCTATTATGCCGAGCTTCGCACCACCC +ACTTCCTTGATAGCGTAGGGCTTGAATACGAGGTCTCCTTCAAAACCGAATTCATCAACTTCCCTAATGT +TTTGGGATATAAACTCACATCCTGCCTCTTCAAGTTCCTTTATCCTCTTTAAAACAATGTCTTTTCCGAA +GGTGAATTCCCAGTGTCCAACCATTAAGTCGTAGCCCGTGAGCTTCATCCAATCTACTACGGACTTTCCG +TCTGTGAACGTTCCTACCGCGGTGGTTATCCAGGTGTCTCCACCGTCGAGGACCAGCACCTTGTCCCTTC +CCCTTTCAGCTATTACGTGTTTTATGAGCCACGTTATGTGGGCTGCACCGCCCATTTTGCCGAACTTCTG +GGCGAGAACCGGGAAGTCTACACAGCTCATAAAGTAAGCTTCAAGGGTTCCGGGGGCTATTTTGTACATT +TTCAGGAAGTCTCTTCCCGTTATCGTTCCGGGAAGTCCCTTTAGATTTTTGGGAGCTACGAGGTTTATGG +GTTCGGAAAAGTAGTGGGGTTTTAGGTGTGCGTGCATGTCTGTTGTGAAAAGCAAGGTAACGTTTCCCAC +GGGTTTGAAGGAAAGTATGTCGTCGAGAGTCATCTTTGCGAGGGCGGATACGGGATTTGTGGCGAGGTAT +GCCCCCGTGACTATTGCGAGCTCCAGAAAGTCCCTGCGGGTCAGATGCATATTTAATCCTCCTTAGAGAA +AAGTATAAAGAAAAAGGAAGGGAAATTACTTGTTAATTGGACTTTCGGGATCGTGGAGGTAGGCGACGAT +GTCCGCAATTTCTTCAGGTGTGAGAAGACCGTGGTAACCGAACCTAAACATAGTTGAACATGGAACCTGA +GACCATGGGTTGTAAATCCTTTCGTAAGTCATCTTGGGATCTATGCCTTTGTTTCCGTAACCTCTAAGAG +AGGGTCCTATATTACCGCACGCTATTATTCTCGGGTCTCCGCAGTGACATGCGTAACAATTACCCTTTTT +GCTTCCACCCTTCTTTCCGTAAAGTGCCTTATACTCCTTCTTTAAAAGTGCAAGGCTTTCGCCTTTTCTC +CAGTCTCCCACTACGTTGCCGTCCTCGGGGTACTTTATGGTGGCCTTCATTTCTTTTATAAATTGGGCTA +CATCTACGCCTTCAGGTGCTATTTGTACGGGATTAGAACAGGCCTTTTGCCACTTGTCCTGTGCAGCGAG +TGCCTTTCTGAACTTCTCCGCCTTGCTTTCTTTCTTTTTAGTCTTCGTCTCAGCCTTCGCTACCTTAACT +TCCTGCTGTTTTGCAGCCTGAGAAGCAGGCTGACAAGCTATAACTCCCGCACTCAAAAACAACGCAAAGA +GAATTTTACCTTTCATAACAGCCCCTCCTTACCTAATTAGACCGGGAACTTCTATCTTTGCCCCATTAGC +AGCCTTCTTCATGTAAAGTTCAAGGGCAACAACTTCCTCTATGTAGAACGGGGGTTTCTTTACCCAGTTC +TTCTTAAAATCAAACTTTCCTTTTTCAGGGTCAAATAGGAAGAAGCTCTTGTAACATCCCCTTATCCTGT +CTTCCATAGTCCAGAGTTTGTCTTTGGATATTCTGTAAGCGGGCCAATGAGCGTAGAGCTTGTCCCTTAC +AGGAGCTCCCAGTTTCTGCAACCTTATCCTCTTTCCGTCAAGAACCTCGTGACATATAGCACAGGAGAAG +TCCCTCGCTCCCACTCTCTTGTACCAGAGTTCTTTACCGAGTTCGTAGAGCCTTTTTTCCTCAGGGTGCT +TTAACTCAACGTTTATGGGCATTCCGTTACTGAGAGTTGCCACGTATCCTGCGAGGGGAACTATGTACTT +CCTTCCCTTTTTACCTTTAGCGTCTACACCTACGTATTTTTCTAAGCAAGCCTTTATCCTGACGTCTATG +TCGGCAACCCTCTTTATATCCGTGTAGTACCTTGGCATTTTGGCGTAAGCTCCAACGAGGTTAGCTCCGT +CCTGTCCGTGGCAGGAAGCACAGGTCTTTCCAGTTTTTCCCTTCAGGTTGTGGTAGTAATCCCTACCTTC +CTCCACTATTACGTCCGCCGGTGAAACTCCCATTTCTTTGAGTATTTTCAACTGCTCGGGTGTTGGAGCT +TCAGCCTTTACAGAAAAGAAAAGAGCCCCACTGAGGAGTGAGGCAAAAACTATTTTTCTCATGACAGCCC +CTCCTTTAAGCTACGTTGATCTTAACTTCCTTCTCCCACTTTCCACCTTTGTTATCTTCGTAAACTATCT +TCAAAGTTCCGGCCTCTTCAGCCTTCATCTTAATGGCAAAATACGGGTTCTTACTTATCCCAGGAGAAGT +GTTGATCTTCGTTACGAGCTTTCCGTTGAAGTAGAGATCAACGTGAGTTATGTAGTGAGCAGGAATCTTC +TTTCCGGTTTTGGGGTCCTTTCTGAGACCCGTTTCCATGGGGTGGATGATCACCATTTGAACCTTGAAGA +TTTGACCCTTCTTAACGTTTTTGGGTACTCTAACGATAGCTCTTCCTATTGAAGCCATATCCCACCTCCA +GAGTTTTTATTAACCACATCCACCAACAGTTACCTTAACTTCCTTGTAAGCCATAAGGTAAGAACCATCT +TTGAGCTTTAGTATTGCCCTTACGGGAGAAGTAGCTCCCATCTTAATTCTTGTTGCAAAGAAGACTTCAC +CGTTCATAGGTGTGAACTCAACGTGAGCTATGTAGGGGTTGGGGTTCTTGTCAACGAATATGTAAAGAGC +CTCTACCTTTTCTATGGGAACGGTTGCGCTTATCTGTATAGGAACGTTCGCACCGGATTCCGCTATGGAA +GGTGCCTTTACCTTTATCTCGTTGGATTCCTTAATCTGGGAAAGACCTACTCCGAGATGCTTCTTGAGTG +CCTCTTCGAGGCTTATCTTAGCAAAAGAGGGGTTCAGAACGGGTGATATACCGAGAGTGAGTCCCAGGGC +CGCTACACCCGCCACCTTTAAAAAGTCTCTCCTCGTGCTCATATCTAACACCTCCTTACACTTGATTTAT +TACACACTCTGGTAAGCATAGAAAGAAAAGTCTGAGCGTCTAAACTCCCGAAAAACTTAGCCAGGACTTT +ACCCCTTAAAGGGTCGTATATAACGAAAGTAGGAGTCCCGAATACGTCGAATTTTTCTGATAAATTGCTG +TTAATATTAACACTAATTACAATAAAATTCTTATTTAAAAATTTTTCCACGTCTTCATCTCCAAAAACGA +ATTCCTCAACTTGGTGACAATATGGGCAGTGATCACTGTAAAAGTATATTAACACTAATTTCTTTTCCTT +TTTTGCGGTATTTACTCCCTTATCGAAATCTGCAAACCATTCTTGAGAGAAAGTAACTGATAGGAACATC +AGGAAAATCAAGAAGAACCTGAGTGCGAGCATCAAGTATAAAAGATACAGGACAAAGGGTTAAAGGACTA +TTAAGAAATACTTATGAATGCATAAAATGTCTTAATTTTCAAAAATGATAAAATGGTAAATTAAACATAT +AAAAATTAGTTTAAGTCTTAAGTCCTTGTCCCCCTTTTAAAAATAAAGGATAATTCTCTTATGGGCTTTG +TAAGGGTCGGAATAATCGGTTGCGGTACGGTTGGAACGGGAACCGCCAAACTCCTCATACAGAATGCAGA +CCTAATAAAGAAGAAAACGGGTATAGAGTTCAAACTCGTGAAAGTTGCGGACATAGACTGGGAGAGAAAG +AGGGAGTTTGAAGTTCCGAAAGAACTGAGAACCACAGATTATAAAGAAGTTATAGATAATTCGGACGTGG +TCGTTGAACTCGTAGGCGGTAAAACTTTCGCTAAGAAGGTAATACTGGAAGCTCTGGAAGCGGGAAAGTG +CGTTGTTACAGCAAATAAACACCTCCTCGCAGAGGAAGGGAAGGAGATTTTTGAAGAGGCCAAGAAGAGA +AACTTATTTATAGGTTTTGAAGCCTCGGTGGGAGGAGGGATTCCCGTGATAAAAGCGTTAAGGGAAGGAC +TTGCGGGGAATAAAATTCTCAACATCCTCGGTATCCTCAACGGAACGACAAATTACATACTCACGAGGAT +GTTTGAGGAAAATCTTGACTTTGAAACGGCTTTAAAGGAAGCAAAAGAAAAAGGGTATGCGGAGGCAGAT +CCAAGTCTTGACATAGACGGGTGGGATGCGGCTCACAAGATTGCTATTCTCGCCATGCTCGCCTACGGTG +GGTATCTAGACTTTAACGACGTTTACGTAGAGGGTATAAGGAACGTTGATAAGCTCGACGTAGAACTGGG +AAAGGAACTGGGATACACACTGAAACTCCTCGCAATCGCGAAAAAAGTTGACTCGGAGGTTGAGGTGAGG +GTTCATCCCACCTTTATACACTCCGAGGAAGCCCTTGCAAAGGTCTCCGGAGTTTACAACGCAGTCATGA +TAGAGGGAGATTTTGTAGGGAAAACCATGTTCTATGGTCAGGGGGCGGGTTCACATCCGACCGCTTCTGC +GGTGGTGGCGGACGTGATAGACGCGGGGAGGTTCTTACTCTGTAGCTCTAAGGTTCTTCCTCCCGTGAAC +TGGGAAGAAGGAGAACTGAAGGTCAGGAAGAACTTTTACTCCAGGTACTACCTTAGGTTTGACGTTCCTG +ACAAGCCCGGAGTTCTGGCAAAGATAGCGAATGTACTTGCGGATTACAATATAAGCATAGCCTCGGTTCT +CCAGAAGGAAATGGTTTGTAAAATCGCGGGCAGGGAGGGTGAAACTATAGTTCCTCTGGTTATCCTGACT +CACAAAGCTTTTGAAGAGGATATACAGAACGCTTTAAAGGAGATACAGAAGCTCCCCGTAGTTGTTGATA +AGCCCGTGCTGATACGTGTGGAAGAGGAGGCTTACTGAAAAAGTGGAAATACTTCTAATCGCTTCTCTTC +TGAGTTTAGGTACTTTCCTTGGCAGTTTTCTTTCTCTGTTTTTCAGGAGTGTGAACGTAGGTGTGAGTTT +AGCCTTTGCGGCGGGTGTTATGCTCGTTGCGAGTTTCACGAGTTTAATACTTCCGGGAATAGAAATCGGC +GGTTTCTGGAAAACCGCTACTGGTATAGTTCTCGGATTCTTCCTTATGATGCTCGTTGAAGTTTTATCCC +CACACGAGCACGTAGTTAAAGGAAAGGAGGGACTGATTAAGAAGGAAAGTTTAAACCGCTTAATCCTGAT +AGTTATCGGCATTACGATTCACAACGTGCCTGAAGGGATAAGCGTGGGTGTCGCTACCTCACATTCATGG +AATACGGGATTTCCTCTGGCAATTGCCATAGCCGTGCAGGACATTCCCGAAGGCTTAGTGGTTTCCCTTC +CTCTCATGGTCATGATGAAGAGTACCTTAATCCCGCTAATAATTGGTTTTCTCAGCGGTTTTATAGAGTC +AATTTTTGCGGTTTTCGGTTACTACCTCATGGAAACCTTTAAAAACCTTCTGCCCTACGGTCTCGGATTT +GGCGGAGGTGCTATGCTATACGTTACCGTAAAAGAGGCTCTACCGGAAATCTACGCTTCGGGAGAGAGGG +AAACTAAAATAACGCTTAGTTTCCTGACAGGTTTCCTGCTTATGCTATTTCTGGATTCCATTGAGATTAA +ATAATTCCTTATGAAGGTAAAATTCTTAGGGTCCTTCTTTGAGGAATTCCCTCCGCCCGATTACCCTGAA +GTGGTATTCGTGGGTCGTTCAAACGTGGGAAAGTCGTCGCTCCTTAACATGGTCGTAGGTTCAAAAGTAG +CAAAGGTCAGTAAAACTCCGGGAAGAACGAGGGCGGTTAATTACTTCCTTCTGGATAAAAAACTCTACCT +CGTTGACGTCCCAGGATACGGATACGCAAAGGTGGGTAGGGAAGAAATGGAAAAGTGGAGGAAAATGATG +GAGAGATACTTCAAGGAGAGGAAGGATAACATAAAGATGGCTTTTCTCCTGATAGACGCAGTAGCGGGAG +TTCAGCCCCTTGACGAGCAGATGATAGAGTGGTTTGAGTACTACGGTATACCCTTTACGGTAGTAATAAC +AAAGATAGACAAGGCTTCTCAGAGTGAGATAGCAAAGACCTTGAAACAGGTCAAGAGGTACGTAGGAGAT +GGAGCCATAGTCCTTTCTTCCGCAAAGGAAGGGAAGGGAAAGAAGGAATTACTCTCCAGAATCCTCAATT +AATCGGTAAAGTTTAAAGAAATCTTCCAGACTAAGTTGTTCAACCCTCGCGTCGGGATTTATGCCAGCTT +CTTTAAGTAACTCCTCCGGGATTTTTTTCCTCAGAACCTTTCTCCTGTTTTGAAAGATTTTTGTCAAAAA +CTTTTTGTAATTCTTTAAATCCTTTACGGGGAATTTTTCGTTTTTTACAAGCTTTATTACGGCGGACTGA +ACCTTCGGAGGCGGGACAAAAAACCTCGGAGGGACGGTCATAACATAATTGACATCGTAAAAGGTCCTCA +CGAATACGGAAAGCCAGCCGGTGTCTTTCTTTCCCTGTAGCTTTTCCGCAACTTCCTTCTGAACCATGAA +AACCGCAAGTGGTACACAATCCTTGTTGTAAACGGTGTTCTCAATTATCAAGCTCGCCACGTTGTAAGGT +AAGTTTCCAACTACTTTTAGTTCTTTCCCCAAACTACAAAAAGGGAATTTTGAAGCGTCTTCGTTTATGA +CTTCTAACCTTTCGTCTCCGATACTTTTCAAGTTTTCAACCATTTCCCTGTCTAGCTCTATTACGTAGAG +TTTTTTCAGGGGATGCTGGAGTAAAACCTTAGTTAAGTTTCCCGTTCCCCCTCCCACTTCCACGACGGTG +TTACCTTCCTCTATATTGAGTTCTTCGGCTATCTTTTTCAAAACGCCTTCGGAAACTAAAAGGTGTTGCC +CGAAGGATTTTTTCAGTCTTACCATTAACTATTAAAATAACTCTATGCAAAACGCCATACTTCTCGTATC +CTGCCCAGATAGGAAGGGACTCGTAAAGGAAATTTCCTCCTTTATAGCGGACAACGGGGGAAACATAGTC +AGCTTTGACCAGCACATAGACGAGCAGACGAAAACCTTCCTTGCAAGGGTGGAGTGGAGTCTCGAGGATT +TTAAAATCCCAAGAGAAAAAATTGAAAATGAGTTTAAAAAAGTTGCCCAAAAGTTTTCTATGAATTTCCA +AATTAGTTTTTCCGATTACGTTAAAAAGGTTGCCATTTTCGTTTCAAAACAGGAGCACTGCTTTTACGAC +CTAATGCACAGATTTTACTCGGGAGAGCTAAAGGGGGAGGTGAAGCTCGTTATAAGTAACCACGAAAAGG +CGAGGAAAACAGCGGAGTTCTTCGGCGTTCCCTTTTACCACATTCCGAAAACCAAGGAGAATAAACTTGA +GGCTGAAAAGAGAGAGCTTGAGCTTTTAAAGGAGTACGGTGTTGAACTTGTAGTTCTCGCAAGGTACATG +CAAATTCTTTCCCCTAAATTCGTAAAGGAGTATGAAAACAAGATAATAAACATACACCATTCCTTCCTGC +CAGCCTTTCCAGGGGCAAAACCCTACGAGAGAGCTTTCGGGAAAGGCGTGAAGATTATAGGTGCTACCGC +CCATTACGTTACGGAGGAGCTGGACGAAGGCCCCATAATAGAGCAGGACGTGGTTCGTGTAAGCCACAAG +GACAGTCTTGAGGACTTCATAAGAAAGGGGAAGGACATAGAAAAAGTAGTTCTCGCAAGGGCGGTAAAGT +GGCACCTTGAGGACAAGATACTCGTCTACAATGGAAAGACAGTAGTTTTTGAATGAAAATTTAATTATGA +AGATAATTCTACTTTCACTCTTCTGGGTATTCTTTTCCTTCGGAAAGATATTCGTAGCCCAGTGGGAAGG +CCCCATAACGCCCACTACCGCTGACTACGTTGAAAGGACTATACAGAAAGCACAGAAGGAAGGGGGAACG +CTGTACATACTTCTCTTAAACACTCCCGGCGGACTTGTGGAGAGTATGAGGAAGATAATTCAGAGTTTCG +AGACCGCTCCCTTTCCCATAGTAGTTTATGTTTATCCGCCGGGCGGGAGAGCTGCTTCAGCAGGGGCAAT +TATAACTATAGCCGCGGACATAGCCGCGATGGCCCCGGGCACCAATATAGGCGCGGCACACCCGGTCCTT +GCAACACCGCAGGGTCGCGAAAAAAAGGAAAAGGGAAAGGACGTTATGATGGAAAAGGTACTACAGGACA +TGCTCGCCTTCGTAAGAGCCATAGCCAAAGAAAAGGGAAGAAACGTAAAAGTAGTTGAAAAGATGGTAAA +GGAGAGTCTTTCCCTTTCTGCGGAAGAAGCTCTGAAAAAGGGAGTAATAGACCTGATAGCGTATAACCTT +GAGGACTTACTCACGAAACTAGAGGGTAAAAAAGTTAAAAAACTTAACGCGGTTTACGAAATAAGAACAA +AGGGCAAAGAAGTAGTGTTTTTAAAACCGAGTCTGAGAGAAGAATTTCTGAAAATCATTACAAATCCGAC +AGTGGCTTACCTCCTGCTCATGCTTGGATTTTACGGAATATTCTTCGAACTTTACAACCCTGGTGCCATA +ATCCCCGGTGTTCTGGGGGCTATATGTCTGCTCCTCGGTCTGTACGGTCTGAGCGTTATATCTATAAACT +GGCTTGCCTTATTGCTTATAGTCCTCGGGATACTCTTTTTTGTCCTTGAACTCCTTACTCCAACTTTCGG +GGCCCTTGCCCTCGGAGGTGCTATTTCCATACTCCTAGGCTCACTTTTCCTCGTAGAAGAGGGTTCACCG +TACGGAGAAATCCCAAAGCAATTAATAATCAGTGTTTCCATTTTTAGTGCCATTTTCTTCCTCGGGGTAG +GTTATCTTGGCTTGAAGGCTCAAAAGAGGAAGAAGCTCACGGGAATTGAGGGGATGATAGGAGAAGAGGG +AGAGGCTATTGTAGACTTTAAAAACGGGAGGGGAAAGGTATTCGTTCACGGGGAGATATGGGACGCTGTA +TCGGAGGACGATATAAAGAAAGGGGATACGGTTAAAGTAGTAGGCGCTAAAGGTCTTAAATTAATCGTTA +AGAAATCTTCGTGAAAGGGCTATATTTATTCCTTAATGGAACTGGATCTCATAAGTTACGAACTTGACGA +GAAAACTAAGGAAGGAATAGAGAAGGTTGTTGAGAAGTTCTTTACTAAAGCTGAACCAGATTTAGTGCTC +ATATTTGACAAAGCAGGCAGGATACTCGCCTGTAAGGGGATGGATATCTCCGATACTTACTCCGAGTTCA +TATCAAGTATTCTCAGTGCTCTGTTCTTCGCCTCCGAAGAACTCACATCGATGCTGGACAAAAACGACGA +GATGAAGGACGTGTTTTACGAGACAAAAAACAGGGTGTTTTTAATGGCAAGACTTGAAAAAGACTTCCTT +ATCGGAGTAATATCGAGGAAAAACCTATCTCTGGGAAGTATCAGACTCTTTTTCAATCACCTTGTGTCCG +ACCTCAACGCAGTTCTTAAAAACCTTAAAGAAGTAGAAAAGAAGAGTCTTAAAATTTCTAAGGAAGAGTT +GAAGAAGAAACTGGATCAGATTCTGGGAAGCTGAAATGAAGCTGAAAATAGTGTTCTTCGGTGCAAGTCT +TGCAGGTAAGAGTACCACGGTGAGAAAGCTTTACGAGATTTTAAAGGAAAAGGGACTAGTAAAGGGAGAG +TTTATGAGTATAGACACCGACGAAAAAAGGACACTCTTTGTGGAAATGTTCCTCAGTAAGATTCCTATAG +ACGGTCAGGAAATAGACTTTAAAATCCTCACCACTCCCGGGCAGTTCAGACTTCACCCCCTCAGAAAGGC +AATAATGCAGGGGGTGGACGGTCTTGTGTTTACCGTCGACTCTCAAACGGGAAGGGAAGAAATAAACTTT +CTCGTTCTTCGTGAAACGGCACACGTGCTTAAGGACTCAACATGGATCTATACTCAATACCCGTCGTTGT +TCAGTACAACAAGAGAGATCTTCCCGACGCACTTCCCATAGACGAACTCCAGCCTATATGTAATCCTTGG +GACGCACCCTATACGGAAACCGTAGCCACAGAAGGAAAAGGTGTGCTCGAAACCTTTAAACTAATAGTGG +AGAGGGTTCTGGAGAGGGATGTGGAAAGAGAAGGTAAGAGATAACATCCTCGGTGAAGTTATCGACTGGA +AGGCTTTAATAGATTCCTTAAAAAAGGAAAGGTTTACAGGCTACATAAAAGTAGAGAGTTGGGATGAAAC +GGATTACGTGATACTCGCTGAAGGGAGTGTAAAGAAAATCGTAAGACATAAGGATAATAAGAAAACCTTT +CTGGATACCTCAAATTACACACCCTCTTCGGAGAGTAAGATATCCGTTTACAAATCCTCACCTCTCACGA +CTGCACACATATGCAAAGACTTAAATTTCTTTGAATACCAGACGCTCAGTTTATCGGGTTACGGGGAAGA +AATATTCCACTCGGAATTGAATTTAGTGAATCCCGAAAAGCTGGAGACCTTCTTCCAGAAAGTTAACCTT +AACGGTTACGCTGTGATCTACACGTACACCAGCATTTACTGTAACGTTTTCCTGCTCCAGGGACATTTGG +TAGGAATAAACGGTGGAAACACATGGGATAGTGAAGTTCCTTCACAAAAGGATTTATGGCAGGGAAAAGT +CTTTTTATCCGCCTATTTCATAGAGCCCGACGAAGTACTTCTTCTCATTTCCCTTAAAAGGGGCTTTAAA +GAAAAGAATGAACTTAATGGAAACGGGTTTTTCGTGAACGGAAATTACGTAGGCTTTGTGGAAAACGGAA +ACATCAAGAAAGGTTTATTAATCCTTCCTGAGGAAATAGTGGAAACGCAGGAAGTAAAAGGAGAAAAGTT +TCTGGAAGTGAACCTGATAGAAAATCCCGAAAGGCTTGAAATTTCTTTTAAAGACCTCATACCTAAGGAG +GAAAAGAAAATCAAACCAGACGTACCCTTAAAGGTAAGAGAGATATTCCTCGACTACATAGGGCCGGTGG +GTAAGATTTTGTGGGACAAGGTACTGCAGGAACTCGACATAAGCCCGGAGGAGTTTACACATCCTACGTT +CAGGATGTTTATAAACAGACTTGCTCAAGAGATACCCGAAGAAGATCTCAGTAAAGAGTTCTTAAATAAA +GCCTGGGAGGTTCTGGATGAAAGCACTTCTACCTAAATCCATTAAAGGTAAAGTGAGCTTAATTATCGGT +TCTATCGCGGTTGCGAGCGGACTGATAACGGGTTTTTACACCTATAACGAAGAAGTAAAAAAAGCCAAGG +AAGTGTCCAAGGAAAAGGTGAGGTTGACTCTTGCCTTTTCAAAGTCTATCAGAGGTTATGTGAGAGAAAC +ACTTAGACCCAAAATATACGAGCTGATGAACGAGTACAAGTGTATTAAGGAAGACTTCATACTGGAAGCT +CAATCCTCTTCCTTCTTGACTTCGAACATTTTCAGAAGTGTAAGCAGAGAGTTTCAGGGGTTGACTTTAA +GGCAAGTGGCTTTCAAACCTTTAAATCCAAAGAACGAACCGACTCCCGTTGAGCAGAAGATAATAGAGTA +CTTCAGGAAAACTAAAGCACCTGAGTACACGGAAATCGTTAACATAAACAACTACAGGTATTTGGTCTCA +GCTTTTCCGGTTAAAGTAGAGGCTTCCTGTCTCATGTGCCACGGAAAAGTGGAAAATATGCCAAAAGCTG +TAAAAGCTATATATAAACCCAAAGAGGACCCGAACTGGAAAGTTGACGAGATACAGGGAGGAATTTTCGT +ATACGAACCCTACGAGGCTACACTTTTGAGGGCACAACTGAGCGGTCTCATAAAGGGAGGAACTATATTC +TTCGTAAACATACTCGTTCTCGGTATCATACTCTGGATACTAAACCGCTACGTTTTCAGCCCTATAAACG +TTCTCAAGGAACACGCGGATAAGATAAGCAAGGGTGAAATAGATGACAGGATACCTGTAAAGGGAGAAGA +CGAGATAGGAGAACTCGCAAAGGCTTTTGAGAGAATGAGGATAAGCATAAAGAAAGTTATGGATCTACTC +AAGTGATCTGATAACCTCTTCTAGGAAGCCCTCCGCTTCCTTCAGAGCTTCGTCACTTCCCTTTAGCTTC +GTGTACAGCTCAAGAACTTCCCTTCCTCTGCTGTCGGCAATAAGGGGATAAATCATCCTAAGCAGAATCA +TAAGCTCCTTCTTCCTCTCTTCTCCGTTTTTAGATTTGATATTTTCCCACCTTTTCTTTATCAGGCTCAC +TTCTGTCTTTCTGATGTCCATAGGGAAAATTTTAAAATACTTGAGGTAATGCCCAGAGCTATTCTGGAGA +TAAACAGTGAAAGGATAAGACACAACGTCAAGAAGTTATCGGAGTTTTCCGGGAAAAAGGTTATAGCGGT +TATAAAGGCGGACGCCTACGGTATAGGTTCTATACAAATGGCAAAAATACTAGAGCCTATTGAAGAAGTG +GACGCTTTCGCGGTAGCCTGCGTTGAAGAGGGGGTTGAACTCAGGAAAATGGGAATAAAAAAGGAAATAC +TCATACTGGGAGGAGTACTGAAGGATGAAGTCCCTTTAGTAGAGGAGTACTTCCTTACCCCCGTTGTTTC +GGATATTGAGCACCTGAGAGCTATAGGAAACAGGGATATAAAGTTTCACGTAAAGTACGACACGGGAATG +GGAAGACTTGGGTTTTTGAACGAAGTTATACACGACCCGAGGGTGGAAGGGATAATGAGTCACCTCTCGA +GCCCGGCGGACGAAGAATTTTCCAAACTCCAGATAAAGAAGTTTGAGGAGATAGTTAAGAAGTACACAAA +AGTTGAGAAAATCCACATGGAGAGTTCAGCAGGTGTTGTGTACAGAGTGCCTTTTACCACTCACATAAGG +GTAGGGCTTGCAATGTACGGCGAAAAACCCCTGAAGAATTACCCCGTTGATATAAAACCCGCACTCACTC +TTAAAGCTAAGTTAATATCCGTAAAGGAACTTCCTGAAAATTATCCGGTATCTTACAGCAGGACGTACGT +AACTAAGAAAAAAACGAAAACAGGTGTAGTTGCCTTCGGGTACGCGGACGGACTCATGAAAACACTGTCC +AACAGGAGTTATTTGCTTTATAAGGGAGAAAAGCTACCAATTTTCGGGAACATTACCATGGACATGACAA +TAGTGGACCTGAAAAATACGGACGCAAAGGTAGGGGATTGGGTTTACGTGGTAAACGAAGAAAGAACCTT +TACGGAACTTGCAAGAGAAGCGGGAACGATACCCTATGAGCTCATGTGCAACTTATCAAAAAGGATTAAA +AGAGTCGTAGTGTAGATTAAAGTAAATAGAGCCACAAATAAAAAGTAAATTTTTAGTTTCTTACTCCCGA +ATATAATCGCGTATCCAGACTTAAATAAATTGTTGGACATAACCGCGAGGAGTATCCCCATCGCCGCAAC +GTCTACGCCTATTTCCCCCTTATCGGAAAGTCTCGCGAGGAGCAGTGTAATTGCGTCTATGTCCATTATT +CCAGATAAAAAACTCAAGACGTAAATTCCCTCGTCACCAAAGTGAGTCTTCAAATAGTGAGAAATAACGC +TTATAGTGGAGTAAATTAAACCGAAGGTAAAAGCCTGAGAGAGGGAAAAGGGATTTTTTATTGACATGCT +CCCACCTTCCTCGTGGTTCTTGTTACCTTTCAAGTACAAAAATATTGCAAACATAAGCAATAAGGCAAAA +TACGGAAGGAGTAATAGGACGAGTTTATAAATCATTCCCTCAAATATGATGAAGGTGTAAAAGATAACCC +TGAAAAACATAACGAGCCAGGAAAGGATTATTGAAAAGAAGAATAGTTCCGAGAGGTATGAGAATTTTCT +TGAGAGATTAGAAAAAGCCATAGTTACCGCGGTACTGGAAGGGATACCGCCGATGAGTGCTGTGAGGATT +AAACTTCCTGTTCCTTTGTACTTCAAAAGGAAGTAACCTACAAAGTCAACCGAGGAAACGAGTATAACGA +ACTTCCAGACTTCTGAAGGATTTAAACCTCTAATTATTTCTCTGTCCGGAAGCAGGGGAAAGACTACGAA +GGAAATTGTAAAGAACTTAAGAACGGTAATTACGTCCTCTCGTCCAGTCTTTTTGCGAGGTTCTCCATAC +TGTCTCTGAGGACGAGGATAAAAGTCGTAAGGATTGTGGTAACAACGGCCAAGTAGTACTCGCCTGCAGA +AACAAGTAGACCTACTATAAATGTAATCAACGCGGAAACTTCGGTGGTTATACCCATACTTCTGTCCTTC +CAGTAACTAATGGACGCAAGGATTATAAGCCCAAGAAAACTCAAGAAAACGTAAGGAAATTCCCTGTAAA +GGAAACCCGAAAGTGTTCCCAGAACCGCTATCAAAGGGAATGTCCTTATTCCCGCGAAGATGTCGTGTCC +GAATTTAGCCCTTATCTCCCTTTCAAGTCCGATAATAAGTCCGAGGAAAGCAGAAAAAACGATTTTAAAT +TCGGGGGAGGCGGAGAACTCCTTAAAAAAATCCATTTACCTTATATATGTAATTATCATCACTATTAAGG +TTCCGAGGATTAGGTTTATGCTGACAAAAACAGGTATAGAAGAAAACAACCTTTTCCTGTAGAGGTAAAG +GTGTATGTAGATGAATATTAAGGTCATTATTCCGAAGAGAAAGAGCTTAAAGTGAAAGAGTGGGTTCTGG +GAAAAGTCCTTCCTGTAGCCGTGCCAGAGTGCCATTCCCGTGGTGAAAAGAACTATTATCGCGAGCCAGA +CTACTAAGAAAAACCTTCCGAGTGTCCTTTGAGCTACCTCTTTCCTGCAGTCCTCAGAAGCACTCCTGAG +TGCGGGGGTTAAAAACAGAACGTTGAAGAACATACCCCCTATCCAGACTATTGCAAAAAATATATGTAAA +AAGAGATAGGCTTTGTAATCCATCCCACCACCTCCAAGATAAAAAGCTTACCACCTGAAGTGAGAGAAAA +CCATGTTCGCATGTGCCATCCTGTGCGTCTCTTCCTTCTTCTTGTACGCTCCTCCCCTCTCGTTGAGCGC +ATCTAACAGTTCTGCCTTCAACCTCTCTATCATAGTGTACTGTTCCCTTCCCCTCGGTCTTTCCCTCGCA +GCTTGAACTAGCCACTTTATCGCCAAACTTATCTGCCTCCTCTCTGGCACTTCTATCGGCACCTGATACG +TAGCTCCTCCCACTCTTGTGGGTCTCACTTCCCACTCGGGCTTTAACTTCTCTATTACCTTATGAAGCAG +TTCAACAGGGTGCATGTTTACCTCTTTCGCAGCCTCTTCCAGTGCAGTGTAGACTATCCACTCAGCCACG +CTTTTCTTTCCGTCCTTCATCACTTTGTTTATTAACTTCTGAACGAGCACGTCCCCGTACTTGGGGTCGG +GCGGTATTTCTCTCGGAGGTACTGGTCCTTTCCTTGGCATCTATCAACCTCCTTTTTCTTCCTTCGGTCT +CTTGGTTCCGTACTTGGAACGGGATTGTCTCCTTCCTTCAACACCGGCTGCATCAAGCGCTCCTCTGATA +ATCTTGTATCTCACACCGGGAAGGTCCTTCACTCTTCCTCCTCTTACGAGAACTATGGAGTGTTCCTGAA +GGTTGTGACCTTCACCGGGGATGTAGGCAGTGACTTCAATACCGTTGGAGAGCCTGACTCTTGCGACTTT +TCTGAGGGCAGAGTTTGGCTTTTTTGGAGTGACTGTGTAGACTCTCACGCACACTCCTCTCTTTTGAGGG +CAGCCTTGAAGTGCCGGAGCTTTAGACTTTTTCTTCCTCTTTTCCCTTCCGTACTTAACTAACTGGTTGA +ACGTCGGCATTCGCTTCCTCCTTCGGTAAGTAAAATTATAAGGTTAAAATAAAAACTCTAAAATGGAAAG +GGTTTGGGAAGCCTACGGATTGACCGAAGAAGAATACAGAAAAATACTAAAAACCTTAAAAAGGGAGCCC +AACCACGTTGAACTCGGCGTTTTAGGAGCTCTGTGGTCGGAACACTGCTCTTACAAGTCCAGCAAAAAGC +ACCTGAAAAAGTTTCCCACAAAAGCGGAATGGGTTGTTCAGGGACCGGGTGAAAACGCCGGGGTTGTAAA +AATTGACGAAAAGGTTTGGGTAGCCTTTAAAGTCGAGAGCCACAACCACCCCTCTTACATAGAGCCCTTT +CACGGTGCGGCTACAGGAGTTGGCGGTATTATCAGAGACGTACTGTCCATGGGAGCGAGACCCATAGCCC +TCGCGGACAGCCTGAGGTTCGGCGAGTTTAATTACCATGAAACGAAGAGGCTCGTTAAAGGAGTAGTAAG +CGGTATCAGTTTCTACGGAAACTGCATAGGAGTTCCCACGGTTGCCGGAGAAACGGTTTTCGAACCTTCT +TATAAAACGAACCCGTTGGTAAACGCCTTTTGTCTTGGAGTTATACCCGCAGGGAGGATGTACAGGGCAA +GGGCTACTAGGGAAGGACAGCTCCTCTTTTTAATAGGTTCTTCCACGGGAAGGGACGGGATTTTTGGAGC +CGTAATGGCCTCGGGAGAGTTTTCCGAAGACGTGGAAGAAAAGAGACCTAACGTACAGATAGGGGATCCG +TACTTTGGGAAGAAGCTCGTGGAAGCAATAATGGAGATAGTGGAGAAGGATTTAATCGTCGGAATGCAGG +ATCTGGGAGCTGCAGGGCTTGCAGGCTCTGCTTCCGAAATAGCTGCAAAGTCCGAAAAGGGTGTGGAACT +TTACCTAGAAAACGTCCCCTTAAGGGAAAAGGATATGAACCCCTACGAGATACTCCTTTCAGAGAGTCAG +GAGAGGATGCTTCTCGTTGTGGAAGAAGAAAACGTTGAAAAGGTCAAAGAGATAGCCAATAAGTGGCACC +TTGAGGGTGCGGTAGTAGGAAAGATAACCGATGACGATACATTCAGGGCTTACTACAAAGGAGAACTGGT +TGCAGAACTACCCGTTTCACTTATAGTAGACGAAGCTCCCGTTTACGATAGACCCTACAAAGAACCCGAA +TACATGAAGGAAGTGAGGAATTTCAATCAAGAGGAGCTTCCTCAAACAGATGTAAAAGAAGCCCTCAAAA +AACTCCTATCTTCGCCAAACATTTCGTGCAAGGAGTGGGTTTACACTCAGTACGACTATCAAGTAGGAAC +GAACACCCTCCTTATCCCCGGGCACGACGCAGCGGTTTTAAGACTCAAGTGGGTTCTAAGACCGGAGCTC +ACAACAGAAAAAGGAATAGCCATATCTTCCGAAGGAAACGGCAGGATGGTTTACCTCAATCCCTACGAAG +GGGGGAAGTTCGTAGTCGCGGAAGTTTGCAGAAACCTCGCGTGTGTAGGAGCAAAACCCTTAGCCATAAC +GGACTGTCTTAACTTCGGAAATCCAGAAAGACCGGAGATAATGTGGCAGTTCGTAAAGGCTGTAGAGGGA +ATGGCAGAAGCGTGTGAGGAACTCGGTATTCCGGTAGTGAGCGGGAACGTATCCCTTTACAATGAAACCG +TTGAGAAAAACGAAATCAGGAACGTATTTCCTACTCCCATAGTCGTAGGTGTGGGTGTCTTAGAAAAGGC +GGAGAAGTATACGCCTTCAAAAGTAGAAAAGGAAAGTGAGCTGTACCTCGTTGGAAACCTTGAGGAGAAC +TTAAGACTTGACGGAAGTGAGTACCTCAAAGTAATCCACGGACTTATAAAGGGAGATGTGCCTCCTGTAG +ACCTTGAAAAGGAAAAGATACTTATAAACCTTCTCATCTCTTTTAACAACAAGGAATTGATAACCTGTGC +CCACGACGTTTCCGTAGGAGGACTGTTAATCGCACTCCTTGAAATGGTCTTTAGAACACCCTACGGTCTT +GAAGTGGAAGTTTACACCGATGAAAGACCGGATGTGTTCTTCTTCTCGGAAAACCCCACAAGGGTGATTA +TAGGCGTGGAAAGTGATAAGGCGGAAGAGGTAAAGAACGCCGTTGAAAAGGCTGGACTTGAGTGGATGTA +CATAGGAAAAACGACGGAAGAGAAAAAGATAAAAGTAACCTTCAACGGAGATACTCTCTTAGAGGACGAG +CTTGAGGAGTACGAAAAGTTATGGAGAACTTCCTTAGAAAAACTGCTTGGCTCTACTTAAGTATAGCAGT +AAGCGTCTTTTTACTCGACATAATTACCAAAAATCTAGCGGAGAAGTTATTTACAACTCACGTTGAAGTG +TTTCCCTTTCTGGAGTTTTACCTGATATACAACAAAGGCGTAGCCTTCGGTCTCCTTTCCGAACTTCCTG +ATCCTTTGAGGCTTCCTTTGCTCTTGATAACTCCCGTTATAGCCCTGATAATTACGTTCCTTTACGCGCT +ATACAGCGGAGACAGGATTGTTGCAATCTCCATGGGATTAATAGGAGGAGGTGCACTCGGAAACCTCTAC +GACAGGTTATTTCTCGGAATGGTGAGAGACTTTATACACCTACATATAGGGGAGTATTACTGGCCAGCCT +TTAACATCGCAGACGCTTCCATAAGTATAGGTATTGCTCTCTTAATACTCAAGTACTTCTTCACTAAGCC +TGCCCTCAAAAACCTTGTAAACAGAACCCGTTAGGAAGACTTCTTTTAAATCCTCCGAAAAATCTATCGT +GAGTACCTCACCGCTTCTAGTTAGAACGTTTACGGGCTTTTTCTTCACTAGACCCTTTAAGTAAGAAACA +ATGGCACAGGCGGTAGCTCCCGTTCCGCAGGCGAGCGTTTCACTCTCAACTCCCCTTTCATATGTTCTCA +CTTTTATAGTATCCTCGCTTACCGGCTGGACGAAGTTTACGTTCGTTCCCTTCGGCTGGAATTCTTCGTG +AAACCTTATAGCCCTACCGAGCTTTATCACGTTTACCTTTTCAACATCTTCCACAGGAACTACGAAGTGC +GGAACACCCGTATTTATGAAAACACCGATTACTTCCTCTCCATCCACGGTTAGTGTCTTCTCTTCGGGCT +TTGAGGGAGGCGTCAACTGAACCTTTACCTTCCTTCCGTTTTCGTAAACCTCCGCCTTTATAACACCCGC +AAGGGTTTCAAACCTGACCTTATTCCCTACAATTCCCCTTTCGTATGCAAACCTAACGGCACACCTCGAA +CCGTTCCCGCACATCTCCGCCACGGAACCGTCGGAGTTAAAAAACTCCCACTTGAAGTCGTTTTCAGGAT +TGTCTGGATTTTTAATGAGTATCAACCCATCCGCACCGACTCCCGTGTGAAAGGCACACACCTTCCTAAC +AAAATCTTCTTTTGATACACCTCTTTCCTTTAAAAAGCTTTCGAGTTTTTCGTCCCTGTCGTCTATTACC +ACGAAGTCGTTTCCCGATCCCTGTAGCTTCCAGAATTCCATAAAAGATGATTATAGTAAGAAGTATGGAA +GAAAAAGAGATAAGCTCCATGAACGTAATACCCCTCGTTGACATAATGCTCGTACTACTCACGATAGTCC +TCACCACCGCTACATTTATAGCAAAAGGTGAAATCCCCGTAGAACTCCCAGAGGCAAAGTCCGGAAAAGC +GGTTCAGCCTCAAGAAAGTGTAGTGATAACGATAACAAAGGAGGGAAAGATTTACCTCAAAAGTAGAGAA +GTGTCCTACGAGGAACTGAAAGAATTCCTGAAAACCCTAAACAGACAAACACCCGTAGAGATTAACGCGG +ACAAAAACGCGAAACTTGAGAACTTCGTGAAGGTGTTTGACCTGCTGAACCAGTACGGTTTTAAGAACGT +AAATCTTTTGGTGAAGAAGGAATGAGTTAAATTATTCTTTATGGGCGAAAAGGAGTTAAAAATTCAGGGC +ATGACGTGCCAGCATTGTGTAAACACCGTAAAAAGAGCATTGAGTGAAGTTGAAGGAGTATCGGAGGTGG +AAGTTTCCCTGGAAGAAGGGAAGGCGAAAGTAAAACTCGAAAAGGAAGTGCCCTTTGAAACCCTAAAGGA +AGCTGTAGAAACTTGGGGATACAAGGTAGTGGAATAATTGAAAATAAATTTCAATTGCAATAAATTATAA +ATGATGATGGTAGAGTTAAAGGGTAAAGTAGAAGAACTTAGAAAACGGCTTGAAGACGTAAAGAAGATAC +TTTCTCCTGAGAAACTTGAGAGTGAATTAAAAGAACTCGACCAGAAGATGTCAGAACCAAACTTCTGGGA +GGATCAGGAAAAGGCCAAGCAGGTAATACAGAGAAGGAAGTGGGTAGAGGAAACTCTGAATAAATTGAAA +AACCTTGAAAAGAGTGTAAAGGATTTAGAGGAGCTAGTGGAGATAACTTCCGAAGAGGACACGGAAACCT +GGGCGATGATGGACGAAGAAATCAAAGAAGTGGAAAGGACTCTAAGAGAACTCGAACTAAAGACTTACCT +TTCCGGAGAGATGGACGCCAAGAACGCGTATCTCACCATACAGGCGGGTGCGGGAGGAACGGAAGCCTGT +GACTGGGCCGATATGCTCTTCAGGATGTACAAGAGATGGGCTGAAAAGAAAGGGTACGAGGTTGAACTCA +TAGACATAACTCCCGACGACGTAGCCGGTATAAAGAGCGTTACAGTCCTCGTAAAAGGTCCATACGCTTA +CGGATACCTGAAGGGAGAGCAGGGAGTTCACAGACTCGTGAGGATTTCTCCCTTCGACGCGAACGCAAGG +AGACACACCTCCTTTGCGGCAGTCTCCGTTATGCCCCAGATAGACGAGGACATAAAGATAGAAATAAAAC +CTGAGGACCTGAAGATAGAAACCTTCAGGGCTTCGGGAGCGGGAGGACAGTACGTAAACAAAACCGATAC +TGCGGTTAGGATTACACACATTCCCACAGGCATAACAGTATCCTGTCAGCAAGAAAGGTCTCAGTACCAG +AACAAGAGAAAAGCACTTGAACTTCTGAAGGCTAAACTCTATCAGCTCGAGATGAAGAAACTGGAAGAAA +AGAAAAAGCAGTACGAAGGCGAGAAAACGGACATAGGCTGGGGTCACCAGATCAGATCCTACGTCTTTCA +CCCCTACAAACTAATAAAGGACCTCAGAACGGGTTACGAGACGGGAAACGTGGAAGCAGTAATGGACGGA +GAGATAGACGAGTTCATAGAAAGTTACCTAAAGTGGAAAGCTCAAAAGGAAAAAGAATCATCCAACAACT +AATACCTGCTTTCCTTCTGCACTCTCTTCAAAACCCTCCACGTAAAGGCTGAGCAGCTTAGCCCCCTCCA +CCAGAGCTTGAATTAAGACGGGATCCCTCAATCTGAAAGGGGGGTCCAGCTCGTAAACAACCTTTGCATA +CCCCCTGTCAAGCTTAACGAAAACGGATAGAGTTCCCTTATCGTAATCAAAAACCTCCTCTCCTTCTACT +TCGTTAACGGGTATAACACTTATCCTCTTTACGTTGAATTCCCTCTTTAGTCCCTCGAAGTAGTCTTTGG +GCTCTTTACTTTCCCTCAAAAGCTTCAAAATCTTCCTTAAGTTTGAAAACATCCTCTTTTCTCTCTCAAA +GTTTGAGAACTCTTTCAACAATTTATGGTAATTCTTCTTCAGCTTTAAGATACGTTTCCTTTCCTTCCCT +ACAACCGTAGCGTACTCAAAGTTGTACGACGTAAAGAAAAGTGCCAGAAACAATATAAAGTGAGAAATCA +TCAAAAGGTAATGACCGGAGAAATAAAAAAAAGCAAGGCCGTAAGTTTCAAGAAGAATTATTCCCGCTAG +AACAGGTTTTCTCCAAGCGTAAACGGATATTAAAACTCCTAAAGCGTAAATAGAGTAAAGAATTTTAGAG +AAAAATACAAAGGCAGGAACGAGAATTATATCCAGAAAAGGAGAAATTAATTGAAGAATTCTTGGTTTTG +AAAAGAAGTAAACGTAAACGTTTATCAAGAAGTAAACTGAGAGAATTCCGACCGCAATGTAATTAACGTT +CTCATACGAAATAAGAAGGAGTGTGGAGAGATAGAGGACGACTAAAAGCCTTGCTACGAAGAAAACCTCC +CTTTTTACTTTATCCAGCATTAATTTAAAAATAGCACACTTTTACTTAAGTACTAAGGTAAACTCGTACG +TACCTTTAGGAGTTTTTTTTACGCTTTCAGGTTTTAAACGCCTGACTATTTCCTCGTTCCCCTCCCCTAC +TAACTTTAAAACCCCGTTCGTGTACTCAATCCTGTAAACTTTTACACCTTGAGGCAGTTTCATAAAAGCT +TTATTGAACTTAATTAAAACGGATTCTTTTTGTGTTTTGGTTAAACTTTTTAACTGCTCTTCCACCAACA +CAGGCGGGATATCGGGAAACTTCTGGGAAAACAATTCCTTCTTTTTTTGATTTAAAGTTTTGAGTGTTTC +CTTCTTTACAGGCTCCTTTAGCGTAAAGTACGCAAAAAAGGCAAGCGTGGACACACCCAAGAACAGGGCT +AAAGTCCTCTGTTCCTTCTGAGATATCTCCTCCTTTCTGAAAGAAGGACTTGAATCCTTGTACACGAACT +TCAGGGAAGCCCCAAATGCTGAATTTAGTTCCGGCTCACAGTAATCGTTAAACAAAGGTTTTTCTACGAA +TTCTTCTATTCCCTTCAGTCTTGCTCCCCCTCCACTAAGGAGTACCTCTCCCGAAAGGTCCACACCTAAC +CCTTCCATTATTTCGTGAAATGCTTTTTTGACAATTTCGTTTTTTAAGCCTTTTTCTTTTTTAATCCTTT +CAGCTTCTTCGTAGTTTACGTTTAAGTTCTTTACTAAGTATTCGTTTAAATAATCTCCGCCCTTTAAAAC +TACTCTGTAAAAATCCAGTTCTCCCTTTGAAACTTTAACGAAGGTCGTTTTTCTCCTTCCTATATCGAGT +ATTTTTAGTTCTTCCTTTCCGAGAACTCCGGATATTCTCGCAAGGGAGAATACCTCGCAATCCAGTGCGT +AGTAATCCTTTGGAACTTCAAAGTCTTTTGCAAGAACCAAGTAGTAGTAGCCATCTTTAAGTGAAAAGTC +CCACAGAACTTCACCGAATTGTGAAACTTCATACTTTAAGTATTCCTTCAATTCGGATATCTTTTTAATT +TCTGTTTTTTCTTTTTTACGAGACACTTGTGAGAAGGGATTACGTATATTTTTTTCCCTTTCTTACTTGT +AGGCTCCCAGGTTTTCTCCAAGAGTGAGTAAGATACGCTGAACCACTTCTCCCCGTCAATGCCCGTAAAG +ATCATCCTTCCATGTAAGATTTAATCAGTTTAAGTAAAAGCAGGAGGGTTTTCTTTACGTCTTCCTTGTT +CTTCGCAGAGATTCCTATAACGGGTATCCCTTCTTCTTCGGATATGTCTAAAGCTACGGCAACGTCTTCA +GGAGGCCAGGCGTTTGGGAGATCCTGCTTGTTTGCCGCAACAACCATAGGAACCGGATACCTGCTCTGGA +AGAAGTTTATTATCCTCCTCGCCTCGTGAAAGGTCTTCGGATCAGTACTGTCTACGAGTATTACTATGCC +GAGGGCACCTTCTCCTAGAATTTCCCACATGAAGTTAAACCTGCTCTGTCCGGGGGTTCCGAAAAGGTAA +AGCTCGTGTTCATCGTCTATCCTTATCTTTCCAAAATCCATGGCAACTGTTGTCTGCTGTTTTACCTCTT +TTTCCTTTTCGTGGGTTACTTTTTTGTCCGTAGTTACTGGTTCTATTTCGCTTATAGTCTTTATAAACTC +CGTTTTTCCCGCTGCAAAAGGTCCTGCTACAACTATCTTTATTTTCTTTAAGTTATTCTTCTTTTCCGTC +ATAACTTCTTGATTTTTTCAATTAATTTCGTCAAAAGATCCAAAGAAATCGTAGGCTTTCTTATCTCTTT +TTTCCTCTTTCGTCTTATAGCACCTATAGCGAGGAGTCCGTAGAGTGTTCTGTACACGGTCAACTTATCA +AGTCCGCTCTTTTCCAGTATATCTTTTACGGTGTTCTCTCCGTTTACCAGTTCCAGAACTTTTCTTTCTT +CTTCCTTCAGGTTAGCCCTTTGCACTTTTACTTCCCAATCGGGGGCTTTTTCGAATACGAGGAGTTCATC +GGATATCTTTCTCTCTGTTTCTTCAAGGGTGAGGTGGCGGGCAGCCTCCATTATGAGTTCTTCCGCCGGA +AAGGCAACCGGCACGTTCTCTGGATAATTTATAAACCCCTGTGTAAAGGAAAATATTCCGTCTTTGTTTT +CCAGCCTGCTCAGGAAAAACTTCTTAATGGTTTCCGCCATAGTCCTTTCATTGAGCCTAAGCTTTTCTAT +CAACTTTTCAAAGTCACGATCTACGTAAACCCTGAAGACTTTATCCACCGGTCTTGCGAGTACAAGTTCT +CCGTCTTTTATGTAGTAAGCAACCGTGATGTCGGGCCACTCGACTATCAGCACACCGCTCTTTTTATCGT +GGTGAAGAACTTGAAGAATATCCGCAAAGGAAAAGGACTTTAAATCTCCCGTGAGAGCCATCGCTTAGAT +GAGTTCCTTTAATTTCTGCTGAGCCTTCTTGATTTCCATATAAATCAATCCAAGTTTACTGTCCTGTCCC +GCTAAAGTCGTGAGAACGGCATCCTGTCCTATTTCCGTTATTACTACGTATCCTTTATCTCCCTTGATCG +TTATCTGCTCCATAGTTCCCTTACCGAGTTCTTCAACGACTCTTTCACCGAGTGAGAGTATGGCGGCACT +CATAGCGGCTACTTTGTCCTCTTCTGCGTTCGCGGGAAGAACTGAAGCTATGGGTAATCCGTCTAGACTC +ACTATAGCCGCCCCCTCAATCCCTGAAGCCTTTATCAATTCCTGTAGAACTTCCTCGTATTTATTCATTC +TTTCCCTCCATTACTTAAAAAATTCTAACTCCTTTTCTATTTCTTCCAGAATACTTTTAGTTCTGGTTAT +TTCCGCTTTCACCAATTCCTCTTCACCGGCTTCGGCGTAATTTTTCACTTTCTTTATTGTATCATCCAAC +TCGTAAATTTTGCGTTTTATGTTGTCAATCTTCTTTGCAATTTCACTTAAAGATTCTCTGAGTATTTCTC +CGAGAGCACCCGCTGGGTCGAGACCGGTCGGCAACGCTCCGTACTCTATTTCACCCTGCTTTAACCTTTC +AACTACTTCCATAATTTGGCCGAGCTTTTCAACAACTTCCGTATACTCCACGTGGACGTCTGCAAGTTGC +TTTTCCAGAGAACTTTTAACGTTTTTTATACCTCCTTCAATATAACTCACTATATCCCGTAGCTCCTCGT +ACAGGGGGGAGTAAAAGACACTTCCTTCAAGGTTTTGTCTATTTTCGTAAACAAATTCCGCAAAGTAGAG +AAGCACTCCTAGAAGTTTTTCTACCTTTTTTGTGTATACGTAAGAAGTAAAGGCTGAAACAAAGAGGGCG +TAACCTCCGGCGATTAAGGAAGATACTATTAATTCCGTTTTTAATACAAAGAAGAGAATCAAGAAGTTCA +ATAAAAATAGAAAAATAAAAATAAAAAGATAAGCTTTCAAAAACTCATCGGTTAAAGAAATCCACTTCAG +TACCTTTATTTCTTGCCCACCTCCTCGAACTTTATTAATTTAATTTTATCAACATCCTTACCGAAGGATA +CACCGAATTCCGAAAGCTCGCTGACCTTAGCTAGATGGACGTAGCCTTCTATTACTTTCATAGCGTAGAG +TTCTTTTACTTTATTCAGGTAATTGAATATATCCTCTTCGAGTATGGCGTTTCCCACGTAACCCCTCTGG +AGTGTAGAAACGTGGAATATTAGCTTGAAAGGTTTTCCATATTTTGCGAGTTGTTTTAGGTCGTTATTCA +AGGCTTCCTGAACCTGTTCGTCGGGAAGCTCTCCGAAGTACGCCATGTATAGAGCCTTTGGATTGTACTT +TTTGAGGGAAGGGATTAAGTCTTTTCCGCCCTCTATATACCACGCTTTTTTGCCAAGTATCCTGAGACCC +GTTACGAGTGCCCCTGCAAATACCGCACAGAGTTGAGAGTCTTCCATAAAGACTACACCTACTTCGTTAA +AGCCGTTTTTTGCAAGCAGTTTTGCGGTAGCGTAGGCAACGTTGAGCCTCGGGTTTACGGTCTTGGGATT +TATGAACTTGTTTTCCGCAAAGGCGAACTTTAAAAATGGAAATGAAAGTCCTGCAATTAAGAGTTCTCTC +CTATTCATTTTCCTCCTCCTTTATGGACATTTCCCTCCTCATGGCGACCTTACCGGTTCTCGCCATCTCC +TTGATACCGAAAGGTTTTAAGAGCTCAATCATGGCGTTTATTTTATCCTCATCTCCAGTAACCTCTATCG +TGTAAGTGTCCGGAGAAACGTCAACGACCTTGCCCCTGAATATCTCCGTTATCCTCAGAACTTCGTCCCT +TGCCCTGGAAGAGGGAGTGTAAACCTTTATGAGAGCGAGTTCCCTCTCCACGTGGGGAACGTCCGTCAGG +TCGGAAACCTTCAGGGTGTCTATTAGTCTCCTGAGTTGTTTTACGACCTGCTCAATTACTATATCGTCTC +CGATAACCTCAATAGTCATTCTCGATATTCCCTTTTCGTGAGTTTCGCCTACGGAAAGTCCTTCTATGTT +GTAACCCTTTCCCGCGATTAAGGTCGCTATTCTCGCAAGGACTCCCATCTCGTTCCTGACTTTTACCGTG +ATTATGTGCTTCCTGACCTGTCCTTTTCTAATTTCCCTCTTCTGGGGTTTAATAACTTCAAGCTCACTCT +TTCCCAAAGTATCCGCCATTACAATCCTCCTGTTTAATAATTTATTATGAAAGTATTAAAAAAAGAGGAA +CTTGTCCCTACGCTTTATCAATTGTTCTCACAGGCAAAGGAAAAGGTACTTGTTGTTTCCGCATGGATCA +GGGGAAGCATATTTAAGGAACTCCTATCTTTGCTTCCCGAGAATGTTCAGCTTGAGGTAATCGTGAGGGC +AGGGAACTTATCTGACATGGATATCACGGACGAAGCCTTCTTCAGGGAAACTAAGAAAAAGGGAGGAAGG +ATACTTCTCAACCCCAAACTCCACTCTAAGTTCCTGATAATAGACGAAAGGTACGCGGTTGTAGGTTCTT +CAAACATAACCTTTATGGGGCTATACCCTGAGGGAAATGTAGAGACAAACGTCTTGATAGAAGAAAAAGA +AAAGGTAAAGGAACTCCTGGAGTTTTACGAGAACCTAAAAGAAGAATCCGTAGATTACACGGACGTTGTC +GGCTATGCGGTATCTTCCCGCTCTCCAAAAGAAGCGGAAATCGTACTTCTCGAAGATCTGAAAGAACAGA +CATACCTCGGCATTCAAGGGGAGGAGTTTTTCCTGTGCAGGCTGAGCAACGTTTCGGGAAAAAAGGAAAC +CAGGGAAGATGCCCTTAACAGGATACTCTCGTCGGAAGTATGGGACTGGAAGGTCGCAGCCCTTTTTGCC +CACCTTTACGAAAGACCTGAGATAAAGACGGGAAGGCTTGAGATACTCGGTGAGTACGAAAAGGAGAGAA +ATCTTTTTAAAACACCAACGAAAAGCGTGGAGTCCGGTTCTCTCGTGAAGAAACTAGAGCCAGAAAGCGA +GGAACTAAAGAGAATACTCTTCAAGAACCACTCAGGGTACGACATGAAGTATCCCACGTACCTCGGAAAA +CTCTACAACACGGAAGTAAAAGCTTACCTCGACATGGACAAGGTTCTGGGTATGCACATGGCCGTTTTGG +GAACAACTGGTTCGGGAAAGACAACTTTTGTAAAAAAGATACTAAAAAACTTCAAGGAAAGCGAGGTGAT +AATTTTCGATATTTACGGAGAATACGCGCAGGAACTTGGAGCGAAAGAAGTAATAGTGGAAAACGTCTTA +ATGCCGATAAGCGTAGAAGACGTAAAGGATTACCTGAAGGAAGCTGGTTCCACTTTGGAAGAACGCTCAA +CGGAAGAAAAGGAATTCTTTTCCGTCTTCAGAAGGGCATTAAAACCCGATATTGAAGCGACGGAGCTGAA +AGAAAAGAGTTTTAAGGAAATATACGAGGAAGCTGTGAAGAACCTCCACTCTCTTCATCTAAAACAGGAT +GCCCAGTCAGTTTACGAACACCTTGAAAGAACCTACTCCAGAGGAGCTTTAGAACAACAACCTAAGGTAT +TAAAGGAAGTTGTAGATTTTCTGAACTCCGAAGAAAGGGTGAAGGTCTTTAACTTCAAGGAAGTGGACAT +AACCGAAACGAAAGTAAACCTCACGGGGTTAATACTGAAAGAAATATTTATAAGAGCCAAAAAGGACAGG +AAACCGCGATTGATAGTCATAGAAGAGGCTCAGAACGTAGCTCCCGAAAGGGGAACGGGAGATGTCCCGA +GCGGAAAGGAGAACGTCGCTTTCGTTTACGCCAAAAAGATAGCGATGGAGGGGAGAAAGTTAAACCTAGG +CTTGATAGCTATAACTCAAAGACCCGCAAACCTGAGCAAGTTTATACTCTCTCAACTAAACACTCAGGTG +ATATTTAAATTAATCACAAAAAACGACCTTGACGCGGTATCGCCCTTTTTTGAATACTCCAAAGAGGATA +TTTTCAGGCTCTTGCCTTTTTTAAAGCCGGGAACGGCCTTCGTAAGCGGCTTGGCCGTCCCCTTCAGTTT +TCTGTTTCAGATGGAGGAAATTCCCTACTACTGATTACTTTTCCGCTCCGGCTTGTTCTTTTGCCTCCCT +TGCCTTTTTCGCAAGCTCAGGAGAGTAAGCCTTACCCTGCCAGAGCATCTTGTAAACTACTTCGTAAGTA +CTTTCCGCGAGCTCCGTAAGCTCTTTGAAGAGCTTGTTAAAACCTTCGGACTTGTGGGACTTTTCGTGGC +TTTCCAGATCCTTCCAGAAGGTCACTATGAGTATTTCCCTGTCCTTGAGGGGGTGTTCCGTGGCCTGTCT +GCGGTTGAACCTTCAAGGGAAACACCACCGGTATTCAGGAGCACGAATCCTCCGTAAAAACCGTCATCAG +AGTGATAGGTCTTTACGTGCTCACAGAGATATGCGGCCTTTTCCATAACCTCATCTATGTCAACACCTTC +CTTCAAAACAACGTAATTTATGTTTACAATGGCATCTTCAGGTATGTCAGGTATTAAAGGATTTCCGTAC +ATCTCACTCACCTCCTTAGCATTTTAGGATATTCAAATATCCTTATATTTTTATGATTTGAAACATGTGT +TTACACCTTTTTTAAGTGAATTACAATTAATAAGATGTTTATGAAACCTGAAGATTTGATACTTACCATT +CCCGCTTTGATGATAGCGGTTATACTCCACGAAGTAGCCCACGGGTACGTAGCCTACAAAATGGGCGACC +CAACCCCAAAAGCAGCGGGAAGGCTTACCCTAAACCCTATACCGCACATAGACCTTTTGGGAACTATAAT +CCTTCCCGGGCTTTTGATGCTCGTAGGCTCTCCCATCGTCTTCGGATGGGCAAAACCCGTTCCCATAAAC +CCTTACAACTTCAAGGACCTTAAAAAGGGGATGTTCCTCACCTCCATAGCCGGAGTGGCTATGAACTTTT +CCCTCGCTGTGCTCTTCGGTATGCTGAACAGACTCCTCAGGGCTGTTGTTTACTCGGTGCCCGAAGAAGT +TGCAACTTTCTTGATAATTCCACTAATGATCTTTACGACTAAAGTGGTTTTAATAAACCTCGTTTTAGGA +CTCTTTAACGCCATTCCCATACCGCCCCTGGACGGAAGTAAAGCCCTGATGAGCCTTCTTTCTTACAAGT +ACTGGGAGATGTTCTACAGGTTTGAGCAGTATGGATTTTTAATAATTACCGTTCTCCTCTTTACAGGAGT +CCTCCAGAGTATCATCCTTCCTCCATTAGTCTTTCTCTACAACCTCATACTCAATTAGTGCATCATTTTC +CCATGCATCTTTCTCATCATCTCCTTCCAGCTTTCTTTGTAATTGTGATACAACCAATACGCTACCGCTT +CCTTTTCCTCTTCACTTAAAGCCTTTCCTATCGGAGGCATTACTCCGAATAGCTTAAACGCCATGGGCAT +ACACACTCCCTTTTCCCTTGAAGGATTCGTTATGTAGTCCTTGACGAAAGTAATAAACTCAAGTTCACCG +GGGTAGAACTTTTTCACCCTCGCTGAAACTTCGTTCATAGGTGGTGCTGCTATAGGGAGTTTTTCTCCCC +TCATAGCCATCATCCTGAACTTTTTAATCTGCTCGGGAGTTGCCCTTTCTATGTGGCAGGCACTGCAGTG +TTTTTTATAAACTTCGTATCCTTTCTGGAGAAGGTTATGATCCACTGCAAAAACTGGAATTGCCAAGGCT +AAGGATATTAAAAGTTTTCTCATTTTACACCTCCTGGTTAGTAAATTCTAATCCACTTTACAGGAAATTT +CACGAGGTTTATATTTATTAATTAGCCCTGCGGCGGGACAGGGTGAACTCCCCCAGGCCCGAAAGGGAGC +AAGGGTAAGCCCGCCGTCCCGTGCGCAGGGTCCTAAAACAAATACCCTCCAGAGGTAATAAATGAACTAC +GTTCCCTTCGCGAGAAAGTACAGACCGAAATTCTTCAGGGAAGTAATAGGACAGGAAGCTCCCGTAAGGA +TACTCAAAAACGCTATAAAAAACGACAGAGTGGCTCACGCCTACCTCTTTGCCGGACCGAGGGGGGTTGG +GAAGACGACTATTGCAAGAATTCTCGCAAAAGCTTTGAACTGTAAAAATCCCTCCAAAGGTGAGCCCTGC +GGTGAGTGCGAAAACTGCAGGGAGATAGACAGGGGTGTGTTCCCTGACTTAATTGAAATGGATGCCGCCT +CAAACAGGGGTATAGACGACGTAAGGGCATTAAAAGAAGCGGTCAATTACAAACCTATAAAAGGAAAGTA +CAAGGTTTACATAATAGACGAAGCTCACATGCTCACGAAAGAAGCTTTCAACGCTCTCTTAAAAACCCTC +GAAGAGCCCCCTCCCAGAACTGTTTTCGTCCTTTGTACCACGGAGTACGACAAAATTCTTCCCACGATAC +TCTCAAGGTGTCAGAGGATAATCTTCTCAAAGGTAAGAAAGGAAAAAGTAATAGAGTATCTAAAAAAGAT +ATGTGAAAAGGAAGGGATTGAGTGCGAAGAGGGAGCCCTTGAGGTTCTGGCTCATGCCTCTGAAGGGTGC +ATGAGGGATGCAGCCTCTCTCCTGGACCAGGCGAGCGTTTACGGGGAAGGCAGGGTAACAAAAGAAGTAG +TGGAGAACTTCCTCGGAATTCTCAGTCAGGAAAGCGTTAGGAGTTTTCTGAAATTGCTTCTGAACTCAGA +AGTGGACGAAGCTATAAAGTTCCTCAGAGAACTCTCAGAAAAGGGCTACAACCTGACCAAGTTTTGGGAG +ATGTTAGAAGAGGAAGTGAGAAACGCAATTTTAGTAAAGAGCCTGAAAAATCCCGAAAGCGTGGTTCAGA +ACTGGCAGGATTACGAAGACTTCAAAGACTACCCTCTGGAAGCCCTCCTCTACGTTGAGAACCTGATAAA +CAGGGGTAAAGTTGAAGCGAGAACGAGAGAACCCTTAAGAGCCTTTGAACTCGCGGTAATAAAGAGCCTT +ATAGTCAAAGACATAATTCCCGTATCCCAGCTCGGAAGTGTGGTAAAGGAAACCAAAAAGGAAGAAAAGA +AAGTTGAAGTAAAAGAAGAGCCAAAAGTAAAAGAAGAAAAACCAAAGGAGCAGGAAGAGGACAGGTTCCA +GAAAGTTTTAAACGCTGTGGACGGCAAAATCCTTAAAAGAATACTTGAAGGGGCAAAAAGGGAAGAAAGA +GACGGAAAAATCGTCCTAAAGATAGAAGCCTCTTATCTGAGAACCATGAAAAAGGAATTTGACTCACTAA +AGGAGACTTTTCCTTTTTTAGAGTTTGAACCCGTGGAGGATAAAAAAAAACCTCAGAAGTCCAGCGGGAC +GAGGCTGTTTTAAAGGTAAAGGAGCTCTTCAATGCAAAAATACTCAAAGTACGAAGTAAAAGCTAAGGTC +ATAAAGGTGAGAATGCCCGTGGAAGAGATAGGGCTGTTTAACGCACTAATAGACGGCTTGCCCAGGTACG +CACTCACGAGGACGAAGGAAAAGGGAAAGGGAGAAGTTTTCGTTTTAGCGACTCCTTATAAAGTCAAGGA +ATTGATGGAAGCTATGGAGGGTATGAAAAAACACATAAAGGATTTAGAAATCCTCGGAGAGACGGATGAG +GATTTAACTTTTTAAAGTATGGGTGTATCTGAGCAAAGGTTTAAGCTAAAAACAAACCTGAAACCCGCAG +GGGACCAGCCGAAAGCCATAAAAAAACTCCTTGAAAACCTAAGGAAAGGCGTAAAAGAACAAACACTTCT +CGGAGTCACGGGAAGCGGAAAGACTTTTACTCTAGCAAACGTAATAGCGAAGTACAACAAACCAACTCTT +GTGGTAGTTCACAACAAAATTCTCGCGGCACAGCTATACAGGGAGTTTAAAGAACTATTCCCTGAAAACG +CTGTAGAGTACTTTGTCTCTTACTACGACTATTACCAACCTGAAGCCTACATTCCCGAAAAAGATTTATA +CATAGAAAAGGACGCGAGTATAAACGAAACGCTGGAACGTTTCAGACACTCCGCCACGATATCCGTTCTA +GAAAGGAGGGACGTTATAGTAGTTGCTTCAGTTTCTTGCATATACGGACTCGGGAAACCTGAGCACTACG +AAAACCTGAGGATAAAACTCCAAAGGGGAATAAGACTGAACTTGAGTAAGCTCCTGAGGAAACTCGTTGA +GCTAGGATATCAGAGAAATGACTTTGCCATAAAGAGGGCTACCTTCTCGGTTAGGGGAGACGTGGTTGAG +ATAGTCCCTTCTCACACGGAAGATTACCTCGTGAGGGTAGAGTTCTGGGACGACGAAGTTGAAAGAATAG +TCCTCATGGACGCTCTGAACAGACACGTTATAAAAGAAGTGGAAGAGTATTCTGTATTTCCCGCCTCCCA +CTACATAGCCCCCAGACCCACCGTTGAACAGGCACTGAAAGAAATAGAAAAGGATTTAATAGAGAGAGTA +AAGTGGTTTAAAAGTCAGGGAAGGGAAGTGGAAGCCCAGAGGCTCTACCAGAGAACTATGTACGACATTG +AGATGATAAGAGAACTTGGGCACTGCAAAGGGATAGAAAACTACTCCCGTTACTTTGACGGGAGAAAACC +CGGAGAGCCACCCTTTACTCTCCTTGACTACTTCCCTGAAGACTTCCTGCTCATAATAGACGAGTCTCAC +ATGACAATTCCTCAACTCAGGGCTATGTACAACGGGGACAGGAGCAGGAAGGAAAAACTCGTGGAGTATG +GCTGGAGGCTTCCCTCAGCACTCGACAACAGACCCCTCAAATTTGAAGAGTTTCTGGAAAGGATTAATCA +GGTAATTTACGTTTCAGCAACACCCGGAGACTGGGAACTTGAAAGGAGCGAGGCTGTAGTGGAACAAATA +GTAAGACCTACGGGACTCCTGGACCCTGTTGTGGAAGTAAGACCGAAGATGAACCAGCTTGAGAACTTAG +TAAAGGAAATAAAGGAAGTCAAAAAGAGAAAGGAAAGGGCTTTAGTTCTTACAACAACAAAAAGGCTTGC +AGAAGAAATAGCTGACTACCTGACCGAAAGGAAGATAAGAGCCAAATATATGCACTCAGAACTGGACGCA +ATAGAAAGGGCACAACTGATAAGGGAACTGAGGGAGGGAAGCATAGACGTTATAGTGGGTGTAAACCTCT +TGAGGGAAGGGCTCGACCTTCCCGAAGTTTCACTAGTTGCCATAATGGACGCGGACAAAGAGGGCTTTTT +AAGGAGTTATCAGGCACTAATACAGACCATAGGAAGGGCTGCGAGAAATATACACGGAAAGGCTATACTC +TACGCGGACAGGATAACTAAAGCCATGGAAAAAGCGATTCAAGAGACCCAGAGGCGTAGAAAGATACAGG +AAGAGTTCAACAAGAAACACGGCATAACTCCAAAATCCATAAAGAAGCCCGTAAAGGAACTCCTCGCAAT +AGAAGAGCTTGATTACGTGAGCGTTCCCGAAGAACTGCCGAAGGGAGTTAAATCAGAAGAGGACATACTC +AAGAAGATCGAAAAGCTTGAAAAGGAAATGTGGAAATACGCTCAAAACTGGGAGTTTGAAAAAGCTGCAA +AAGTTAGGGATGAAATTAAGAAACTGAAAAAGTTATTAGGTTTGGATTAGAGAGGGGAAGCGGCCCATTA +GCCGCAGGAGAAAGAACTTCCGCATCCGCAGCTTCCGGTTGCGTTGGGGTTCCTTATCGTAAACCCACCG +CCCATGAAGTCAACTACGTAGTCAAGTTCCGCACCGTTTACGTAGGGCATGGAGAAGGGGTCTATTACAA +CTTTCACTCCGTCGTATTCAAATACGTGGTCTCCTTCTTCTACGGTGTCATCAAATCCCATAGCGTACTG +GAATCCGGAGCATCCACCGGGAACTACTCTAATCCTGAGTATGGGGTTTTCTATGTTGTTCTCCTGTGCA +ACCTTCTTGATTTCTTCAACAGCCTTGTCAGTTACCTTAAAAATAAATTGTTGAGCTTGCTCTTGCATAA +CTCCTACCTCCTTTAAAGTTTAATTTACTAAAGATTAAAAGTATACAACTTCCGAAGTAGGTTTATGAGG +AAATTCATAAATGCTTTTCAAATGCTAAATCGGGGATAAATTTAAAAGTTAAATGAAGAGAAAAAAGAAG +CTAAAAAAGAGAGTGAGACTTGACTTTGCAAAATTCGTGGTGGAGGAGGTTAAATCCAAACTGGGGGAAA +GAAGATGGAATTTTACGACCCGAAAGTAAAGCAGGAAATAAAAGTACTGCCAAAGGACTACGTCCAGTCC +GTGGATAACATGTCCGCAAACGACTTTTTAAAGATATACCTGGAAACCTTACGTTATCAGGATCCCTTTA +ACCAAACTGACATCTCAAAAAGTTTGGACGATATGGTAAAGATAAACCAGATAAAGTACTTCACCGAAAT +GAAACAATTCCTCGAAAGCCTGAAGGCGTGGATGAACCAGATGACGTTCTTAAACACCGCTACTCTAATA +GGAAAAGAATTTATCTTCAGGACTGAAGTTTTAGACACTATAAAGAGGGATAAATACTATATACTTTCAC +CGGAAAACGTTAACAACGCGAAAATAAGGGTTTACGACGGAGAAGAACTCGTTAAAGAGGTAAAAATTGA +TATAAAAAAGGGTTTGAACGAGATAGACGTCTCGGATTTGCCCAAAGGTCAGTTCAGTATAAAAATCTTT +AAAGGGGATAACGAACTCACAGGCTGGCAACTCGGTTTTAAAGAAAAAATAAACGCGGTAAGTATCCTGA +ACGGAGATTTATATCTGGAACTCTCTGAAGGAACTTTGATTTCTTCCGATAAAATTATTTACGTGGGGGG +ATAAAGCATGCTAAGGAGCTTTTACAACGCGATAACTGGCATGGACGTTTCTAGGTTTGCCCTGGACGTT +ACCTCAGACAACCTAGCAAATGCAAATACAGTAGGGTTCAAGAAATCAAGACCAATTTTTCAGGACATGG +TTTCACAGGTAGTTGTAGGCTTAAACACCACAACAGGAACGGTAAAAACGACCACATTCGGAGCCGGAGC +GGTAGTAGATTCCACTCAAAAGGTATGGACAATAGGCAGTTTTAAACAAACCGAGATAACGACTGACCTC +GCTATAGAAGGTAAAGCTCTCTTTATACTCAGAGATGTTTTAACAAACCAAACATATTATACGAGAGACG +GCAGATTCAGAATAAACAGGGAAGGATACCTTATTAATCCAAACGGACTTTACGTTCAGGGATTTAAGGT +AAATCCTGTAACAGGTGAAGTTACCGGAACACAGTTAGAAGATATAAGAGTAGAAACGCAGATACCTCCG +AAGGCTACCGGTGAGATTTACTTTAATCCGCCGACGAATTTAGATGAGAGAGCTCCTATTATAGACCAAA +CTACTACACCTTTTAATCCTCTGGATTCATTTACCTACAATTACAGGTACACGTTAACTATTTATGACAG +TTTAGGCAGGGAAGTTCCGGCGGATATTTATTTTGTAAAAACGGGGACGAATCAGTGGAAAGTATACTTC +TTGGCTTCTTTAAAAGAAAGATATATAAACGTTGATTGGAACGGGGATGACGATAAAACAGATATAGTTT +TCCTTGATTTATTTAACGATCAGGTTCATATTGCGGATAACGGAACTTTTAGTACGCTCCCTACATTCGC +TTCAAAGACCCTCGAGTTTGACCCCTCAACGGGGAAATTGGTATACATTCCGGGTGGTGATATTGTTCAG +GATACAGCTAATCAAAAGTTTTACCTAGAAGTTGATTTAACACCGGAAAGTGGACCTTCTGAAATAAACG +ATCCGAACGATACAGAGTCTTACTTAAACAAGTTAGGGGCAAAGTTAGGTAGTGAAACTAATAAAATTAA +AATTTACGTAGGTGAAGGTATATTACAGAATAATGTAATTCAAAATTCCTACATCACCCAACACGCAGCG +GACTTTGTCGTTACTATGGATCAAGACGGGTACGCAAGGGGCGAATTAATAGACTTGTACGTTCTTTCTG +AGGATGGTGTTGTTGTAGGTGTATACTCAAATGGGGAAACCCTTCCTACTTACAGACTTGCCCTCGCACA +GTTCACCGATCCCGAGGAACTTGTCAAGAAAGGTTCCAACCTTTACGCTTCTGTAAAAACTCCTACGATC +TTACTCCCCGGAGGTTCTAACAAAATACGCTCCGCCGTTGTTGAAATGTCAAACGTGGACATAGCAAAGG +AGTTCATAAACCTTATAACAGCCCAAAGAACTTATCAGGTAACGCAAGGACGATAACCGTTACTAATACG +ATACTTGAGGACACGATAAATCTAGTAAGATAAAGGTATGGCTGAAGAGGTAAGGGAAGAAGCACAGGCG +GGCGGTGGGAAAAAGAAATTAATCTTCCTCCTTCTTCTCTTAATACTTCTCGCAGGTGCAGGGGCAGGAG +CTTATTTTTTCCTATTTGCTAAAAAGGAAGAGAAAAAGGAGGAAAAAGCTCCAAAGGTTGCTCCTCCCGA +AGTTGGCATTATGTACAAACTCGACCCGCCGTTTATAGTAAACCTTGCAGATCCTGAGGCAACCGTTTAC +GCGAGGATATCCATAACTCTGGAGGTTGCAAATCAGCAAGTACTTCAAGAAGTTCAGAAAAAAGAACCCG +TTATAAGGGATGCGATAATTGAGATAATTTCAAGCAAAACTTCCAACGAGATAAGAACCCCCGAAGGTAG +GGAACAATTAAAACTTGAAGTTCTAAAGCGTATAAATACAATCCTTTCAGAAGGTGGAGTGAGGAACGTA +TACTTTACAGAGTTCGTGATTCAGGTAGAGTAAGGTTTATACAACCATACTCAATTAATATTAGTTTGCT +ATTGATAATTCTTATCGGAGAAATAAATTATACCTTATTATGAGAGTTGAAGCCAAGTGGTGGAAAAAAT +TAGATGACGGAAAAGTTGAGTGTTATCTGTGTCCTGTTAGCTGTAAACTAAAGGAGGGGAGTGTAGGCTC +CTGCGGTGTGAGGGCAAACGTAGGCGGTAAGCTTTACACATTCACTTACGGTTCTTTAATATCAGCTGCC +ATAGATCCCGTTGAGAAAAAGCCTTTATTCCACTTTTTACCCGGACACAGGACGCTTACAATAGCGACGC +CGGGTTGTAATCTCCACTGTAAAGGATGCCAGAACTGGGAAATCTCACAAGTTCCGAAGGGAGAAGTATT +TAAAAACAGGTTTTACGACGAGACTTTTGTTCCACCAGAGGTAATAGTTGAAAAGGCAATAGAACACGGA +TGTGAAAGTATATCCTATTCTTACTCAGATCCCACGATATTTGCCGAGTACATGATAGACGTTGCCAGAC +TTGCAAAGGAAAAGGGACTCAAAAACATAATGGTAACCGCAGGATACATAAACCCGGAACCCTTGGAAGA +AATAGACAAGTACATGGACGCCTACAGCATAGACCTTAAGTTTTTTGACGATAAAGCTTACAGAGAATAC +TCAAAGGGAAGGTTAGAGCCCGTTCTTGAAACGATAAAGTACGCATTTAACAAAGGAAAGTGGGTTGAAC +TGACCACTCTTTTAGTTCCGAAGTACTTAACGGAGGAACAAATTAAAAAGATTGCGGAATGGATAGGTAG +TGAGCTCGCTCCATGGGTTCCGTGGCACTTATCTAGGTTCTTCCCCCACTACAAAGCTTTAGACTTACCG +CCCACGCCCGTTGAAGACTTAATGAAAGCTTACAAGATTGGAAAAGACGCAGGACTTGAATACGTATTTG +TAGGAAACTTATTCGGAAATGATTACGAAAGCACATACTGCCCTAAATGTGGAAATGTAGTTATCGGAAG +ACAAGGATATTACATAACAGAAATTAACTTAGAAGACGGGAAGTGCAAAAATTGCGGATACGAAATTAAG +GGAATTTGGAAAAAGTAAATTTTAAAGCCCCCTTGCGGGGGCAGGAAGATTTTTAGAAGTTGTAGAATAC +GGAAAGTCCTACATCAGTATAAGAATCTTCTTCTTCTGTAAGGTTCACATTATCAAGCTTAACATTTTCT +ACCCATAGAGCAATTCTGTTTGTAGGACCTTTTATATAGTAGTTTATAGCTACACCAAAGGATTTGAGCT +TAGGATCACTACCTGGTCTATCAAATTCAGTTTGTACGTATCTAGCAGCTAATGCAGGTTTTCCAAGGAA +CACTTTTTGATCATAAAGTAGCTGTCCTTGAACTAACCAACCTGTTCTATCATCTCCATCAGTTCCTGCC +CAATTTGTATGCTTTACATAACCTATTTGTATATCAGGAACTATAGTACCGAATTTTTGTTCCCACATAA +GATCAACGCCCCAAGAGTCCTGATCTTTAGCTCCTTCTCCGAAAGGCTGAGAAGTGTAAGAAAGACCTAT +TGTGAGAACATCTTTCTTTCCAACGTAAGTATTCTTAAGAACGTATCCCTTCTCAGCTTTGTATCCAAGC +ATTGTGGGAGTAAATTGAACTCTTATAGAGTATGCCGTTTTTGCATTTGATGTAGCTCCTTCATCACTTG +CATCAAATACACCAACATAGTATTTAAACATTCCATCTGCTATGTTACCCCATGCGGTAAGACCTGCACT +TCTGGATCCGCTCCTAAAAGGTTTGTGGTCGTTGGCTACAGGATTTGTAAATGCGTGTTTATAACCTGCT +ATTGCACTCATTCCAAGCCATGTGGGGAATAGATATGTCCAATAACTTTGGAGCCCAGAGTGTCTTTCAA +AGGGCACTTTGTAAGAACCAGCAATAATGTTAAATTCTGGCGCAAATGCGAGATTAATGAATGAATCAAA +TACTTCAATATCACCTGCTTTTCCTGGAGCAAACAATGACGCTTGGAATCCATAGCTAATTATCTTATTG +AGCTTGTACTTGAAGTAAATTCTCGCATCCCTGTGAGTAAATACTATATCAGACTTATCTTCGTTTCCAT +CAACTATTCCTCTGTCATCCTTAATTATAGCATCAATAATTCCCCTTGCACCGAACTTGAGAACTTGCTC +TTCGTCAATCCTTATGGTTACCGCGTTTGCGGAACCTGCTAAAACACCTAAGCTGAATACCGCCCCTGCG +AGGAGCAATCCTTTCTTCATAACCGACACCTCCCTTTAAATTTAGGCTAATAAGAATTATAGAATTTTTT +AACACAAGTTGTCAACTTTTTTTTGAGTTTTGCAATATTGCAAAAGCAGGTTTTAAAGACCTTAAAGGTT +TGCAAAAATACAAAAACACTTTTAATATCTTAACAAATCGTGAGAAAGCTTTTGTACGAACTTTTAGAAG +ACGACCGTTCCTTTGTATTTTATATATACAATACTTTTTCTTTCTCGGTAATTCTAATTTCCGTAATCCT +CACTCTGTACGACGAGTTCTACGGATTTCACTCCAAACTCCACCCAGTAGTTCTGGAAATAGAATGGGTC +GCAAGCGGTATAATCGCTTTTGAACTCATAGGGAGGTATATACTTGCGGAGAACAAATTAAAGTATTTAA +CCAATTCTTTAACTATCCTAGACTTTATAGCATTAATTCCTACATTTCAGATATTCAGAGCTGTAAGGCT +TATTGTTCTTATCGCGAGAGTTTTGAGACTTACCTACAGGTACAGGTTTTTCTTTGGATTTTTTGCAAAC +ATTATTAAGGAGTTTGCCTTTGAGCTTATCTTTGTGTTTGCCCTGATACTTGTAGTAATTTTCAGCATTC +TGTTAATAGTTTTTTCGGTGGAGCACGGCGGCGGAAATGAGAAGATAAATACTTTCTTTGACGCTCTTTA +CTATGTGATAATTACAGCCACGACTGTAGGCTACGGAGATATAACGCCTACCACACCTCTTGGTAAAGCC +CTTGCTATGGTTCTCGGAGTGCTCGGTCTGTTTCTTTTTTCCTTAATTACCGCAACTGTGAGCACAGCCT +TTTTTCACTACGTTAACATGTTAAAGATGGGAATGGTGAGCTTCAGAGAACTGAAAAATCACATAGTGGT +GTGCGGGTGGAACGAAACGGGAGAAGTAATGCTGGAAGAAATAATGAAGTACTGGGAAGAAAAAGGAGAA +AGAAAAAAGCCTATAGTCGTGGTTACAGATCAGGAACTTGAAACGAGGCACGAGTTTTACTACAAAAAAG +GCGATTACGTGAGTGAAGAAGTTTTGAAAAACGCAGGTGTAGAACACGCGGACATGATAATCATACTTGC +GGAAAAGGGTGTGGATCTCACGGAAGACTCTATAGATGCGAGAACCATTTTATCTTCCATGCTTGCGAGG +GATCTAAACCCGAAAGCTACTATAATCGCAGAAATACTCCTCAGGGAAAACGCTAAAACGGTGAAGAGGA +AAAACATTATAGATTACATAATCGTAGACGGAGAAGTTGTGGGACAAATGATTTCAAACTTCTTGAAGAG +AAAGGACATACCCCAGATACTAGATTACTTCCTGGATAAGGTAGATTACCTTGAGATAAAACCGAAAGAA +GAAAAAACTATAAGGGAGATTATTCAGGAATTTGGCAAAAAGGGAAAGCTCCTAGGCATAAAGAGGGGAA +GGGATTTTATATTCCTTCCAGACCTTGATATGGAAGTAACTCCTGAGGACACCTTAATTCTTGTGAAAGA +AAAGTAGTATTGTTTTATGGCTTTAAAAACCATAAATTAATAAATATAACAGTAGTTGAATAGATGGCAG +AACTGGAAATACATGTAAAACGGAGCGTATTTTCACCTGATGGAAAATTTTTAGGAGTCGTGGAAATGAA +GATATGGAAAGTACCAAAAGATAAATGCCATCCTGAAGGCTACAAGTACTCCCTTGTTTTTGCCTTATAC +AATGAAACAACGGGAAAATTTGATGGAAACTTTTTAAGATACGATAATTATCAATGTGAAGGACACCATA +AACATCTTAAAGGTAAAAAGTTCCCTTATAAATTTACGGATATTGAACAATTGATAGAAGATTTTAAGAA +CGATTTTGAAAAATTAATTGAGGAGGTTGTGAAATGAAAATTAAAAAAGTGGTAATAGAACCCATAGAAG +ATTTTTTTGAGGAAGTAAAATACGCAGTTAAACAGCATAAAACCGGAAAAAATGTTAAACTCGAATATGT +ATCTTTTAATTCAGTGGAAGAATTGAGCAGGATTTTAAGCCCCAGGAGAAAAGAAATTATTGATGTGGTT +AAAAAGTACAATCCGTCCTCTATAAGAGAACTCGCTCAGATTTTAAAAAGGGACTACAAAAACGTCTATA +AAGACGTAATTTTACTGAAGAAAGCAGGATTTCTTGAACTTAAAAAAGAAGGGAAAAACCTAAAACCTGT +GGTGCCATATGAAGAAATAGAAGTGATCGTTAAAGTGGGTAAATCTTAATAAAATTACTTTTATGGGTTA +CAGAGTCGCGATAGTTGGAGCTACGGGAGAGGTAGGAAGAACATTTCTGAAGGTCCTTGAAGAGAGGAAT +TTTCCCGTTGATGAACTCGTACTCTACGCTTCGGAGCGTTCAGAGGGAAAGGTTCTAACTTTTAAGGGGA +AGGAGTACACAGTAAAGGCTCTTAATAAAGAAAATTCTTTTAAAGGTATAGACATAGCACTTTTTTCCGC +AGGAGGTTCCACGAGTAAAGAATGGGCTCCCAAGTTTGCAAAAGACGGCGTCGTTGTAATAGATAACTCC +TCCGCTTGGAGAATGGACCCCGACGTTCCTCTTGTTGTTCCCGAGGTAAATCCAGAAGACGTAAAGGACT +TTAAGAAGAAGGGAATAATAGCAAATCCAAACTGTTCCACCATACAGATGGTTGTGGCTCTAAAACCTAT +ATATGACAAAGCGGGAATTAAGAGGGTAGTAGTTTCTACGTATCAGGCTGTTTCGGGTGCCGGGGCTAAA +GCGATTGAGGACCTCAAAAATCAAACTAAAGCCTGGTGCGAAGGGAAGGAAATGCCAAAAGCCCAGAAGT +TTCCTCACCAAATAGCCTTCAACGCCCTTCCCCACATAGATGTTTTCTTTGAAGACGGCTACACGAAGGA +AGAAAATAAGATGCTCTACGAAACGAGGAAGATAATGCACGACGAGAACATAAAGGTTAGTGCAACCTGC +GTAAGGATTCCCGTTTTCTACGGACATTCGGAAAGCATATCCATGGAAACGGAAAAGGAAATATCTCCTG +AAGAGGCTAGGGAAGTGCTGAAAAACGCTCCGGGGGTAATTGTAATTGACAACCCTCAGAACAACGAGTA +CCCGATGCCTATAATGGCCGAGGGCAGGGACGAGGTATTTGTCGGAAGGATAAGAAAAGACAGGGTCTTT +GAGCCAGGGCTTTCCATGTGGGTAGTTGCGGACAACATAAGAAAGGGTGCGGCTACCAACGCTGTTCAAA +TTGCAGAACTTTTAGTGAAAGAAGGACTAATCTAAAAGGAGGTATGAGATGGCCGAAGTTCAGCACGTTG +ATGAAGCTTTTGAGACATTAAAAAACGCTAAAGTCGTTGCCGTTGTAGGCATTTCTCCAAAGCCCGAAAG +ACCCTCTTACTACACCACAGAAAAGGTAGTAAAGAAGGGTAAGCACAAGATATACCTCGTAAACCCCCGC +TACGCGGGTCAGGAGATATTCGGAATAAAGGTTCTTCCCTCCCTGAAGGACGTTCCAGAGCCCATAGACA +TAGTGAACGTTTACAGAAACCCCGCACACGCGGAGGAAGTCATAAAGGAAGCCCTTGAAGTTGGAGCAAA +AGCGGTATGGTTTCAGCCTGGAGCGGAAAACCTAGAGGTTATAGAAAAGTACAAGGACAAGATAAAGATC +ATTTACAACGCGTGCATAGGGGTAGAAGCGGGCTACCTCTGAGCCCTTTTCTTTTAGTTTTCTCTTTATA +AATTTATTTAGTTAGGAGAGTTTAAAACATGCTGGGATGGATAGCTAAGAAAATCATCGGAACAAAGAAC +GAGAGGGAAGTAAAGAGGTTAAGGAAATTCGTAAACCAGATAAACGAACTAGAAAAGGAACTGGACGCCC +TGACGAATAAAGAACTCGTTGAACTCGCTCAAGAACTCCATGACAAAATTAGGTTTGACGAGGAATTAAA +GGAAAGAGTCATTAAAGGAGAAATCACACCGGAAGTTATAAAGGCCTTTGCCCTTGTGAGGGAAGCTGCA +AAGAGGACACTGGGACTCAGACACTTTGACGTTCAGTTAATAGGAGGACTCGTCCTTCACGAGGGCAAAA +TAGCGGAAATGAAAACTGGGGAAGGAAAAACCCTCGTTGCCACCTCACCTGCAGTAGTAAACGGAATGAC +GGACGAAGGGGTACACATCGTAACGGTAAACGACTATCTCGCGAGGAGAGACGCCCAGTGGATGGGACCA +ATATACAAATTTCTCGGACTTGAAGTGGGAGTTATAAACTCCGACGGAAAGACTTACCTCGTTGAGTGGG +TTGATCCGGAAAAAGTAAAGGAAGCCATAGAAAATGACGTGAGGGTATGGCCGAAAGGCTACTACGAGGA +AATCCTTCCCTCTGAAAAGGTAAACATAGACGCTAAGAAGACTTACTTTACCACCTTAAAAGAGGCTGAA +CACAGAAGGAAAGCCTATGAAGCACACATAACCTACGGAACTAACAACGAGTTTGGCTTTGATTACCTGA +GGGACAACTTAGCCTTCTCCAAGGAAGAAATCGTTCAGGTTAAAGGACACAACTACGCCATAGTGGATGA +AGTGGACTCAATCCTGATAGACGAAGCCAGAACGCCACTAATAATCTCAGGTCCGGCTCAAATAGACTCA +CAAATATATCACGTTGCGGATGCAGTAGTGAGGAAACTCAAAAAGGACAAAGACTTTACCGTTGACGAAA +AGAACAGAACCGTAAACCTGACGGAACAGGGAATAAAGAAAGTTGAAAAGATGCTCGGAATAGACAACCT +TTACGACTTAAAACACGTTGACCTCCTTCACGCCATTCTCCAGTCAATAAGGGCACACCACCTCTTTAAG +AAAGACGTCCACTACATAGTGAGGGACGGAGAAGTTTTAATCGTTGACGAGTTTACGGGAAGAGTTCTCC +CTGGAAGAAGGTGGTCCGACGGACTCCACCAGGCAATAGAAGTAAAAGAAGGCGTCCCAGTAAAGGAAGA +AAACCAGACTCTGGCTTCAATTACCTTCCAGAACTACTTCAAGCTTTACAGAAAACTCGCCGGAATGACT +GGAACTGCGGAAACGGAAGCCCTTGAATTTAAAGAAATATACGGCCTTGATGTGGTAGTAATCCCAACAC +ACAAGCCCATGATAAGGAAAGATCACCCAGACCTCGTTTTCAAAACCAAAGAAGAAAAGTGGGAAAGGGT +AGTAGAAGAGGTCCTCCTTAATCACATCTTCGGAAGACCAGTTCTCGTGGGAACCGTTTCCATAGAGGAC +AACGAAAAACTCTCCTCACTGCTCAAGAATAAAAAACTCTTAAAGGAAATAGCAAACAGAAACAGCTTCA +AGAGAAGGCTTGAAGAAACCGCTAAGAATTTGGGAGTTTCTCCGGAAGAAGTTCAGAAAAAACTTGAAGA +AGTTCTCAAAAAAGGTATTCCTCACAACGTCCTGAACGCAAAGCACCACGAAAGGGAAGCGGAGATTATA +GCTCAAGCGGGAAGGGTTGGAGCTGTAACGATAGCCACGAACATGGCGGGAAGGGGAACGGACATACTCC +TCGGCGGAAACCCCGAATACCTCGCAAAGCAGATGCTAAAAGAAAAGGGAATTAACCCGGAAGAGGCTAC +TGAAGAACAGTTCAGGGAAGCCCTAAGAGAGGCTTACAGGATAACTGAGGAGGAAAAGGAAAAGGTTAAG +AAGCTCGGCGGACTTCTTGTTATCGGAACGGAAAGACACGAGTCAAGGAGAATAGACAACCAGCTCAGGG +GTAGAGCGGGAAGGCAGGGAGACCCCGGAGAGAGCAGGTTCATAGTTTCTCTGGAAGATGACCTCCTCAG +ACTCTTTGGAGGGGAAAGGGTAAGCAAGTTAATGGACATGCTGAAAATAGAAAGGGGCGAACCCATAGAG +AGCAGGATGGTGTCCAAAGCCCTTGAAAACGCTCAGAAAAGAGTAGAAGCACAGAACTTCCAGATAAGAA +AGAGACTCTATGAATTTGACAGCGTAATGAACATACAGAGGGATGTAGTTTACACGTTAAGGAGACAGCT +CCTTGAAGGCGAAAACGTCCATGAGAAGATAAAGGAATTTTTGAAAGACATAATAACTCAAAAAGTGAAC +GAGCTCCTTCCCGAAGACGATCCAGAACTCTGGGACCTAGAACCCTTAAAAGCCTTCCTAAAAGAACTTA +CGGGAAGAGAAGTAGAAATCCCGCAGGTAAGGGATAAGGAGGAGCTAATACAAAAGCTCTACGAAGAACT +CTTAAAGATTTACGAGGAAAAGGAAAAAGAGATAGGAAGTCCAGAAGCTATGAGGGAACTCGAGAGGGTA +ATTCTCCTTAACCTCCTAGACAACGCATGGAGGGAGCACCTTCACACTCTCGACAGGTTAAGGGAAGGCA +TATACTTAAGGGGATACGCGGGGAAAGATCCGCTCATAGAGTACAAGAGGGAAGCTTACGAGCTCTTTGA +AAACATGATGGAAAACGTAAAACTGAACACTCTCATGACACTCTTTAACGTCCAGATTAAGTCCGAAGAG +GAGATAAAGGAAGTAGAACACGAAGAAGAAAAGAAGCACCAGAGACTCCTTGAAGAAGCAGAGCTCCAAG +GTGTTCAAGGAAAGAGTGATAAAAAGCCCAGACCCAAAACTCTAAAAGAAAGATTAAAAGAAGAGAGACT +GAGAAAGAGGAAATTAAAAGCGAAGAAGAAAGAACAGGAGTGAGCTAAAATTCTACGTATGGATAACTTA +GAAAACCTCGTCAAAAAATACATAAAACCCGGATACGAGTACGAAGTATTCTTTGAAAGGGTTAAAAAGT +TAAAGATAGAAGTCTCAAATGAGCAAGTTGAAAACGTCTCTTCTTCCGAAGAACGGGGTATAGGAATAAG +GGTTTTAAAAGATAAACGCCTTGGATTTTCCTACACTTCTTTTCTCGGTGAGGAAGAGATAAAGGACACA +GTTGAAAAAGCCATGGAAATGTGTGAAATTCAGGAGCCTGATGAGGCAAACGGCTTTATAGAGAAACTGA +AACCCTCTAAAGCGGTCTCCGTTTACGACGAAGAGTCCCTGTCAATTCCCTTACAGGAAAAGATGGAAAT +ACCCGTCAAGATGGAAAAGTACGCAAAGGAACTGGACAAGAGGATTGTAGGAGTGAGAAAGTCCACCCTC +ACCGAGGTTGAGTTTGAAGTAAGGAGCTTTAACTCTTTTGGTGTTGAGTTCGGATATAGGGGAACCTCTT +ACACCTCTATGATAGCGACACTCGGAACTGAAAATGATGACAGCGCAATCTCTTGGGAATTCAGAGGCGC +AAGGAGACTGAAGAACTTAAACTGGAAGTCCATGGTTGAGGACGCTGTCTTCAAAACCGTAAACCTCCTT +CACCCATCTCCCTTTGAAACTAGAAGTATGCCCGTTGTGTTCTTCAGGGAAAGCTTTGCGATGCTCCTTG +ACGCCTTCAGCCCTATGTTTTTGGGAGACTACCTGGTTAAAGGAAAAACACTTTTAAAGGATAAGGTAAA +CGAAATAGTAGCGAGTGAAAAAATCACGCTCGTTGATGACGGCTCCATGGAAGAGGGGTTTTCCACTTTC +CCTTACGACGCGGAAGGAGTGCCCACCAGAAAAAATTTATTAATAGATAAAGGAGTGTTTAAGGGCTTTC +TGCACAGCCTCTACACCGCGAGGAAGTCCTCTCAGGAACCTACCGGAAACTCCGTAAGAGGATCCTACAA +AGAACTGCCATCTTCGGGAACCACGAACTTTTACTTAGAAAAGGGGAACCTTTCCTTTGAAGAATTACTC +TCCTATTACGATGAGGTTTTCTTGGTTCTGGAGGTAATGGGACTCCACACCGTTGACACTATTTCGGGGG +ACTTCTCCCTTGGTTGTTCGGGAATTCTTTACAAAAAGGGAAAGAAGGACAAAACGGTAAGGGGCATAAC +TGTAGCGGGGAATATACTAGATCTACTTAAGAACGTTGAAGAAGTGGGGAACGATCTCACTTTTTATGGG +AGTGTAGGTTCACCCTCGGTTCTCGTTAAAAAATTAACCCTCGGAGGGGGGTGATGAAAAAATTAATCCT +CTTACTACTCTGGATTTTTCTATTAACCTTTTCCCTTTCATCTTTCTACATTTCCTACTCCGCATTCAAC +GAAGAGAGGACGCAAAAGATAGCGGGAAACCTCGGGGCATTTCTTTTAGCGATCCCCGAAAACAAGGTCG +TTATACTCCCAAATCCCGAGCTTACAATTATAAAAGTCCAAAAGAACGGACAGATATTTATGACTGCTAA +CGCGGTAAAACCCTTTGACCCTAAACTCTATTCTGGATTTAAAAAGAGTTTTAACGGGACACTCGTAGAG +GTTTACGTCAAAAATGCCACCCTTGACGATTTTTTTATGTTTTTAGTAAGTAATCCTACCTTCGGCGGAC +TTTTAGCCTTTGTATTTATTCTTTATATATCCTTCTTCTACTTTACGGTGAACGAACTGAGGGAGGTTAA +AGTAATCAGAAAAGCCGAAAAGGAACATTCTTTTGACGCAAAGGAAGTAATAAACTCTCTCAAAGCCCTA +AAGGTTCTATTGCACACTGAAAAAATACTCAAAGAGGAAAGTGTGGAGAAAGCTAAATCCATCCTTGATG +AAACCATTAAAAAGTTAGAAAATAAATAGGAGGGGCTTGAATGAAAATTTTGATAGTTTCCTTCGATAAA +ACCTTAGTTGACAGCTTAAAAGAACACCTCGCACAACACGAAGTTTACACGGCAAAGAACGCCGAAGAAG +CCATAACCCTATCTCCATCGGACATCGATTTAATAATCTTCGACGCCATTTCTGGTGCAATTTCCGAAGA +AGAGATAAACGAATTGTATTCAAAGAAGTTTAAAAATCAAAAGTACGTGATACTTTACGATGAACTCTTT +CCCGTAGATCCCAAAAACATACTTCCCCCTAACAAAGTCCTCGTTTTGAGGGATTCTCCACCCGAAGAAA +TAATAAGGAGAGCCCTTGAAGAAAAGAAAGAAGAAACAAAGGAAGAAGGGATAGAAATAGGCGCAAGCGT +TCCCGTAGAAGAAGAATTAAAGACCGAGAAAAAAGAAGAAAAGGTGGAAAAAGAAGAAACAGGAAAGGCT +AAGGTTCTGGTAGTGAGTTTTGACAAGAAACTTACAGATAATATCACTAACGCCTTAAAAGGAAAGTTCA +GCGTAGAAGTTGTAAGGAACATAAAGTCCGTGAAAGAGAAGGGACTCGAGGCCGACATTATCGTTTACGA +CGCCATTTCCGGTTCTATAGCGGAGAAAAACTTAATGGAACTGGCAGAGGTTCCCCAGCTCAGGGAAAAG +CACTTTATAATCCTCGTAGACGAACTCTTCCCAATAGACGTTGAAAAAATAAACCTGCCGAACAAGAGCA +CCCTGAACAGGGATGCTGGAGCAGAGGCTATAGCCGAGGAAGTTGAAAAGGTCGCACAAAAAGTAAAGAA +GGAAGAAATAAAGTCTATGGAAACGGAAGAAGTAAAGGAAGAAAAAGTAAGGGAAGAAATCCCTGAAGAA +GTACCTCAAGAAGTGGAAGAAATTAAAGAAGAAAAACCAGAAATGTCTGAAATTAAAGAAAAGACCGAAG +CTATATCTACGAAGGAGAAAACTCCGGAAGCGGTTCAGGTGCTGGCGGAAAAGCTCTCTGATGAGAAATT +TATACGCAGTTTGCTTGTGGAAGCTATCTCAAAGGAACTTCACGGAGTAAGAGAGGAAATAAAGGCGGAA +GTGAGGGATTACATAAAAAATGTGCTTGAATCGATAATAAGAGAAGAGATCGAAAGAGCCTTTGCGGAAG +TGGGCGTTGCAAAGATAATAAGGGAAGAGACTAAGAGGATAGTCGAGGAAAAAATAAAGGAATTGCTGAA +GTAAATTTAAATTCTTATGGAAGTTCTCCACAAACCTGTACTTTTAAGGGAAAGTGTTGAGTTTCTGACC +GAAAACGGAGGAAAGATTTACGTTGACTGCACGCTCGGAGGTGGAGGGCACGCAAAGGAAATTCTGAAGA +AAAGGAAAGATATTTTCCTTATCGGAATAGACAGGGACGAGGAAGCTATAGAAATAGCAAAGGAAAATTT +AAAAGAGTTTGAGGGGAGGTTCAGTATATACAAGGCGAACTTCAAGGATTTGGACCTGGTTCTGAAAGAG +GAAGGTATAGACAAAGTAGACGGATTTCTCTTTGACCTCGGAGTTTCCATGTACCAGCTAAAGGGAGAAA +GGGGGTTTACCTTTCAGGAGGACCAGCCCCTTGATATGCGTATGGACAAAGAGCAAACGTTAACCGCTTG +CAAAGTCGTAAACAACTACCCCGAAAGGGAGTTAATAAGGATACTCAAAGAGTACGGCGAAGAGAAGTTT +GCGGTAAGGATTGCAAAGGCGATAGTCCAGAGGAGGAAGAAAAAGCCAATAGAAACGACGGGAGAACTCG +TTGACGTAATCCTTTCCGTGGTTCCCGAGTACTACAAACACGGCAAGATACACCCCGCCACGAGAACCTT +TCAGGCGATAAGGATTGAGGTAAATAAAGAACTGGAATCCCTCAAAGAAGCTTTGGAAAAAACACCTTAT +CACTTTAACTCAAAAGGCAGACTCGTAGTCATTACTTTCCACTCCCTTGAGGACAGGATAGTTAAGCACT +TTATAAAGGAGAAAGAAAAGGAAGGAATTTTTAGGATAATTACGAAGAAGCCTGTAACGCCGTCCGAAGA +AGAAATCAGGGAAAATCCAGCCTCGCGGAGTGCGAAACTTCGTGTAGCTGAGAAAATTTAATGTTATAAT +TACAATCTTGCTTTAAACTCGGAAGAGGTGAATGGGATGAAGACATACAGGATTAAGCCCGAAGAAGTGG +AAAGAAAGTGGTGGGTAGTGGACGCAACGGGAAAGACTCTGGGAAGACTTGCAAGCGAAATAGCTAAAAT +TTTGAGGGGAAAGCACAAACCTTACTATCAGCCGGACGTTGATTGCGGTGATTTCGTAATAGTTATAAAC +GCGGAGAAGATAAGAGTTACGGGTAAGAAACTCGAGCAGAAGAAGTATTACTGGCACAGCAGATACCCCG +GAGGATTGAAGGAGAGAACCCTCAAGTGGATGCTCGAAAACAAACCCGAAGAGGTTATAAGACTCGCGGT +AAAGAGGATGCTTCCCAAAAACAGACTCGGACACAGAATGCTTAAGAAGTTAAAAGTTTACAGGGGACCT +GAGCATCCCCACCAAGCTCAAAAACCCCAGCCTCTGGAGGTTAAAGCATGATTCAGAAGTTAAAGGACTT +TAAATTAACCCCCGAAAACACTTATTACGCTACCGGTAAGAGAAAGGAAGCGGTTGCAAGGGTGTGGCTT +CTCAGGGACAGACCCAATACCTTTATAGTCGGGTCAGATAAGACGAACAAGGAATATGACCTAAGGGAGT +ACGTCCAGAGGGAAACACTTTACAACAAAATAATGTATCCTTTTAAAGTTACAGGACACGAGGGTAAGTT +CGGCATATACGCAACTGTCAGAGGCGGCGGAATATCCGCACAGGCGGAAGCTATAATGTACGGAGTCGCA +AAGGCACTTCTCCAGCACAACCCCGACCTGAGACCCACCCTTAAAAAGGCAGGACTCCTTACGAGAGACG +CAAGAGAGAAGGAAAGGAAGAAGTACGGTCAAATGGGTGCAAGAGCCAAGTACAGATGGAGCAAACGTTA +AGAGTTTCCGTTTTCGGTGCCACCGGTTATACCGGTATAGAACTCCTTCGCTCCCTTCTCACACACCCCC +ACTTTGAAGTAAAAAACCTTATCTCTCAGTCTTACAAAGGCAAAAAAGTAAGGGAGGTACTTCCCTTCTT +TTCAAACACCTACATATCCGAGATAGAGTTCCTTGAAGAACCTGTTGAAGACTACGAACTTGCCTTTTTA +TGCCTTCCTCACGAAGTCTCCTACGAGATAGTTCCCAAACTGCTCTCCCAGGGCAAAAAGGTTGTGGACC +TATCCGGTGCTTACAGGATAAAAAGTCCCAAAGCTTACGAGGAATTTTACGGATTTAAACACGAGAGGGA +AGATATCCTTCAGAGGGCTGTTTACGGACTTCCAGAAGTTTTTAGAGAGGAGATAAAAAATAGCGATCTC +GTGGCAAACCCCGGGTGTTATCCAACGGCTACACTTCTGGCAATATACCCCTTCCTCAAGGAAAGGGTGG +GAATAGAGAGTGTAATTGTTCACGCCCTTTCGGGTGTGAGCGGAGCGGGAAGGAAGCCAAAACAACAATT +TCACTTCCCCGAAATGACGGAAAACTTCTTCAATTACGCGGTAGAAAAGCACAGGCACACTCCCGAGATG +GAAGACGTAATAAGGAGAGTTTACGGAAGAGAAGTAAAGGTAAGGTTTACTCCCACCGTAGTTCCTACCT +CAAGGGGAATGATATCCACGGTTTACCTGAAATCAGAAAAATTAAACGTAAAGGAGCTTTTCAAGGAAGT +TTACGAAGACGAGATTTTCGTAAAGGTTGTGGACGAACCACCTCAAACCAAGTGGGTTCTGGGAACCAAT +TACTGTTTTATTTATCCCCATTACGACGAAAGGACAGGCTATTACGTTATTATTTCTGCAATTGACAACT +TGGGTAAAGGAGCTTCTCTACAGGCGGTTCAAAACGCAAATTTAATGTTCGGGCTTGCGGAAGACGACGG +GCTCCTTCAACTTCCCGTTTTCCCCTGAAAGTTTGTTATACTAATTCTCCAAATGCGCGTTAAGGTGGAC +AGGGAGGAGCTTGAAGAGGTTCTTAAAAAAGCAAGAGAAAGCACGGAAAAAAAAGCCGCACTCCCGATAC +TCGCGAACTTCTTACTCTCCGCAAAAGAGGAAAACTTAATCGTAAGGGCAACGGACTTGGAAAACTACCT +TGTAGTCTCCGTAAAGGGGGAGGTTGAAGAGGAAGGAGAGGTTTGCGTCCACTCTCAAAAACTCTACGAT +ATAGTCAAGAACTTAAATTCCGCTTACGTTTACCTTCATACGGAAGGTGAAAAACTCGTCATAACGGGAG +GAAAGAGTACGTACAAACTTCCGACAGCTCCCGCGGAGGACTTTCCCGAATTTCCAGAAATCGTAGAAGG +AGGAGAAACACTTTCGGGAAACCTTCTCGTTAACGGAATAGAAAAGGTAGAGTACGCCATAGCGAAGGAA +GAAGCGAACATAGCCCTTCAGGGAATGTATCTGAGAGGATACGAGGACAGAATTCACTTTGTAGGTTCGG +ACGGTCACAGGCTTGCACTTTATGAACCTCTAGGAGAGTTTTCCAAGGAACTCCTCATACCCAGAAAGAG +CTTAAAGGTTTTAAAGAAGCTAATAACGGGCATAGAGGACGTAAACATTGAAAAGAGTGAAGACGAGTCT +TTTGCTTACTTCTCCACTCCCGAGTGGAAACTCGCCGTTAGACTCCTGGAAGGAGAATTCCCGGACTACA +TGAGTGTCATCCCTGAGGAGTTTTCGGCGGAAGTCTTGTTTGAGACAGAGGAAGTCTTAAAGGTTTTAAA +GAGGTTGAAGGCTTTAAGCGAAGGAAAAGTTTTTCCCGTGAAGATTACCTTAAGCGAAAACCTTGCCATC +TTTGAGTTCGCGGATCCGGAGTTCGGAGAAGCGAGAGAGGAAATTGAAGTGGAGTACACGGGAGAGCCCT +TTGAGATAGGATTCAACGGAAAGTACCTTATGGAGGCGCTTGACGCCTACGACAGCGAAAGAGTGTGGTT +CAAGTTCACAACCCCCGACACGGCCACTTTATTGGAGGCTGAAGATTACGAAAAGGAACCTTACAAGTGC +ATAATAATGCCGATGAGGGTGTAGCCATGAAAAAAGCTTTAATCTTTTTATTGAGCTTGAGCCTTTTAAT +TCCTGCGTTTAGCGAAGCCAAACCCAAGTCTTCAAAGAAGAAGTACTACACTTACGAGAAGTACAAGAAG +TACAAGAAAAAGAGAAGGGTGTGGATAAGGCGATATCCGAGAAAGGCCAACACTCTAACTGACGCACACA +GGGTAAAGCTCGAAGAAATGGTAAAAGAGATGTTCTAAAAATGGACAAAGACAGCTTAAGGATCATTGAA +GAGTTAAAGATAAGACAGGGTGATACTTGGCGTGTATTCAAGATAATGAGCGAGTTCGTGCAGGGCTTTG +ACGAGCTCAGTGACGTCGGCCCTGCGGTAACCTTTTTCGGAAGTTCAAGGGCAAAGGAGACGGACAAGTA +CTACAAACTCGCTTACGAGACGGCTTTCAACCTCGGGAAACTCGGTTTTACGATAATAACGGGGGGAGGA +CCCGGGATAATGGAGGCGGCAAACAGGGGAGCGTACGACAGCGGAACGGAAAGCATCGGACTGAACATAG +ACATCCCCAGAGAACAGTTTCCCAATAAGTACCAGACTAAAAACCTGAAGTTCAAATACTTCTTCGTAAG +AAAAGTGATGCTCCTCAAGTACGCCATGGCTTACGTGATCTTTCCGGGAGGTTTCGGTACCTTTGATGAG +CTCTTTGAAGCGCTTACACTTATACAAACTGGAAAGAGTCATAAATTCCCGTTAATACTTTTCGGCAGTG +AGTACTACTCCCACCTGTTGAAGTTCATGGAAGAGGTAATGGTAAAGTTCGGAACGATAGACAAGGAAGA +CATTAACTTGATGGTTCTCGTGGACGACCCCAGAGACGTTGTAAAGCACATAATGAACAAAGCGAGGGAA +AAGTACTTCCACTTGAAAAAGTTCGGAGAGACTTCCTTTCTGAGAAAACTTGAGAGAATATTAAAGAATT +ATGAGGCTTATACATCTGTCTGACATCCACGCGGGAAAGAATCTCGGGCGTGTCTCGAGAAACGAAGACG +TAGTTTACGCACTCAATCAGGTAGTAGACTTTTGCAAAGAAAACAAACCCGATTTGGTCCTCGTTGCGGG +AGACGTTTTCGATAAGGCTAACCCCGATAACGAGGCGAAAGAGATTATTTTCGACTTCTTCTTAAAGCTC +CACTCCTTAAATATCCCGTCGGTTGTTATATCGGGAAACCACGACAGTTACGAGTTTATGAAGAGTTTAA +AAAAACTCCTTCAAGTTATAGACGTGTACGTCGTTCCCAAACCGAACTTAGAGGAGTGCGTACTTGATGT +AAAAGGTCTAAAAATCGCATGCCTCCCATACCCTTCCGAGAGGGTTTTAACGAGGGCGGGCGAGGATTCT +AAACTCTCATACGCAGTTCTCGTGGAAAAGGCCATCAAGTATCTTTACGAAAAGGTAAAAGATGCACCTC +TTAAGGTACTCCTTTCTCACCTTTTTATAGCGGGTTCAAAGTACACGAGAACCGAGAGGGAGGCTACTAT +CACAGATTACTACGCGGTAGAACCTTCCGCAATTCCCGAAGGCTTTGATTACGTAGCCCTCGGACACGTA +CACAGGTATCAGAGGATAGAAAAAGCACCAACCCACGTTTACTACACCGGTTCCCTCTTTCAGCTTGACT +TTTCTGAAGCCGGGCAGGAAAAGTTTTTTAACTTCGTAGAATTGAAGGAAGGAGAGCCTCCCCACGTTGA +AGCGATAAAACTCTCACTGAAGAACCCACTTCACACCTTTGAAATAAACCAAGAAAATTACGCAAAGGAA +CTCGAAAAAATAAAAGACGTTCAGGGCTACATCAAGGTTCACTTAATCGTAAAGGATAAGACGAAGATGC +ACCTTGTAGCTGAAAAGGTAAAGGAAGCACTAGGGGAGAAACTCATAAAACTTGAACTCCTGACTCCGGA +AGAAGCCATTAAAAAGAGACTGGAAGAGGAGAGGGAAATCCAGAAATTGAACTTACTCGACCTTTACAGG +GATTACTTCAAAGAAAGTTACGGAAGGGAAGTCCCTCAAGAAATAATAAAAACCGTTTCCCAGTTATTAG +AGCAGGTACATGAATCCTGAAAGCAGGGTAATAAGGAAAGTTTTAGCCCTTCAGAACGACGAAAAGATTT +TTAGCGGAGAAAGAAGGGTTTTAATCGCCTTCTCGGGCGGGGTGGACTCCGTAGTCCTCACAGATGTCCT +TCTAAAACTTAAGAATTACTTTTCCCTTAAAGAAGTAGCCCTTGCACACTTCAACCATATGCTAAGGGAG +AGTGCAGAGAGGGACGAGGAGTTTTGCAAGGAATTTGCCAAGGAAAGAAACATGAAAATTTTTGTAGGCA +AGGAAGACGTAAGGGCTTTTGCGAAAGAGAATAGAATGAGCCTGGAAGAAGCCGGAAGGTTCCTGAGGTA +CAAATTCTTAAAGGAGATCCTTGAAAGTGAAGGTTTTGATTGCATAGCAACCGCTCACCACTTGAACGAC +CTCCTCGAGACTTCCCTTCTCTTTTTTACGAGGGGAACGGGACTCGACGGACTTATAGGTTTTCTGCCGA +AAGAAGAAGTTATCCGAAGACCCCTCTACTACGTAAAAAGGAGTGAGATAGAGGAGTACGCAAAATTCAA +AGGACTCAGGTGGGTAGAGGATGAAACCAATTACGAAGTTTCCATACCCAGAAACAGGATAAGACACAGG +GTAATTCCGGAGCTCAAAAGGATTAATGAAAACCTAGAAGACACTTTCTTGAAAATGGTAAAAGTTTTGA +GAGCGGAAAGGGAATTTCTGGAGGAGGAAGCGCAGAAGCTTTACAAGGAAGTAAAAAAAGGGAACTGCCT +TGACGTAAAAAAGTTAAAAGAAAAACCCTTAGCCCTTCAAAGGAGGGTTATCAGGAAGTTTATAGGAGAA +AAGGATTACGAGAAAGTAGAACTGGTAAGGAGTTTACTGGAAAAGGGAGGGGAAGTAAACCTCGGGAAGG +GAAAAGTTTTAAAGAGGAAGGAAAGGTGGCTCTGCTTTAGTCCTGAGGTTTGAACTCGCAGGTTTCGGGG +TCTATTGTTCTGTAGAGAGGTTCTACCTTTCCGCCGGGTGTGGAGTCTTCAAAGTCTCTGGGAACTCCGA +GTTCTTCTATGCAGTTTACGAGGTCGTGGTAAAACTCAGCAACCTTAACCAGTCCTGTTTCCTTTCCAAC +TTCGTTAAACATCCTTATCTTGTCCGTAGCCTTACCCTTACCCCTTTCAACTATCGCTCCCGCGTGACCG +AAGGAAACACCTTCCATCTTCTCTTGGAACTTACCGGCTACAAACGCCGCAACGGGTTTGTTCCACCTAC +CTTCCTTGTAAAGTCTGAGTATCGTCTCGGCTGCCTGCTCTTCGTAAGTTCCGCCTACCTCTCCCTGTAT +AACTACACCCTTGACGTTGGGGTCATCCGCTATTTCTTCTAGAACGTCCGCAAAGGTTGTACAGGATATA +ACGTCTCCGCCGAGTGCCAGAGCCATGTAAACACCCCATCCCCTTCTCTTGAACATTTCCGCCGTTGTCG +TGGTAAGTCCTCCAGACTTAGAGAGTATGACGAGTCCGCCGTCCGCGTAGGCTATGGAAGGATTTTTACC +TCCTATCGCACCAATCCTTGCGGGAATTCTCGGAACTATGCAACCGAGGGAAGTAGGGCCTACTATCGTA +ACACCCCTTTCTTTCGCGTAGTGATAGAAGTAAACGGTATCCCTTATGGGAACGTGTTCCGTGACTATGT +AGATTAACTTGATTCCCGCGTCGATGAGTTCTATTACCGCGTCCTTTACGGAAGCTGGAGGAACGTAAAC +GAGCCCAGTGTTTACGTCTTTTCCTTCGGGAGAAGAAAGAGCTTCCTTTACGGTGTTGAAGACGGGAACT +CCCGCAACTTCCGTTCCGCCTTTTCCGGGCGTAACTCCAACCTTAATAAATCCGGGGTAGAGGGCTTCAC +TTTCGGTAACGACCTGAGAGGCTTCCCTTCCCGTAATACCTACAACAATTATCCTCGTTTTATCGTTCAA +GTACTTCGTACCTACGTTCCAGTTCTTTTCCATAATTGGTTTATTATAACGCGGTTTTAAAAAGCTTGTG +ATAAAAAGCAATGATTTAGCCAAGTGGACAAAAATCTTACAGCGCCTATTTAATAAATTCTTAACGGAGG +TGATGAATGGTACAGCTCGCCTTAAAGGAGGAGAAAGAACTTACTAAGGAGGAGATAAAGGAACTCCAGA +AAGAAGTTAGGAGACTCGCAAAGGAAAAGAACGCTGTAATACTCGCTCACTATTATCAGAGACCGGAGGT +TCAAGATATAGCGGATTTTGTAGGAGATTCTTTAGAGCTCGCCAGAAAGGCTTCTCAGACGGACGCGGAC +ATTATTGTATTCTGCGGTGTTAGGTTTATGTGTGAAACCGCAAAGATAGTAAATCCCGAGAAAAAGGTTC +TCCACCCAAATCCGGAAAGCGGATGCCCCATGGCAGACATGATAACGGCAAAGCAAGTAAGGGAACTCAG +GGAAAAGCATCCGGACGCGGAATTCGTAGCCTACATAAACACCACCGCGGACGTTAAGGCGGAAGTGGAC +ATATGCGTAACCTCCGCAAACGCCCCAAAAATAATAAAGAAACTCGAAGCTAAAAAGATCGTATTCCTAC +CGGATCAAGCTCTCGGTAACTGGGTGGCAAAGCAAGTTCCGGAAAAGGAATTCATAATATGGAAAGGTTT +CTGTCCTCCACACTTTGAGTTTACGTACAAGGAACTCGAAAAGTTAAAGGAAATGTACCCCGACGCCAAG +GTGGCAGTTCACCCAGAGTGCCACCCCAGAGTCATAGAACTTGCGGACTTCGTAGGATCTACTTCCCAGA +TACTCAAGTACGCCACAAGTGTTGATGCAAAAAGGGTAATAGTGGTAACCGAAGTTGGACTCAAGTACAC +ACTGGAAAAGATTAATCCGAATAAGGAATACATTTTCCCCCAATCCATGAATTACTGCGGAACCGTTTAC +TGTTGTACAATGAAGGGAATTACGCTACCTAAAGTTTACGAGACCTTAAAGAACGAAATAAACGAAGTGA +CGCTTCCCAAAGATATTATAGAGAGGGCGAGGAGACCCATAGAGAGGATGCTCGAGCTCAGTTAAAGTAT +CTTCTTTGCGGTTTCCCACATGGCTATAGCACCGGCGGACCCGACATTTAACGAAGTTACTTTCCCCTTC +ATTGGTATGGTTACGATTTGGTCCGAAATATCTAAAACACTCTTTGAGACTCCTTTGTCCTCGGATCCCA +AGACAAGAGCTACGGGAAGAGGAATGTCAACCTCCCTTATATCCTTTCCTCCTTTTTCTACCGCAAACAC +CCACCCTCCCATCTTCTGGAAGTTCTTAAGTTCTCTCGAAAGACTGGAAACTTTTGAAATCTTCAGGTGA +AAGACTGCACCGCTTGAAGCCTTAACTACGGTCTCGTTGATGGGAGAAGTCCTGTCCTTAGAAATTAAAG +CTCCAACTCCGCCGAGAACCTCGCAGGTTCTGAGCAAGTTTCCCACGTTTTGAGGGTCGGTTATGTGGTC +TATCACTATAAAGAAAGACTTTTTCTCAATACACTCCTTAAATAGTTCATGAGGGGAAACGTAATTTACG +GGAGAAAGAAGCGCAACAACTCCCTGAGTTTTCTTGGTTCCCGCGAGTTCTTCTACTTTCTTTCTTGATA +TCCTCTGAACTTTTACACCTCTCTTTTTTGCGAGTTCTAAAAGTTCTTTGGGCGGGTGGCTGTCGTGAGC +CACGTAAATCTTTTCTAAGTTTCTTCCCGCCCTCAATGCCTCTATTATCGGGTTCCTTCCCCAGATTACG +AACTTCTTCTCCATTTTATTTCCCTAAAGTCTGTGGATCCTTCTCACAAAGTAAGAAATCACCTCGTACC +ACACCTTTACCACTTCCCAGTCTATAGCGAAGTAGTCGTCTAGCTGTGTGTGTCTGAGAGTAAAGGGATC +TGATGAGAGAAAGAGTGTTTGTGCTCCCTTTTCTTTGAAGGGTACGTGGTCGCTCATTCCCGTCTTACTT +TCCACAAAGGGTATATCCACCTTCATGTCCATCAAGTGTTTGAATAATTTTTCGTTGATGAGCCTTCCGT +TTTCCCCGCTCGCGTCCTCGTACAGAACCGCCGGATTCTTCCAGCCTATAGAGTCGAGGTTTATCACGTA +AAAGATATTCTTTGAGTGAAGGGCGTGGTGAGAAGCACCTTCCAGTCCTAGTTCTTCGCAATCCGTAAAG +AGTATCCTTATCCTGAAGGGAATTTCCTGAAATCCCGCAAGTTCCCTTGACATCACGAGCAAAAGTGCTA +CGGAAAGACCGTTGTCTATAGCACCGTACACGAAGGGTTTTGTATCGTAATGAGCTACGAGCAAGAGCAC +GGGTCCCCTTCCGAACTCCACATAAAGGTTCTTCCCCTTTATCTCCTTTTTCTCCGTTCTTATATCGAGG +ATTACGTTCTTTCCCTCAATTCTTTTGACTATTTCCCTAGTAGTGTTTACCGCAAAGAACTTTACGTCTC +CTATAGTTCCAGAAAAGGGCACGTCCAGTTCTTCCAGAAAGGTTACCATTCCGGAAGCTTTTTTATCCCT +TAAAAACTTCGCCTTTTCGGAGTCCCTCCTTCCCCCTACGGGCAGGGCTACTACCTTTCCCTTCAAATCC +TTTTCTTCTTCAAGGTTTTTAAGGATTACTACTTCTCCCGATGTCTCTCCCCAAAGACTTCCGATGAGCG +GAAAGGCCGGGAATTCTTCCCCTTCGCACTTTATCCTTGCAGAAACGGGAACGGTTTTAGTTACGGAAAA +ATCCTCCTCGTAAACCTTAAAACCTTTCCTCTTCAGATAATTTTTTATAAACTTCCTCGCTTCTTTATTC +CCTTTAGTGCCGGAAAGCCTGTTTTTCCAACAAATCTCCTCGCATACTCTTTGAATTTCTTTTATCTTCT +CACTTATCATAAACGGGCGTTAACCACTTTTTGTACCTCTGGATTTTCCCCCTTACTGCGTTAAAGTAAA +ACTCCTGAAGCTGTTTTGTTATAGGACCTATCTCTCCGTTTCCTATCTTCCTGTTGTCTATCTCTACCAC +GGGAGTCACTTCGGCAGCTGTCCCCGTCAAAAACACCTCGTCCGCGGTGTAAAGCTCACTCCTCGCTATT +GGTCTTTCCTCCACCTCCACAACTAGTTCCTTTTTCAAAAGAGTTATTACCGCGTTCCTCGTTATGCCTT +CAAGTATGTGTTCGTTGGGAGAAGGTGTTATGGCCTTTCCGTTTTTTATTATAAAGATATTTTCTCCCGA +ACCTTCCGCAACGTAGCCCTGAGAGTTGAGAAGTATAGCCTCGTCGTATCCAGACATGAGGGCTTCAGTC +TTTGCAAGTGCACTGTTCACGTAGGCCCCCGCAACCTTCCAGCGGGATGGTATTGAGTTGTCGTCGTTCC +TCCTCCAAGAAGAAACCTTTGCCCTTATACCCTTTGAAGTGTCTAGGTACCTGCCGAACCTGTAGAGGTA +TATCGCTATTTCGGGTGTGTAGTCTATTAACTTAGGAGTTAATTTCAAGTCCTTAAAGTAAGCTATAGGT +CTTATGTAAACGTCCTCCCTTATCTCAGATTTTCTTAATATCTCTTTAGTAATTTCAACGAGTTCCTCAG +CAGAGTAGTTTAATTCCATAAACAGACACCTTGCGTTAGTGAGGAGTCTTTCGTAGTGTTCCTTTGCAAA +GAGGATGTAGAGTTGTTCCTCTTCTTCGTTCCAGTACGCCCTTATCCCTTCAAAGATGGCCGTGCCGTAG +TGGAAGGAATTGGTCATTATGCTTATTTTTGCCTCTTCCACGGGCACTATTTTGCCTTCGAAGAAAGCGA +AATCCATGGAAAAAGATTTTAGCATTTTTCAAGGAAATAAGTTAAACTTAAAGTATAAAAGGCAAAGGGA +GGAAGTTATGCAAAAAAAACACAGGCTTATTTTCCTCGCAACGGTTTTAGCCGGTTTGATACTATTCTAC +TTCGGTGTGGACACGTGGATGAAACAAAAACAGGTTCAGCAAAACCAGCCTCCTCCCATAGTCATAAAGC +CGGTAGCTCCCGTAAAGCCAAAAACTCAAGAAAGTAATCAAACTACAAAGAAAGAGGTAAAACAGGAGGA +ACAAAAGAAGGAAGAACCTAAAAAGATGGTACAAAAGCAAGAAACGCAGGAAAAGAGGGAAGTAAAAAAA +TCCGAGAAGAATGAGGTAAAGCAGACTCAGGAGAAAAAAGATGTAAAGGTTGCGAAAAAGGTTCCAAAAA +CAGAAAAGAAGGCTGCGAATTTAAGAACGTACAAGTTTCAGGTGGGGGCATTTCGCTACAGGGAAAACGC +TTACAAAATGGCAAAAATCGTGAGGAGTAAAGGTTTTGACGCTCAAGTTGTTAAGGTTGGAAGTCTTTAC +AGAGTTTACGCCTACGTTAAGGCTAAAAATTACTGGGAAGCGAAAAGAGAAATTAAGAAGCACTTTAAGG +ATGCTATATTTGTAAGGAAATGAAAAAGGTTCTTTTACTGCTCTCTTTAATCTTACTCCTATCCTGTTTT +CCCAAAGTAGAACAACGTCACTGGAAGGTTTACTACGATCTCGGAACCGCAGCTTTTGCGGCGAGGAATT +ACTCGGAAGCCATCGCAAACTTCCACAAGGCTTTGAGGGCAAACCCGGACGAACCGAGGATATGGAACGC +CCTCGGGCTCGCCTACATGGAGGCAAAGGAGTACAAAAAGGCGGAGGAGAGTTTTAAAAAAGCCCTTTCC +ATAAACCCGAACTACTCGGAAGCCAGAAAGAATTTAGGTATTCTTTACTACAAACTGGGAAGGTACGAAG +AAGCCCTGAAGTACCTTCAGGAAGCGGCAAACGACGAGTACTACGAAAAGAAACACGAAGCCTTTTATTA +CTTGGCGAAGGTATACGAGGCAAAGCAGGACCTTAAAAATTACGTCAGGTATTTAGAAAAGGCGGTAGCC +TACAACCCTAACTTTGTTCAGGCTCAGCTCGAACTTGCACAGGCTTACGAGAATTTAGGAAAGTACGAGG +AGGCAGAAAAGATTTACAAAAGTCTTCTTTTGAACGGCTTTAATAAGCCATTTCTCAAGTACAAACTCGC +GGAAGTTTACTATAAGAAAGGAGATTACGAAAGGGCGAGGGAAATTATAAAGGAGCTCCTCTACAAGGAA +AACCTCACCAACGAGCAGAGGGAAAAGGTAAAGGAACTCCTCACAAAAGTCCTCCTCGCTCAGCAGAGAA +AACTCATAATCCCAAGAGTGCATAAACCTATTAAAAAAGAAGAAAAGAAAAAGGAAAAGTACTACGCGGT +GCAACTGGGAGCCTTTTCAACGAAGGAAAGGGCGGATAAACTCGTTCAAGAGCTAAAAAGTAAAGGTTTG +AGGGATTTAAGAATCCTTCCCACTGACGGCGTTTACAAGGTAATTTACGGAAGGTTTGAAACACCAGAAG +AAGCCAGAAGAGCAAAGGAAGAGGTGAAAAAACTCGGAATTTACGGATTCGTCGTTGAAATCAAGTGAGC +GAACTTCCTCTTATAGGATTTCAAAGTGTTTAAAAGAAGTGCGGTTACCGTCATAGGTCCTACTCCCCCC +GGAACCGGCGTTATGGCACTCGCCTTCTCCTTTACTCTTTCAAAATCAACGTCACCGACTATCTTCCCGT +TTAACCTTGAAATTCCGACATCTACGACCACCGCGCCTTCCTTTATCATGTCTTCCTTTATGAGGTGAGG +AACTCCCGTTGCGGAGATGAGTATATCAGCCTCTTTGGTGAACTTTTTAACGTCTTTCGTATGAATGTGG +CACACGCTTACCGTTGCGTTCCTCCAGAGCATCAAAAGGCTTAAGGGCCTTCCCACTATAAAGCCTGCTC +CCACTATGGTAACGTCTTTTCCTTTTACGTCTATACCGTAGTGCTTTAGCAGGATGTCTATACCGAGGGG +TGTGCAGGGTATAAAGCCGTCCTCTATCTGTGCTACGAGTTTTCCCATATTTTCGGGGTGAAAGCCGTCC +ACGTCCTTTTCGGGGGATATAGAAAGGATTACCCTCGTCTGGTCTATGTGCTTTGGAAGGGGAAGTTGAA +CGAGTATTCCGTCCACCTCTTCGTTCATGTTGAGTTCGTATATAAGTCCGAGGAGTTTTTCTTCTGAAAC +GTCCTGCGGAAGATGATAAAAAAGAGACTTTATTCCAACCTTTTCGCAGGCTTTCCTTTTGTTGTTCACG +TATATCTCGCTTGCAGGGTCGTTTCCTACAAGTATAACGGCGAGTGCGGGCGGTCTGAAACCCTTTGAAG +TAAAATTTTCCACCTCCTTCTTTATTTCTTCCCTTATCTTCTTTGAGAGGCTCTTTCCGTCAAGTATTAG +AGCCATCTTTATCCACCCCGTTGAAGTTTATTTTCTCCTCAATTATGTAAGGTTTTTCTCCCCTGCTTTC +GTAGTACGTCCTGACAATTAGTTCCGCTATAATCCCGGTGGATATAAGTTGAATACCGGAAAGTATTAAA +AGGACTCCCAGGATGAGCAGAGGCCTGTTTCCTATGTTTTCCCCGAAGAAGAGTTTCAAAACCGTAAGGT +AAAGCCCAATTAAAAATCCCAGAGTGAAAAGTATAAAACCTATCCCACCGAATACGTAAAGAGGTCTTGT +TATATACTCGTTTAGGAACTTAACAAGGAAAATGTCCAGTATAACCCTTATTGTCCTGTCTATTCCGTAC +TTTGACCTTCCGTATAGCCTCGGGTGGTGCCTTACGGGGATTTCTGTTATCTTTGCACCGAAGCGTTTTG +CAAGAGCTGGTAGAAACCTGTGCATATCGCCGTACAGCCTGTACATCTTTGCTATGTCAGCCTTGTAAGC +TTTAAGTGTACATCCGTAGTCGTGGAGTTCTACTCCCGTTACTTTTGAAATGATCCAGTTTGCTATCTTT +GAAGGGAGTTTTCTCGAGAGGAAGGGATCTTTTCTATCCTTTCTCCAACCGCTCACTATGTCGTAGCCTT +CTTTCATCTTCTCCAGGAGTTTAGGAATGTCTTCTGGATCGTTCTGGAGATCCGCGTCCATGGTTATTAT +CACATCTCCCTTTGCGTGTTCAAATCCCGCGTATATGGCAGCGGTTTGCCCGTAATTCCTCCTAAACCTT +ATTACCTTTACCTTTTTATCCTTATTCGCTATTTCCTTTAAAATTTCAGGAGTCCTATCTGTTGAACCGT +CGTCTACGAATATTATTTCGTAGTCTTCTCCCAAAGAATCAAGAACCTTCTTTAACTTCTCGTAAAGAAC +GGGAATATTTTCTTCCTCGTTGTAGGCGGGAATGACGACCGAAATCATTAGAAGAAGTATTTTATCTTAA +TTTGTATGAAAAGGATTATCGCTCTTTTGTTTTTCTTCCTTATAGCTTTCGGATACTCACTCAGCCCTGA +GGAAGAAAAGCAGTTAATAAGGGATATAGCGGAGATAAAGGCTACCCTTAAAACTTTCATGGAACAGACG +GACAAGAGATTTCAGGACCTTAACCAAAGAATAAACGAACTCAGAGAAGACATGAACAAAAGGTTTGAGC +AGGTAGACAAGAGGTTTGAACAGGTAGACAAAAGATTTGAGCAGATAAACAATGAACTGAACCGGCTCAT +ACAGATAATGGTGGGGATATTCGCGGGACAGATAGCTTTAGTGGCAGCGGTTATAGGTTTTGCATGGTGG +GACAGGAGAACGATTATAAGGAAGTCTAAGGAAGAAACCTTTGAAGAGATGGAAAAGGAATTAAGACCTG +AAAAGTTCAAGAAACTCCTCAACGCCCTCAGAGAAAAGGCAAAAACCGATAAAGAACTGGAAGCGATACT +TAAAAAATACGGTTTGTTGTAAGTTTTTAATAATATGAAACTCCTTGATACTACCGTACTCCTGGACTTC +CTCTCGGGGGAAGAAGAGAAAGTGGAAACAATAGAGCAATTTTTTGAAGAGCTTTCCCAAAAAGGTGAAA +AATTGTTCGTTCCCGAAGAGGTCATAATAGAACTCGTTTACTTTCTGGAGCACGGATACAAATGGGAGAG +GGAGGACATTTACGAAGTAGTTGAGACTATCTTAAACGACGAGCTCTTTAACGTAGAACTAAAACCCTTT +ATAAGGGAGGCTATCAAGCTTTACTCAAAGAGACAGGGGACTTTCTTGGATTGTCTAAAGAGCGTAAAGG +CTAAAAAGATGGGAATTAAGGAAGTGGTTTCCTTCGGGAGGAGGTTTAAAAAGCTCGGCTTCAAAACTGT +AAACCCTTACGAGGAGAGTTAAAATTATTACTTCCATGGAACTCATCTTTGAAAAATCCAAAAAGGGAAG +GAAAGGTTATAAACTTCCAGAGCTGGACGTTGAAGAGGTAAATATAAAAGAATACCTTCCGGAAGAGTAC +TTAAGGGAAGAGCTTGACTTTCCAGAGGTTTCGGAGCTCGACGTTGTCCGCCATTACACTAACCTATCAC +ACCTGAACTACGCCGTTGACACGACTATGGTTCCTCTCGGCTCCTGCACTATGAAGTACAACCCGAGAAT +AAACGAGGAACTCGTAAATAAAAAGGAATTCTTAAACGTCCACCCGTTAACCCCAGAGGAGTACATACAG +CCCCTTTTAAAGCTCGTGTACGAGTTAAAGGAACTTTTAAAGGAACTTGGAGGTTTTGCAGAAGTTTCCC +TCCAGCCTGCAGCGGGAGCACACGGTGAACTCCTCGGACTTCTGCTCATTCACGCATACCATCAGGATAG +GGGAAATAAAGAGAAGAAAGTGGTTTTAATCCCCGACTCCGCTCACGGAACCAACCCAGCGAGTGCTGCT +ATATGCGGATTTGATATAAAGGTAGTAAAGAGCGACAAGAAGGGAGAACTTGATTTCGAAGACTTTATAA +AGAAACTGGATGAGAGAGTTGCCGCTTTAATGATAACGAACCCGAATACTTTGGGGATTTTCGAGAGGAA +AATAAAAGAGATAGCTGAGGAGCTTCACAAAAGGGACGCTCTCCTTTACATGGACGGGGCAAACTTCAAT +GCCTTGGTTGGTAGGTTCAAACCAGGAGAGTGGGGAGTTGACGTTATGCACTTTAACCTTCACAAAACCT +TCTCAACACCCCACGGAGGGGGAGGACCCGGAGCAGGACCCGTGGGCGTATCGGAGAGGTTAAAACCCTA +CCTCCCCGTTCCACAGATTGAGTACGACGGGAAAAAATACTACCTTAACTGGAATATAGAAAAGAGCGTA +GGGAAGATCCTCGCCTTTCACGGACACTTCCTCGTCTGGCTGAAAGCCCTCGCTTACATACTCACCTACG +GAAAAGACATAAAGAAAGTTTCCGAGTACGCAGTCCTGAATGCGAGGTATTTAAAGCACCTGCTTAAAGG +CGTGTTTAAGGACCCTTACCCTGAATCTCCCTGCATGCACGAGTTTGTTCTCTCGGCTACTAACCTTACA +AAGTACGGCGTCAGGGCTTCCGACGTTGCAAAGAGAATACTAGACTACGGCTTTTACGCTCCCACCATGT +ACTTCCCCTTAATAGTCAGAGAAGCCTTAATGATAGAACCCACGGAAACGGAAAATCCCGACACTTTGAA +AAAGTTCGCCCTAATTTTAAGGAAAATCGTTAAGGAAGCCAAGGAAAAGCCCGAAATTCTTAAGAAAGCT +CCCCACAGGACACCCGTGAGGAGGATAAAGGAGGCAGAAGCCAACAGGAACTTAATCTTGAAGTTTAAAG +ATATAAAGGAATAGAATTTAAATTTCTCGGAGGTAAAGACCTTGTACAAGGTACTGATTACTGACCCGAT +AGCTCCCGAAGGGATTGAACTGCTTCAAAAGGACCCGGAAGTTGAAGTTTACAACGAGCCAGACATTTCC +TACGAGGAACTCCTTGAGATTATAAAGGACTTTGACGCAATAATTACGAGGAGCAGAACGCCCGTAACCA +AGGAGCTTCTGGAAAGGGCGGAAAAATTGAAAGTCGTCGGAAGGGCGGGCGTAGGTGTTGACAACGTAGA +CATAGAGGAGGCGACAAAGAGGGGAATACTCGTCGTAAACACGCCCGGGGCAAACACGATAGGTGCAACG +GAACTCACGATGATGCACATGCTCACGATAATGAGGAACGGACACAAGGCCCACGAGAGTATGCTCAACT +ACAAGTGGGACAGAAAGAAGTTCATGGGAGAAGAACTCTACGGAAGAATCCTTGGGATTATAGGGCTCGG +AAACATAGGCTCTCAGGTTGCGATAAGGGCAAAGGCCTTCGGTATGAAGGTGATGGCCTACGACCCTTAC +ATTCCCAGAGAAAAAGCGGAAAAACTGGGAGTAAAACTCGTGGACAACCTCCACGACATGTTAAGGGAAA +TAGACGTCCTCACCATTCACGCACCACTCACCCACGAAACAAAGAACATGATAGACGAGAAAGAGTTTGA +AATAATGAAGGACGGCGTTTACATAGTCAACTGCGCGAGAGGAGGGATAATAAACGAGAAGGCTCTCATA +AAGTACATGGAGAGCGGAAAGATAAAGGGAGTGGCTCTGGACGTTTACTCAAAGGAACCCCCACCTCCCG +AATTTATAGACGAACTCAAGAGATTAGCGGACAAGGTTAACATATCCCTCAGTCCCCACATAGGTGCGAA +CACTTACGAGTCCCAGAGGAACGTTGCGGTAATCGTAGCACAGCAGGTTTTAAAGGCTTTAAAAGGTCAA +ACCGTGGAGTATGCAGTAAACGCACCCTTCCCCGACCTTTCGGTTCTCACACTCATAAAGCCCTACCTAG +ACCTTGCGGAAAAACTCGGGAAGTTCCTCGTTCAGTGGACGGAAGAGGGAATAAGGGAAGTTCACATAGA +GGTAAGGGGAGACATAGCGGAATACTTCCAGCCCATATCCTCCGCGGTTTTAAAGGGCATACTGGAAGAA +GTCGTGGACTTTCCCGTAAACATCATTAACGCCTTCTACGTTGCCAAGGACAGGGGAATAAAAGTTGAAG +AACTCTCCTCTGAAGAAACTCCCGACTTCAAGCACTACATAAAAGTAGTGGTAAAGGCTGACGGAAAAGA +AAAGGTTGTAGCGGGAACCGTCCTGGAGGGGCAAATCCCAAGGATAACCGAGATTGACAGATACAAGGTA +GACATAGAACCCGAAGGAATACTTCTCGTTTTTGAAAATAAAGACGTTCCGGGAGTTATAGGAAAGATAG +GCTCAATACTCGGAGAGGCTAACATAAACATAGCGGGCTTCAGACTCGGCAGGGAAAAGAAAGGCGGTAT +AGCCATAGGAATTCTCAACTTAGACGAACCAGCTTCGGAGGAAGTTCTCAGCAGAATAAAAGAAATACCC +GAAATACTCTTCGTCAAACACATCGTCCTTTGAGCTTCCTCCCTTATAATTTTGCTTATGCTCGAAAGGG +AAAAGCTCGCACGCCTCATAAAAAAACGCTCCCTGAAAGTAGCGGATGAACCCGTGTTTAAACTCTCCTC +GGGAAAACTCAGCAGGTACTACGTGGATTTAAAACAGATAACCTTTGATCCCGAAGGGGATTACTTAATC +GGAAAAGCTATGTACGAACTCGTCAAAGAATTCAACCCTGACGCCTGCGGTGGACTCACTCTCGGTGCAG +ACCCCATAGCCTACGCAATTGCCTTCGTTTCCCTTATGGACTCAAACCCTATAAAACCTTTCGTGGTAAG +AAAAGAACCCAAAGGTCACGGTATGAAGAGGCAGATAGAGGGTCTTTTAAATCCGGGAGAAAGGGTTGCC +GTTCTGGAAGACGTGGTAACCACGGGCTCTTCAGCTCTAAAAGCTGTAAAGGCATGTAGAGAATACGGCC +TTGAGGTTATAGGCGTTTTTGCGGTGGTTGACAGGGAAGAGGGAGGCAGGGAAAACATAGAAAAGGAGGG +AATACCCCTTTACTCCCTCTTTAAACTCTCGGAACTCCTTTAGATGTAGACCTCTTCCCTCTTTGCGACT +TCCACTATTTTGTCGAGGAGTTTTCCAAGTCCCCAGCGTTTTTCTGCGGAAATCAGTACCGCATCCCCTT +CAATAAACGCAGGGTGAGGCAGGTGGTTCATTTCGTTTTCCGTTTCCACGAGCTTGTCCGCTTTGTTGAG +GGCGTATATTATGGGCTTTTCCTCCGCTCCGAGTTCCTTTAAAACCTCGTTTACAGTGCTCACGTAATCG +AGCCAGCCCTCGTCCGATACGTCCACAACGTGGAGTATTATGTCCGCTTCCTGAACTTCCTCCAAGGTAG +CTTTGAAGCTCTCTATGAGCTCGGGAGGCAGTTTCCTTATAAAACCTACCGTATCCGTAAAGAGAAGCTT +AAAGTCCGGGTATATAACCCTCGCGGAGGTCTTTGTGTCAAGCGTTGCGAAGAGCATGTTAGCCACGTAG +GTGTCCTTCTTCGTGAGCGCGTTCATCAAGGTTGACTTTCCAGCGTTGGTGTAGCCCACTATCGCCACCC +TTACTATCCTTTCACCCTTTTCGCTTCTCTCCCTTCTCTTTCTTTGCTCCCTTCTCCTCTTTTTTATCTC +TTCAAGCTCCTTCTTTATCCTGTGGATACGTTTCTTTATGAGCCTTTTCCTAACTTCCGTTTCTTGCTCA +CCGGGTCCCCTCGTCCCAAGTCCACCCCCAAGTCTCGAGAGTGCCTTTCCCTTTCCGTGGAGTCTCGGGA +GTTCGTGCATGAGCTTTGCGAGTTCCACCTGAAGTTTCGCCTCTTTCGTCTTAGCTCTCCTTGAGAATAT +CTCCAAAACTAAATCCGTCCTGTCGAGAACCTTTGCGTTTATGACTTTTTCAAGGTTTGATATCTGAGCG +GGGGTGAGGAAGTCGTCAAACACAACTGTGTCCGCCTTAGTCCCCCTCACTATCTCCCTTATTTCCTGAG +CCTTTCCCTGACCTATGTAATACTTCTGATCGGGGAAATTCCTCTTCTGGAGTATGTAACCGAGGGTCTT +TCCGCCGACGGCCTCAACTAGACCCTTAAGTTCTTTAATGGATTCCTTAGAAAACTCCTTTGATATATCT +CTTCCCCAGACTCCTACTAAAACCGCTCTCATTCAAGAATTAATTTAATTTTTACAAGAGTTTTATCAAG +TTCATCCACCCTCTACTATGGTAGAAACCGCGTGCTTGTAAATCAGGTGAGGCTGTCCTTCAACTTCAAG +GAGAATGGTGTACCTGTCGTGGTCGAGAACCTTTCCCACTATCCTGTTTCCCCTCGTTAGAAATACTGTA +ATGGTTGTTCCCTGTTGTTTGAACCTGTTTAACAGCTCGTCCTGTATGTTAACTTCCCTTTGTTCCATAG +GATACATAACTCAAACCTCCTGAAGATTTAAGAATAAATTATAACTTCCGTTGAAGCAAAGTTTTAAGGA +ATTTAAATTAAGTTTATGCTACGCCTCTGGGAGGAGCTCAACAGAGTAGAAAACCTTTTCCTGGAACTTT +TAGACGACCCAAAGAAAAAGGACGTACTCCTCTACCTCATATGCTACTGCCAGCTCGTGAGGAGAGACGG +AGAGTACGAGGTTGAACTTCCAAAGCTCATAAATTGTGCAGAAAAACCTTACAAGTACATATCGGGAAAC +TGGCAGGACGTTTTACTTGAGCTCGGAGTCCTTTACCTTAAGGATAAAAAGGGGAAGGTCTACACGGGGA +AAGAGATACTCCTTGTGAAAAATCCAGAGGGCTTTAAGGTGGGAATACTTCCCGATTACAGGGAAGACTT +TTACAAATTCTACACAAAACTCTTGAAGTACTGGTCAGTTCTCAACTCTAGGAGAACACTCGGAAGCAAT +ACTACACCTGACTACTACACGCCCCTTCTCGTGCACACCTTTAACGAGAAGCTCTTTAAAGAGGCACAGT +ACTTTTCTGAAATACTCGCTATGAGGTTTCCCAAGGAGAAGAACTTATTCCTCTCGGTTAAATTAGTTTC +AGAGTTTTACAGGGAGTACGCAAAAACGGGAAGGGTTAAAGCGGACAACTTAAACGATGCCATTAATTTC +CTCTCCGATACACCCGACGTTTTTTACTCCGTAAACGTTAAGAAGTTCAAAAAAGATATCAAAAAGTTCT +TAGAAAACTTAAACAAGGGTGAGTTTTACTACATCACGATAGAATTTGCATCAGAGAACAGAGGGAAAAA +GAGGAGTATTTTATCTAAGCTCTGGAACTTTATAAAATCCTTAGGAGGTAAGAGATGGAATTCTCGCAGC +TCAGGAATGGATTACTACTCTTTCATAGAACACTTGTTGAAAAAGCACAGAAGGCAAATGATGAGGAGCT +TAGAGAGCTCTACACCCAGGCTGCAAGGTACTTAACGGAAGTTCTAAAAAACCTGGAGGAGTTTGACAAG +ACCATGAAGAAGATTAAGGAACTGGAGAGTAAAAACTTAAACCCCAATTGATTAAGGAGTTTTCAGATCC +CCTTTACGGTTTCGTAAGAGTAGGGGAGGCGGGTTTAAGGCTCATAGATTCCTTTCCTTTTCAGAGGCTC +AGGTACGTAAAACAGCTCGGACTCGCTTACTTAGTATTTCCATCCGCCCAGCACACCCGTTTTGAGCACT +CACTCGGGGTTTACCACATAACGGAGAGGATATGCGAAAGCCTGAAAGTAAAGGAAAAGGAACTCGTTAA +ACTCGCAGGACTCCTTCACGATCTCGGACATCCACCCTTTTCCCACACCACGGAAGTGCTACTTCCTCGG +GAAAGAAGCCACGAGGACTTTACGGAAAGGGTAATAAAAGAAACGGAGATTTACGAAATATTGAAGCAGG +ACTACTCCCACGAAGATATAGAAAGACTCGTGAGGATTACCCTTGGGAAACCTGAGGACGAGGAAGAAAA +ACTCCTCAGCGAGATAATCACCGGGGAGTTCGGCTCCGACAGGATGGACTACCTCAGGAGGGACGCCTAC +TTTTGCGGGGTATCTTACGGCTTTTTTGATTACGACAGACTAATAAGCACTCTCAGAGTCTATGAGAACA +AAGTAGTGGTAGATGAAAGTGGACTGAGAGCCTTAGAGAACTTCCTTATCTCCCGTTACTTTATGTATGT +TCAGGTTTACTTCCACAAGGTCGTGAGGATACTTAGCATACACCTCGTTGAGTTCCTGAAGAAGCTCATC +TCCCAGGAGGACTTTACGGATATAAACAACTTTCTAAGGTTAAACGACGCTTTTGTAATATCCGAACTCT +TCAAAAGGAAAGCATTCAGAGAGGATTTTGAGAGGATATTCCAGAGGAAGCACTTCAAAACGCTCCTTTC +CACGGAGAATTACGAGAAATTCTCAGAAACGAAGGAAAGACTTTTAGAAAAATTCCCGCAGGAAAAAGTG +AGATTTGACGAGGTGGAGAAAGAAGTTTACGGGGGGAATATATACGTTCTCAGTTCAGAAGGACTAAAGA +AAGCTCACGAACTCTCCCCGCTCATTGCTTCCCTCAAACCCATAAAACTTTATAGAATTTACGTAGACAG +GCAGTTATGGGAGAAAGCCCGTTCAGAATTAAAACTCTCTTGACGTTCTTTTCCTACACAGCTGTTCTCT +TGGGAGGGATTTCCCTCTACGGTGTAGCAGAGGATTTTGTTTACATATTCTTCATCCTCTCCTTTTTCCT +CGGACTCGGCGTCGATCTGAAAGGTTTTCCGAAATTATCAAGACTTTTGTTAAATGCTCTAGGCATTCTC +GGAACGTTTTTCTTTTTGAGTTTTATATCTCTCGAAAATCTAATCACGCCTGTGGCAAACGCTCTTCTCT +TTTTAACTGGAATAAAGCTACTGGAAGAAAAAAAGGCGAGGGATTACTACCAGATTACACTTCTAGCTTT +CCTGAGCTCGGCGGTGTCCACTGCGGTAAATCCCGATCCACAGTACTTCTTAATATTCTCACTGGGAAGT +GCTTCTCGGAGTTATCCTCTTAATCCTCATAAACTTTTACAGGGCTCTGGGAGACAGACCCCTTGACAAG +GAGTTTATCAAACACCTAACCTTTATTTCTCTCGGTTTTACATTATCGACTTTTGTATTCTCGTGGTTCT +TCTTCGTAATACTTCCCCGCGCTAATCAGCCACTCTTTGACCTCTTTTCACAGAAAAAGGCCGGGCTAAT +AAGCGGTATATCCGAAGAAGTTGAACTGGGAAAAGTAGGAGAGATACAGCTAGACAGAACTGTAGTTTTG +AGGGTCTTCGGATTAGAGTTTAAAGAAAAACCCTACTGGAGGGTCTCGGTTCTAGACACATTTACGGGAG +AAAAGTGGGTAAAAAGGGTAAAAATCAAAGAGAGTGAACTTACCTTTCCGAGGGGAAAAAAATACACGAT +AATTCTGGAGCCAACATACGAGAATTACCTGCCCTTACTCGACTATCCCGTAAAAATCCAGAAAGTGGAG +GGAACAAATGAAAAACCAGTCAGGTTCAAAGGAGGCTTTTACGAATTTCAAAAACCAGTAACAAAACCCC +TCAGGATAACAGCCTACTACAAGGAAGAACCGCCGGGTGATAAGCCCTTGCCCATTTACACCCACCTCCC +TCCCGACATTCCCGAAAGCGTAAGGGATCTCGCAAAGAGATTGCAAAGGGGAGCAAAAAGTAACGAAGAA +AAGATAGAGAGGGTAAAGGAGTTTTTCAAAAACAACGGATTTAAGTACACCTTAAAACTCGAACACGCGG +GCGGAAATCCCCTTGAGGAATTTCTCTTTAAAACGAAAAGGGGAAACTGCGAGTACTTTGCCTCTGCAAC +TGCGGTACTCCTCAGGTTGATGGACGTTCCTACAAGGCTTGTGAGCGGGTTCTACGGAGCTATGAAGAAC +GAATACGGGAACTACTACATAGTCATCAACGCCATGGCACACGTGTGGGTTGAAGCATACGACGGAAAAA +AGTGGGTAAGGGTAGATACTACACCCCCTTACGTTCCAGAGGGAGTAAGGGAAGTTTCAAAATTAGCACT +CTTTTACGATGCCCTCATTACCTTCTGGTACAACAACGTCGTGAATTTCAACACACAAAAGCAGAGAAAG +GTGTTTACAGATACAGTAAAAACCGTTAAGGAAATTTTAAACGAGATAAAGGAAAATCCCATAATATTGT +TCGTTCCAGTAATCGCTTACATACTCTTCTCCCTTGTCAAGAGTTTCAGAAAAACGCCTGAAAACCTGTA +CAGAAGGTTACTTCAAAGACTGAAAAAGTACGGCATTCATGCTAAACTGCCCGAAGAAGTGCTGGAAAAA +ACGAAGGGTATGGAGATATATCCTTACGTTAAGTTTGTAGTGAGAACTTACCAGAGGTGGAAGTACTCAA +AGGTGAAGGACAAGGAAGAACTCAGGGAAGCTTATAGGGTTCTTAAGAAAATTTAATAATCTGAATATAA +AAGAATACTAAAATTCTGGTAAATTAATAAGAAGGATGATAAGAGAAGAGCTTTTGAGCGAGGAAAAGCT +CGAAGAGCTGGCGGAATTTTTTAAGGCACTTTCCCACCCCGTCAGGTTAAAGATTATAGGAATACTCATT +GAGGGAAAGCAGTGCGTTAAAAACCTGGGAGAACTATTAAACCTTTCCCAGCCCAGCGTTTCTCAGCACC +TCTCGATACTCAAGGCACGGGGCATAGTAGGTTGGAAGAGAGAAGGCTCGATTATATGCTACTATATTAA +AGACGACAGGGTTAAGAAAATCTACGAATTAATTGTAAAGGAGGAAGAACATGGCAGGTAGAGTAATTGA +ACTTAACGAACAAAATTGGGAACAAGAAGTTCTCCAGTCCGATAAACCTGTTCTCGTTGACTTTTGGGCA +CCATGGTGCGGACCATGCAGGATAATAGCTCCCATAATTGAAGAAATTGCGGAAGAACTGGGAGACAAAG +TAAAGGTAGGAAAGCTCAACACCGACGAAAATCCCAACATAGCAATGAGGTACGGCATCAGGGCTATACC +CACGATAATCCTCTTCAAAAATGGGGAGGTGGTGGATACAAGAATAGGTGTCCAACCAAAAGAACGATTA +AACAAATGGTTCTTGAGCACGTTTAATAATTTATGGAGGCTCAGGCCGGTTTTGATACCTTTATTGAAGC +CACACGTTACCTCTTTCGGGGGCCCTCCCCCCAGGAAATCCTTCTCTTAATAATCGTCCTTGGCGCATTA +ATCACGGTAGTTTCCCTGCCTTTTTTTTACTCAAAACTTAAAGAAAAGCAAAGGATAAGAGAGAACTTTT +TTCGCAGGGCAAGGGATTTTGACCTGACAGAAGAAGAAGCGAGCGTTTTGTGGAAGTACGTAAAAGAAAC +CGTCCTTAACCCGAACCTTGTATTTGAAAACAAGGCTGTCTTTGAAAAAGTAGTTGATAGGATAGTTCAG +AACGGAAATCCGGAAGAGATAAAACTCATTTCCAGCATAAGGATGAAACTGCGCTTTAGCTCACTTCCCT +GGTTTATTCCTTTAACTTCCACTAGGGATATAGAGGTATACCAGACAGGTGTTCTTGTTGTAAGAAATAG +AAGAGTAGACGCCTACGTTTACGACAAGGACGAGGAATTTCTTTACATAGCCCTCTTAGAACCCGTAGTG +GTAAAGCCGGGAGAAAGGGTTTCCTTTTTCTTCCTCAGGGAGAACGACGCCAGATACAGTTTCGACGCTA +CCGTAGAAAAAGTTTTCAACGAAGGAGGAAGGACGGTAATAGTGGTAAGACACACAAGCGAGATAAAAAG +GATACAGCTAAGGGAAAGTGTAAGGTGGAAAGTGAAGCTCCCTGTAAAGTTTACCCTTTTGAAGGAAAAC +GGTGAGGAGATAAACGCGGAAGGACAACTGGAAGACATCAGCGTAAAAGGGGCAAGGGTTTGCTTTGAGG +GAAGACTAGACATCAAAGAAGGCGACAGGATACTCCTTGACTTTACACTTAAAAACTATACATTTAAAAA +TTTGCTCGGCACGGTGGTACACCAGATAGTGTACGAGAAGAGAACGTGCCTGGGTATTAAGTTTGAAGAA +CTTTCTCGTAAGGAAGAGGAAGTTATAGGACAGTTCATTTTGGAAGAACAGAGAAAGCTACTGAAGGCTT +ACAAGGAAGGAGAGGTATGAGTAACAGAGTAGTCATTATCGGAAGACCCAATGTGGGAAAGTCCACACTG +TTCAACAGGATTATAGGGAAAAGATACGCCATAGTTGAAGACTATCCCGGCGTTACGAGGGACAAAATAG +AAGCAAAGGCAGAGTGGGCGGGCAAAGAGTTCATAATAGTGGACACAGGGGGACTCGTTCCAGAAACGAA +GGACGAACTCATCAGAGAAGTTAAAAAAGTTGTGGAACAGGAAATCCCGAAAGCGGACGTAATACTCTTC +GTGGTGGATGGAAAGGAAGGGCTAAATCCTCTGGATCAGGAGATAGCAAAGTACCTTTACCCTTACGCGG +ATAAAGTTCTCCTCGTCGTAAACAAGATAGACAACCTGAGGCAGGAGAAAAACGTAGCAGAGTTTTACAC +CCTAGGTTTTGAAAAGATTTTTCCTATATCCGCCCAACACGGAAAAGGGGTTGGAGAGCTTCTGGACGAG +GTTGTAAAGTACCTCAAAGAAGAGAAGGTAGAGACTGTAGAAGAGGGTATAAAGGTAGCCTTTATAGGAA +GACCGAACGTGGGGAAATCCTCGCTCGTTAATGCAATCCTCAAGGACGAGAGGGTTATAGTTTCGCCCAT +TGCAGGAACCACTAGGGACGCGATAGAAATACCCTTCAGGTGGAAGGACAAAAACTTCATTTTGATAGAC +ACTGCCGGTGTGAGGAGACCCTCAAACGTTGAATACGGTATAGAGTTTTATTCCGTAGGGAGGAGTTTAA +AGGCTATTGACCTTGCGGATGTATGCTGTTTAGTCATAGACGCCTCGGAAGGTCCTACCCGTCAAGATAA +GAGACTCGGAGGACTTATAGAGAGAAGGTATAAGGGTTGTGTCATAGTTGCAAACAAGATGGACATATCT +CCATGGAGTGAAGAAGAGCTTGAAGGGATAATCAGAAAGGAACTCTTCTTTTTAGACTTCGCACCAATAG +TGTTTACGGTTGCGACGAAGGGAAAGGGAGTTGAGGAACTCCTGAACTGGATAGACGTAGTTTACAAGGA +TTACACAAAACAACACAAGACTTCCTTTGTAAACCGAGCGGTTCACAAAATACTCTCTGAAAAACCGCCT +CCTAGGTACAGGGGAAAGGAGGTAAAGGTTTATTACGCCTTTCAGGAAAGCACGAAACCGCCAACGATTG +TTCTCATAACAAACTACCCTGACGCCTGGAAGGAAAACTACAAACGCTTTTTCATAAAGAAACTCAGAGA +GTACCTGAACATCAAGTATGCCCCAATAAAGCTCGTGATAAAGGGAAGGGAAGATTAATTATTGATAACT +CCTCACAAGGGAAAGGACTACGAGTTCCCAGCCGTTTGCGAGGACAAAGAGCATTATCTTAAAGGGGAGG +GAGATGAGCTGGGGCGGTATCATGATTATCCCCATGGAAATTAAAATTGAAGCCACCACGAGGTCCACTA +TGAGGAAGGGAATGTAAAGGAGGAAGACTATCTCAAAGGCGGTTTTTAGTTCGCTCACCATAAATGCGGG +AATTACGACTCTCAAAGGGATTTCGTGAGGTTCTTTTACGGAGTCCTTCGGGATTTTCGCTATACTCAGG +AAAGCCTCTAAGGTTTCCTTTCTCGTGTGCTTGAGCATAAAGTCCTTGGCGTAAAACTCAACTCTTTTAA +AGAACTCCTCATCGCTTATTTCCTCTCTTATGTAAGGCTGGAGAGCCTCTGAATTTATCTTGTCTATCGT +AGGCTTCATTATAAAGAAGGTAAGAAAAAGGGAAAGGGCTATTATCACTTGATTTGGCGGTGCTTGGGGA +GTGCCTATTGCCTGTCTCAGAAGTGATAGAACCACCACTAGCCTCGTAAAGGAGGTAAACATTATAAGGA +TTGAAGGGACGAGACTGAGGATAGTTAAGAATATCAGGAGCCTTATAGAATCTACTAAGTTCCCCTCACC +GACTTTTAGTTCAATAGGAGGAATTTGGGAGAAAACAAACCCTGCACTAAGAATGAGAATCGTTAACGCT +TTCCTCATAGAGCACCTTGGCGTAATTGGGACTTATCAAAAGGTAAAACTTCTTCTCCTTTATCCTTACA +CACACGAAGAACATATCTTTCCCGAGGGGAAGAACTTCCTCAAGTTTTAGGTTTTTAGCTTTGAGCCTTT +GAAGTCTGCCCCTCAGGATTACGGGAAGTGCAAAGTAAAGGAGGACGAGAACTACGAGGAGAGAAATGCC +AACCTTTAGCAGGTATTCAAGAACTTCGTTCACTTTTCTATTATCGTCTCTTCAACTTTCATACCGAAGT +GTCTTCCAGCTTCTTCCACGTATCCGAGAACCTCATCTCCTTCTTTTAGCTCGGACACCGATATGGGAGT +CCCGTCGGGCTTTGTGAGTCTTATAGTTTCCGCGTTCTGGAGTATACAACTAAGTTTTTTGTTTTCATAC +CTCCCTTCTATCAGTAGCATGGGTCTCCTTTCAACCTTAGCCCTTCCGACGTACGTTACCCTTCCCCTTC +CCTTGTAGTCGTAAACCATGACTTTGTCCCCCGCCTTCAGTTCACAAAGGTACTTGGTTCTGTTGTTCGG +AACCCTTATGTACATGTGAACCGCTCCCGCGTTTACCCTGAAGGGTCTCGCGGCAACGTAAGGATTTTCT +TCAGTCTCCGCGTGAACGAGGAACATTCCTCCCGAAGAGTTTCCAACGAGCATTCCCTCGCCCCTGTGAA +GGAGCGATATAGTATCCACACAAACCCTGTCCCCGAGTCCGAGGGGAAGTATTTTCGTTATTTTTATCGT +TACAAGTTCCAGTTTTTCCTCGTGTTCGCTGACGATTTGTCCCACTTTCTTTATTTCGTTTATATCCCTG +CTCTTTAAGACTACTCCCTTAACACCTTTTTCCAGTGTCTGAAGTGCTACTTCAGCTTCCTGAGCGTTTT +TCACAACCGCGTAAAGCTCTTCCCTCTGGGCTATTAAGTTCTCCAAAGGAATTACGGTCCAGTCCGTGGT +CTCCACTATTACCTTCACGTTTGGAGGATATTTTGCAGCCCTTTCCTCGTCTTCCTTTCCCTTTATCAGA +ACGTAAACCACATCTTCCCCGAGTTTCAGATCTCCGTCCGGTGCTATTACGGTTATTCTCCCGACTTTTT +TTACCTCCTCAACCCTTCCCTTTTCCGGGATAACTACCGCGTTAGCTCCGGCCTCCAAGGCAACGGATAC +GATTTTTCTGTCAAAAGGCTCAACCCATACCCAAAATTCTTTCATGCTATTATTATACAAGGGGGTATTG +TGAAAAAAGCTTTAGGAATTTTAGCAATCCTCTTAATCCTCGTAGGTGGATACTTTGCGTACGACAAGTA +CATGGACAACAAGGCGAAGGAACAGGTTGAGTACTTTTTAGACAAAACCTTAAGAAAATCGGGAAAAGGT +TCCTACAAATACGTTGATTACAAGCCAATCGGCGGAGAAATAATAATAAAAGACGTTTACTACAGAGACA +GGAACGGAGAAGAGTTCAAAATAGAGGAGATAATAATAGAAAAATTAAGCGAAACGGAAGGGAAGTTTTT +ATTCAAGAACGTAAAGCCTTTAAAGGTTAAAGGAAAAGGTTTACTGGAAGAGTACGGCTATAAAGATCCG +AAATTTAACCTTTTCGTCTCTTACGAAGCTAAACCTAAGGAAAAGGAATTCCACTTAAGGAGTTTGAGTT +TAGATTACCCTGAAGCCTTTGAAGTGAATATTTCCTTTATTCTTGGAAATTACGACCACGCCTTCTGGAA +AACGGTTGCTTTGAGCGATAGACCTCCTGAAGAAGTGAGTTTTCAAGTCCTCTCAGAACTCGGCAGTATC +AAGATAAACTCTCTTGAAGTTGTATACAGGGACAAAGGATTTAAGGAAAGAGTAATAAAGAAGGAAGCCC +AAAAAAGGGGAAAAACTCCCGAGGAATTCAAGAAAGAGTTAATCCGAAAGATTGAAGAAGAGAAATTAAA +GGCAAGGTCCGAGTTTGAGAGAAACCTCCTCGACGCCTTTGAGAAATTTTTAGAAAAAGGAAAGGAAATA +AAGGTAGTTATAAAACCAAATCCTCCTCTGAAGATACAGGATTTATTTGTAGTCGCAGCGGTGCAAAAGG +ACGAAAGGGAGCTTCTTAAACTCTTAAATCCTGTGATAGAGGTAAAGTAAATTTCTCATGCCCCTGTGAA +CAAGGAGTGGGTCGTAAATACCGAACTTGGAAAAGTACTTCCCCTCTCCGCCCGTTATAACCACTTTGAA +CTTTCTTTTAAATACTTTTCTCCAGAGTTTCAGTGTACTTTTAATAAATTCTGTGCTCTCCCTGTAAGCC +CCTCCCAGGACGCACTCTCGTGTAGAACGCCCAAGAAAAATTTCTACCTCTTCGGGAAAAAACTCGGGAA +TTCCCTCCGCCAGGTCGGAAAGAATTTTTAACTTCTTTCCAAGTCCTAAGGTAATAAACCCTCCCTTAAA +TTTGCCCTCAAGAACTAGGTCAATTACAAGGGCAGTACCCGCACTGATTACTACAACATTCTTTCCGTAA +AACTTTTTGGCGGAGTAAGCAAGTGCTACCCTGTCCGTGCCCAGCGTTTCAGGAGTTTTGTAATCAACCT +GTATAGGAAAGTTTTCCTTCTTTAAAAACTTTATCTTCGGTATTTTTCCCCTTACTTTTTCGCTAAAACT +CTGTTTTACGGATATTCCGAGCGCTTTTAATTTAGGAAATTCTTCCTTTAAAAATTCTTCGTGTGAAAGT +TTCAGAAAATCTTTTACTTTCTTCCCTTCCCATAGGGCGATATCAACGGAGGAATTCCCTACGTCTACCG +TCAAAAACCTCATTCTTCTTTCATATAACCTCCACCGCCAGGGGTTTCTACCCTGAGCCTGTCTCCTTTT +TTCAAGTATACGGAAAACTTGGAGGGCATTTCTTTTTCTCCTTCTTCAGTTTTTATTAGATTTATTCCGG +GCATTCCAGGTTTTCCTCCGAAGAGTCCGTAAGGAGCAAGCCTCCTCCTCTCCGAGAGAACGGTAACTTC +AACGTCCGTCAGGAATTCATACTCCCTCACGATGCCGTCTCCTCCCCTGTGCATTCCTTCACCGCCCGAA +CCCTTCCTTATGGAGTACTCGGTAACTAGAATAGGGTAGTAGTGTTCAAGGGCTTCTATGGGGGTGTTTA +AAGTGTTCGTCATGTGGGAGTGGACCGCACTCTCGCCGTCTCCTTTAGCACTCGCCCCCATTCCTCCTCC +TATTGTCTCGTAGTAGGTAAAAGGTTCTCCATTTTCGGGGTTTATTCCCCCTATTGTCACGTGGTTCATA +GTCCCCTGACTCGCCGCGGGAACTTTTTCCGGAATCGCCTTAGAAAAAGCTCCGAGAACTACGTCCACGA +TTCTCTGGGAGGTTTCCACGTTTCCGCCCGCAACACCTGCGGGAAATTCCGCATCTACAACACTTCCCTT +TCTCGTAATAACTTCAAGGGGTCTAAAACAACCCTCGTTTACGGGAATATCGCTTCCGAGTAGAGAAATT +ACCGCGTAGTAAACCGCGGAAAGTGTTATAGCCCTTACCGCGTTTATTCCTCCCCTCGTCTGGTCATCTG +ATTTAGAAAAGTCAAATATTAACTTTTCCTTTTCAACCTTAAGTTTTAAGTGAATCTTTACGTCTTTCCT +TCCGTAGCCGTCGTCCTCCATGTAGTCTTCAAACTCGTACTCGCCTTCTGGAAGAGCTTTTATCCTTTCC +CTTATTATCCTTTCCGAGTAATTCATAAGTTCCTTTGAAAAGAATAAAACCTTTTCAATTCCTTCCCTTT +CTATGAGTTCCCTTAACCTCTTTATCCCCGTTATGTTAGCCATAATCTGGGCTTTAAAGTCCCCTTCCCT +TTCCTCAGGAGTTCTTACGTTTCTTAAGAAGACCTTCATGAAATCCTCGTTTAGTTCTCCCCTCTTCATC +AGTTTTAGAGGCGGAATTATGAAACCTTCCTGAAATATGCTAGTGGAAAGGGGCATGGAACCGGGGGTTG +CTCCTCCAACGTCCGCGTGGTGTGCCCTGTTTGCGAGGAAAAAGAGTAGTTCTCCTTTGTAGAAGAAGGG +AGCGACAAGTGTTATGTCTGGAAGGTGCGTTCCGCCCATGTAGGGGTCGTTCAGTACCACCATGTCCCCC +TCTTCAAACTCACCTTTAAAAGCTTTAATAGCCTCTTTTACGGAAAGGGGCATAGAGCCTAGGTGTACGG +GAATGTGTGCCGCCTGAGCGACGAGGTTTCCCTCTTTATCAAAGACTGCACAGGAAAAGTCCCTTCTTTC +CTTAATATTCGGGGAGAATGCTGTTCTCTGGAGAACAAGTCCCATCTCTTCCGCTATTGACGAAAAGGCG +TTCTTGAATACTTCAAGGAGTATAGAGCTGTTCATCTTGACACTCCCAAAAGCATTTTATACAATAAAAT +ATTGGCACGTGTGAGAAAAGCTGGCGTAGCTCAGTCGGCAGAGCGCGGGATTTGTAATCCCGTGGGCGCG +GGTTCGAGTCCCGCCGCCAGCTTGGAATTGGGGCAGGATGCTTAGGAGGGGTGGCCGAGCGGCCAAAGGC +AGGGGACTGTAAATCCCCCGGGCGTCCGCCCTGCGCAGGTTCGAATCCTGCCCCCTCCATATTACTGAGC +GGGCGTAGCTCAGTTGGTAGAGCAGCGGCCTTCCAAGCCGCAGGTCGCGGGTTCGAGTCCCGTCGCCCGC +TCCAATATAAAAATCCCTTCCTTCAATAAATAAGCCCAGGTAGCTCAGTCGGTAGAGCGCACCCTTGGTA +AGGGTGAGGGCGCCGGTTCGAGTCCGGTCCTGGGCTCCACTTCCCTGATAAAAATCCCTCTTTACAAACG +TAAAAGAAATAATTTATAATATTTTGTTACCTCAAAATTCGGAGGTAGGAAATGGCAAAGGAGAAATTTG +AAAGGACAAAAGAACACGTAAACGTGGGAACAATAGGACACGTTGACCACGGCAAAAGCACTCTCACTTC +CGCTATAACATGCGTTCTCGCTGCAGGCCTCGTTGAAGGCGGTAAAGCTAAGTGCTTCAAATACGAAGAA +ATCGACAAGGCTCCAGAAGAAAAAGAAAGAGGAATCACGATAAACATCACCCACGTTGAGTACGAAACCG +CCAAACGCCACTACGCTCACGTTGACTGCCCCGGTCACGCTGACTACATCAAGAATATGATCACCGGCGC +AGCTCAAATGGACGGTGCAATACTCGTTGTTTCCGCAGCAGACGGCCCCATGCCCCAAACTAGAGAACAC +GTGCTTCTCGCAAGACAGGTTAACGTTCCTTACATAGTCGTTTTCATGAGCAAGTGTGATATGGTTGACG +ACGAAGAACTTTTAGAACTCGTTGAGCTCGAAGTTAGAGAACTTCTCTCCAAGTACGAGTATCCCGGAGA +CGAAGTTCCCGTTATCAGAGGATCGGCACTTGGAGCACTTCAAGAACTCGAACAAAACTCTCCCGGCAAG +TGGGTTGAGTCCATAAAAGAGCTTCTCAACGCGATGGACGAGTACATACCGACACCACAAAGGGAAGTGG +ACAAGCCCTTCCTTATGCCAATAGAAGACGTGTTTAGCATATCCGGAAGAGGAACGGTTGTAACCGGAAG +AGTAGAGAGAGGAGTTCTGAGGCCCGGAGACGAAGTAGAGATAGTAGGACTCAGGGAAGAGCCCCTCAAG +ACAGTTGCAACGTCTATAGAGATGTTCAGGAAGGTGCTTGACGAGGCACTGCCCGGAGACAACATAGGAG +TGCTGCTGAGGGGAGTAGGAAGGGACGACGTAGAAAGGGGACAGGTATTGGCGCAACCTGGGAGTGTAAA +GGCTCACAAGAGGTTCAGGGCACAGGTATATGTACTTAGCAAGGAGGAAGGAGGAAGACACACTCCGTTC +TTTGTGAACTACAGACCGCAGTTTTACTTCAGGACGGCTGACGTGACGGGGACTGTGGTGAAGCTTCCAG +AAGGAGTGGAGATGGTGATGCCTGGGGACAACGTAGAGCTTGAGGTGGAGCTTATAGCACCTGTGGCGTT +GGAAGAAGGGCTCAGGTTTGCGATAAGGGAAGGTGGTAGAACAGTAGGTGCAGGTGTCGTTACTAAAATA +CTGGATTGAGGTTTGAAAAATGGCTAGGGAAATAATTACTCTCGCTTGTACCGAATGCAAGAGGAGGAAC +TACACCACTACGAAGAACAAGCAGAAGCACCCCGAGAGACTGGAACTCAGGAAGTACTGCAAGTGGTGCA +GGAAGCACACCATACACAGAGAGGTAAAATAAATTCTTAATTAGTGGGGCTGTAGCTCAATTGGCAGAGC +GCGGGACTCCAAATCCCGTGGGTGGGGGTTCGAGTCCTCCCAGCCCCGCCACTTAAAACTTTCCAGAGGT +ATACCTCACAATGGAAAAATTAAAAGAATTCCTCAAAGGCGTAAGAGATGAACTCAAAAGGGTAGTTTGG +CCCTCCAGGGAATTAGTGGTAAAGGCTACGATTAGTGTTATAATATTTTCCCTTGCTATAGGGGTTTATC +TCTGGATTTTGGATCTCACTTTTACTAAAATTATATCCTTCATCCTTTCCTTGAGAGGGAGCCTATGAGC +GAGCAACAGGTTCAGGAACTTGAGAAAAAGTGGTACGCACTGCAGGTAGAGCCCGGAAAAGAGAACGAAG +CTAAGGAAAACTTACTGAAAGTTCTGGAACTGGAAGGTTTAAAGGACCTCGTTGACGAGGTAATAGTTCC +CGCAGAGGAAAAGGTAGTCATAAGGGCTCAGGGCAAGGAAAAGTACAGGCTCTCTCTCAAGGGAAACGCG +AGGGACATATCCGTTTTAGGGAAGAAAGGTGTTACCACATTCAGGATAGAGAACGGAGAAGTTAAGGTCG +TTGAGAGTGTTGAAGGAGACACTTGCGTAAACGCCCCTCCCATATCAAAACCCGGACAAAAGATCACGTG +TAAGGAAAATAAAACGGAAGCAAAGATAGTTCTGGATAACAAAATATTTCCCGGATACATACTCATAAAG +GCTCACATGAACGACAAGCTCCTCATGGCTATTGAGAAAACTCCCCACGTCTTCAGACCTGTAATGGTGG +GCGGAAAGCCCGTTCCTCTGAAAGAGGAAGAGGTTCAAAACATTCTCAATCAAATAAAGAGGGGTGTTAA +ACCTTCCAAGGTTGAGTTTGAAAAAGGAGATCAGGTAAGGGTTATAGAAGGACCGTTTATGAACTTTACG +GGAACTGTTGAGGAAGTTCATCCCGAGAAGAGGAAATTAACTGTTATGATAAGTATTTTCGGAAGGATGA +CTCCGGTAGAACTGGACTTTGACCAAGTGGAAAAGATTTGAAGGAGGACTGAAAAATGGCTAAGAAGGTG +GTAGCCACAATTGAGCTAATGTTACCGGCTCAACAGGCGTCTCCGGCACCACCGGTAGGTCCCGCTCTGG +GTCAGCACGGTGTTAACATAATGGAGTTCGTTAAGCAATTTAACGCCGCGAGCAGGGACTACGAACCCGG +AACGATACTGCCGGTCGTTATAACCGTTTACCAGGACAGAAGCTTTACCTTCATAATGAAAACACCCCCC +GTCTCGTACCTACTTAAAAAGGCGGCGGGGGTTGAGAAGGGCTCTTCCGATCCCAAAAGGGTAAAGGTCG +GAAAGATAACGGTAAAGCAACTCGAAGAAATAGCGAAGATGAAGATGAAGGACATGAACACCAGAGACCT +GAAAGCCGCTATGAGAACAGTTGCGGGAACTGCAAAGAGCATGGGTATTGAAATAGAAGGTTGGAAGGAG +TAGAGCCATGGCTAGAAGGGGTAAAAAATACATAGAAGCTTCAAAGTTAGTTGATAGAAACAAAAGGTAC +ACTTTGGAAGAGGCGGTTGATCTCTTAAAGAAAATGGAAGAAGTCCTCCAGAGAAGGTTTGACGAAACCG +TAGAACTCGCCATGAGGCTGAACGTAGACCCAAGATACGCGGACCAGATGGTAAGGGGTTCTGTGGTTCT +TCCCCACGGACTCGGAAAACCTATAAAGGTAGTTGTCTTCGCGGAAGGTGAATATGCAAAGAAGGCAGAA +GAAGCTGGAGCGGACTACGTAGGCGGCGACGAACTCATAAACAAGATACTCAAAGAAGAGTGGACCGACT +TTGACGTTGCTATAGCTACTCCGGAGATGATGCCAAAAGTTGCAAAACTTGGGAGAATACTGGGTCCGAG +AGGTTTAATGCCCTCTCCCAAGACGGGAACGGTTACCACGAATGTAGAGCAGGCTATAAAAGACGCTAAA +AGGGGTAGGGTAGAGTTCAAAGTTGACAAGGCCGGTAACGTCCACATGCCCGTAGGAAAGATATCTTTTG +AAAAGGAAAAACTCATAGACAACCTTTACGCCGCTATAGACGCTGTGGTAAGGGCAAAACCACCCGGAGC +AAAGGGACAGTACATAAAGAACATGGCTGTATCCCTCACCATGAGCCCGAGTGTAAAGCTCGATATAAAC +GAAGTTCTAAAGAAACTTCAAGAAAAGGCTGCTTAACGGAGGTCTGAGTTATGGCTGAATTTGACAAGGA +AGCTTACGCAGAGAGGGAAAGAAGCGCAGCAAGCAGGAAAACCCTCTTAAAGAAACAGGAACTCGTAAAC +TCCTACAAGGAGAGACTCCAGAAGTCTAACGGATTTGTAATATTCTTCAACTTCCAGGGAATAGATGCCT +ATCCCCTCACACTTCTCAGGCTGGACATAAAGGACCTGAAAGGTGAAATCGTTGTAGGAAAGAATACGCT +CTTTTACAGGGCTTTTTCCGATACGGTTCTCTCGGATCACAGGGATATATTCGTAGGACCCACCGCGGCA +CTCTTTGCGTACGAGGATCCCGTAGCCGTAACAAAGAAACTCGTAGAATTCCTGAAGGAGACCTTTGACA +AAGAGTGGGAAGGAAGGATTAAGGGTGGACTTCTTGACTACAAGTACATCACTCCCGAGCAGGTAAAAGA +GCTTGCGGAACTCCCAAGCAAGGAAGAACTCATCGCAAAACTGCTTGGAGTTCTCATGGCACCTGTAACG +CAGCTCGCTATGACCTTAAAAGCTGTTCCGCAGAAACTTGTTCTTGTTCTTAAAGCTATTGAAGAAGAAA +AATCTAAAGGAGGTCAGTAAAGATGGCAACTTTAACTATTGACGAGATTGTAGAAGCTATCAAGAATATG +TCCGTATTGGAAGTTGCCGAACTTGTTAAGAGACTTGAAGAAGAGTTCGGCGTTTCCGCAGCTGCAATGG +TAGCAGCTGCACCCGCGGCAGGAGCCGCAGCAGGAGCACCCGCTCAGGCTGAAGAGAAGACCGAGTTTGA +CGTAATCCTCAAGTCCCCCGGAAAGAACAAGATACAGGTTATCAAGGTGGTAAGGGAAATCACTGGACTC +GGTCTCAAGGAAGCAAAGGAACTCGTGGACAACGCTCCCAAGCCTATCAAGGAAGGAGTACCCAAGGAAG +AAGCGGAACAAATTAAGAAGAAGCTCGAAGAAGCTGGAGCGGAAGTCGAGCTCAAGTAACTCCTTCTTTT +CCTTTTCCTTTACACTTTTGCTCAGGAGGCAGGAACGCTCTGTACGTAAATGGAAACATTAATCTTCTTA +CCGGTTAGGGAATTGAAAAAGGAATACTTGACAGTGTACTTTTTTGGTTTAAATTTAAAAGATCAGTTAA +TGGGGATATTATTGCTTCATTCCGCCTTCTTTAAGAAACATAAAAGAGGAGAGGTATAAAAATGGCAAAA +ATTGCGCTACCCCGTAAGTTTTTCGGCAGAAGGTTTGAAGTCCTTGAACCTCCTTACTTACTCAGCATAC +CAAAAAACTCCTTTGAAAACTTCGTCCAGTTAAAGGTAAACCCTTACAAAAGGAAAAACGTAGGTCTTGA +ACACATATTCAGGACTTCCTTTCCCTTTAAAGATCCTGACGAAAACTTCATACTCGAATACCTCGGTTAT +GAAATAGGTGATTGGGAATGTAATAGATGCGGATACAAACCAAAAGACGACCTTCTGGGAGGATGGGACG +TAGACTGTCCCCAGTGCGGAGCAAAGCTCGTTTACAAGGAAAAGTTCACACCAGAGGAGTGTAAGTTAAA +GGGGCTCACTTATTCGGCTCCCCTCAGGGTAATGCTCCAGCTCAAGGCAAAGACTAAAAACGGCTACAGG +GAATTTCCTCCAAAGAAGGTTTACTTCGGTGAAATCCCCCTAATGACCGAAACCGGCTCTTTCATCATTA +ACGGAACGGAAAGGATAATAATCAACCAGCTAATACGTTCCAGCGGTGTCTTCTTTGACGAGAAGGAAGA +AAAACAAAAAGACGCCACTATAACGAGGATTCTTTACAGGGGAAGCATAATTCCCGATAAAGGTTCAAGA +GTTGAGTTTGAACTTTCAGGTGCTACGGACCTCATATCTGCAAGGATAGACAGGAAGAAGCTCAGCGCCA +CAGCGGTGCTCAGGGCTTTCGGTCTTGAGACCGCATACGACATTCTCAAGTACTTCTACGAGGACGTAAG +GAAGTTCATAGTAAAGGACAAGTACCTTTACGACGCACAAACGGGAGAGGAGTTTACACCCGAGGATTTA +GAACATCATTACATCTTTGCGATAATCAAGTTCAGAGGAAAACTTGTAGGATTTGCATCTTCCAAGGAAA +GGGACTTCATAGAGGAGAGGTACATAGAGGAGTGGGAGGATCTCGTAAGACTCCTTGACGACGACAGGAT +AGAGGTTCTCAGTGTAACGGCGGTACCGAGGGACGTAGTTATAAAAAGTCCTTATGGAAAGAGCCTGATA +GACACCCTAGCAAACGATACCTCGCCCAAAGACGTGGACAAAAGAAGCCCCGTAAAGGTTCCCGCGGAAT +ACACCCTGAGGGACTACGGATTAATGGAAATGTACAAGAGACTCAGACACATCGAAGCGATCACTATGGA +AATAGATTCCGTCATAGAAAGGGCGAGGATATTCTTCAACGTATTCTTCAGGGACCTAAAGAGGTATGAC +CTCTCAAGAGTCGGTAGGGTAAAGATAAACGCCAAAGTTCACAGGATACCGAAGGTTCTGAAACCTGCGG +ATGTAGATCTCCTTGACCAGCTCCCGCCCCTAGCTCTCGCGGAAGACTATGGCGAGTACAAGGCGGGAAC +GAGGGTTACGAAAGATCTCTTAAAAGAACTCTTCAAGCAATACAAAGAAATAAAAGTTAAGGACTACACG +GAAGACGAAGCGAGGTTTATCCTCCCCATAGACCTCGTGAATATCCTGAAGTACCTTATAGACCTCAGAC +ACGGCAGGGTAAAGAAGGACGATATCGCACACCTCGGAAACAGAAGAGTAAGGTCCGTAGGAGAACTCCT +TGAAAATCAAGCGAGACTCGGAATTGCCAAAATGGAAAAGGTCTTCAGGGACCGCTCCGCGGTTATAAAC +CCCGAACAGCCGGACCTCAAACCGCAGGATTTCATAAACCCGAGGTACGTCACAACAGCTATAACGGACT +TCCTGAAAACCGGACAGCTCTCTCAGTACCTTGACAACACAAATCCCCTTTCTGAGCTCACCCACAAGAG +GAGACTCTCGGCCCTCGGTCCTGGAGGACTTACGAGGGAAAGTGCAAAATTTGAAATAAGAGACGTTCAC +CCCTCCCACTACGGAAGGATTTGTCCCATAGAAACGCCCGAAGGACAGAACATAGGACTGGTTACCTCAC +CCACAGTTTACGCCAGGGTCAACGAGTACGGCTTCCTCATAACTCCGTACAGAAAGGTTGAGAACGGGAA +GGTAACCGATAAGATTGAGTGGCTTGCGGCTTATGAAGAAGAAAATTACGTAATAGCCCAGAGCACACCC +ACCGACGAAGAGGGTAGACTGAAAGCTGAATTTATCCTCGCCAGACACAAGAACGATATAAGACTCGTAA +AACCTGAACAGGTTGAGTACATAGACGTCTCTCCTAGACAGGTAATATCACCCTCTTCTTCACTCATACC +CTTCCTTGAGCACGACGACGCAAACAGGGCACTCATGGGTTCAAACATGCAAAGGCAGGCGGTTCCCCTC +ATATTCACTCAGGCGCCCCTCATCGGAACGGGAATGGAAAAGAAGATAGCGAGAGATTCCCATGCAGTAG +TAGTTGCAAAGAGGGGCGGTGTGGTAGAGGAAGTTGACAGTTCCAAGATAATCATCAGGGTAAATCCCGA +GGAGATAAACTTCGACGACCCTCTGGACATAGGTATAGACATATACGAACTCAGGAAGTTCCAGAGAACT +AACCAGAAGACCTGTGTAAACCAGAGACCCATAGTCAGGAAAGGAGAAAAGGTTGAAAAAGGACAAATCA +TAGCGGACGGACACTCCACTGACAGGGGAGAGCTTGCACTCGGAAAGGACGTTCTCGTTGCCTTCATGCC +CTGGAGAGGTTACAACTTCGAGGACGCAATAGTAATATCCGAGAGACTCGTCAAGGAAGACGTATACACA +TCTATCCACATAGAGGAACTGGAAGTAGAAGCGAGAGAAACGAAGGTAGGAGAAGAAGAAATAACGAGGC +AAATACCTGGAGTTCCTGAAAGAGCACTCGCTCACCTTGATGAGCACGGAATAGTAAGGGTGGGAACTTA +CGTAAAGCCCGGAGACATTCTCGTTGGTAAAGTCACTCCAAAAGGAGAAACGAGGCTAACTCCCGAAGAA +AAGCTCCTTCAGGCAATATTTGGTGAAAAGACAAGGGACGTAAAGGACGCATCCCTCAGGTGTCCTCCCG +GAGTTGAGGGAATAGTAATAGACGTTCAAGTGTTCACGAGGAAGGGAACCGGCAAAAAGGACATGCTAGC +TGAGAAAGTAGAAAGGGAAGAACTAGAAGCACTGGAGCAGGAACTTGAAAAGAAGAAGAACCTCATCATC +ACCGGAAGGGATAAGGTTCTAAAAGGACTTGTACTGGGAAGGAAGGTAGAAAAAGACGCAAAAGTAGGAA +GGAAGACCGTAAAGAAGGGAACAGTTATAGACGAAAAAGTCTTTGAAGAGTTCGTAAACTACATACTCGG +CAGACCCGAAAACTTCTTTGAAGACGAAGACCTTATCAGAAAGATAAGGGAAATAGCGGAAAGGACGAGA +ACTCAAATAGAAATGCTCAACAAGGTATACGAAGAGAAAAAGGAAACACTCCTCAAGAGAAGGGATCTCC +CGCCCGGAGTTATAACGCTTGTTAAAGTGTTCATAGCGAACAAGAGGAAGATAAAAGTCGGTGACAAGAT +GGCGGGAAGGCACGGAAACAAGGGTGTTATATCCGTGGTTCTTCCCGTAGAAGACATGCCCTTCCTCCCC +GACGGAACGCCCGTTGATATAGTCCTCAACCCCCTAGGTGTTCCCTCACGTATGAACGTAGGACAAATTC +TCGAGACGCACCTCGGCTGGGCTGCAAAAGAACTCGGAAAGAAGATAGGCGAGATGATTGAAAAGGGAAG +GGACAGGAAGGCTATAACAGAATACCTGAAAGAAATATTCGCAATAGGAGACAAGGACGGGGAAAACGCC +AAGTTCATAGAGGAATTCCTGAATTCCTTATCCGAGGAAGAGTTCTGGAGTGTGGTCAGGGATTACGCTG +AAAGAGGCATTCCTATGGCAACGCCCGCCTTCGAGGGTGCCGAAGAAGATGCAATTAAAGAACTCCTCAA +GAAAGCGGGGCTGCCCGAAAACGGAAAGACCACCCTTTACGACGGGAGAACAGGAGAGCCCTTTGACTTT +GAGGTTACCGTCGGTTACATGCACATGCTAAAGCTAATCCACATGGTTGACGACAAGATACACGCAAGGG +CAACAGGACCTTACTCCCTCGTTACGCAACAACCCCTCGGTGGTAGGGCGCAGTTTGGTGGACAAAGGCT +TGGTGAAATGGAAGTTTGGGCACTCGAAGCCCACGGAGCCGCTTACACCTTACAGGAAATGCTCACGGTT +AAGTCCGACGACGTTGAAGGAAGGACGAAGGTTTACGAGGCTATCGTTAAAGGAAAGTACACCTACACAC +CCGGAATACCCGAGTCCTTCAAGGTTCTCGTAAGAGAGCTAAAGGCTCTTGGGCTAAACGTTAAGTGTCT +GAATGGTGAAGAGAAGCCTTGTGACGAGGTTGAAGTTAAAGAGGAGGAAGAAAAATGAGTGAAGCAAGAA +GGGGTATCTTCCCCTTCTCAAAAATTAAATTGATGCTCGCTTCTCCCGAGGATATCAGAAGCTGGTCTCA +CGGTGAAGTTAAGAGACCTGAAACTCTAAACTACAGAACTCTGAAACCCGAAAAGGACGGTCTCTTCTGC +GCTAAGATTTTTGGTCCCATAAAAGATTACGAGTGTCTCTGCGGAAAGTACAGGGGAAAGAGGTACGAAG +GAAAGATATGTGAAAAGTGCGGTGTTGAAGTTACAACTTCTTACGTAAGGAGACAGAGGTTCGGTCACAT +AGAACTCGCTGCTCCCGTCGTTCACATATGGTTCTTAAAGAGCACACCCTCCAAGATAGGAACGCTCCTT +AACCTCACTTCAAGAGACGTTGAAAGGGTCGCTTACTTTGAGTCTTACCTCGTTATTGAGTATCCAAACG +AGGAAGAAGAGGAAAAGTTTGAGAAGGACGAGCACACGATACCACTCAACGACGGCATTTCCACCAAGTG +GGTAAAACTCCACGTGGTGAACGAGGAGGAGTTTGAGGAGAAGTACGCCTTCACCATAGACGAAAAGTAC +GAGCACGGAATGGGGGCGGAAATACTCAAAGAAGTTCTATCAAAACTCGACCTAGACGCCTACTCCAGAA +AACTGAAGGAAATAGTAAAGCCCTACTCAATAGGATTTGAAGACCTCGGAAAAGAAATTGAACAGAAGTA +CAAGAACCTTTACCAGAAACTTATCAAGGTTATCGCGGACGACTTCAGGGCTTACGGCGTTGAGATAAAA +GGACTTGAAGATCACGGACTCAGCCTAGAACAGGCTATCCACAGGATTCTAAACGAAGAACTGTACCTCA +ATGTAGAGACGGGAGAAATTTCCCTTGAAGACTGCGGAGACAGCTGTCTCACGGGAAGGGACGCTCTGAA +GGAGTACTACGAAAGGGTAAGGGAACACAAAAAGGACATCCCCATCTTTGAAAAGATAAAGGAAGACATA +AGATCCACGGTACTGAGGGAAATATCCGAAGCCAGAATCAGGAAGGCGCTCAGAACTCTCCAGCTAGTAG +AGGGCTTCAAGAAGAGCGGAAACAGACCAGAGTGGATGATACTTGAAGTTCTTCCAGTTCTTCCTCCGGA +ACTACGTCCCCTCGTTGCACTGGACGGAGGAAGGTTTGCAACTTCTGATCTGAACGACTTCTACAGAAGG +GTTATAAACAGGAATAACAGACTAAAGAGATTAATAGAACTGAACGCCCCCGACATAATCATCAGAAACG +AAAAGAGAATGCTTCAGGAGGCGGTTGATGCCTTAATAGACAACGGAAAGAGAGGAAACCCTGTAAAGCA +AAATGGAAGACCTTTAAAGTCTCTTGCGGACTACCTGAAAGGTAAACAGGGAAGGTTTAGGCAAAACCTC +CTCGGAAAGAGAGTTGACTATTCAGGACGTTCCGTTATAGTCGTCGGTCCAGAACTCCAGATGCACCAGT +GCGGTCTTCCCAAGATAATGGCCCTCGAACTCTTCAAACCCTTCGTATACAGGAGACTGGAAGAAAAAGG +GTATGCGACTTCCATAAAACACGCAAAGAGACTCGTAGAGCAAAAGACACCCGAAGTATGGGAGTGCCTT +GAAGAAGTGGTCAAAGAACACCCCGTTCTGCTAAACCGTGCTCCAACGCTCCACAGACCTTCAATTCAGG +CTTTTGAACCCGTTCTCGTAGAAGGAAAAGCCATACAGCTACACCCCCTCGTTTGCCCGCCCTTTAACGC +GGACTTTGACGGAGACCAAATGGCCGTACACGTCCCCCTCGGAATAGAGGCTCAGCTTGAGTCTTACATA +CTTATGCTCTCCACGCAAAACGTACTTTCCCCCGCACACGGAAAACCCCTCACGATGCCCTCACAGGACA +TGGTTCTTGGGACTTACTACATCACCCACGACCCCATACCCGGAAGGAAAGGAGAAGGAAAAGCTTTCGG +TACCTTTGAAGAAGTCCTCAAAGCTCTTGAACTCGGACACGTTGACATACACGCGAAGATAAAGGTAAAA +GTTGGAAACGAGTGGATAGAAACAACTCCCGGAAGGGTACTCTTCAACTCCATAATGCCCGAAGGACAGC +CCTTCGTTAACAAAACCCTTGACAAGAAAGGACTTTCAAAGCTAATCACTGAACTCTATATAAGGGTAGG +AAACGAGGAGACTGTTAAGTTCCTTGACCGTGTGAAAGAACTTGGATTCCTCAGGTCAACGCTTGCGGGT +ATTTCCATTGGTGTGGAAGACCTGCAGGTTCCCAAGGCAAAGAAGAAGATAATAGAGGAAGCCCTCAAGA +AGACGGAAGAGATATGGAACCAGTACGTTCAGGGTATCATCACCAACAAGGAGAGGTACAACAGGATAAT +AGACGTCTGGTCCGAAGCCACGAACCTCGTTTCCAAGGCGATGTTTGAAGAGATAGAAAAGTCTAAGAGA +ATAGAAAACGGAAAGGAATACCCGGGAACCTTTAACCCCATATACATGATGGCAATCTCTGGAGCGAGAG +GTAACAGGGACCAGATAAGACAGCTTGCAGGAATGAGAGGTCTTATGGCTAAGCACTCTGGTGAGTTTAT +AGAAACGCCGATTATCTCAAACTTCAGGGAAGGTCTTTCCGTTCTCGAGTACTTTATATCCACTTACGGT +GCGAGAAAGGGTCTCGCGGACACCGCCCTGAAAACCGCATTTGCCGGATATCTGACGAGAAGACTCGTTG +ACGTAGCTCAGGACATAACCATTACTGAACGTGACTGCGGAACCGTTAAAGGCTTTGAAATGGAACCCAT +AGTAGAAGCGGGTGAAGAGAGGGTTCCCCTCAAGGACAGAATATTCGGAAGGGTTCTCGCGGAAGACGTA +AAAGATCCCTACACCGGTGAGATAATCGCAAGGAGAAACGAGGTAATAGACGAAAAACTCGCGGAAAAGA +TAACGAAGGCGGGAATAGAAAAGGTAAGGGTACGCTCACCTCTCACCTGTGAGGCAAAACACGGCGTTTG +TGCTATGTGCTACGGATGGGATCTCTCCCAGAGGAAGATAGTATCCGTGGGTGAGGCGGTTGGAATTATA +GCAGCACAATCCATAGGTGAGCCCGGAACACAGCTCACCATGAGAACCTTCCACATAGGTGGTGCAGCAA +CAGCTCAGAAGGTTCAGAGCTTCGTAAAGGCTGAAAGTGACGGTAAAGTCAAGTTCTACAACGTAAAACT +CATAGTAAACAGAAAGGGTGAAAAGATAAACATCTCCAAGGACGCAGCTATCGGAATAGTGGACGAAGAA +GGCAGGCTCCTTGAAAGACACACTATACCTTACGGTGCGAGAATTCTCGTAGAAGAAGGCCAGGAAGTTA +AAGCAGAAACTAAACTCGCAGATTGGGATCCCTTCAACACTTACATAATCGCTGAAGTAGGCGGAAAGGT +AGAACTCAGGGACATAATCCTCGACGTTACCGTAAGGGAAGAAAGGGATCCGATAACAGGAAAGACGGCG +AGCGTAATATCCTTCATGAGACCAAGAGACGCTATGCTACACACTCCCAGAATAGCTGTCATCACAGAAG +ACGGGAAAGAGTACATCTACGACCTTCCTGTTAACGCCATTCTCAACATACCGCCCGAAAAGATATCCCT +CGAGTGGAGAGTATGCCCCACCTGCTCCGAGTCCGAAGAGACCACTATACAGCACCAGTACTACGTGGTT +AAAGACCTTGAAGTTCAACCCGGTGACATACTCGCGAGAATTCCAAAAGAAACTGCTAAGGTTAGGGACA +TCGTCGGTGGTCTTCCGAGGGTTGAAGAGCTCTTTGAGGCGAGAAAGCCCAAGAATCCCGCAATACTCAG +CGAAATAGACGGTTACGTTAAGATTTACGAGGACGCGGACGAGGTGATCATATTCAACCCCAGAACCGGT +GAAACCGCTAAGTACTCCATAAAGAAGGACGAGCTAATCCTCGTAAGACACGGTCAATTCGTCAAGAAAG +GTCAAAAGATTACGGAAACAAAGGTTGCGGAAATAGACGGTCAGGTAAGGATTAAGGGAAGAGGCTTTAA +GGTAATCGTTTACAACCCTGAAACAGGACTACAGAGGGAGTACTTCGTTCCCAAAGGTAAATTCCTGCTC +GTTAAGGAAGGTGACTTCGTAAAGGCAGGGGACCAGCTCACAGACGGAACACCCGTACCCGAAGAAATAC +TCAGGATAAAGGGAATAGAAGAGCTGGAAAAATTCCTCCTTAAAGAAGTCCAGATGGTTTACAAATTGCA +AGGTGTTGACATAAACGACAAACACTTTGAAATCATAATCAAGCAGATGCTCAAGAAGGTGAGGATTATA +GACCCCGGAGACAGCAGATTCCTCGTAGGCGAAGAAGTGGACAAAGAAGAACTCGAAGAAGAAATTCAAA +GGATCAAGCTCGAAGGCGGAAAACTGCCCAAGGCTGAACCCGTACTCGTCGGTATTACGAGAGCAGCACT +TTCCACGAGAAGCTGGATTTCCGCTGCATCCTTCCAGGAAACTACGAGAGTACTCACAGACGCTTCCGTT +GAAGGTAAGATAGACGAACTCCGAGGTCTTAAAGAGAACGTAATAATCGGAAACATAATACCCGCCGGAA +CGGGTGTGGACGAGTACAGAGAAGTGGACGTAATCCCTGCGGAAGAAAAGGTTCTCGAAGAGAAGAAAGA +ACCCAAAGAGGGCTCTTAAGCCCTCTTCCCTTTAAAAACCTTCTTTAACAGGAGTAAAAGGAACAAGATA +AAATAAGAATTTGTCTCTGTGTTACATCCACCGCCTCCACCATTTGAAGTTTTACTCCTATTTGGAACGT +TAGGATTAAAGGAAGTATCCGAGGAGGTAGGAATACTTTCTCCGTAAAGTTTTATGCTTCTTATTAACCC +TTCTGAAGTCTGTATAGTTAATTCTCCCGTATACGTCCCTCCGCTTACGGGACTAAAGGTTATTTGAATA +CTGCACTCTTCAAAGGGTTTTAAGGCTTTCAGTGTACAGTTTTTACCGCTAACCTTAAATGCGGAGTTTG +AAGTCCTCAAGCCGGTAATAATTAAATCCTTTTTTCCCGTGCTTCTTACCGTAAGACTGAGTGTTTTACT +TTCACCTGAATTCAAAGTCCCGAAATTGAGCTCTCCCGTCGAGAGACACATCTTCTGAGAGCTTTCACCC +GAAAGTAGGTTGTTCAAGTTCAGTAGATTACAAGTATAACTTTTTCCATCGTAGTCCTTTGAATTTTCTC +CCGTAAGAAGTATCTCCCTCTTTATTTCCCGAGGCGAGAGATTTCTGTTTAAAGAGTAAAGTAGTGCCAC +AGCACCTGTAACAAAAGGAGCGGATAGAGAAGTTCCTGCACCCAACACTAGGGATTTCTCGCAGGAGTTT +GAGTGTTTTCCCGTGTATAGACCTAGTATTTCTTCACCGGGAGCAAATAAGTCAACCGTATAGTAACCGT +AATTGGAAAAGTAGGCGGGCTTTTTGTACACGTCGTAAGCACCCACACATATCTCGTTGTCCAGGTTGTA +GTTGCAGGGGTAAAAATCTATTTCGTCGTTGTTATCCCCGTAATTTCCCGATGCGGTAATGTAAACGCCG +TTAAAGTTTGATATTTCCTCGTACTGAACTCGGCTAAAAAGGTATTCCCCTCCGTAACTTGCGTTAATCG +CTATAACTTTTATACCCTTATCCCTTTCAAGTTTTTTAATGTACTCAAAGCACGCAAGTTCTCCCTCAAG +CTCTCCAAATCCGGAGGCGTCTAAAAACTTACAGGGAATTATCTTCACTCTCCAAGCTACGCCGGGAATT +AAGAACCCATTGTTGCCAACAGCACCGATTATTCCCGCAATTAACGTCCCGTGTCCGTCGTCATCGTAAG +CATCCGGAGCGTTACAACCGGGAGCGTTGGTATCATAATATCCCCTAGGATAACAGAGTACGTTTACACC +GTAGCAGTCGTCAACGTAGCCGTTCCCGTCGTCATCAACACCGTTGTCGCAAACCTCGTCGGGATTTTTC +CAGAGGTTATCCTTCAAATCAGGATGGTTGTAATCCACACCTGTGTCAAAGACCGCAACGTATACTTCTT +GACTTCCAACACTCCTGTCCCAGGCCTCCGGGGCGTCTATCGCTTCAAGATCCCACCTGTAGGAAAAACA +GGTATCGTTGGGTAATTTCAAAGCCCTGAGTTTAACGTTTTTCTCAAGGATAAAATTCCCGTTAAAGGAT +TGTTTAAAGAGTGGCCCGTCGGGAAGATCAAGTAAATAAACTTTTTCAGAGATCTTTTTCTTCAGGAAGG +TCTTCAGGCTTTCGGGAAGTTCTCCCTTCAGTAAGTACTCCTCTCCAAAAGAGACTGCCACGAGAAGAAA +AAGTATTAACGCTATCATTTTCCATTAGAGTATAAGACTAAATTAAAGCTTTATGAAGATTTACAGAGCC +GGAAAGTTAGACAACCTTCGCTCCATTACCCTGTTCCACGCTATGGCAAGACTCGGGTATGAGGGTTTGA +TAATAACGACACCTGTGGAGACATATGCAAGTGTAGGGTACTTTGATAAAACACAGGAAATACTTGATTT +GGAAAAGTGTAAAAAACTGGGAATTCCCGTAATAAGGAGAGAAGTGGGCGGAGGAGCTGTTTTGCTACAC +GAAAATCAGGTGTTTTATCAATTAATTCTCAAAAAGAGCAGAGCTCCCTTTAAGGTTATTGACGCTTACA +AGAAGTTCTCTCAACCCGTTATAAACGTTTACAGAAGACTGGGTGTGGAAGTGGAGTACAGACCCATAAA +CGACCTCGTGGTAAAGAGAAACAAGAAAAAGATAAGCGGACAGGGAGCCGCGGACATAGAAGACTCCTTC +GTATTCGTAGGCGGGATTCTTCTGAAGTTCAACACAAAACTCATGGCGGAGATATTCCGGATTCCGGAGG +AGAAGTTCAGGGATAAAGTTCACAAGAGCTTAGAGGAAAACGTAACCTGGGTAGAGAGAGAAACGGGAAG +ACTGCCCTCTTACGAGGAAGTTGAGGAATTTCTCGTGGAAGAGTTTTCTAAAGTAATTCCCTTTGAAGGA +GAGGAACCTGTACCGGAGGAAGCAATAGAACTTGCGGACAAACTAAAAGAAGAATTCACCTCAGAAGAGG +TACTCTTAGAGGATACGGGAAGGAAGCACAGGGCTATAAAGCTGAGGGAAGGGGTGTACTTGAGAACCGC +GGTTCACAAAGCGCAGGGAGGCTTGATCAGAACTGAAGTCTATACGGACGGAGAGGTAATAGAAAGGGTT +AAAATTTACGGAGACTTTACCCTTTATCCGAAGGAAAGCTTAAAGGAACTTGAGGAGAAACTGAAAGGGA +TAAAGTTTGAACCAGAAGAGATTAAAAAGGTAGCGCACGAGTTTTTACAAAAGGTGGATATGCCGGGGGT +GAGTGCTGAAGATTTAGTTATCGCCATTTACGGGGACTGAAAGGGTCTTATCTTTATTATCACTCCCTCC +TTACCCTTTTCTATCTTCTTTACCGTGTGCACTTCAAATATTAAGTTGTCATTTTTTATCACACCCGCCT +TTTCCATTACGTCCCAGAGGCTCTTTAACATGTTGTCTATATCCCTCTTCCTCCTGTTCGGGAGTATTAA +GGTTATATCAACGGATATCTCATAATCTATTGCATCTCCTTTAAACTGTTCTCTCAGTTCCCATATGGCT +CTCGCTTCCCAGTTTGTAACTCTCGGGGGTTTAAACACCTTCCCTCCCTTCGGTCTTATGTACCTGTTAC +TTTTGGGTACGGGAAGCTTTGAAAGGTAAAGCTCAATTTCTTCCATTTCTGATATCATTTTATGAGATAA +TTTTATATTCCATTTCTTCTGAGGAGGAGAGAAATGAGCAGTGAATTGCTCAGGAAGATTGAACAAAAAT +ACCTTCCCAAAAAGGAATATCCAGATTTCAGAGTAGGCTACACAGTAAGGGTTTACTACAAAATAAAGGA +AGGAGATAAGGAAAGGATTCAGCCCTTTGAAGGTGTTGTTATAAGAATAAGGGGAAGCGGTGCAGGAAAG +ACCTTCACAGTAAGAAGGGAGTCCTTTGGAGTAGGGATAGAGAGGACATTCCCCTACTACAGTCCCAACA +TAGAAAAGATAGAGGTTGTGAAGATAGGTAAGGTAAGAAGGGCAAAACTCTACTACCTAAGAGAACTAAA +GGGTAAAGAAGCGGAAAGGAAGATTAAGGAAATCAAGCAGTGGGAATACGAGGCTATGCAAAGGAGAAAG +GAAGAGGCGAGAAAGCAAAGGGAAGAAGAACAAAAGCAGGCTCAGGAGCAGGCTCAAGAACAGGAACAGA +ATGCTTAATTACGAATTAGAACTTTGGGAAAAGGGTCTTTTAGTAGCTGGAGTTGACGAAGCGGGGAGAG +GTCCACTGGCCGGGCCCGTCGTCGCCGCTGCTGTCATACTTCCACCCTTCACGGAACCCTTTATAAAGGG +CGATTCAAAGAAATTAACCAAGAAAGAAAGGGAAGAGGCTTATGAGGAGATAAAAAACAAAGCCCTGGCT +GTGGGAACGGCAGTTGTGGACAGTGCAGTCATAGACAGGGTGAACATACTCAGGGCCACGAAACTCGCCA +TGAAAAGGGCTCTCAAAGACTTGAAGTACCATTACGATATTGTCATCACAGATTACGTAAAGCTTGAAGG +AGAAAACTGCATGCCTCTAGTAAAGGGAGATGAGAAAAGTCTAAACTGCGCCTGCGCCTCTATTATCGCA +AAGGTTATAAGGGACAAGATTATGGAGATTTATCACAAGATTTATCCGGATTTTAACTTTGCTTCAAACA +AGGGATATCCTTCAAAAACTCACCTGGAAAAGGTGGAGAAGGGAGAGTACACGGAGATACACAGGAAGAG +CTTTTCCCCCCTTAAGAAAAAACTTTTTTAGGAAAATTGTTCAAGTTTTATCTTATGCTGTGTTAAATCA +AGGAAGGCATACCTTCCTTCTTCAAACTCTCCGGGATTTACAACTATAGTGTTACCCACGAGTTCGTGAC +CTTTGCCTACGTGTCCGACTATCGCAACTTCAGGGTTAAGGGATTTTATTATCGTATTCACAACGGCACT +TCCATGGTGTTTGGGATCCTCGGGTGTCCTGTCTACAAACTCACCTATAGGCGGAGTGTAGAATATTGTT +ACCAGTCTTCTGGGTTTGAGTTCATTTACGAACTTGAGAATGTACTCAACGTACCATCTGGGGTACTTAA +GTACAAAGTCCTCTTCAAATTCGTGTTCCGTTAATAAGCCTCCGAAGCCTATAACTTCAAACTCTCCCCT +CCAGCCTGCAAAGCCTTCGTGAAGAACCCTTATGTTAGGGTAAGCGGTTTCAGCCTCGTAAGCTGCTCTC +AGGAATATCTTCAAAGGTGCGTCATTCTTCCCAGGAACTACAAAGGTTTTAACTCCGAGTTCTCCTATTT +CCCTGAAGAACTTGTCCAAGGTTTCAATTATGTAGTGTTCATTTTCGTGAATTACCTTCCTGTTTGGTTC +TCTTCTCGCAAGGTGAGCCCTTTCGTACTCCTTTTCCAGAGCTTCGTTTTTAAGTATATTTCCTACAACG +ACGAGAATATCGGGTTGCTTTTCGGCTATAACTCCCTTTAACTTGGGGAGTAAGTCAAACCTTTCCTTGA +AGTTTTTTATTGCCAGTACTTTTCTTGGCATGATTCCCACCTCCTCTAATATTTAATATACCCCACTCAA +GAATTTTTATAAAGTTTTTTGTAATGATAAAAAAGCGAAAAAATCCTTTATTTTTGGAATTGCTGGATTT +TAAGATAGGAATGGCGGAGCGGACGGGATTTGAACCCGCGACCTCCGGCTTGACAGGCCGGCGTTCTGAC +CGGGCTGAACTACCGCTCCAGCCAGTGTAATATTATATAACCTGCGAAAGAAAAATTCAAGAGGGAAGAG +TTCAGTGGGCGTACCTGAAAGAACTCGGGTTTAGTATATCCGGATAGTGGGTTTCCATTTCGTAATCAAA +CATCTGTTTCCTTATCCTCTTGAGGTCGTTTTTGTTGGGTCTGAAGGGATAGCTCTTTATGTCTGAAACA +GAGCAATCTCCGAAGGGCCTGTTGCAAGCGACTTCTGTTGTCTTTCCTCTGCACCCGGCGGTCATGAAGG +GTCTTCCGCTCCAGAATATTTCTTCAAACACTTCTTTGGAAACTCCCCAGTCTATTATCTGTCCCTTTTC +GTTGAACTTCATGTCCTCGTATCTCGCAAGCCCGTTGTCTATCAAGTATCTTGCCATTTGAACCCTTCTG +TACTGTGGTGCAGGACATGGCTTTTCTTTTTCCATTAATGAACCTTCTTCGGGCCAGAAGGAGAAGAGGT +GAGTCCTTCCTCCGAGGTCTCTCACTCTCTGTATAGTTCTTACCATTTCCTCTTCAGTTTCCCCGAGTCC +TACAATCAAGTGAGCTCCTACGTGTCCATCTCCCATAATGTCCGCACACCACTCGAGAACTTTCCAGTAG +GTTTCCCACCTGTGGGGACTGTTCATAGGTCTTCCTCTTAGTTTTTCAAAGAGTTCAGGAGTTGCCGCGT +CAAGTGCAACCGTTAGAGTTTCCGCTCCGAGTCTCTTGTAGTCCTCAAGGTCTTCGTAAGTGTGTCCTGT +GGCGTTCAGGAGGATTGATATGAAAATTTTGTCACCGAGTTCTCTGTGAACTTTTTCAAGTATGTACTTT +GTGTCCCTTATAGCCCTCGGGTGGGTTATCTGGGAAATACAGAGTCTCTCTGCGTGTCCCACCTGCTTGG +TTCTTTCGATAATTTCGTCCGTTTTTACGGTAGGCCACTCAACCCTTATGAAGTTCTTTTTAGAGTATTC +TATTTCTCTGGCTTTCTGGAGACCGCAGTAAGCACAGGTGGCGTGACAACCTGAAGGATAGGTGAGAAGC +GTGTTTATACAGCTCAGCTTTGTGTCCCTGTAAAACTGTCCGGGAATGAGTCCGAGTGTCATTGCAGCAG +CCCAGCTTATCTGCATGTATTCGGGGCTTTCCTTTTGCTCGGTCAACTTTTCAAGCACTAATTTGTTCAT +ACCGTCCCTCCTTAGGGCTTTATTAATAACATTCTAAAACTCTTATAAGAACTGGAAAATAAGGTGTGGT +TATAGGACGTAAAGCGGGAATTATAATTTACGTTATGCACGCACTCTTACTTCTTTTACTCTCCTTTACC +TTTGCCCTTGAGCCCTTATCTGAGTGGTGGAGTAAGGCAAAAGAGGTATGCCTGTACGGAAAGTACAAAA +ACTACGACGGAACACTCAGAGACATAAAGCCCTTCTGTTGCAAAGTGGAAAGGGTTGAAGTGGAACCTAT +AAAGGGACTCCTGAAGGGAAAGTTCGGGCTAAAGGAGAGTTTAAAAGTTATCGCCTCGTGCAACGGTGCT +TTTTACGGAGTGATGAGCTACGACGGGACAATTCTCGCGGTAGGTGGCAAGAAGGGAATAGTTAAAGAAA +CACCTTCTGGCGTTATGGAAGTGGAAGACGAAAAAACGATCCACTTTGTAGTTTGCAGAAGCGGGGCGAG +TCTGGAAGGTTGTTACGGAGAGGTGTTTGCAGAAGGCTACATAATAAAGAAGAAATGATAGCCCTCAGTA +TTGCAGGGTTTGACAACAGCGGTGGAGCGGGAACCTTAGCGGATATAAGAACATTTAAGCACTTCGGTAT +TTACGGAGTTGCCGTAATAACCGCCCTGGCGGTTCAAAACACCCAAAAGGTTTACGAGGTATTTCCCATT +CCGCCGGATGTAGTTAAGGAAGAGCTGAAAGCAATATTTGAGGACTTTCCGATAAAGGGTGTAAAGATAG +GTATGCTTGCAAATAAAGAAATAGCGGAAGTGGTTTACGAAACTCTTAAGAGTAAAAAAACAAACTTTAT +AGTTCTTGATCCCGTTTTTCGTTCAAAGTCAGGAAGGGAACTTCTTTCAGAAGAAGGGGTTGAGTTTCTA +AAAAGTGAGTTTATTAAAATCGTTGACCTAATTACTCCAAACGTTCCAGAGGCAGAAATTCTTTGCGGAG +AAGAGATAAAGAGTTTAGAAGACGTAAAAAATTGTGCCCAAAAAATTTATTCCTTAGGGGCTAAAAGCGT +GCTTATAAAGGGCGGGCACTTGAAAGGAAACTATGCGATAGATATTCTTTACGACGGAAAGAGTTTTTAT +GAGTTTAAAGCTCCCAAAATTGCAGGAAAAACTCCGAGAGGGACGGGTTGTGTTTATTCCTCTGCAATCC +TTGCCAATTACCTGAGGCACAAAGACCTAATAAAAGCGATAAAAACAGCGAAAGATTTCATTACAGAAGC +TATAAAAAACAGTAAAAAACTCGGAAAAGGCTACGAGATTATGGACTTTTGAAACTCTGAATAAAGTACT +CAAAGACTTTGAAGAAATCCTGAAAGTGGTTTGACATGGTGATCGTTATTAACGGAAGTGATAGGAGGAG +TATTATAAGCCCTATGGAAACCTGAAGTGGAAGACCTACCATAAACACGTTCATCTGTGGTATGAACCTG +TTTACCACTGCAAGAACGAGGTTAAGGATTAAGGCGGTAAGAATAAGAGGCATGGCGATTTTAACACCTA +GTCTAAAACTCTCGTAAAAGAAGTTTAAAAAAACTTCGGGGTTTAAGTAAAAAATATTAAAAGAACCTAC +GGGAAGTCTTTTAAAACTCTCCGCAAGCCCGAGGATAATAAACTCTCCGCCTCCGAGTGATAGGAATATC +AACGTGCCGTAAAGGGTAAAAAATCCGGAAAAGAGACTCATTTGGGTCATTCCCGGAATAAACATCTGGA +GGAAACCGAGACCCGTGTGGAGGGCTATAAGTTCTCCAGCTATTATTAAAGCGTCAAACAAAAGTCTCAG +TATTAAACCTGCACTGAAGCCAAAAAGAAGTTCGTTCAAAGCATAAACCAGAAATTCCACGAAAGTGTTA +ACTTTCACCGGAGTAATGTTTATAAAAGAAAGCACGGCGAAAGAAAGGGCAAAGGCGAGGTAAAGTCTTA +TAGTGTTAGGAATTAAAAAAGAACCATAAAAGGGAAAGGTAAATAGAAAACTAACAATCCGAAAATAGGA +AAGTAAAAGCGTGATTAAAAACTCTTCGGAAGTTACCTTATCCATACGGGAATGTTTGCAAAAATCTCAA +CTGCAAAGTCAACGAGCTTTCTCATCATCCAGCCGCCGAGGAGAAATATAACGAGAAATGCGGTAATTAC +CTTGGGGATATAGGAAAGCGTCATTTCCTGAATTTGAGTAGCCGCCTGAAATATACTAACCACAAGCCCA +ACAACGAAAGTGGAAAGCAATACGGGAAGTGCCAAAAGAAGCGTCATTTCAAGTGCTCTTTGCCCTAAGG +AAACTATTAAATCCTGTTCCATATAAAGATTTTTACCATAGCTTCTTCCACACGGTACATTAGGAACAAA +GAAAATCCAAGAAATGTCCACGCCCTCCGAAGTCAGTTTCAACTCCACTACGGTACATTAGGAACTTATT +TAGCATTCAAAAAAGGAGTTCTTGTAAATACAGTTTCAACTCCACTACGGTACATTAGGAACAAGTGAGG +AGATGGGAAAGACATGAGGAAATTCTACGTTTCAACTCCACTACGGTACATTAGGAACTGCTGGATTTCC +CTTCCTTATTTTAATGTTCATTACGTTTCAACTCCACTACGGTACATTAGGAACCCTGCGTGCCTGTGTC +TAAAAAATAACGTACTATCAATAACTTATTAGACACCCGACCCTCACGAAACGAATGTTAATTTCCGCTA +ACCCAAGGTTCTGCAAGCTTGAGTATACCTTTATAAAATTTTTACCCTTGATTTTCAATCCTTTCAACTT +TATCGCATCATGATTTCATTTCATCACACCATCAAAACATCACTTATCAAGACCCACCACCCCTATTCAG +TTGCCAAGGAGCCGGCTGGGGCTTTTTAGCCCCTTTTTAAAAGTATATCACATATCTTTAATGTTTAAAG +TGTCTTAAACCTGTGAATATCATCGCTATTCCGTGTTCATTGCACGCATCTATTACTTCCTGATCTCTTA +TAGAACCGCCGGGTTGGATTACCGCAGTTATTCCTTCTTTAGCCATTATGTCTATACTGTCTCTGAACGG +GAAGAAAGCTTCCGAGGCTACCACGGCACCTTTGAGGTCAAAACCAAACTCCTTGGCTTTGTTTATAGCA +CATTTCAAACTGTCAACTCTGGAAACGTTTCCCGAGCCTATGCCGAGAGTTTGTCCGTTTTTGGCTATAA +CTACGGCATTTGACTTTGTGTGTTTTACCACTTTCCAAGCGAATAACAGATCTTCCATTTCTTCTGCCGT +AGGTTCTCTTTTCGTGACCACTTGGAGTTTTTCGTAAAGTACCGTGTCTTCGTCCTGAAGGAGGTAACCG +CCGCTAACTTTTTTCACGTCAAAGGCGTGTTGAAAGCCGAAGAACCTTATGACTCTTAGATTTTTCTTTC +TTGATAATTCCCTTAAAGCTTCTTCGTCGTAATCGGGGGCAATCACAACTTCAAGGAACATGGAGGTTAA +TTCTTTTGCGGTTTCCCCGTCAACCTTATCGTTAAAGGCCACTATCCCCCCGAATGCGGATACGGGATCG +GCTTCCTTTGCCCTCAAAAACGCTTCTTTTACGGAAGAGCCGAGAGCTACGCCACAGGGATTGTTATGTT +TTATGATTGCACACACAGTTTGATTGGGAAATTCCGCAACTAACCTAACCGCGGAATCGGCGTCCAGATA +ATTGTTAAATGACATTTCCTTTCCTTGAAGGACCTGAGCTTTAGTTATTCCTATATCTTCCAAAGGGTTT +TCGTAAAGGAAACCTCTTTGATGGGGGTTTTCTCCGTACCTCAGTTTCTGCATACGCTTAAGGGGGAGAG +CTTCTTCCTTCCCGAAAGTATCTATGGAATAGAGCTTCTTAAAGGCTTGAGATATTACACCGTCGTAGTA +GGCGGTATGGGAAAAGGCTTTCCATGCAAGGTAAGCCCTGTCCTGAAGTGTCAGGTTTCCCTTCTTTAAC +TTTTCTATTACCCAGTCGTAATCTTCCGGATCTACGAGGATGACAACCCTGAAGAAGTTTTTTGCAGCCG +CCCTTATGAGCGTAGGTCCCCCGATGTCTATAAATTCCATTAAGTCTTTATCCGTTAAACCTTCCTTTAA +TTTCTCTTCAAAGGGGTACAGGTTTACGACGACAACGTCTATGGGTTTTATTCCATGCTTTTCTATTTCT +TCCTTGTCCTTTTCTACCCAGTCTCTGAATAAAATTCCTCCGTGAACTACAGGGTGGAGGGTCTTAACCC +TTCCCTCAAGTATTTCGGGAAAACCTGTAATTTCGGAAACCTCTTTCACGGAGATGCCTTTCTCTCTGAG +GTACTTCGCCGTTCCTCCCGTTGATACGATTTCGTAGCCGAGTTCCTGAAGAGCTTTTGCCAGTTTGTCT +ATTCCTTCCTTCCTGTATACGGATATTATCGCCCTCATTTGTAAAACATCTTACCTCAGCAACCTCAGTA +TGTCGTTTATGAACACGAAAATCGTGAGGGTTATGATTATGGCAAGTCCTACCCTTTGCCAGTACTCCTT +GAACTTTTCAGGAAGAGGTCTTCCCCTTAACCACTCTATGGCAAACAGCAGTATCAGTCCACCGTCGAGT +ATGGGTAGGGGAATGAGGTTAAAAATACCAAGTTGAAGTGAAATGAAAGCCATCATAACGAGGTACGGGA +TAAATCCGCTCTGGGCGGCCTGTCCCGCTATTTGTGCTATCGCTATAGGTCCCCCGAGAGTCTGGAAAGA +AACCTTACCGGTTATAAGCCCTGCTATGGTTTTGAGTGTAAGAACCGTGAGTTCCCAAGTTCTGTTTACC +GCGCTCGCCAGAGCCTCTCCGAAGGGCTTTTTCTCGACTACGGTTTCGGTTTTCGGAAACAAGCCTATGA +AGTAAGTTCCAGTTTTCGGATCTTTTGCCGGAATTAATTCTTTCTCAATCATTTTTCCGTTTCTAAGAAT +TTTGAGTTTTATAGCTTTCCCCTGACTTTTTCTTACTTCTTCTACGAGTTCGTACCACGTGTTTATCTTC +TTTCCGTTTACCTCAAGTATTAAGTCCCCCGGTTTTATGCCAACTTGATCTGCGGGTGAGCCTTTCTTTA +CCCCCCCGACCACGGGTTTTACTAATGGGGCTATGCCGAGTTCTTCACCCTTTTGTACGTTTGGGACCTT +TATAGTTAGATGTAAAACTTCGCCGTTCCTTTCTAAAAATAATGTAGTTTCTTTAACACCGTCTAAGGAT +AGTCTTATCAGTGCATCTCTTAAATCTTCCCAGGTTCTTACTTCGTAGCCGTTTATCTTTATTATCTTGT +CTCCCGGTTTTATCCCTATTTTTTGGGCTATTGAGTCCCTTTGTACATATCCTACAACTACTGGTTCCTT +TAAATACTTGGGAACTTCTACGCCCGCGGTGTAAACAAGGGCAAAAACGAGTATCGTAAACAGAAAGTTA +AATAAAGGTCCTCCGAGTGCTATGAGTATCTTCTGCCAGGGTTTTTTAGTGGAGAACGCCCTCGGATCAT +GAACATTTTCCTCTTCTCCGTAGAGCTTTACGTATCCTCCAAGGGGAAGGGCTGCTATCTGGTATACAGT +TTCTCCCCACTGTCTCCTGAATATAGGAGGACCAAACCCTATTGAAAATATCTCTACCTTTACCCTGAAG +AGTTTTGCCATTAAAAAGTGACCGAACTCGTGAACCCAAACGAGGACACCTATTAGAATTAAAAAGGCTA +TTAAACCCATTACTTTTCTCCCAGAACTACCACTATGACTTTCCTCTCTCTGGGACCGTCAAAGTCCGCC +AGGAATATGGACTCCCAAGTTCCCAGAGCCAGTTCTCCGTCTATTATAGGAATTACTCTTGAGTTTCCTA +TGATTGCGCTCCTTATGTGGGCTGCGGAGTTTCCTTCCATGTGGGCATAACTTGGGTCGTTCCAGGGGAT +TAACTTCTCAAGGGAATACACAATATCCCTCACGACGTCCGGATCAGCCCCTTCGTTTACGAAAACACAG +GCAGTGGTGTGTGGTGTGTAAACGACGCATATTCCCTCTCTCACCCCGGACTTTTTAACCACCTGATCAA +CCTGCTGAGTTATGTTCACTATACTGGTGTGTTTTGTGGTCCTTACTCTAAGAACTTCCTTCATGCTCAA +GGAAATTATACCTCTCTTTTACCTTTTTAATTAACCCTTCGTCCTCGCACTTACCTATAAATTCTTCAAA +CTCCTTCTTTAAGTTTTCAAGGTGTCTCTTTTTTGCCTCTTCCGTTTTTGGTTTTTCCGCCTGTATCTTG +TGTCCTCCTTCCATCAAGCCCTCGGGTATGTACCAGTCCCTGAAGTAGGTGTATCCGAGCTTTAAAAGTT +CAAATCCGAGCCTTGAGAGTGCGGGTGGAACCCCCTTTTGTAACTCGTAAGTAGTTTCTTTGTCTTCAAA +GTACTCCACGAAAATCCTTCCGAAATGCTCACTTAAGAATTCGTAAAGTTTTCTTTCTGCTTCGCTTCCG +AAAAATACGTTCCTCAGATTCGGATTTACGCCGAAGACCTCCACCCAGGGTTGCCAGTAAGGTTTTCTTC +CGAGGAACACTTTAAGCGTTAAAAGAGGTTTACTTCCAAGGGAAAGGTCAAAGTTGAACTCCTCTTTAAA +CCTTCCTTGGGATTTCCTTACGAGCCTTATTTCTCCTTCTTCGGAATTTATACCATTTTCCAAGGTTTTT +AAAAGCTCTTCATACTTCACCATAATATAAATTAAAAGCTATGGATTTTGAATACGTAACGGGAGAAGAG +GGATTAAAAAAGGCAATAAAAAGGCTCGAAAATTCTCCATACCTTTACCTGGATACGGAAACCACAGGAG +ACAGGATAAGGCTCGTACAAATCGGAGACGAAGAAAACACCTACGTTATTGACCTCTACGAAATTCAGGA +TATAGAACCTCTGAGGAAATTAATAAACGAAAGGGGGATAGTAGGGCACAACCTTAAGTTCGATCTTAAG +TACCTCTACAGGTACGGGATATTTCCCTCGGCAACGTTTGACACTATGATAGCGAGCTACCTCCTCGGAT +ACGAGAGACACTCCCTCAATCACATAGTTTCAAACCTACTCGGATATTCCATGGACAAGAGTTATCAGAC +TTCCGACTGGGGAGCGAGCGTTCTGAGCGACGCTCAGCTCAAGTACGCTGCAAACGACGTTATAGTCCTC +AGAGAACTCTTCCCTAAGATGAGGGACATGTTAAACGAGCTAGACGCTGAGAGGGGAGAGGAACTGCTCA +AGACTAGAACGGCAAAGATTTTCGATCTGAAGAGTCCCGTAGCAATAGTGGAAATGGCTTTCGTAAGGGA +AGTTGCAAAACTCGAGATAAACGGCTTTCCCGTGGACGTAGAAGAGCTAACCAACAAGTTAAAAGCTGTG +GAAAGGGAAACCCAGAAGAGGATACAGGAGTTTTACATAAAGTACAGAGTTGACCCTCTCTCTCCGAAAC +AGCTCGCCTCACTCCTGACGAAGAAGTTTAAACTGAACCTTCCCAAGACTCCTAAAGGGAACGTATCTAC +AGACGACAAGGCTCTTACTTCCTATCAGGACGTAGAACCCGTAAAACTCGTTCTGGAAATAAGAAAGCTT +AAGAAGATCGCGGACAAGTTAAAGGAGTTAAAAGAACACTTGAAGAACGGGAGAGTTTACCCGGAGTTCA +AGCAAATAGGAGCTGTAACGGGAAGGATGTCCTCCGCACACCCAAATATCCAGAACATACACAGGGATAT +GAGAGGAATTTTCAAGGCGGAGGAGGGAAATACTTTCGTCATTTCGGACTTTTCTCAGATAGAGCTCAGG +ATTGCGGCCGAATACGTAAAGGACCCGCTTATGCTGGACGCCTTCAAAAAGGGAAAGGACATGCACAGGT +ACACCGCTTCAGTGGTACTCGGAAAGAAAGAGGAAGAAATAACAAAAGAGGAGAGACAGCTCGCAAAAGC +TATAAACTTCGGTCTCATATACGGCATTTCCGCTAAAGGGCTTGCAGAATACGCAAAGCTTGGTTACGGC +GTTGAAATTTCTTTAGAAGAAGCTCAGGTTTTGAGAGAGAGGTTTTTCAAGAACTTCAAAGCTTTCAAAG +AGTGGCACGACAGAGTTAAGAAAGAACTAAAGGAAAAGGGAGAGGTAAAAGGTCATACGCTTCTTGGAAG +GAGATTTTCCGCAAATACCTTTAACGACGCTGTAAATTACCCCATACAGGGAACGGGTGCGGACCTACTA +AAACTGGCAGTTCTACTTTTTGACGCAAACCTCCAGAAAAAGGGAATAGATGCAAAGCTCGTGAACCTCG +TGCACGACGAGATAGTCGTAGAGTGCGAAAAGGAAAAAGCGGAAGAAGTAAAAGAAATACTCGAAAAATC +CATGAAAACGGCGGGAAAGATAATACTGAAAGAGGTTCCCGTGGAAGTAGAAAGCGTTATAAACGAAAGG +TGGACGAAAGATTAATATAATCCTTATGCTTAAACTCAAGTTCAACGAAGAAGGACTCATTCCCGTAATC +GCTCAGGACTACAGAACGGGCGAAGTAAGAATGCTCGCCTACGCAAACGAAGAAGCTATAAAAAAGACTC +TGGAGACGGGATACGCCCATTATTACTCAAGGAGCAGGAAAAAGATATGGAAAAAAGGGGAGACCTCGGG +AGAACTCCAGAAGGTAATTGAAGTAAGAGTGGACTGCGACGAAGATGCACTAATCTACGTAATAGAGCAA +GAAAAGGACAGGGCATGTCACACGGGTGAGAGAAACTGCTTCTTCAGAGACATAGAAGGAAACAAAGTGG +AAAAACCACTTCCCTTTGAAGTACTTCCCAGATTACAGGACGTGATAAGGGAAAAAATAGAAAGAAAGGA +AGAAAACTCTTACACTGCAAAGTTGGTAAGCCAAGGGAAGGAAAGAGTGTTCCAGAAGTTCGGAGAAGAA +GCCGTGGAAACCCTGATAGCCTTAATGAAAGGAGAAAAGGAAGAGGTGATATACGAGAGTGCGGATATGC +TGTACACCTTTCTCGTATCCCTGAGCGTAAGCGGGATAGACATAAAGGAGGTGATGGAGGAACTCATAAG +ACGCTTTAAGTGACGCCTGCGGGCTCTTTTGCCCTCTCTCCCAGTGCCAGCCACCTGTAATCCACGTTGA +ATCGTTTCGCTATGAATACGAGCGTAGCGTCACAAGGTCTGGAGATACCCTTCTCTATCTCCTCGAGCTT +CTTTGTGGAAATGCCTATAGCCTTAGCGAACTCCTCCAAGGACATTCCCCTTTCTTCTCTGATCTTCCTT +ATCCTCTCTCCCACTCCAATCATGGCTCCACCTCCTCCCTTTTTAATTTAAAATTTTAAGGAAATGAGAA +AAGGACTTGCAAGTAGGGTAAGTCACCTAAAACCTTCCCCCACGCTGACCATAACCGCAAAAGCAAAAGA +ATTAAGGGCTAAAGGAGTGGACGTTATAGGTTTTGGAGCGGGAGAACCTGACTTCGACACACCCGACTTC +ATAAAGGAAGCCTGTATAAGGGCTTTAAGGGAAGGAAAGACCAAGTACGCTCCCTCCGCGGGAATACCAG +AGCTCAGAGAAGCTATAGCTGAAAAACTACTGAAAGAAAACAAAGTTGAGTACAAACCTTCAGAGATAGT +CGTTTCCGCAGGAGCGAAAATGGTTCTCTTCCTCATATTCATGGCTATACTGGACGAAGGAGACGAGGTT +TTACTACCTAGCCCTTACTGGGTAACTTACCCCGAACAGATAAGGTTCTTCGGAGGGGTTCCCGTTGAGG +TTCCTCTAAAGAAAGAGAAAGGATTTCAATTAAGTCTGGAAGATGTGAAAGAAAAGGTTACGGAGAGAAC +AAAAGCTATAGTCATAAACTCTCCGAACAACCCCACTGGTGCTGTTTACGAAGAGGAGGAACTTAAGAAA +ATAGCGGAGTTTTGCGTGGAGAGGGGCATTTTCATAATTTCCGATGAGTGCTATGAGTACTTCGTTTACG +GTGATGCAAAATTTGTTAGCCCTGCCTCTTTCTCGGATGAAGTAAAGAACATAACCTTCACGGTAAACGC +CTTTTCGAAGAGCTATTCCATGACTGGTTGGCGAATAGGTTATGTAGCGTGCCCCGAAGAGTACGCAAAA +GTGATAGCGAGTCTTAACAGCCAGAGTGTTTCCAACGTCACTACCTTTGCCCAGTATGGAGCTCTTGAGG +CCTTGAAAAATCCAAAGTCTAAAGATTTTGTAAACGAAATGAGAAATGCTTTTGAAAGGAGAAGGGATAC +GGCTGTAGAAGAGCTTTCTAAAATTCCAGGTATGGATGTGGTAAAACCCGAAGGTGCCTTTTACATATTT +CCGGACTTCTCCGCTTACGCTGAGAAACTGGGTGGTGATGTGAAACTCTCGGAGTTCCTTCTGGAAAAGG +CTAAGGTTGCGGTGGTTCCCGGTTCGGCCTTCGGAGCTCCCGGATTTTTGAGGCTTTCTTACGCCCTTTC +CGAGGAAAGACTCGTTGAGGGTATAAGGAGAATAAAGAAAGCCCTTGAAGAGATCTAAACGGCCAGAACC +CTATTCACTTCCTCTATAGATGTTATTCCTCTCTTTACCTTCAGAAGGCCATTCTTGTAAAGGGTTCTCA +TTCCCTTTTCTATCGCCTTCTTCCTTATTACGTCGTGAGTTGCTCCTCTTATTATGAGTTCCTTTATGTC +GTCGTCAACTTCCAGTATCTCGTGAACAGCGGTTCTCCCTTTATACCCCGTGTAATTACAGTACTCGCAC +CCTCCCTCGTGAGCTTTGTATATAACCACTTCTTCGGAAGGATCCTCTATTACACCTATTCTCAGCAGAA +CATCCTTCGGGATATCCGCTTTCTCTTTACACTTAGGACAGAGTTTTCTTATCAATCTCTGGGCTACGAC +GAGAATCAGGGAACTTCCAACAAGAAAGGATTCTATTCCCATGTCGACGAGTCTCGTTACGGTAGTGGGA +GCGTCGTTTGCGTGAACGGTGGAAAATACGAGGTGTCCCGTGAGAGAAGCCCTTATCGCAATCTCCGCCG +TTTCCGAGTCTCTTATCTCTCCAACCAGGATTATGTCTGGGTCTTGCCTGAGGAAGGCTCTAAGTACGTT +TGCAAAGGTAAGTCCTATCTTCTCGTTTACCTGAACCTGATTTATTCCGGGAATGGAGACCTCTACAGGA +TCTTCTACAGTCATTATGTTCACGTCCGGTGTATTCCTCTCCATCAAAGAAGCGTATAGCGTCGTAGTTT +TACCGGAACCCGTAGGACCAGATACGAGTATCATACCCCAGGGTTTCCATATAGCCCTTCTGTACTTTTC +AAGGTCATCCGGTTCGAATCCTAGGTCTTCCAGCTTTACCTTTAAGTACTTTTCTGCCTCCTGTATTCTC +ATAACGACCTTTTCACCGTAAACCGTTGGAACCGTGTTTACCCTGAGATCTATTTTCTTTCCCGAGACGT +TTACCCTTATCCTGCCGTCTTGGGGTTTTCTCCTCTCTGATATATCCATGTTCGCCATTATCTTTATACG +GGTTATTAAACCGTCTTTAATCACAGGTGGAAATTCCTTGAATATCCTCAGGACACCGTCTATCCTGAAC +CTCACCCTCAAGACTTTCTCTTGAGGTTCTATATGTATGTCTGAGGCGTCTCTCCTTACAGCCTCGTAAA +TTATTAGATTTGCGAGCTTTACAACAGGTGCTGCATCCGCACTCTTCAAGGCTTCATCGAGAGAAACCTC +TTCATCTACCTTTTCTATAACTATCTCTTCCGCTGGTATCTCCTCGAGTATTTCGGTCACTTTAGGGAAC +AGCTCATCTAGAGCTTTATTTATAACGGAAGGGGGTGCGTAAAAAGGTATAACGTGCATTTTCGTGATAA +ACCTCAGTTCGTTTAGCATATCCTGGTTGTAAGGATCAAAGGTGTATATAAAGAGTTTGTTATTCTCAAC +CTTAAAGGGAATTACTTTATACTTCTCTATTAAGTTTCTGGGAACGATGTTCAAAACTTCCGCGGGGATT +TCAGAGGTGTTTATTTCCTCTACTACCCTGCTAGGTATGTGCTGCTTGAAAAATTCAGTCAATTGATCTT +CCGTAATGAGCCCAAGTCTTATCAAAGCTTCTATAGGATCTTCGTCCTTTTGTATTTCTGACAGTACCTT +TTTGATGTCGCCGTCTTTTATATAGCCCGCCTTTGCGAATAAAGTGAGGAGTTTTTCTATCCTCTCCTTA +TCCATAACTTTCCTCTTCCGAAGGGAAATTGCCCCCTTCCACGTCAATTTTAAAATTTTTAAGGGCTTCC +TTTACCAATTTAGCTCCTTCAAGGTACCTTCTCACAAACTTTGGTTTAAAGTCCTCAAAAAGACCGACTA +TATCGTGAAAAACGAGCACTTGTCCGTCAACGTACTTTCCCGCACCTATTCCTATAACTATAGAGTTTGA +ACCTTTCCAGAGTTCTTTCGCCAAGTGTGTGGGAACGCTTTCAAGAACGATCATAAAAGCTCCCGCCTCT +TCCAGAGCTCTGAAATCTCTCCTTAGTTTTTCCTCCTCTTCTTTTTTCTTTCCCACAACCTTCGGTTTTC +CAAAGACGTTTATGTGCTGGGGTGTAAAGCCAACGTGACCCACCACAGGTATTCCTATTCTCGTTAATTT +GTACACGAGCTCCGCTATCTCCTCCCCGCCCTCAAGCTTTACAGCCTTTGCCTTAGTCTCTTTTATAACC +CTTCCGCAGTTTTCCACCGCCTTTTCCATAGAAACCTGATAACTCATAAAGGGCATGTCCGCTATAACGA +AGGCGTTTTTTACTCCTCTCATAACGCACTTTGTGTGATAAATGATTTCTTCCAAGGTAACTGAAAGCGT +ATCCCCTTCACCTTTTACGACAGTTCCGAGGGAGTCTCCGACGAGTATGCAGTCTATCCCGACCTCGTCG +CAGAGTTTGGCACTCCAGTAATCGTAGGTAGAAACCATGGTAATCTTTTTCCCTTCTCTCTTCTTCTTGA +AGAGAGTCTGGAGGTTTATCGCCATTTATTACAAGTTTAACTCCTTGAGCCTGTTTTTAATAAACTCCCA +GCTCCACGCCCTTGCCTGATTTAAGGGAAGCTGTTTTCCTATATGCTCCTCGTAGCCCTCAACCCAAACC +CATTCTCCGTCTGTGAGGAGTTTAAAGTTGTTTGTCCTGCTCGCCCACTGCCAGTAATTGTGAGGTGTTA +TCCCCATAGCCCTCTTGAAAAGTTCTAATTCTTGAGGTGTCAGTTCCCTTACTTTTTTCTCTTCTTTCTC +TTCTCTTTCTTCCTTCTTCTCCTCTACTTCAGTTGGCTTTTCTTCCGTTTTTGGTTCTTCTTTCTTAAAA +AGGGAGAGTATCTTCTTGAGCACTTTTAACCTCCTGAGTTTTACTTAAAATTTATACTTTATGAGCAGGT +TGAGAATATACACGGAATCTGGAGAACTTATAAAAGACATTACTGACCCAAAGGAAATAGCTGAAGAACT +TCAGAAGATAAATGTCCTGTTTGAAAGATGGAGGGCAAACGCACCCCTAAAAGAGAACGCAAGTGACGAA +GAAATTATAAACGCTTACAAACATGAAATAGATAGGCTAATAAACAAATATGGATTTCAGTCCTACGACG +TTATAGCTATGACGCCCGAACACCCTAAAAAAGATGAATTGAGACAGAAGTTCCTCAAAGAGCACACCCA +CAGCGACTTTGAAGTGAGGTACTTCGTTTACGGAGACGGCGTGTTTTACCTTCACCCAAATGACAAGGTT +TACATACTCCACTGTACGGCGGGAGACCTCATCAGCGTCCCTCCGAACACTAAACACTGGTTTGACATGG +GGGAAAATCCTAACTTCAAGTGTATAAGGCTCTTCACGACACCCGAAGGCTGGGTAGCCGAATATACCGG +CTCGGATATAGCGGAAAAGTTCCCCAAGTACGAGGAAGTTGTAAATGGTTAAGGCTATTCTTCTTGACAT +AGAGGGCACTATCGCACCCCTTTCCTTTGTAAAGGAAGTAATGTTTCCCTACTCAAAGAAGAAGTTAAGG +GAATTCCTTGAAAAAAACTGGGAAAAACCTGAGATAAAGAAGATTGTGCAGGAAGTGGAAAAGATAGAGG +GAAGGGAACTCTCCCTTGAGGAAGCAGTGCAGCTTTTCTCAAGATGGATAGACGAGGACAGGAAAATAAC +ACCGCTTAAAGAACTTCAGGGACACATATGGGAAGAAGGATTCAAAAGCGGTGAGCTGAAAGCCCCCCTG +TACGAAGACGCCTACGAGAAAATAAAGGAGTGGAAAGAGAAAGGTATTCCCGTTTACATATACTCTTCTG +GTTCTGTAAAGGCTCAGAATCTTTTTTTCGGTCACAGCGTTTACGGGGACATAAGGAACTTATTTTCAGG +TTTCTTTGATACGAAGATAGGAAGCAAAAGGGAAAGAAGTTCTTACGAGAAGATAGCCAAAGAAATAGGT +CTTCCTCCTCACGAGATACTCTTTATCTCGGACAATCCGGAAGAACTCAAAGCTGCAAAAGAAGCGGGAA +TGAAGGTAATTCAGTCCGTAAGGGAAGGTGTTGAGCCGTCAGGGGACTTTGAGAAGATAACTTCTTTCAG +GGAGCTGGAGATATGATTTTATTCTCTCCTAAGGAGATAAAAGATATTGAAGAGCTTGTAAAGGAAAGGG +AAGGAAGTGTAGAGGAAATAGAGGTAATCAAACTGAACGAGACTCCGAACATTTCCCAGTTCCTCGTTTT +TATAAAAACCTCAGAAGTTCCCCACTACCATGCGGAGCACGACCTTACGTTCACCGTTCTCAAGGGAAAG +GGAGAACTTTACCTTGAGGGTGAAAAAAAGAAACTGAAAGAGGGAGATTGGGCTTTCATACCGAAGGGAG +CGGTTCACTTTTATAGGAACACAAGTGAGCTTTCCGTACTCCTTGCCATCTTCTCACCGAGTTACGACGG +GAAGGACAGTGTGAGGGTAGAGCTGTGAACGTGGAACTCTTTAAGAAGTTTTCCGAAAAGGTAGAAGAAA +TTATAGAAGCCGGCAGGATTTTGCACTCAAGGGGATGGGTTCCCGCAACGAGCGGAAATATATCCGCAAA +AGTAAGCGAGGAGTACATAGCGATAACAGCCTCAGGTAAGCACAAAGGTAAGTTAACTCCCGAGGACATA +CTCCTTATAGATTACGAGGGAAGACCGGTTGGAGGAGGAAAGCCCTCCGCGGAAACGCTCCTTCACACCA +CCGTTTACAAGCTCTTTCCCGAGGTGAACGCCGTTGTTCACACCCACTCTCCGAACGCTACCGTGATTTC +CATCGTTGAAAAAAAAGACTTTGTAGAGCTTGAAGACTACGAACTCCTGAAGGCTTTTCCGGATATACAC +ACCCACGAAGTGAAGATTAAAATTCCCATATTTCCGAACGAACAGAATATTCCTCTTCTTGCAAAAGAAG +TTGAAAACTACTTCAAAACCTCAGAAGACAAGTACGGTTTTCTAATAAGGGGGCACGGACTATACACCTG +GGGAAGGAGTATGGAAGAAGCCCTAATCCACACCGAGGCCCTTGAGTTTATCTTCGAATGTGAACTTAAA +CTCCTTTCTTTTCATTCTTAGTTCTCCCTATAAGCATTTCCCTTTCCGCCTCACACTTCCCCAGTCTGTA +ACTCAAATCCTCTATCTTGTTAATGATTTCTAAGAAATTCTCAGAAATTTTTTTTACATCCCCGTACAAT +CCCTCCCTTAAGACTATATACTCGTGGTAAATCCTAAGGGCTTCCTCCACAATTTGTACTTCCTTTTTGT +TAAGTTTTGTTTTTAGTTCTTCTAAAATTTTTAACGTTTGTTCATCAAAAACAAACGTCTTCTTCTTCAC +GACAAACCCCCTAAAGCTTTACCTTACAATTTAAAAACCTTTTTTGTTTTTTCAAATTTATTTAATTTTT +CTTATATCCTTTTTAACTTATCGTGAGATTTTATAAACCTTAAGAAGGTAATCTATCAAAATCTCCAGAG +GTTCTTTATCAAGTTTTTCATCCCTCATAGGAACCGCAAAGGGAGATAAGACTAACTTCCTGACTTCGTT +CTCTTCCATAGGGGGAACTGGAGCCTTCAGGCTCGCTACAGTTCCCTTCCTCTTTCTTCCGATTTCCCTT +GAAGAGCCTACCTTAAAACCGAGAGTAAGTAATGACTTCCTGACCGAAAGGGAAGAAGAGTAAGAGACCC +AGTACCCCTTCTCGTCAATCCTTTCTTTAATTAACGACAGAAAGTCTAAGGTCCACAGTTCCGGGTTTTT +GTAGGGAGAAAAAGCGTCGTGAAATACAGCATCCGCTTTGAAGTTTTCTACTTCTTTAATCCTCTTCCTC +GCATCTCCCAGAAGTACTTTTAAACTAAGTCTTTCCCCTTCGTACTCCGGGACTCTCTCCAATAAAAATT +CGTGAATTTCCCTGTAGGGTTCCGGCAGGATAGGAAATTCTTTCAGCAGTTCCTTCTCAAAGGAGATTAT +CTCAACTCTCAATTTTGGGTTCACTTCCCAGAGGTGTTTTAAGGCAACTGCCAGGTTGTACCCGAGACCG +AAACCTACATCCAGAATCCTTATTACTTTCCTTTCTTTTGCCTTTTCGAGAATTCTTGAGGGTCTTACAA +ACTTGTAGAGACTCTCCCTTATAGCCCCCGCAGTTTGACTGTGGTAGGGTTCTCCGTAAGTCTTGTGTAT +CAGTGTTTTTGAACCGTCCGCCGTATCGGCAATTTCCTGCCCGCTTTCCTCGGGGTTGTAAGCGAACCTC +AGGAACTCCCTCAGGATTACATTAAATTCTTCCTCGGTTAGTGAAACTTCCTTCTTTCTCAGATAACTTT +CTAAGTAATTTTTCAAATATTCTTCCCTCTTCATTTCTTCAGTTCTTCTATGTTGTATATCTCGTAAACG +GGTCTGTGGTTTGTGAGACCTATGGACTCCCTGTAAACGATTAAGTAATACCTGTACTTGTAGGCTTCGC +TCAGGTACTTGTCTAACCGTTTCCTCAAATGAACGGAAAGCCTTATACTGAACTTTGGAATTTTCGTCTT +TTCCCTCTTCATCCTCTCTTCAAGGTAGTTCAGTGCCCTCTTTACCCTCTTTGCCTGTTCCATGCAGTAC +TCTATCTTCCTCCCGTATCCGCCCCCTACGGAAGCGATTTCCTTTAGAATTTCATCATCCAGACTTTCCT +TTGAGAGCATCAAGTTTTAATATAAAGACTTAATGGTAAAAGTATCCGCAGAAAACTTCCTTTACTTTGC +CATTTCAGTTCTCGTAAACCTGCTCTTTCTGAAAATTCTCTACATCTACTTATTCCTTCCGAATATAAGC +CCGCCTCAAGCTTTTACGCCCCTGAGTGTGAAGATAGAGGAAATAAAGGCTCCGCCAAAGAAGCCGGGAA +AGCCGCAGAAAAAAGTGGTGAAAAAGAAGCCCGAGGCTGTATCAGTCTCTCAGGCTCCCGAAAAGGGGGA +TGTGCCCGTAGAAGTGAAGGAAGAAAAGGAAGTTTCACTCCTTCCCGAACTTGAAAAGAAGATCAAGGAA +AGACTGAAGAAGAGAAAAGAGGTAAAACAAATAGGAGAGATTTCCGCGGTAGTTTCGAAGCAGAAAGTGG +AAATAAGACTGGGAAGCAGGAAGCTCGTTCACGTACCTCCGCCCCCCGTTTTTCACGTAAAGGAATACCC +ATCTCTCGTTCGCATAAAGATATGGGTAAATCCGGAAGGGAGAGTGATAAGGGCTATTATTATCCAGAGG +AGCGGTGTAACGGAAGTTGACGAAGGACTTTTGAGATTTACGAAAAAACTGAAGTTTGAACCTATTGAAG +TTCCCGAAGTTCAGGAAGGTGTGATAACCTTTACTTTTTCCACTTAAAATTTATGGTATGGAAAACTTAA +AAAAGTACCTAGAAGTTGCAAAAATAGCCGCGCTCGCGGGTGGGCAGGTTCTGAAAGAAAACTTCGGAAA +GGTAAAAAAGGAAAACATAGAGGAAAAAGGGGAAAAGGACTTTGTAAGTTACGTGGATAAAACTTCAGAG +GAAAGGATAAAGGAGGTGATACTCAAGTTCTTTCCCGATCACGAGGTCGTAGGGGAAGAGATGGGTGCGG +AGGGAAGCGGAAGCGAATACAGGTGGTTCATAGACCCCCTTGACGGCACAAAGAACTACATAAACGGTTT +TCCCATCTTTGCCGTATCAGTGGGACTTGTTAAGGGAGAAGAGCCAATTGTGGGTGCGGTTTACCTTCCT +TACTTTGACAAGCTTTACTGGGGTGCTAAAGGTCTCGGGGCTTACGTAAACGGAAAGAGGATAAAGGTAA +AGGACAATGAGAGTTTAAAGCACGCCGGAGTGGTTTACGGATTTCCCTCTAGGAGCAGGAGGGACATATC +TATCTACTTGAACATATTCAAGGATGTCTTTTACGAAGTTGGCTCTATGAGGAGACCCGGGGCTGCTGCG +GTTGACCTCTGCATGGTGGCGGAAGGGATATTTGACGGGATGATGGAGTTTGAAATGAAGCCGTGGGACA +TAACCGCAGGGCTTGTAATACTGAAGGAAGCCGGGGGCGTTTACACACTTGTGGGAGAACCCTTCGGAGT +TTCGGACATAATTGCGGGCAACAAAGCCCTCCACGACTTTATACTTCAGGTAGCCAAAAAGTATATGGAA +GTGGCGGTGTGAAGAGAATCGGACTTACGGGAAACATAGGTTGCGGAAAGTCCACGGTAGCACAAATGTT +CAGAGAACTCGGGGCTTATGTCCTAGACGCAGATAAGTTAATCCACTCCTTTTACAGAAAAGGACACCCC +GTTTACGAGGAAGTCGTTAAAACCTTCGGTAAAGGTATACTGGACGAAGAGGGAAATATAGACAGGAAAA +AACTCGCAGACATAGTTTTTAAAGATGAAGAGAAGTTAAGAAAACTGGAAGAAATCACCCACAGAGCCCT +TTACAAAGAGATTGAAAAAATTACTAAAAACCTATCCGAAGACACCCTCTTTATCTTGGAAGCCAGTCTC +CTAGTTGAGAAGGGAACTTACAAAAATTACGATAAGTTAATCGTGGTTTACGCACCTTATGAGGTTTGCA +AAGAGAGGGCAATAAAGAGAGGTATGAGTGAAGAGGACTTTGAAAGGAGATGGAAAAAGCAGATGCCAAT +AGAGGAAAAGGTAAAGTACGCGGACTACGTTATAGACAACTCAGGAAGTATTGAAGAGACCTATAAGCAG +GTAAAGAAGGTTTACGAAGAACTCACAAGAGACCCTTGAGTTTGTAAAAGAGCAATCCTATGTACTCCCT +AATGGCTATGGACGAGTCGTAAAAGACGCTGTACTTTGGAAAAAGGCTATAAACGTTGTACTTCCCTTCA +AACTTCAAGTCCGTGGGGTAAGGGATTACCTCGAGACCTGCTTTTTTAAAAACCCCCACCGCCCTTGGCA +TGTGAAAGCCAGAAGTTACCAATATTACTTCTTTACACTTTAATAGTTTTTCACACATCTCCTTTACGAA +CTTTGCGTTTTCAAAGGTGTCCCTGCTCCTCACGTCCGTGTAGATATCCTCTTCCGGAACTCCGAAGCTC +CTTAACAGTTCCTTCATAACTTTAGCTTCAGGGATAACGTTTATTGAAGCTCCGCCGGAGAGAATAATGG +GTTTCTTTAATTCCTTGTAAAGCAAAAAGCCAGTTATGAGTCTTTTAAAAGAAGAAGCTTTAAGCCTTCC +GTTGTTGTAAACGCCTCCTCCCAGAACAACTATGGCATCTCCCTTCAAAACTTCGGGTTTTTTGTAGTAA +TTCTCAAGAGGGTAAATTAGCAAATCCTTTATAGGTTCTACGGATATGAGGTATAGAGACAAGGCACAGA +GAAGGGCAAACCTTCTTAAGAACTTTCCCTTTGAGAGGAACGATATAAACAGGAAAGCTATTACGTAAAT +CCCGGGTGGCAGTATGAAGTAGGAGATTAACTTTTTTAGGAAGAACATTACTCCTTCTTCCGAACCGCTA +TTATAACGTTTTCTATTCCGTTCTTCCTCGCTAAATCCATTACCTGAACCACGAACTTATGCTTTACGTT +TTCGTCTGCTTCTATTATGAGGTAATCGTACTTCTTCTCTTTAAAAAGCTTTTCCAGATCTTCCGAGGAA +ACACTCTTTCCCTGAACTTTCATATTCCCCTTCTCGTCTATCTGAACCTTCAGGGCGGTGATTTGTACTT +TTTCTCCCGTTTCCGCGAAGGGCAGTTTAACGGCTATAAAGGTCTCAGGGGACTGGAAGGCGAGTATCGC +GAGGAATAGAAACACCGCCAAGAGCGTATCTACTAAAGGAACTACGTCTATGTACGCCCTTTCTTCTTCC +CTGAACCTTAACCTTTTCCTCAGGTTCATATCTTTACTCCAGAGAGTGTATGATTTCCCTCGCTTCCTCG +CTGATTCTGTCTAGTATGTGATTTCCTATAGCCTTGTAAACCCAGTAAGCGAGAAGTGCAGGGATTGCAA +CTCCTAGTCCCGTTGCCGCAGCCACGAGAACTTCACTAATTCCTTTAGCAAGCAGGTTCATAGCCTCTCC +TTGAGTGGTTATTGCGTAAGCTTGAAACACCTTTATAAGACCCGTTATCGTTCCGAATAGTCCAAGAAGC +GGAGCAACCGAAGCCGTGGTGGAGAGTATGGGCAGGTTTTTCTCTATTTTTGGAACTAAAGCGGAAAGCT +CCTCCTCCATCAGCCTTATCAGGTATCCCTTTTCCTTTTTTCCTTTCAGGTATTCCTCAAGGGTTACCGA +TACAGCCTTCGTGAAAGGGTGATCAACCACAGTGGAAATCTTCAGGGCACTCTCGTAATCCCCCCTGCTT +ATTAGGGCTTTTATCTCCGTTAAATTCCGTGGAAGGAAGTTCTTTACCCTCAGGTTAACAGCCCTCTCTA +TTATCACGTACCACGAGAGTATAGAAAGTAAAATCAGGGGGTACATAACTATACCGCCCTTTTCTATCCA +CGCTAAAATGGCTTCCATAACTTACCCTCCGCACTCTGGAAGTCCCTTCTTTAATTCTAAAACCCTTTCC +TCTTCCCACTTCTCCAGTTTGAGACCTTCAAGCCTCTTGAGTATGCAGGAAGCGTCCTTCTTTGCTCCGA +AGCTCTTTAAGAGTGTTGTACTTTCCAAAACTGCTCTCTTATAGAAGGGAAGGTCCTTCTTTTCGCTCAA +TACAACCTCAAGGAAGTACTCAAGGGCTTTTTTATCGTCTTCACCTTTGTACTCGTTGCCGAGGTAGTAA +GCGGCGCTCAGGGCAACTTCAGGTTTTGCACTCTTGTAAGCAATAAAGAGGTATTTTCTCTTCTTCGTTT +TTTCGTAAAGTTTTAGAGCTACTTCCTTTAATTCCTCGGATTCGGGGTACTTCTTTATGAGCCTGTTAAA +TAGCCTCTCCGCTTCCTTTATCCTCCCGAGCTTTAGGTATATCTGTATAGCTTTTACCTTTTCAGGGTCA +CTCCTCTTTTCAAGGAGTCTAGCGAGCTTAAGGAGGTTTCCCCTTTCTTCGTAAAAGGTAACGAGTTTAG +CAAAAGCCTCCTCCGCTACGGCCTTATCCTTTGACTTTAAAAGGTTTATTAAAATCCTTTCCTTTTCTGA +GGGATTGTCTACAACATCCGCTAGGAGCAGTGAAGCCCTGTCCCTGTATTCGGGATTATTTACGAGCTTC +CTGAGTATGAACTGTGCTTCTACCTTTCTCCCCTCCTTCGCGTAAATTCGCGCAAGCTGGAGCTTGAGTT +CAGGAAGGAGGGGACTGTTCGGATACTTCTCCTCAAAGTCTTTTACTATTTTTTCAAGCTCCTTTGTGGG +GGCTTCTATCTCAATCTGTGCAACACCGAGGAGTGCTTCCTTCGCCTCCGGATTCTGGGAGTACTTACTG +AGTATTAGTGTGTATATGGCCCTTGCCTTTTCCTTTTGCCCGAGGTTGTAATAGGAGTCCGCAAGTTTTA +GGAGGGCTTTTAACCTGTACTCCTCGTTTTGAGTGAGTTTCTCGAAGTAAGGAATAGCCTTTTCGTACTC +CCCGTCTATGAAATAACTGAGCCCCGTGAGGTAAACTTCTTCAGGTGTTTCGTTGTAAAGGAACTTCCTC +GCCAGTTCCCCTTTACCGAGCGAAATCGCAGCCTTTGCCTTTAGTACCCTTGCCTCGTAAGAGTTATCAT +CTTTGAGAAGTTCAAGAACCTTTTCGTAATCTCCCGCGTTGAAGTAAGCTACCGCTTTGTAGTAAGGGTT +GTCGAAGTACTTTTCTGCCTCAAGCCAGTTTCCTTTTTTGAATAGGTACCAGCCGTAATACTCTTTGTAA +AGTTTAGGGTACTTTCCTGCGATCTCTTCGAGTGTTTTCAGGAACTCATCTTCCATGTCCGTAGAGTAGA +GCACTTCCAGTAGAAGTCTGTAGTACTCCCTGTCTCTGTCTTTGACATTTTTGAGAATTTCATAGGCTTT +TTCGTAATCCTTTAACTTTAGGGCTGCGTATACTGCGTACTTCCACTTCCCCGCCTTCTCAAAGTATTCA +AGAGCTTTCCTGTAATTTCCTCCGTTGTACGCCTTTACACCTGCGTACTCAAGTACCCACTTCTCTCCGG +TTTTTCTGTACACGAAGTCCGCAAGGGAATGATCTTTAAGGAAAAGAGAGAGGTAAACACTCTTTGCAAG +TTCCGGGTTTAAGGTTTCCAGTATCACAGCGTAATCCAGAGCTTCCTTCGTTTTCCCTTCGTTCAGGGCT +ATTAGAGCTAAGTAGTAAAGGACTACATCCCTGTAAGGTATGAGCTTGTCTTTAAATTCCAGTAAGATTT +TTTTAGCCTCCTCTAATCTGCCCCAGTTAAAGAGCTTTATAGCCCTCCTTACCTTTGTGCTTATGAGGTA +ATCGAGGTTAGGTCTTCCCGCTATGAAGTCGTTAACGTAGGCACAGTACTTTTTAAAGGTGTACCTCTGA +CAGTTTTGAATTTCCTTTTTTGGGATAATTCCGCTCTCTCTTATCATGTAGACGTACTTCCAGAGTAAGG +GCTCCTCCGTGGGGTAGGGTTTTTCGAAGAGCTGGAAGTAAAGTGCGAAGAAACTCTCACAGGAGGGCAT +GGTGTACATATGTGCGGTGTTGCAGGCTTCTTCAAAGAGTTTTAAAGCCTCTTCTTTTTTGCCTTTCTTG +ACGTAAACGAGACCGAGGATGTACTTTCCCGCGTTAGTGTAGGGCGAGTTAGGTATGGAAATTAAATCCT +TTAAGTACTTTTCCGAGGCAAAGAGGTTTCCCTTTTTGTAAGCTTCAACGGCGTTTTTGTACAGGTTTAC +GTCCTTCGGAGCTCCGCAACCTCCCTCCTTTGGAACGTAAAGCTCGGCTTCCTCTATCTCCTTCGGAGGT +TCTAACACTTTTCCGATGATGTTTTGGAGAATTACCTCTCTCTTTCTGAAGGAGAGTTTATCTGGCGGGA +TGTAGGGGGGCTTTTCAACCTTTATTATGTCTTTTACTTTGACTTTTACAGTCAGTTCTTTTTGCAGTTC +TTCGGAAAAAAGAAGCAGGGGGATTAATAATAAAAGACTAAAGAGCTTTATGGGCTTCAACATACAAATC +CCCCAAGTGACACGTAATGTTGAGCTTTTGAATCACGTTCCTCCCTTCACTGTCTAAGTATACCACCGAG +TAAGAGGCGTTGTCACACCCAAAACTCCAGAACTTAGAAAGGTCAATGTCCAGCACCGCACAGTAAAGAC +ATCGTATAGGAACCGTGTGGGATACTACTGCAACCGTCTTCTCGTTGTAATTCTTCAGTAAGAATTCAAG +AAAATTTTTAACTCTTTTAAAAACGTCTAAAAGGGATTCTCCGCCTTCAAACTTTACTCTGTGAGGTTCT +TTTAACCACTTCTCAAATTCTTTCGGAAATTTTTGTTTCACTTCTTCAACCAGAAGTCCGGACCACTTCC +CGTGGTCTATCTCTATCACTCTTTCTTCGGGAATAGGCTCAAGTCCTATCTCCTCACCTATAATTTTTGC +GGTTTTAAAAGTTCTTTTAAGGGGGGAGGAGAAGAGAACCTGAATGTTTTCTTTTTTTAGGGCCTTTGCA +AGCCTCCTTGCCTGCTCAACACCCCTTTCAGTTAAATCCGGATCGAGGAGTCCCTGATAGCGTCCTATGG +GATTCCATTCGCTTTCCGCATGCCTTACAACTATGAGCTTGAGCATTCATAAAATTATATACACTCCTGT +CCCATCTTCCTTGCAAGCTCACAGAGTCTCTGTATTCTCTTTTCCGTTGAAGGGTGTGTAGAGAGTAGTT +CCATTATTCCACCGCCCTTTAGGGGATTTTCTATGAAGAGGTGTGCTGTTCCGGGATTTACATTTGCGGG +AACCTGCATTACGTACTCTTCAATCTTTTTGAGTGCCCTCGCAAGTGCCACTGGACAACCGCATATCTTG +GCTCCGGTCTCGTCCGCGAAGTACTCCCTTGAACGGGATATTGCGAGCTGTACGATCGTGGCTATTATGG +GAACGATTATGATCATAAGTATTGCACCTATCATTTCTGCAAAACCGCCACCTTCCTCTTCTTCATTCCT +GTTGAGTCCTCCGAAGAATAGTGCCCACTGTGCCATGTTTGCGAGGAATCCTATCGCTCCCGCTATGGTT +GCCGCTATGGTTGCAACGAGGACGTCCCTGTTTTTAATGTGTGCAAGTTCGTGAGCGAGAACACCCTTCA +ATTCCTCCTGATCCAGTATTTCAAGAATTCCTCTCGTTACCGCAACAGCTGCGTGCCCCGGTCCTCTTCC +CGTTGCAAAGGCATTTGGCTGTTCCATGGGAACTAAGTAGATTTTTGGCTTTGGCATGTTAGCCCTTCTT +GCGAGCTCTTCCACTATCTGGTGTAGCCACGGAGCTTCTTCATACGGTATTTCCCTCGCACCGTACATGG +AGAGGACTATCTTGTCTGAGAACCAGTAACTCATAAAGTTCATAAAACCTGCGATAATAAGGGCGATTAA +CATTCCGGCAGTTCCACCGATAATCCCGCCTATAGCCATTAAAAGACCGTTAAAACTCCGAGAAGTATTA +CAGTTCTTAACGTCCAGCTCATCACCAAACCTCAGAAATTCTCTCTCACTCATAGGTTCATACTCGATAT +TAAAAACGGGCTTGCCAGAGTCTATAAGGAGATAATAATACAAAACACTCTTTGAATTTATGACACTCTT +CAACTACGGAAAAGTCAAAGTAATTTAAGAGTTCCTCCACCAGAACTCCGTTGTTCTTGAGTCCTATCTT +AAGTCCGATTTTCTTTGCCTCTCTGCTCAGAAATACAGCGTAATCTTTAAGGTCTTCTTTTGTGAGGTTA +AATCCTGTATCGTACAGGTATATGTCAAGGTTATCCGGATCAACACCATCACACCCTTTTTGCTTTGCGA +GTTTAAGTCTCTTTACCATGAGTTCCCTTACTTTTTCGTTTCTGACATCCAAAAAGTACTCACCTTCCCA +TCCCTCATAAGGTTTTCCTATAGCTTCTTTCGGAAACTCATTTGCATCGGGTCTCCACTCTTCCCAAGTT +CCCGCGGAGAAATAACAAATAACGGTTTTACCTTTGGCTTTTAATTCGTTTATCACTTGAACGGAGTTAT +CAAAAAGATCTATGTCGTAAAGTTCTACGTTTTTCGTAGTATCCACTTTACCTTTAAGTTGTATATACCA +AGTAATCTGTGGCGCTTTTTTGTCAGTACCCCCACCGCCATCACAGGAAAATGCAAAAAATATTAAAAGA +TTAAAGAGCGTAACCAAATAACCTGACGTATTCAGGTCTTCTCCTCCAGTCCGGTACCACCTTAACCCAG +AGTTCCAGGTAAACGGGTCTGCCCAGAATTAATTCAAGTTCCTGTCTTGCCCTCTTCCCTATTTCTTTGA +GTCTCTGGCCCTTCTTTCCGATGATTATGGGTTTAAGGTTTTCCCTGTCCACTATTATTTCTCCCTTTAT +CACGAGCATGTTCGGGTTCGCGTCACCGGGTTTTATTTCATTTATCTTCACCGCTATGGACGTTGGAACT +TCTTCTCTCGTTAGCATCATCGCCTTTTCCCTCACTATTTCCGCCGCAAGAAGTCTGAGGGGTAGATCAG +TAATCATATCCTCGGGAAAGAGGGGTTCTCCCTCAGGCAGGTACTTCAAAATCGTCTTTACTAGTTCATC +CAGGTTTGCACCTTTCAATGCACTAATCGGAACTATTTCCGTAAGTTCAGGGTGTTTCTTGTGTATCTCA +TCTATTAAAGGAAGTACGTTTTTGGCAGGACCTATTTTGTCTATCTTGTTTATGACGACTATTACGGGTT +TATTTAAGGGTTTAATAAAGTTCTGGTATATCTCCTCGTCTCTCGGTCTCCAGCCTTCCGTTGCGTCAAT +CATAAAGAGAATTACGTCTGCTTCTTCCAGAGATTGTTTTGCTATTTCCACCATGGAATGTCCTAGAACA +TCTGACTTTTTCGGCTCGTATATACCGGGTGTGTCCAGGAATATAATCTGGGCTTCGTTGGGGATGTTTT +TCACTCCAAGGACGCGCATACGCGTAGTTCCGGCTTTTGGTGAAATGATAGATACTTTTGTCCCGAGTAA +GTTGTTGAGTAGCGTGGACTTTCCCACGTTCGGTTTTCCGACTATTGCAACGTATCCGACCTTCATAAAA +ACCTCCGTTTACTAAACTTAATTTTCTTTATAAAGAATATATCATATTTTCCTTTTGGCTACCTCTTCAG +GAGTTTTAGTAGGTAAAATATAGCGGTTTGCGTGGAGAGAAACCTGTTTTCGTTCCTGCTTCCTTTAAAA +ATCCTCTTAATTACCGTCAATTTATCCTTTACAAAGATTCCTATGTAGGTAAGACCTTGAGGTTTTGTAA +GTGTTCCGCCCGGCCCGGCTATGCCCGTTATCGCTATCCCACAGTCAGTTCCTAAATTGCTCTTCAGTCC +TACCGTCATCTCCAAGCACGTTTGCCAGGAAACCGCACCGTATTTTTTTAGCGTATCCTCACTGACGCAT +AGATACTTTACCTTCAAATCGTTCGAGTAAACCACAAAACCTCCGACGAAGTACTCGGAACTTCCCGGAA +CGTTTACAATCCTCGAAGACAGCATACCCGCTGTACAACTTTCTGCAGTCGAGAGAGTAAAACCTTTTTC +CTTTAAAATTCTGCCGAGAGTTTCCTCTAAACTTTCGGGTCTATCCGTGTAAACGTAATCACTCAGGATT +TCCTTAGCTTTTTTCCATTCTTCTTCCTTCTCAAAAGTAAGGTCAACTCCGCTCAAAGATGCAAGGATTT +CGTAGTTTAAGTCCTTTAATTTTTCTTTTACTTGTCCTTCTTTAATCTCAAAGGTTCTGAGAACGTACTT +TCCTTCAGGTATTTTTTCCTCACAGGGGAAGGGCAGTAGTGTACTCATATTATAATTGTAGATAAACAAA +AAGAAGGAGGTGGAAAATGGGACAAATGGTGGAGTTTGAGAAAAACGGAGTTAAGGTCAGGGGATACATA +GCTACTCCGAAGTGGGCTGGTCCTGCGGTGTTGGTCTTTCACGAGTGGTGGGGGCTTGAAAGTCCGCTTT +CCAATATAAAGGAGATATGTGACAAACTGGCGGATGAGGGATTTGTAGCCTTTGCTCCGGACTTTTACAA +GGGTCAATATGCGGACAACCCGGACGATGCGGGAAAACTCATGACCGAGATGTTTGAAAAGAGAATGGAC +GAAGTCGATAGAATATTTCAGGCTTCCGTTGAGTTCGTAAAAGAGTGCAGGTACACATACCCTAAAAAAG +TGGGGATAACCGGTTTTTGTTGTGGTGGAACACTTGCGATGTACTTTGCCGCAAAGTTTCCCGAAATGGT +AGACGCAAGCCTGCCATTCTACGGACTACCTCAACTTACTCAGATAAATGCAGAAAATATAAAAGTACCT +ATTTTCTTCATACTTGCGGAAAAAGACGAATTCGTTAATAACGACGAAGTAATAGACATAGCAAAGACAG +TATGGAAAAATGGAGTGGACGTTCAGGTAAAAGTATTCTCCGGCGTTACGCATGCGTTCTTAAACGAAAA +GAGAGAGGACGTTTACGATCCCAAGCGTGCCTGTGAAGCGTGGGAACTGGCGGTAAACTTCTTCAAAACA +TACCTCAAATAACCTCCTCCCTCCTCTAAAACTTTTTTCTTTTCCTCCGATAAATATAAATGACAAAACC +TTAAAAAGGAGGTAAAAGGGATGGCAACGAGGATTAATTACAATTATGAGGCTGCCGTTACTTATACTAG +TTTAAAACAAAACGAGAGGTTGATGAATAAGTCCCTCTTAAGGCTTTCTACCGGTCTCAGGATACTCTCC +GCAGCGGACGACGCTTCCGGACTATTCATAGCGGATCAGCTTGCACTCGTATCCGCAGGACTTGAGCAGG +GTAACAGGAACATTCAGTTCGGTATTTCCGCACTCCAGATAGCCGAAGGTGGAGTATCCCAAATTTACGA +CAAACTAAAGACAATGTACCAAAAGGCTGTAAGTGCCGCAAATGATATTAATGACCCGAATGCAAGGGCT +GCACTCCAGAGGGACATAGAAAACTTAAGAGATGCTATTTTGAAAATCGCACAGGATACAGAATACAACG +GAATAAGACTTCTAAACGGTTCTTTCAATAACGTAAGAATTCACTACGGTGCGAGAAGTGCTCAAACGCT +ATCCGTGAGCATATCAAGTGTATTACCACAACAACTTGGTGGATACGTAGCAGAAGATTCTCCAGCCACC +GCAACGGATACGAATAACGTTCTTACAAATATAGGCACAACGAATACCAACTATTCAGTGGCAAGCGGTG +ATTCTTTAGCGTTTACATTCACAGACGGGACAAGCATAACGTTTAACTCCTTAAACCAGCTCGGATATGA +CTTCAACAATACTGGAACTTACATACTTGACGCATCCGCAATTGTGAATACGATAAACAACAACCCGACA +CTTCAAGGGAAAGGAATAAGGGCTTATGCGGAGAACGTATCGGAAGCTGACCTGACATTTGATACGACAA +ATGTGAATATTGACCAAGGTGATGAAGTAACTATTACATTCTACTCAGGAGGAGAACTTGTATTTACAAA +GACGTATACAGATACGGTAACACTAGACCAGTTTATAGCTGATATAAACAACCAGGCTGGTGGAAAGCTT +ATAGCTTCAAAGGACCCTTCAGGAACCAAACTCGTTCTTTCCACACCAAACGGGGAAACCATATCTGTTG +AAGTAACAGTAAACGATGCAGATGGAGATACAGTAGTAAGCAGTATAAACCTGGGGGCTCTTCTGCAAGG +TGCAGCTGGAACTGTAGTTAATACCAGTGGAGCTACAGCATCCGCGGTAAAAGTCGGAACGCTTATCGTA +ATGGGTTCAGAAAACTTCACAGTTCAAGGAACCGGAATAGCATACTTTACAGCAGCTACGAGCGGAACAT +TCAACTCACTTAATGATGTAGACGTAACAACTAACAAAGGTGCTGAAATCGCTCAGGTTTTAATCCAGAG +GGCTGTAAGACAAGTTGACACCATACGCACCCAGATAGGTTCAACTATAAACAACCTCCAAGCTATCTAC +GACGCTCAAGCGGTTGCTAAAGACAACACGGACAACGCAGAAAGCATAATTAGGAACGTGGACTTTGCTA +AGGAAATGACTGAATTCACTAAATATCAAATAAGGATGCAGTCCGGAGTGGCTATGCTCGCACAAGCAAA +CGCTCTACCTCAACTGGTTCTCCAGCTCCTCAGGTAATGTTTCCTTTTCCCTTTTCTTTTTACCTTTTGA +GGGGCTGAGATGAGGGTTCAAAGAGAAAATGGTTCTTTTGACTGGGAATTTCTCAAAGAGATTCAACAAA +ACATCTTACAAAACAATTCAAAAAACCTTGAAAGCTTCAGGAAGGAAATAAAGGAAAATTCTAAAAAAAT +TCAAAAAGTCAGCAACGAAGAACTCCAGAAAATCATAGAAGAGATAAAGAGAAAACTTGATTACCTGAAC +AAATACTTAAAGATAGAAATAGACAAAGATCTTGAAATTCCCGTTGTTAAGATAATTGAAAAGGATACAA +ATAAAGTAATCAGGCAAATTCCTCCCGATTACCTTTTAGAACTAATGAAGAGGATAGACGAGATGTTAGG +TATTTTAATAAACGAGAGGGTATAAATATGGCCGGAGAGCTTTACTTTTCGGGAGTAACCGGCGCTTACG +ACTGGGGCAGTGTTCTTGATAACATAATGGCTGTAAAAAGTATTCCAATTCAAAAACTGCAACAGAAAAA +GCAATTAATAAACCAAAAACTCCAGATACTCGGTGAATTTTCTCAAAAACTGAGCGATTTAAAAAACTTA +ATTGAAAATTTTAATCTTGAAAGTGCTTTAAAGACTAAAAAGGCTGACGTTTCTGATTCAGATGTAATTT +CAGTTTCCGTGTCGGAAAATGCGCCCGAAATTTCCTTCAGCGTTAACGTTTTGAACACCGCGAGTAAAGA +AATACTCGTTTACGATGCAGGTTTTAATTCCTTGGACGAAACTATAGGGAGTGACGGAAGTTTTACACTG +AGGTACTACACGAGTCCCACCGATTACGTGGAGTACACGATAGATTACTCTTTGATTGATACCTTAAAGG +ACATCGTAAATAAGATAAACGAAACTCAGGACTACGTTAAGGCTTCCATTTATTACGACGGAAACAAGTA +CAAGTTAATGCTTGCGGAGACCTCAGAAGAAAACTCTACCGTGGAAACAGCTCCTGACCTTTCAACAAAA +GCCATACACCTCCTCGGAACACTGCCTCACCAGTTCGGAAATAACGTTCTTATTCAACAAGCTAAGAACG +CAAGGATACAGATAGGAAGCGGGGACGTTATAGAGAGTGCGGGAAATACCTTTGAAAACGTTATAGAAGG +AGTGAGCATAAGCGCAAAGAGAGCAGGTACTTCCGAGGTAAGTATTTCTCAGGATTTCAGTAAGATAAGG +GAATTTTTAAATAATTTCGTGAAGTCTTACAACGAAGTCGTTTCTCAAGTAAAGAGTTTAACCCTCGGAG +AAAATGCACCTTTTAGGGGTGAAAACACGATAATGAACGTAAAGTACGGGCTTTCCGATACGCTCACACC +GCTCATGGAACTCGGTTTAATAGAGTACAAGGAAGACGGAACCATATCCCTGAGCGGGAATCTGGAAAGT +GTTATTAACGAAAAGCCTGATGAATTTAAGTTAAAAATGACTCAATTCTTGGAGAGTGCAAAAGCTGTAG +CTAAGGTAAATTACGAGGCTTTTGAAGACTTCAAGGAATACTTGAACGACCAGGCGGAAAGGATAGACGA +AAATATCAGACTCCTTAGCCAGAGGCTGGTTCAGGAGGAACAAATACTTAAAAGGCAATTTGCACAGCTG +GAAGACTTTATGAATTACGCAAATCAAATAAGGGAGAGGTTAAAGCAGTTTATGGTATCTATCTCTGAAA +TGAACGGAGGTAATAACAAATGAGAAACATTGCAGAGGCTTACTTTCAAAATATGGTAGAAACCGCCACA +CCTCTTGAGCAGATAATACTCCTCTACGATAAAGCGATAGAATGCTTAGAAAGGGCTATAGAGATATACG +ATCAAGTAAATGAACTTGAAAAGAGAAAGGAATTTGTGGAAAACATAGACAGAGTTTACGACATCATCAG +TGCATTAAAGTCCTTTTTAGATCACGAAAAAGGAAAAGAAATAGCTAAAAATCTGGACACGATTTACACT +ATAATCCTGAATACTCTCGTTAAAGTGGATAAAACCAAGGAAGAACTCCAGAAAATTCTGGAAATTTTAA +AAGATTTAAGGGAAGCATGGGAGGAAGTGAAGAAGAAGGTTTAAACCTCTATGTGGTTGTAGGCGTAGTA +AAAGTCTTCGTTAAGAGCGTGGGAGAATTTTATTCCCTGCTCTTTTACCCTCCCGTTGAATTTCTCCTTT +ACCGCCTTTAGAAATTCCATCAAGATTTTGTCTCCAGCTCTTGCAGAGTATACCGTTGTGGCTACCTTGT +CCTCGTCTATCTGGACGGTAGAGCCGAGGAGGTAATTCCCGCAGAAGAAGAGGTATTTGTTTAGTTCTTT +TTTCACTTCAAGTTTTTTGCAGTAAGGCTTTAAGTACTCTTCCGTGAACTTTGCAACCTCTTCAAGTGCT +TCCATCTTCGCACACTCCTTTGGCCTTTACCTTTCCGCTCTCGGTTTGATATTCCTTACCTTTTTCAAAT +TTAGCTCTGAGTATGTAGCCTAGTGCCATTTTTCCGCTCGGAGAGACGGAAGTTATCAATCCTATAGCCT +TATTTCCTTCCAGAATTTTCTCTTCCTCCTTGACCTGTTCAATCACTTCAAACTTTGTCAATACCCTGGG +CGTTCTTCCTCTGAAGTAAACCCTCGCTATCGCCTCCTGACCCACGTAGCACCCTTTATTCAAACTAATG +GCGTAAGGAAGTACTCCCGCTTCAAGAGGTGAGAAACCTTCCCTGAGCTCCTTGTGTATCCTCGGAACGC +AGTTCTTAATCCTTTCCTCTTCAAAATCCTCCACAGAAGCCTCTTTATCCTGAGGAAGTTCTTTAAGGAT +ATCTTCTATCTTTCCGAAGAGGTCAAAGCCCACGGTCTTTAACCTTACAGGATTTTTCGCAAGGTAAGCT +CTTCCTTTAACTCTTTTATCTCGTAATCGCTGAGTTCCACTCCGAATTTTTCCTTTACAAACTCTTCTGC +ACCCTCACCGTATATGAAAACGTGTTTGTAGTTCGGAGTTAAGTCCTCAAAGTAGACTTTCAGTGAAAGT +TTTAACCTGTTGAACTCGTTTATTACGAAATCTGCAGGCTCTTCCGTGTCGAGTATATAGTAATCCTTTA +TTTTGTATACGAAGAAGTCCGCTATGGGCTGACCATTTTGCTTGAGCCACAGGTTGTAGTTAAAAGTGTA +GGGCTTTAAAGACTTTATATCATTTGTAAGGAGTCCATGAAGGAAGTGTGTGTGCTCCTCCGGAGCGGTA +AGTCCCTTCATCAACATCTTTACAGGCTTTCCGTAAACCTTTATCTTACTTCTCTTTAAATCTATCCACT +TCATACTAATAAAATTCTATTGTTTAAAAGTATTATTTCACTTTATGCTCAGAATAAAGAATTCTAAGAG +AAAAATCTAAAGGAAGATTTAAGTTTTTCCATAGGGAGGGCTATCATGAAGAAATTGGTTTTACTCTTTA +TGTTTTTCAGTTTCCTTTTTGCGGAAGAACATGCAAAGTTCGTACAGACGCCTTACGAGGCTCCATTCAA +GGTTGTTGTAGAATTTTACTTTGACGAGCCTGAAAAGATAAGACCTGCACTTCTCTGGGTTTCAAACATC +ATATACGTGCTCTCTAACGAACCTTACAACTTCGTACCCGGTGAGGATATAGACATAGTCGTGATAATCC +ACGGGACGGAGATAACAACTCTCGTTAAGAAAAACAGGGAAAAGTACAAAGACATATGGGAGAGAATTGA +GGGAATGAGCATGTACGGGGTTAAGTTTAAGGTTTGTGCTATGGCGGCGGAACAGCTATACGGATACTCT +AAAGAAGATTTTCCGCCTTTTGTTGACCTTGTTCCTTCAGCTATAACGGAACTCCTCCACTGGCAACAAA +AGGGATACGCACTCCTTATACCACAAATATATGAAATGAAAAGGACAAGAGAGGAAATAAGGTGATTATT +CGTACTCCGTTGAATCCTTGTCCAGCTCTGCGTACTTTTCGCTCATCTCAACAGCTTGTTCAAACAGCTG +TCTTTCTCTTTCCGTAATTTCGACCGGTCTTCTTTCCTTTGTGGGTACAACTTCTTCTGCGCTTTCCCTT +CTTTGTTTACCTTCAAGAACCGCATCCGCAATTTTAGAAGTGAGGAGTTTTATGGATTTGATAGCGTCGT +CGTTTCCGGGAATTGTGTAATCAATAACTGTTGGGTCGCAGTTTGAGTCCGCTATGGCAACTATGGGAAT +TCCTAGTTTTCTCGCTTCGCTAACCGCTATCTTCTCCCTCACCGTGTCTACTATCCAGATAACGTCGGGG +AGCTTCTTCATATCCCTTATACCGTTGTAGAGTTTTCTCAGTTTTTCCATTTTCCTTCTCAAGTTTCTCA +CTTCCTTTTTGGGGAGGACGTCAAATATTCCGTCTTCTTCCATCCTTTCGAGTGTTTGGAGCTTCATAAT +GCTCTTTCTGACCGTCTGGAAGTTTGTGAGGAGTCCACCTACCCATCTTTCGTTAACGTAGAAAGCTCCG +CACCTTTCCGCCTCTTCCTTAATAATGTCCTTTGCCTGTTTCTTCGTTCCGACAAAGAGTATCTCACCGC +CCTGAGCAATAACGTCCGAAACGAAGTGATAAGCGTCTTCAAGCATTACTATGGTTTTGTTCAGGTCAAT +TATGTGTATCCCGTGTCTGACTCCGTAGATGTAGGGAGCCATTTTGGGGTTCCATCTGGACTTTGAGTGT +CCGAAGTGAACACCCGCCTCTAAAAGTTCCTTCATGGAAACTACCGGCATACTTCACACCTCCTTGGGTT +TTGCCACCCTTCCCCATCACCCCGAAGCTGGGGCAACCCAAGCGGGGAAGGTGCGGTTTAAAGAAATAAT +TTTAATCCTTCTTCTCACCGTTTTCACCCTTTTTCTTTTCAAGTTCCCTTTTTTCCTCTATTACACTCCT +GTCAAACCTGTAAATCCTTCCGCAGAAATTGCAGGAAACTTCCGCAAGCTCGTTTTCATTAAAGAGGTCC +TCAAGTTCCTGAGTACTCATCAAAAACAGCGAAGCCTTTGCTACTTCCTCATCACACGGACAGTAATACT +CAACTTCCTTCAAACCTATGAGCTGAGGTTCCATGTCTTTTAAGATTTCCACCGCTATGTCCTCAGGTCT +CATTCCCTTTTCCATCATCTCCGTAACGGGAGGGAGGGAGAGAATTCTCTTCTCAAGTAGTTCCTTTACC +TTCTCAGAAGTCCCGCCGAGCGTCTGAACCAAGTACCCTCCTGCGTGTTTTACGCTTCCGTCTTCGTTTA +CTTTAACACCGACCGCAACCGCGGAAGGCGTTTGTTCGGACTGGTAAAGGTAGTAAGCTATATCCTGTCC +TATTTCTCCCGAAATCAACGGAACTACGCTCGTGTAAGGTTTGCCCATTCCGAGGTCCTTTACAACAGTA +AGAGTTCCCTTTCCAACTATCTTTGCAACGTCAAACTTCTTTTTACCTTCTACTTCTTTTGTGTAGGTAT +CCACGTTTGGGTTTCCTACAAAGCCCCTTACTCTTCCCTTTGCGTCTGCCTCTACCACTATAGTTCCGAT +AGGTCCATCTCCTTCTATTTTTAAAAGGAGTTTTTGGTTGGTACCGTGCTTGAGGAGAGAAGTTAAGAGA +AGGGCTCCCACTATAGCCCTGCCCATGGCAACGGTGGCCGACGGTGATAAGTTGTGTATCCTCCTTGCGG +TTTCAACGGTGTTTGTAGCTTTAACGACGTAAACCCTTACGGGCTCCTTTTTGGGAACCGCTATAACCAT +ATAGTCTCTTTCTTGGAAGTAGTCTTTTAGATCCTTCTTTACCTGCTCGCTTAGCTCCTTTATCAGCATA +ATATTTTAAGTTATCCTATCCCACCGCTCTCTCAATAATACTCTTGACTATTTCCTTCTCAAGGGGTGAG +CTTATCTTGGGTATTATCGTTTCCATTACCACGGTCTTGGCATCTCCGTACTTTCTCAGTCTCCTTGCAC +ACCTTATCGTGTCCCTGATGGAGAACACGAATTCTACCGGCTCTTCGGACTGCTGTGTCTGGTAAGCCCT +GTAAGCCTTTCTTATCTCGTTTGCTATCTTGAGGAGGTCAAAGAGGAGTTTTACATCTCTTTCCCTTTCG +GGAGTTCTGAGTTTTTCTCCGAGCTGTGTCTTTACGTCGTTTACCACGTAATACCAGAGGTACGTAAACT +CTTCCTTGTTCAGAGAAGCAAGTGTATCCAGGTAGTCTTTAAGTATCAGGGCTTCGTCGGGGTAGTAAAA +GCCCTTTTCGTCCTCAAAGGGAGGGTAATCCACGTACATTATGTCCGCCCTTGACTTTATGTCTTGAGGG +AGTTCCGAAACACCGAGGTAGTTCTGAGGGTTCATTCCCCCCACGAGTATCACGTCGGGTCTCGCCTTTA +CCACCTCTCCGTAAGAGAGAACCAGGTACCTCCTGTAGTCAAAGAGGGGGTTGAATATTTTGACAAGAGA +GGGAGGAAGTGTGTTTATCTCGTCAAGGTATATCACGGCTCCGGGCGTTCTCAGGGCCCTAACGAGGTCG +GAGTAAACCTTCTTCGTTCCCTTTTTGGGGTCAAACTCGTAAATGAAGGTTATGTCTTCCTTTTCCATCT +TTGAATTGCAGGGGATTATAAAGAGGGGTCTGTTGGTGAGAGCAGAGAATACTTCAACGAGGAAGTTTTT +ACCTACACCCGCGTCACCCTCAAGTATGAGTATTCCCTCGTGGTACTGGAGCTGCTCTTTTACTAAAGAT +GTGAACCTCTCAAGGTTCTGGACGAACCAGGGGGTTTCTTCAAAAGAGACGAACTCCGGAACTCTGTACT +GCTCTGCTGAACAAAGGCCGTTTAAGTGTTTTAAGTACCTTCCGACCCAAGGGGGAAAGTGCCCGACTTC +AGACTGTTCAAGTATGTTGTTGTAGCGCTTTGGCTCTACGCTCAGGCCGTCTTCCCTCTCAAAGATAAGC +CTTGCGAATACTTTTCCGTCCTGCAGGAACTTGTCCTCTACTTTTACGTGCCACTTGTACCTTACGGGCT +CAGCTTTGAACTTCTCTACTTCTTCCCTTCCGAAGATTACCTTGTCTTCAAGGAGTTTTATAGTGAAGGT +TTTTAGCCTGTCCTCTATTAATTTCTCCTGAAGGGTCTTGAGGAGTTCTTCGTTTGCGTAGTTGTAAAAC +TCCCTGGGAAGTGTTGATATAAACTTCCTTGTTTCCTTTACCTCTTGGAGGCTTTCGAGCTCCGAGAAAC +TCTTAACCTTTGCCCTTGATATGGCTTCCCTTACTTTTTCAAGGTGCTCGTTTAACTTCTTGTTGAAGAA +CTCAACGACTTCCTTTCTCAGTTCTTCCAGCTTTTCCTTCCATTCCTGGGAGACTTCTTCAATTTTTTCC +TTGAGTCTGTTGTAGTCCTGTCCGGTTATTGTTCCTTCCTGGAGTTTTTTCTTTATGTTTTCGTAAAAGA +CTTCGAGTTTTCTCTCTTGAAGTTCTTCACGTGCCTTCAGTATTAATTCTCTTACTTCCTTTAAAGGAAC +GCTTATTTCTTCAAGTTCCCTTAAGGGCTTTACGGACTCAAGTTCCTCTTCGGTTTTTGCCTCCTTTAAG +ACTTTTTTAAACTCCTTGTATATCTCGTTTGCGTTCTTGATTATCTGCTTTTGCCTTTCCTTGGGATACA +AGAAGTCTATGAGGTTAGTTTCGAACTTCTCAAGGAAGTAGTAAAGCTTTCCTTCTTGTTCTTCCCACCT +TGAGGTGTAAACGCTTCCGTCTGAGGCTACACGGACCACGCTGTAGCCGTACCCTTCCAGAAATCCTAAA +AATTGATTGTTCCTCAGGTCGTAAACGCCGAGTCTGTTTTCCTCTTCATCCGCACTAAAGAGGAAGCTAC +CTTCCGGAGAAACGTCTATGAGTCCAACCCTGTGGGGGAGTTCAAGCTCTCCCTCCACTCTATCCAGGGC +GGAGTCGTAAATTGCAATCTTTTGTTTTTCGTTGTCCGCTATGAATACTTTATCCTCGTAAAGGGCTATC +GCCCTATTTCCCGCGTAGTTCAGTTTTCTGAGAAGATTACCGCCTATTGAGAAAACCGCACACCCTTGCG +TTCCGCTCAGGAAAAGCTTCCCGTTCGGAAGTATCTTTAAAGCTCTGAGGTCACCTATTTCCGCGTCCCT +GTATATGAAGGTGCTCTTAAAGTCAACGGTGGTCTGGGTGAGATCGCCTGAAAGGTCTATTACGTAAACC +TTCTCTCCTACCACTCCGAAGGCTAAAGAACCTTTCCTTATATCGAGTCCACCAGTTGGTCTTAGTCCTT +CCTGTGAAATCCTTACACTTTTCCATGTCTTGGGGTCTTTTGAGTTTTCCAGGTAGTAAATCACGAGGTA +TGGAGGTGCTACTACTCCCAAGTACTTTCCTCTGAAGACTATGTCCGTGATGGACTGAGCGGGGGGCTTT +GAGGGGAGTCTGTGAAGGTTGCCAGCCCAATCGTAGAGCTGGAATATGCCGTGTCTCCTTCCTACAAGAA +CCCAGTAGGCGTCTTCGGAAACGTCTAAGGTTTCTATCCAGTACTCCTCTATCTTTGCGTCCGGATCCCT +TTTTAAGGGGAAGTACTTGAACTTCAAATCACCTACGGTGAACTCGGGAGTTTTTTCTTCTTTCCTTTCT +TCCTTTTTAAGGAACTTGTTTAAAATACCCATTTAAGATAAACATATTAAAGACTTAAAGGTGCACGACT +TTCTGAGGAATCTCATACTGAGTTAAAATTTCCACTATGAAAGCTTACACCAAGTACTTAACCTTCAACA +CGAAGAAGAGAAGGGAACTCATAAGGATTACGGACGAGGTTAAAAAAGCGGTGGAAGAAAGCGAAGTGAA +GGAAGGTCTTTGTCTTGTTTCCTCCATGCACCTGACATCCTCCGTAATCATTCAGGACGATGAGGAGGGA +CTTCACGAAGACATCTGGGAGTGGCTCGAGAAATTAGCACCATACAGACCTGATTACAAGCACCACAGAA +CCGGAGAGGACAACGGAGACGCTCACCTAAAAAACCTCTTAACTCACCTTCAGGTAGTCCTTCCTATAAC +GAACGGGAAGCTGGATCTGGGACCGTGGCAGGAGATTTTTTACGCGGAGTTTGACGGACAGAGACCGAAA +AGAGTTGTTATAAAGATAATCGGGGAGTAAATAATTCTTAATGGCTGAGGAGCATAAAACAGAACGGGCA +ACTCCGTACAAAAGGAGGAAGGTAAGGGAAGAGGGAAACGTAGCAAAGAGCCACGAGATAGCATCCTCCC +TTGTAGTCCTCCTTTCCCTTCTCCTATTACTCTTCCTTGGAACTTACATAGCTAAAGAAGTAATACTCAT +TTTTCTGGCGGTAACGGGATACGTCCACGCGGATATATCCGAGCTAGGAAGCCTTTACGAGAACTTTTAC +GAAAACATCGTTAAGGTTTTAACCCCGCTGTTTTTCTTAGCTCTATTAGTCGTCATTCTTTCTCACGTGG +CACAGTTCGGATTTATTTTTACCTTGAAGCCTCTCTCTTTTAAGTGGGAAAGGATAAACCCTTTTGAAGG +TATAAAGCGATTAATCTCTCTAACCACTTTATTTGAAACGGTAAAAAACACCCTGAAGGCTTTTCTGCTT +ATAGGTATAGCGGTTTTCGTTTTAAAGGGCAGTCTTTACTTTTTCCTCTCCTCTTCCACTTACCCTTTGG +CAGAAACTCTGAAGAGTTTTATTAAGACCTCAGCTATAACGCTTATAACCCTCGGAGTGGTTGCCCTCCT +AATAGCCTTTCTGGATTACGCCTTCAAACGCTGGCAGTACGAAAAGAAGATAATGATGTCGAGAAGGGAA +TTGAAGGAGGAGTACAAACAACTGGAAGGACACCCGGAAGTAAAGAGCAGGATAAAGGCAAGGATGAGGG +AGCTCGCAAAGAGCAGGATGATGGCAGAAGTTCCCAAGGCAACAGTAGTTATCACAAACCCAACACACAT +AGCGATAGCCCTCAAATACAATCCGGAGAAAGACAAAGCTCCCGTTGTTGTTGCAAAGGGAAAGGGCACT +ATAGCCCAGAAAATCGTTGAGATTGCAGAAAACTACAGTATACCCGTAGTGAGGAAACCGGAACTCGCAA +GGGCACTCTACCCTGCGGTTGAGGTAGGAAAGGAAATATCCCCTAAATTTTACAAAGCCGTAGCGGAAAT +AATAGCCTACGTTATGTTCAAAAAGAAAAAGGTTTACGCCTGAGGACGCAGGAAAGAAAGCACCTTCTGG +GCTACCTTTTTAGAAGCCCTTATGCAGTCTGCGGTGGAGACCCCGTAGAGCCAGTTCCCCGTCAGGAACA +GCCCAGGATAATCCTTTTCCATTTCTTGAGCTAGGTTCAAGAACCTGTCGTACCCCAGAGTGTACTGAGG +TATAGCCCTCTTCCACTTCTGAACGTGCATAAAGTCTATACAGTCTATTTGAAGTATCTCTTTCAGTTCT +CTTTCTACTATGTTTTCTATTTCTTCCTCGGAGAGCTCTATTACCTCTCTGTCCGTTGCTCCTCCCAGGA +ACACCGTTAAAAGTTCCTTTCCCTGAGGTGCTCTTCCCGGGAATAACTTTGACATAAACATAGCTCCGAG +AATTCTCTTTTTTCCACTCTCGGAACTAAGAAGCCGAACCTTCGGGAATTTCCCTTCAACACCTACGTTC +ACAACTACTACGGGAGGATAATCTATCTTGTCGAACTCTTCGCTCGCACTGAAAGAAACTTCCTTCAGGA +GATAAGAGGAAGTGTAGGCCGGGGAAGCTACTACGACACTTTTTGTCTCAACCTTTTTCCCGCGCACATC +AAGCCTGAAGAAATCCTCAAACTTCCTCATTCTCAGAACTACGTTTTCTGTATGAACTTCAAGCTTTTGA +GCAAGTGCATTTATTAGCTCTCCCAAGCCTTCCCCGAAGGATATTAGCTTGCCTTTAGGGCCTGCGGTTT +TTTCTTTGATAAATGCCTTTATTAAACTTCCGTACTTTTTCTGAGCTTCATAAAGTTTAGGTGTGGCGTG +CTTGAGGGATAACTTTTCCGGATCACCAGCGTAAACCCCCGAGATAAAAGGAGCCACGACGTAATTCAGG +AATTCCTCGCCGAAATGTTCTCTTACAAAATCCGCTATGGAAATGTCTTCATCAACACCTCTCTTAAAGA +TTTCCGTAAGGACTTTCAACTTCGTTTTAAGGGAAAGAAGCGGTGTTTTAAGAAATTCCACGGGCGACAT +GGGAAGGGGAATTAACCTTCCCTTTTTGTATATGTATCTATATTTAGAAGAAGGAGAAGCCTCTACGGGT +TCAATTCCTGCCTCTTTCAAGAAATCTATAACTTCTTGATCCGCAAGTATAGTCTGAGCCCCTACTTCAA +AGAGATATCCCTTTTCTTTCACCGTGTGGATCGTCCCCCCTATCCTGTCGTCCTTTTCGTAAACTACAAC +GTCCACACCCTCCTTTTTTAACCTGTATGCTGTAGAAAGTCCAGAAATTCCTGCACCTATTACCACAACC +TCTCGCATATCCAAATTCTAAAACTTTTCCTTCTAAACAAACCCTGACAAAAGCTTGGAAAAAACTTGAA +AATGTTTTAAAATACTAAACAAAGCCCTTTTTGGGCTCCGGCTCCTTGGCAATTGAATATGGTAAGTGAA +CCTTAATAAGTGATGCTTTGATGGTGTGATGTATTGAAATCATGATGCAACATAGCTAAAAAGATTGAAA +ATCAAGGGCATAAATTTTTACAATGATATACTCAAGTTTGCAGAACCGCGGGTTAGCGGAAATTAACATT +CGTTTCGTGAAGGTTAGGTGTCTAATAAGTTATTGATAAAGCGTTATTTTTTAGGCACAGGCGTGCAGGG +TTCCTAATGTACCGTGTGGAGTTGAAACCATAATAGGAGAATTTAGGAATGCTGATATGCGGGAGTTCCT +AATGTACCGTGTGGAGTTGAAACTTGTCGAGAATTACATCGTCAGGAGTTTCTACTTCAAGGTTCCTAAT +GTACCGTGTGGAGTTGAAACAACTTAACAAATCCTTAACATTTACGGAGTACAAAACATAATAAGCAAAC +TCAGGGAGGTAAAAGGATGAACAGGAAGAAATTTCTTCTTGGGGTACTAGCATTAGCAATTTTTCCCGCC +GCAGGAATAGCAAAGGAAAAAGTAATCAACGGTGCTGGAGCAACTTTTCCCGCTCCTCTCTACTGGAAAT +GGGCTGACGCTTACTACAAGGCAACCGGTATTAAGGTAAACTACCAGTCCATAGGTTCAGGTGGAGGAGT +TAGGCAGATAGTAAACAGAACAGTTGACTTTGGAGCATCTGATGCTCCCTTAAAACCTGAGGAAACAAAA +AAACACAATCTGGCTCAATTCCCGACTGTGATTGGAGGTGTTACCGTAGCTTATAACTTAAGGGGAGTAG +AAAATCTCAAGCTCTCTACAAGAGCGGTTTGTGATATTTTTCTCGGAAAAATTAAGTACTGGGATGACCC +AGTTATAAAGAAGGATAATCCCGGAGTAAAACTTCCTCACAAGAGAATTACCGTTGTTCGCAGGAGTGAC +GGTTCAGGAACTACCTGGATATTCACAAACTACCTCTCCAAAGCTTGCCCCGAGTGGAAGGAAAAAGTCG +GTTACGGAAAAGCGGTAAGGTGGCCTACAGGTATAGGTGCTAAAGGAAACGAAGGTGTAGCAAACTATAT +AAGAAGGATAAAAGGAGCTATAGGCTATGTGGAATACGCTTACGCAATTCAAAACAAGATACCCGTCGCG +GCAGTGGAAAACAGAGATGGAAAATTTGTAAAACCTTCTATAGAAACATTCCAAGCAGCTGCTGCAAACG +CAAAGTGGGATCCTAAAAAAGACTTCTACGAAGTCCTGACATGGCAGCCCGGTGAAAAAGCTTACCCCAT +AGCTGGTGCTACCTTTATACTCCTTGCAAAGGACGAAGACAGGAAGGAAATAAATAAGGAAGTAGTTAAA +TTCTTTGACTGGGCTTACAAAAATGGTGATAAAATGGCTATAGAGTTGCATTACGTACCGTTGCCCGAAA +ACGTTAAGAACATGATTAGGAACTACTGGAGAGAGCATGGATGGTATTAATAGAAGGAAAGACAAGGTAA +TAGACAAGCTTGTCTTTTTAAGTCTGGGCTTTTTTGCCTTTTTTCTGGGGCTTTTATACCCTCTCTTCGT +AGGAGTATCTCTCTTAAAAGAGTCGTGGCTCGCTATTCAGAAGTTCGGAGTTATAGGGTTCATAACGGGT +ACCGTCTGGGATCCCGTTCAGGAGATATTTGGCGGACTTCCCGCAATAGTGGGAACTCTTATTACAACCT +TCTTAGCTTCCCTGATAGCGATACCCGTTTGTATAGGTATAGCGATTTTCATAGCAGAACTCTGTCCCAA +ACCTCTAAAGCCGGTGTTTACTACGGCGATTGAACTACTCGGAGCAATACCGAGCATCATTTACGGGATG +TGGGGATTTTTTATAATAGCCCCATTGATGGCAGACTATGTAGAACCCTTCCTGCAGGAAACATTTATAG +ACGTTCCCGTAATAGGAAAACTCTTTGACGGAGCACCTACCGGTATTGACGTCCTCACTTCAAGCTTTGT +TCTTTCCATAATGATAATCCCCTTCATGGCCTCAATAGTAAAAGACGCCTTTGAAATGACGCCTCAGCTA +TTAAAGGAAGCAGGATATGGAATGGGCGCCACAAAGTGGGAGGTTATAAAAGACGTTATAATCCCTTACG +CTTTTCCGGGAATCGTGGGAGGAGCGGTTCTTTCTGTGGGAAGGGCACTCGGAGAGACTATGGCAGTCGC +ATTTCTAACAGGAAACGTTCACCAAATTCCCAAGTCTTTATTTGACCAGTTAACGACCATTACCGTTGCG +ATAGCAAACGAGTTTACAGAAGCTCACCAAGACATATACCTTTCTTCCCTTTACTACCTTGCCCTAATAC +TCTTTATAATGTCTTTCCTCCTTTTAATCCTCAGCAAGTTCTTAATCTTCAAGAGGTTGGAGAAAAGATG +GAAGGTCACGGGAATTTAGAAAGGTACGTAAAGTGGAGGAAGTTCAAGAGCAACTTAATTCTGTTTTTCA +CATTTCTTACAGCACTCTACGGACTCGTCTGGCTTGTTTGGATAATAACCGATGTAACTATAAAAGGATT +TTCAAACCTTAGTTTGGATCTTCTCCTGAAGGATCCTACTCCCCCGGGCGTGGAGGGTGGTGGTTTAAAA +CACGCCTTCGTGGGACATTTAATAATCACTTCTCTGGCTGTAGTTCTCGGTGTTCCCATAGGCATAGCCG +CAGGAGTATTCTTTACGGAGTACGGCAGGTACAGCAGGTTTGTCTCCTTACTCAGGGATCTTACGGACAG +TATAGTGAGCCTACCTTCTATAATTGTCGGAACATTTATTTACGCTGTAATGGTCAAACCGGTGGGACAC +TTTTTCGCCTTAAGCGGTTCTGTTTCGCTAGCCTTGTTAATGCTTCCGGTTATAGCCATAACAACCGCCC +AGATGCTGAAAATGGTTCCCGACTCTTTGAGGGAAGCTGCTTACGCCCTCGGAGCGTATAAGTGGCAGGT +TATAAAAGACGTTTCCCTCTCTGTCGCAAAGAGGGGAATACTTACGGGAGTAATTCTGGGAATTGCCAGA +ATTACAGGGGAAACCGCTCCGCTTCTATTTACTTCGTTTAACAACAACTTTACCACTTACAACATATTTG +AACCTATGGCCTCGCTCACTGTTACCATTTTCGTTTACGTTATGGGACCCTACGACGACTGGCACAGAAA +AGCGTGGGCTGCCTCGCTCATACTCACAATCGGAACGCTTATGTTCTTCATCCTTGCAAAAATCCTCGTC +AGAGCTAAAAAGTAAAATTATTATGAAAAAATTCTTTCTGTTTCTTGTTTTACCAATATTTCTCTTCGCT +TCTCCTCTTAAGGCTGTTTTTGACTGTGCGGTCGGAGACCTGGACTGGATTAGCTTAAGACTCAGTCTTA +TTAAGAAAACCGCAGAACAATTAATGGAAGAAGGAAAAAGCTACAGATTTGTTATAACGATACACTCCCA +CTGTATAAAAGTGGTTGATGCAGACCTGAAGAAATTTCCCGAAAGTGAACGCAGGAAGATTGAACTAATT +CAGAGTCAGTTAAAAACTTTAAAAGAAATGTATTCAGTAGATGTTAAAGCCTGTCAGATAGCTATGAATA +GAGGAAAGATTAAGAAGGTTCCCCCCTTTGTAGAAACCGTTCCAAATAGCTGGATCACACTAATTGAACT +CCAGAATAAAGGCTTTGCCTTTGTACCCTTTTAAAATAAAGACTTGAGGAGGAATTAAATGAACCCAGTT +AAAGAAATGTTAAAGGAAAAAGCAGGATACATTCTGTCCACTTTAATGTCTCAGGGCGGAGAGTACGGAG +AAATCTTTTACGAGAAATCCAGAACCACGAGAATGCACTTAGAGGACAGAAAAATAGACAAAGTTACCCA +CGGATACGACGAAGGCGTAGGACTCAGGTTAATAAAAAACGGGAAAACTTATTACGGATACACCACCAAT +CCGACCTTTGAAAATCTGAAAGAACTTGCAAAAATACTCGCAAGGGGCGAAGGGCACGGACCCGTAGCCA +TAGGAAAGCGTTACATTCAGGGCTATACGGAAGTTTTAATAGACCCTGATAAGGAAAGTCTGAAGTTCAG +GGCTGAAATCTTAAGGAGGGCTGACGAAAAGGCGAGGAGCTTCGGGGACAAGATAAAACAGGTTCTTGCG +GTCCTTATGGACAAAACCAGGGAGATTATGGTTATAAACACCTTAGGAGAAACTGCGGAAGACACACAAA +AGAGGGTGGTTTTCTTTGTAGAAGTTGTTGCAAGCGACGGAGAAACTCTGCAGAGGGGGTATGAGAGCCT +CGGGGGAAGGAGAGGTTTTGAGATTTTCAACGAAACGCCTCCAGAAGTCATAGCGGAAAAAGCGGCAAAG +AGGGCACTACTTATGCTGAGTGCAAAACCTGCCCCCGCGGGAACTTTCACCGTGGTGATGTCCTCTCAGG +CGGGTGGTACGATGATACACGAGGCGGTGGGACACGGGCTTGAAGCAGACCTCGTTCAGCAGGGACTCTC +CGTTTACGCTGGAAAGCTCGGAGAAAAAGTAGCCTCGGAGCTCGTTACCGTAATAGATGATGCAACCCTT +CCCTATCACAACGGCTCCTTTACGGTTGACGACGAAGGCGTTCCCGCCCAGAGAAAGGTTTTAATAAAAG +ACGGGGTACTCGTAGGGTACATGTACGACAGACTCAGGGCTATGAAAGACGGAGTGGAATCAACTGGAAA +TGGAAGGAGACAGAGTTACGCCCACATTCCCATAGTCAGGATGACAAACACCTTTATAGACAAAGGCCAG +GACAATCCGGAGGACATAATAAAGGACACCAAAAAGGGAGTACTCGTTGTGAAAATGGGCGGAGGAGAAG +TAAACACCGTGACGGGAGATTTCGTTTTTGAAGTAATGGAAGGCTACATGATAGAAAACGGGGAGATTAC +TTATCCCATAAGGGGAGCAACGCTCATATGAAACGGACCCAAAGCCCTTCAGGACGTGGACGCTGTCGGA +AACGACCTCCGGTGGGCTATACGAACGTGTGGAAAAGATGGGCAGGGTGTTCCCGTAACAGACGCCCAGC +CAACTATAAGGATCAGGAAATTAACACTCGGCGGGGTGGAAACGTGATAAAATGATAATTGTATAAAAAT +TTAGGAGGTGGGTAACCATGCCTGTGTTCGTAATTTTAACAACCCTGACGGACGAGGGGGCAAAGACCCT +TAAGAATAAGCCCGAAAGAATTAAGGAAGTTGACGAGGAACTCTGCAACAAGTACGGAATCAAAATCCTC +GCTCAGTACGCCTTAATGGGTCCTTACGACTTCCTGAACGTTGTAGAAGCTCCCGACAACGACACTATAC +TCAAAATGGCAATTGAACTAAACTCCAGAGGAACCATAAGGACACTCACGATGCCCGCTTTTGATATTGA +CACACTCATTAAGGACTTAAAGGAACAGCAGTAAAAATCCTTTCCTCCTTTTTCCTTTTAACCTTTGAGT +AATATAATATTTTTATGGTAGAAGTTGAAAAGAAGATAAAGGAAGGTTTAACCTTTGACGATGTCCTTTT +AGTGCCCCAGTACTCTGAAGTTCTGCCCCACGAAGTTGATGTGAGCACTTATCTGACAAAGAGGATTAAG +CTGAACATCCCCATAGTCTCCGCCGCTATGGATACAGTAACGGAAGCACGTCTCGCTATTGCCCTTGCCA +GAGAGGGAGGAATAGGTATTATCCACAGGAACCTCCCCATAAAGAAACAGGCGGAGGAAGTTGAAAAGGT +TAAGAAATCCGAGAGCGGTATGATAATAAACCCAGTAACTGTAAAACCGGACACACGCGTAAAGGAAGCA +CTTGACATAATGGCAAAGTACAAGATATCTGGTGTTCCCGTAGTAGATGAAGAAAGGAAACTCATAGGTA +TTCTTACAAACAGAGACCTCAGGTTCATAAAGCCCGAAGACTACTCAAAACCTGTTTCCGAATTCATGAC +AAAGGAGAACCTCATTACCGCACCTGAAGGTATAACTCTGGATGAGGCAGAAGAGATATTCAGGAAGTAC +AAAATTGAAAAACTCCCGATAGTGGATAAGGAAGGAAAGATAAAAGGACTCATAACGATTAAGGACATAG +TAAAGAGGAAAAAATACCCAAACGCTTGCAAGGATGAACTTGGAAGGCTGAGGGTCGGGGCAGCCGTAGG +AACTGGAGAGGAAACCCTTGACAGGGTAGCGGCTCTCGTGGAAGCGGGAGTGGACGTCATAGTAGTAGAT +ACGGCTCACGGGCACTCCAAGAGGGTTCTGGAAACCGTAGAAAAGATTAAGGCAAACTTCCCGGAAGTGG +ACGTCATAGCGGGTAACGTGGCAACGGCTGAAGGAACAAAAGCCCTGATAGAGGCAGGAGCGGATGCGGT +AAAGGTGGGTGTTGGACCTGGTTCTATATGCACAACCCGTATAGTTGCAGGTGTGGGTGTTCCGCAGCTC +ACCGCGATAATGGAAGCCGCAAGTGCTGCAAGGGAGTACGACATACCCATAATAGCTGACGGAGGGATAA +GGTACTCCGGGGACATAGTAAAGGCTCTCGCAGCGGGTGCAAGTGCCGTAATGCTCGGGAACCTCCTTGC +AGGAACGGAAGAAGCCCCTGGGGAGACGATTTATTATCAGGGAAGGGCTTACAAGGTCTATAGAGGAATG +GGCTCCTTAGGAGCTATGAGTTCAAGACTATCTTCTGACAGGTACGGTCAAGAAAAAATGGAAAAGTTCG +TACCGGAGGGAATTGAGGGGAGAGTTCCTTACAAAGGAAAACTCGCGGATGTAGTTTACCAGCTCGTGGG +TGGACTGCGTTCGGGAATGGGATACGTGGGTGCTAGAAATATTAAGGAACTGCAGGAAAAGGCAAAGTTT +GTAAGGATTACGTGGGCGGGATACAGAGAGTCACACGTTCACGACGTTCAAATTACGAGAGAAGCTCCCA +ACTACTGGGTCGATTAAATTCCCTTTTTTCCTTCTTTCTTCATAAAATTTCTTAAAACTTCAAGAACTTC +CTCGTACTTCGTAAAGGTGTAAGGAAACTGCATCTGGAAGAACTTAATTTTCACTCCATGCTCTTCCATA +GTCCTTACTACGTTTATTACCTTTTCCTGAGGAGGGATGTAAGGAGCTATTACCGCAAACTCATCTCCTC +CGATTCTGAATATTACGGAACTGGTTAAATCTAAAATATCCTGTTTCATTAGCTTTATAATTACGTCCTT +GACGTCAACCGCTGAACAGCACTGAATGTTTATAGCTTCCACGAGTTTCTTCAAAACCCTGTTTCCTTCT +TCCCATCCGTGTTTTCTGTTGAACTCAAGTAAGTTGTAAATATCAAACAGGGTAAGACAGAAAGGCTCTC +CCTTTTCTATAAAAGCCCTGAGGGTGGGGAGGAAAAGGTCTCCCTTTACAGCCCCCGTTATAGAATCTAG +GTAGTAAAAACTCCACCTGATTTTTTCAATCTCTAAGGGACAGTTATTCTCTCCGAGAGGCAGAGCCCTT +ATTCGCGATAGCGCCCTTACGGCGTAAGGTACAATATCGGGATCAAACTGCTTTCCCGCAAGCTCTTCAA +GCTCTTTCAGGGCTTCGTTCCAGCTCTTTGCCCTTTTGTAAATCCTCCTCGTCGTCATAGCCTCAAAGGA +GTCGGCTATCGTGTAAATTCTCGCAAGCAGGGGAATTTCTTCGCCTTTTTTGCCGAAGGGATAACCCGTC +CCGTCGTACTTTTCCTGATGGTACAGAAGAACTTCCAAACTCTCCCAAGGTATTTCTAAATCTTTTACCA +TTTCGTAGCCGAGTTCTACGTGAAGCTTCATTATTTCGTACTCTTCGGGTGTTAGTTTGGCGGGTTTTAA +AAGGATAACGTCTGGTATGGCAACTTTACCCACATCGTGGATATAACCGCCGAGTTTAAGGAGTTCTATT +TCTTGTGAGGTTAAACCGAGTTCCTTTCCTATTAACTGGGCGTAAAAGACGCCCCTTTCCGTGTGTCCTC +GTGTGTAAGCGTCCCTCAGCCCGATAAGTCTGATAAAGAACTCAGCATTCAATTTCACTTTATGTTATTA +TATGTTTAGTGAATGAGGGTTCAATAATGAAGATTAAGGAAACTGAGCTTCCGGGAGTAGGCAAGAAGTA +CACGATAGAGCTAGAAGAAGGAGGAGAACTGACTCTCATCATTCACAACACTGGAAGGAGGGAACTCTAC +CTCGTTGAGGAGGAAGAAGAAGAACCCAGTTGTGTCTTTTCTTTGACAGAAGAGGAAGCGAGAGAACTCG +GTTTTCTCCTGGCGGGAACTACGTTCCAGACTGTGAGCACCGAAAGAATGGAACTCTTAATGAAAGAGAT +AGTAATGGAGTGGGTGAAGGTAGGGGAAAATTCAAATTTTATCGGAAAGACTATAGCTGATCTAGAAATC +AGAAGGAAAACGGGTGTGTCTATAATAGCCATTATCAGAGATGGGGAGATGATTCCCAGTCCTGACCCAT +ACAAGGAAAAGATACAGGCAGGAGACACTTTAATAGTCGTGGGAACGAGGGAGCAGCTCATCAAGTTCTT +AGAAATGTGCGGAGACTGCAGTACCTGAAATGGAACATCATTTGCACCACATAATTCAAGAAACAGCTCC +TTACTTAGTCCTTTTATTTATGTTCATTTTCGGTTACACATTCCAGAAGGTAAACATTCCCTCCATTATA +GCCTTTATGATTATTGGTTTTTTAGCCCAGCCTTTAGTCCCTCCTGAAAAAATAAAAGACTTTGAAATAT +TCAAACACGCCGGGATAATACTGCTTTTCTTCTTCATTGGTCTTGAGTACTCCTTTGAGAGACTCAGGAC +TATGCTAGGTGCCTGGAAAACGGGCAGCATTGACTTCGTATTTAACTTTATACCGCCCTTTATAATCGCC +TACGCTTTCGGGTTTGACCTGATCACCGCCCTCATTCTCGCAGCAGTGTTTTACCCTTCCAGCACTTCCA +TAATCGCAAAACTTTTAATGGATTACAAACGTATAGCCAGCCCTGAGGCGGAATTGCTCATCGGTATTCT +CATATTTGAGGATCTCGTTGCCATACTCCTGCTAACGATAATTATCCCTCTTAAAGAAGCGGGTAGTATA +GAGTTTACAACTATTCCCGTAAGTCTCGTAAAACTCGGTGTAGCCTTCCTATTATTCTGGCTAATATACA +AGTACCTCATTCCCAAGATAAACGCGTGGCTCGACAGAGTTTCTGAGGAAGATATATTCATATTCTTCAC +CCTCGGTTTAGTACTGAGCATTGGAACTATCTTTCATTCTCTTGGCATTTCCGAAGCGCTCGGAGCTTTT +CTCCTAGGTGTCATCGTCCCCGAAACAAAAGTTCTTGAAAATATAGAAAAGCAACTTTCGGACTTAAAGG +AACTTTCAATGGGACTGTTTTTCTTCTTCTTCGCTTATGAGACCCAGTTAACGAAGCCCGAAAACTTAGG +TCTGCTAATACTCCTTATAGTTCTCGGAATAATTCTCAAGATCATTTCTACTTACCTTGCTGGTTACGTT +TTCGGCTTGAAGAAAAAGTCGAGACTCAGGGCTTCCCTCTCCTTCGTTCCGAGAGGTGAGTTCTCAGTAA +TAATGACTTCTTTCGAACCAGCTTTAAAATCCACTTCCATACCCTTCATATTCTTAACCGCGGTAATTGG +AAGTATCCTCTTTGCATTGGCTCCGAAGGTGGCGGATATCATCTACCCGCCTAAGAAGAAAAAGAAGAAG +AAACCGATCAAGCGTCCGAAGAAAGGTTATTTAAAACGCTCTCGAGCCTTTTCCGAGCACGCTCCAAGTC +TTCAGTCTTCCCGACCCGAAACTCCTCCCCAACAATAACCTCTCCTCTTGTAAAGGGGTAAGGGATTACG +AGACCGTCCCATGTATTTAACCTTATAAACTTCTCAAACTTTACCACCGCAGGTATTATGGGGCTTTCCG +TCTTTTGAGCCAAAAACACCACTCCCGGTTTTACTCTGTAAGCGGGACCTTCGGCCCGTCCACAGTTATC +GCAACGTTTTTTCCTTCTTTTAAGTATTCAATTAACTTCAAGGTGGCACTCCTTCCTCCCTTTTTTGCCT +TTCCTTCTTCCGTAGAGCCTCTTACCACTTCAAAGCCGAGCTCTTTCAGCAGCCTTGCCGCTATTTCCCC +GTCCCTGAATCGACTTACCAGCACCACTATTCCCCTGTCCATTCCGTAGAGGGCGAGACCGAGAGCGTGC +CCATGCCATAGGGCGTATATCTTTCCCTTATCTTTCCTGAACTCGTAACGCTTCTTCCACCTTATAGTTC +TCCCTATTATCCTTAAAATCAATCCGATAAAGGGAAGCATTAGAAAAATAAGCCTGTACTTTAACTTATT +CATTTGAAGCATATAATATACCTTTTAGGAGGTATGAGTTTGACTAAGACGAAAAGGGTCTCCGACGTTG +CAAAGGAGCTTGGGGTAAAATCTAAGGAAATTATAGAATTCCTCAACGAGTATTATCCCAGACCGGACGG +AAAGCCCTGGAAGGCTTCCCACGGTTTAGACGAACAGGCACTTGAGATGATATACGACGCGTTCGGTATA +AAGGAAGAAGAAGAAAAAGAAGAAGTGGTAACGGAGCAAGCCCAAGCTCCCGCAGAAGTAGAGGAAAAGA +AGGAAGAGGAGAAAAAGGAAGAAGTTATCGTAGAAGAGGTTGTGGAAGAAAAGAAACCTGAGGTAATCGT +CGAAGAAATAGAGGAAAAGAAAGAAGAAGAAGAGAAAAAAGAGGAGGAAAAACCTAAAAAGAGTGTTGAG +GAACTGATAAAGGAAATTCTCGAGAAAAAGGAAAAAGAAAAGGAAAAGAAAAAGGTAGAAAAAGAAAGAA +AAGAAGAAAAGGTAAGGGTAGTAGAGGTGAAGAAAGAGGAGAGGAAAGAAGAAAAGAAGGAAGAGAAGAA +GGAAGAAGAAAAGCCTAAGATAAAGATGTCTAAAAAGGAAAGAGAGATTATGAGAAAACTCGAACACGCT +GTAGAAAAGGAGAAGAAGAAACAGGAAAAGAGGGAAAAGGAAAAGAAGAAGAAGGAAGAGGAAGTAAAGA +TAATTTACATACCCGAAGTAATTACTGTGAGAGAACTCGCAGAACTTTTAGACGTACCTGCGAACAAAGT +TATAGCTGAATTAATGAAGAGAGGAGTTCTCGCAACCATAAACCAGCCCGTTCCACCTGAGGTAGCGGTA +GAGGTTGCCGAAAGTTTCGGATACCTTGCAGAAGTAAAGAAGGAAGAAGAAGAACTTGAAGAGGAAGCAC +TCTTAAAAGAAGAGGAAGAAAGGGAAGAAGAGCTCCAACCCAGACCTCCAATAGTCGTTGTTATGGGACA +CGTTGACCACGGAAAGACCACTCTCCTTGACAGAATAAGGAAGACAAACGTCGCGGAAAGGGAAAAGGGC +GGTATAACCCAGCACATAGGTGCTTCACAGGTTGAACTGCCCGACGGCAGGAAGATAACGTTCCTTGATA +CCCCGGGACACGAAGCATTCACTACGTTAAGAGCGAGAGGTGCTAAGGTAACGGACATATCGGTTCTCGT +GGTTGCGGCGGACGACGGGGTAATGCCCCAAACCATTGAAGCAATAAACCACGCAAAGGCCTTCAACGTT +CCCATAATAGTTGCGGTAAACAAGATAGACAAACCTAACGCGGATCCCATGAAAGTAAGGAGGGAACTCT +CGGAGCACGGTCTAATTCCCGAAGAGTGGGGGGGAGACACCATATTCGTTGACATATCCGCAAAAACGGG +ACAAAACGTGGATCAGCTCCTTGAGATGATACTACTCCTTGCGGACATACTGGAACTAAAGGCAAATCCC +AACAAAAAGGCAAGGGGCACAATAATAGAGTCTAAACTGGACAGAAAGAGGGGACCCGTTGCTACCGTTA +TAGTAGAGGACGGAACCCTTAGAGTGGGTGACCACTTCGTTGCAGGTACAACCTACGGAAGAGTACGGGC +TATGTTTGACGATAAGGGGAGACAGGTAAAGGAAGCCCCTCCCTCCACACCCGTAGAGGTACTCGGATTT +GAAGAACTTCCTGAAGCGGGTGATGAACTCATAGTGGTGGATGATGAAAGAACTGCCAGGGAAATAGCGG +AAAAGAGAAAGGAAAAGAAAGAGAGGGAAGAAAAGCTACAAACTATCAGGCTTGAAGACATCTACAAAAA +GATACAGACAGGTGAAACGAAGGAACTCAGGATAGTCCTCAAGACAGACACCATGGGGTCCCTCGAAGCA +CTCAAAAAATCACTTGAAGAACTCTCAAACGAAAAGGTACAGGTAAAGATCATACACGGTGCGGTGGGCG +GTATAACAGAAAACGACATAATGCTCGCCAAAGCGTCTGGTGCCATAGTCATAGGCTTTAACACTAGACC +CGATCCCAAGGCAAGGGAACTCATGGAAAAAGAGAAGGTAGACGTCAGACTTTACGGAGTCATATACGAG +GCTATAGAGGACGTCAAGAAGGCACTCGTTGGTCTGCTTGAACCTATCAAGAAAGAAGAAGTTATCGGAA +TGGCTGAGGTTCGTGCTACCTTCAAGATCAAGAAGGTGGGAACCGTTGCGGGTTGCTACGTGCTCAACGG +AAAACTCGTCAGAGGTGCTAAAGCAAGACTGATAAGGGAAGGAGTAGTTATATACGACGGGGAAATAGAA +AGCTTAAAGAGGTTCAAGGAAGACGTGCAGGAAGTCACAGCAGGTTACGAGTGCGGTGTTAAATTAAAGG +ACTACAACGACGTAAAAGTGGGTGACCAGATAGAATGCTACGAAATAAGGTACGAAAAACCGACACTCTG +ATAGCCCTCAACGAAGTATACGAAAGCATTCAGGGGGAAGGTCTACTTGTGGGCCTTCCCTCCGTCTTTA +TAAGACTTCAGGGGTGTAATTTACGCTGTCCTTGGTGCGACCAGCCAGAAGCTTTGAGCTTTTCAGGTAG +GAAAGTAAAACTGAGTTCTTTGATAAATGAATTAAAGAAGTTCACAGCCAAACACATAGTTATAACTGGT +GGTGAGCCTTTCGCTCATAGAGAACTCCCTTTCATAGTGGAATTCCTCCTTTCGGAAGGTTACTCAGTTC +AAATAGAGACCAACGGAACACTCTGGGTGGAGGAGATGGAAAAGTTTGCAGAGGGTATTCACATAACCTG +CTCTCCTAAAGGGGTTGCAAAGTACTACGTGCATCCCAAGATCTTAAAGTACGCAAAGGAATTGAAGTTC +GTTGTTGACAAAGAGTTTTCCAAAGAAGTCCTTAAAAAAGAAGAGTTTGAAAGATTTTTAAGGGAAGGAA +AAGTGGTTCTTCAGCCCGAGAGCAACAGAAAGGAGATGATGGAGAAGGCTCTAAAAATTCAAAAAGAGCT +TTTAAAGGAATGCTACACAGTGAGGGTAATCCCTCAGGTTCACAAGTGTTTTGACCTGAAATGAGAAAAC +TGATTTCTTTAATCCTAGTAATTATCTTTCCTTACATTTCCTTAGGGCTTTCTGCAAGAATAGCCTTCAG +CGAAAAGTTTATAGAGTGGGAATACTCAAGAAAAAATTTTCCCGAAGACAGGTGGGGAATGGAAAAAGAA +GAGAGACTAAAACTTGCAAAACTCGGACTGAAAGCCGTAATAAGCGATAAAGGTATGGAAGAATTCAAAA +AGGCAAGGTTGAAAAACGGCAAAAGAGCCTTTACAGACAGGGAAGTAAAGCACATGGAAGACGTAAAGAG +ATTTCTGTCTTTTTTCTTCCCATCCGTTTACGTACTCTCGATAATATGGATCGCAGGAGTGTTTTTACTC +AGGAGTTTTGACGTTTTAATCTGGAGCGGAATTTTCAACTCCTTACTTTTGCTTTTCTTAGGAATTCTTA +CTTTTACAAATTACGAGAAGGCTTTTGAACTTTTTCACAACGTAGTTTTTGATCCATATTCTTGGAAGTT +CAGGTATTCGGATACACTCATAAGGATTTATCCCATGAAGTTCTGGTACGATGGAACTTTATTTGTCGCG +ATATTGAGTTTTCTCTTCGGAATTTTAGTTCTTTTTACAGGAATTCTGGGAAAGAAATTTTTGAAAGGGA +AAGGGGCTTAAACTTTAGCCCCCATTTGTTTTGCCTTTTCTATAACGTCCTCTATTGTTCCCACCATGTA +GAAGGCGTTTTCGGGAAGGTGGTCGTACTTTCCTGTGAGAACTTCCTTGAAGGACCTTATGGTATCCTCG +AGTTTTACGTACTTACCGGGCATACCTGTAAATTGCTCCGCAACGTGGAAGGGTTGAGAGAGGAACTTCT +GTATTCTTCTCGCCCTGTTAACGATAGCCTTGTCCTCGTCAGAGAGTTCTTCCATACCGAGGATTGCGAT +GATTTCTTGAAGTTCTTTGTACCTTTGGAGAATCCTCTTTACTTCCATTGCAACTTCGTAGTGCTCTTCT +CCGACATACTCGGGAGCGAGGTACTTAGATGTAGATTCGAGGGGATCTATTGCGGGATATATTCCGAGCT +CAGCGAGTCTTCTTGTGAGAACGGTCGTAGCGTCGAGGTGCGCGAATATGGACCAAGGTGCGGGGTCAGT +TATGTCGTCTGCGGGAACGTAAACCGCCTGAATTGCGGTAATAGAACCTTTCTTGGTTGAAGTAATTCTT +TCCTGAACTTCACCGACGTCAGTATTGAGGGTGGGCTGGTAACCAACCGCGGAGGGTAGTCTTCCAAGAA +GCGTTGAAACTTCCGCACCTGCCTGAACGAACCTGAATATGTTGTCTATGAATATGAGAACGTCCTGACC +TTCCACGTCTCTGAAGTACTCAGCCATTGTAAGTCCGGTGTGTGCCACCCTGAACCTAACTCCCGGAGGC +TCGTTCATCTGTCCGTAAACCATAACCGTGTAAGGGAGAACTCCGGACTCCTTCATTTCGAGCCAGAGGT +CGTTTCCTTCTCTTGTTCTCTCGCCCACTCCAACGACAACGGAATACCCTTCGTGGAAACGCGCTATGTT +GTGGATGAGCTCCTGCATGAGAACGGTCTTTCCAACTCCCGCACCGCCGAAGAGTCCAACCTTACCACCC +TTTATGATGGGCTGGAGGAGGTCTATAACTTTAATACCCGTTTCAAGAATTTCAACTTTCGTGGATTGTT +CAACGAGTTCGGGTGGATTTCTGAACATGGGCCAGTACTCTTTAGCCTCTACCGGACCCTGCTCGTCTAT +GGGTTGTCCCGCAACGTTGAATATCCTTCCGAGAACTTCCTTACCTACGGGTATCTTTATGGGTCCCCCC +AAGTACTCAACTTCTTGACCTCTCACGAGACCATCTGTTGGACCCATCGCTATCGCCCTTACTCTGTGCT +CCCCTATGTGCTGTGCCACTTCCATGAAGAGTACTTCTTCGAACCAGTTACCTCTGTCGTCTATAGCTCT +TCTTATTGTTTTGAGACCGTCTTTGATTTTGGGAAGTTCCTTTACCCCTTCGAACTCCACGTCAACAACG +GGTCCTATGACCTGAACTACCTTTCCCTTAATCACTTCCGCCATCTATAAACCTCCTTTATTGTGCTTTA +AGAGCTTCAACAGCGTTGGTTATATCTATAAGTTCGGTTGTAATAGCTTCCTGCCTTGCCTTGTTGAACA +CGAGGGTCCACTGCCTTATTAGGTCCTCTGCGTTCTTGGTTGCGTTGTCCATCGCTATCATCCTCGCGAA +GTGCTCCGCCGCGTTGGACTCAACCATAGCCCTGTATACCTGGTAGTTAAGGTACAGGTTTACTATGTAG +TCAAAGAACTCCTCTTCTGAGACTTCAAACTCGTAAGTTCCAAGCTCTTCCACTTCTTTTTCTTGGGCTT +CAAAAGGCAGGAAGACCCTTACCTGAGGTTTGTAGCTCGCCCTCGTGACCATCTCGTTGTTTATCAAGTA +AACCCTATCGGTTTCTCCGTTTAAGAACCTCTCCTTTACTATTTCTGCCACCTCTTTAGCCACATTGAAG +TTTACGGTCTTTCTAAAAACTTCATCGTATCCCTTTATTACGTTGTATCCCCTCTTCGTAAAGTACTGAA +AGCCCTTTCTCCCCACAAGTATAAGGCTAACCTTAACACCCTTTTCTTCCTTCTCCCTTATTAAATTTTC +CGCTGTTCTGATTACGTTTGAATTGAAAGCTCCCGCGAGACCCCTGTCTGCGGTAACGAGGATAACGTCA +ACGTTTCTTTCTTCCCTCACGTCAAAGAGGGGATTATCTTCCGTGTCCACATGGGCAGCGAGATGTCCTA +CGAGTTCGTAGAGTTTCTCCGAGTAGGGACGGGAAGCGTAAACGAGTTCCTGAGCTTTCCTGAGTTTTGC +GGCGGAAACGACTTTCATCGCGTTCGTTATTCTCTTCGTGTTCTTTATTCCCTGTATCTTTCTCTTTATG +TCCCTGGGAGAAAGTTTCGCCATAACGCTACTTATTATAAACTAATGTCTAAAGGAAGTAGTATAATTTA +AACCTTCGCAAAGGAGGTAAAGGATGAAGGTAGTTCTCGTAAAGGACGTAGAAGGACTGGGATTTTTCGG +AGACGTGGTTAACGTAAAAGACGGGTACGCCATGAATTACCTCATTCCCAGAGGTTTAGCCCTCCCGGCA +ACTGAAGGAAACATAAAGCACATACAAACAATCCTCGCTCAAAAGGAAAGGAAACTGCTGAGAGAAAAGA +AGAAGGCTGAAGAACTCGCTAAGAAGCTCGAAGGTATGGTGATAGGAATTAAGAAACCCGCCGGAGAAGG +CGGAAAGCTTTTCGGTTCAGTTACACCCGCGGATATAGTAAACGCACTAAAAGAAAAGGGAATAGAGATA +GAGAGGAAGAACGTGGTCTTCTACCACCCCATTAAAGAAGTGGGAGTTTTTCCAGTAAAGATAAGGCTTC +ACAAGGACGTTGAGGTGGACATTAAGGTTGACGTAAAACCTGAGGAGAAGTAAATTCCTGTTATGCGAGA +AGTAAGTTTAAATGAAAAAGAGTTTCACTTAAATAAGGACTTATTTTTCCTGCTCGGTGGAGTCCTCCTC +TCCGTTTTAGCTGGATTCTTTCTCCCCTTTGAAAACCTCTTCTGGTACAAATCCGCCTTTCTGGGATACA +TACTCTCTTCTGTGGTTTACGTAGCCTACCTTCTGGTACGTGAAAGGATAGTTGGCGTAGTAGCAACGCT +GACGCTTTACCTTTCCCTGCTCCTCAACTTAACGGGAATGATAAGGAGGGCTTACGAGAGTTATAAGCTC +GGCGTTTTCCACCCGCCTTGGAGTAATTTGTTTGAAGCACTAACCTTCTGGAGTTTTATAGCCGGATTTG +TTTACCTTGTTATTGAAAGGAAGTACGGATTTAAGATACTCGGAGCTTTTGTAATTCCCGTAATTGCAGC +AATTTCTGGTTTCGCCATATACAAGGCAAATCCTGAAATAACACCCTTGATGCCCGCCCTTAGGAGTTAC +TGGCTTTACCTTCACGTGGTAACAGCCTTTACGGGATACGCGGGTTTTACAGTTGCATTCGGTGGAGCGG +TGGCTTACTTGCTCAAAGAGCACTTCCCGGAGAATAAATTCGTAAAAAACCTCCTTCCGAGAAGGGAAAT +CCTCGACGAGATAACTTACAAATCGATCGCCATCGTTTTTCCGATATGGACCGCCTCAATAATCCTGGGT +GCTGCGTGGGCAAATGAGGCGTGGGGCGGTTACTGGAGCTGGGACCCTAAGGAAGTATGGTCCTTAATAG +TCTGGCTATTCTTCGGAGCGTATCTGCATGCAAGACAGCTTATGGGCTGGAAAGGGAAGAGAGTTGCTTG +GCTTGTGGTTTTCGGGTTTATTACAGTTCTTATATGCTTCTTCGCGGTAAACCTCTACTTCCCGGGACTT +CACTCTTACGCTACCGAGTGAAGTTCTCCACTCTTTCTTTCGCTATTTTTACCGCCTCCCTCATTTTATC +TTCCGTTGTGTTTATGGTTTTCGCCACGTTCCTGAGTATCCTTTCGTTGTCGTGGTGATTTTCTAAAAGT +TCCACTAAGGAAAGAAGGAGTCCGAACTCGTTGTACCTCTTCTCAAGTGCTTCTACAACCTCAGAACTCA +TCCCGAGTTCCCTTGCCAGTGAGGCAGGCTCTTCGTTCATAAGCTCGTTAACTAAGGAAAACAGTCCTAT +CATGTACCCTTCCTTTGCGTATTCGGGAATGTAAATTTTTGCGAGTTCCTGAGCAAGAACTGCCCTGAAG +AAAGAACGCTTTATTATCTCCTCTTCGTATTTACCCGCAAAGAGTTCCGACATCGCTATAACGAGGAGTA +GGTTGGCTATGTTGTTTATGCTCAAGAAAAGCACCGCATCGCTGACGCTTTGTATGTCCTTGCTCTTTCC +CGGGTATAGGTTTTTAACCCACTTCAGGATTTTATAGGTAAGCCCCACGTCCGACTCTATTAAGTTAACT +ATCTGGTTTACGTCCTTTTTCTCTATGGCATCGTATAGTTTAATTATCGTGGTCTTTAAGAACCTTAGGT +TTCTTCCGTTCTTTACGACACTCGGGGGAAAGAGATTTCCTTGAAAGAGGTCTCCGAGCTTTTTAGCCTC +TTCAAAGTCTTCCTCCGTGTTTACTCCGTAGATTATTACCTTTTTGTTTATGTACTTAAGGGCGTCGACT +TCGTCTTCAAAGTCTTTTCCTTCAAAAGAACGCCTCTTCCAGTTGACGCTCACGTAGTCTGAAAGGGGTA +AGAGGGGAAGTACGGATACTTTGTCAAATCTGAAATCGGAGATCAGGAGTTCGTATCCTTTTGCCTTCAG +ATCTTTCAAGGCGTTAACGAGTTTTTCGTTTACTTCCTTTACATCCCTCAGCTTTATAACTACCTTTGAA +GGGGGAAAGAGTTCGTAGGCGTCACTTTCTATGAACTCTTCGGAAAACTCAATCACGCACTTTTTGCCGT +CTATTTCCTGAATTACATTCTCTTCTATTAAAATGTTCATAACTTTAGCGGGATTGTCTGCATTCTCTCT +CAGTTTGAATTCGAACCCGAACAGCTCCTTTCTCCCGTCCAATATTGGGTGTCTGTAAAGGAGATCCATT +CATTTAAAATATAAATTCCTGTTTTATTTTCTGTGAATATTTTTTAACCTCACCGATCAGGTAAATGGAG +CCGATAATTAGCATGTCTTCTTCTAAGTTTAGTAATTCTTCTATCGTAAACACTTTCGTTTTAAATCCCA +TTTCTTTTGCGAATTTTTCTAAATTCTTTACATCTTCTGCCCTGTAGTAATCTATCGGAAGGAGGTAAAT +TTCCTCCGTTAGATTTCTCAAGAGTGTCAAAGTCAATTCCCATTCTTTTCCTTTAAGGGAAGAGTAGGCC +ACCTTTACTTCGGGAAAGTGTTTTTTCACGGTCTTTACCACCTTTACAACGGAGTAAGGGTTGTGGGATG +CATCCACCATTAAAAGTGGTTTTTCCCTCAGCACTTCCATCCTGCCTTCCCAAACCGTATTTTTCAGGGC +TTGATTGACCTTTTCGGGGCTGAGCTTAGTAAACTCCGAAGAGAGTGTGATGGCAAGTGAAGCGTTGTCT +ATTTGCCACTTTCCCCAAAGGGAAAGCTGAGCACCTTCAAGACTGAAGTTTTCACTCTCGTACTTTTCAA +GAACAGTTCTTTCTCTTTCAACTTTTCCCCAATACTCGTAATCAATTCCGGCAACTTTAAGATTCTTTAA +GCCGAGTTCAAGAGCCCTTGTGTATAAGGGATATCTAGCACTTCCCAGAATTAAGGGTTTCCCTTCCTCG +TAAAGTCCGAGCTTTTCCTCCGCTATTTTTTCCACCGTGTCTCCGAGCCACCTTGTGTGGTCTCTCTCCA +CGTTCGTTATTCCTCTCACCCCGGCTTCGGAGACTTTTGTAGCGTCCCACCTTCCTCCCATTCCCACTTC +AAAAACAGCAACGTTAATTCCTTGGTCCTCAAAGTACTTTACCGCTATCAGGGTCGCAGCCTCAAAGTAT +GTGAGGGAAAACTTTTCAAAAACTTTTTTCAGGTCCTTGACGTAATCTTTTAAGACTTCTTCCTGTATTG +GCTTTCCGTTTATCCTCCATCTCTCGTTTTCGGATATCAGGTGAGGGGAGACGAACCAGCCCGTTTTAAA +GCCGTGTTCTCTTAAAATTCTCTCGGTAAAGGCACAGGTAGAGCCCTTTCCGTTTGTTCCCCCTACCAGA +ATTGAAGGGTAATTTTTCTGGGGATTTCCTATATACTCGCAAGCCTTTTTTATCCTCTCAAGCGTTGGTT +TTACGTCAAAGTCCTTTTCTTTGTATAGTTCCCACAAAATTCCCATGGCGAATAGAGTTTATAATTTAAA +GCATAATGGACAAAGAAAAACTAGAAAAAGAAGTAATAAAACTCCTGTCAAAGAAGAAAAAACCCCTTCA +CTTCCTACAGATAGCTAAAGCCCTTGGGCTCGGGAAGAAGGAGAGGAAGACCTTAAAAAAGGTAATGAGA +AAGCTCAAGAAGGAGGGTAAAGTAAAGGTTGTAAAGGGTAAGTACGAGTACACGGGGGAAGAGGTGGTCA +CAGGAACCGTTATAGCCTACCCTGGAGGATTCGGATTTCTGGAAGTGGAGGGAGGAAAGGATATATACAT +ACCTCCCTTTGAAATGGTAAAAGTTTTTCACGGAGATGTCGTAAAAGCAAAAGTAACCGAGTTTAAAGGA +AAAAAGGAAGTAAGGATAATAAAGGTCCTAAAGAGGGCTAAGAAAGACATAGTGGCGAAGGTTGTTTTTG +AAGACGAGCAGTGCTACGTTGTACCCTTAGACGAAAACGCCCACCACCGTATCCTACTCTCAAAAAAGGA +CTGCCAAAAATTAAAGGAAGGTGAAGTAGTTGTCCTTAAGATAACCCAGTTTCCCACGAAGAAATCGCCC +GCGAGGGGGAAAGTTATAGAAGTTCTCGGAAATCCGAAGGAGAAGTTCATAGCGATAGACGTAATCATAA +GGAAGTACAACCTACCCACATCCTACCCTGAGAAAGTTATTAAGGAAGTTGAGGCAATTCCGGAAGAGAT +TCCCGAGGAAGAAATAAAGAGGAGAAGAGATTTAAGGGAGCAGTTGTGCTTTACTATAGACCCCGAGAAG +GCAGGGGATTTTGACGACGCTGTGGCGATAGAGCTCACACCCGAAGGCTACTATAAACTTTACGTCCACA +TAGCGGATGTGAGTTATTACGTAAGGGAAGGAACGGAAACGGATAAGGAAGCCTACAAAAGAGGTTTTAC +GTACTATTTTCCCGACAGGGCTCTCCACATGCTTCCTGAAAAACTCTCCGCAAAACTCTGCAGTCTCAGA +CCCAACGAAGACAAGCTCGCCTTTACCGTTGAGATGGTATTTGACGAGAGCGGAAACCTGAAGGCTTACG +ACATTTACGAGAGCGTTATAAGGAGCAAGGCACGCCTCACTTACAACGAAGCCCTTGCCCTTATAGTGGG +AGATCCAGCCCTTGAGAAGAAGTTCCCCAACCTCGTAGAGCCTCTAAGGATGATGGAGACCCTTTACAGG +ATTTTGAGCAGGAAAAGGTGGGAGATGGGGAGTATAGACTTTGACCTCCCCGAGGCGGAGGTTATCGTTG +ATGAATACGGTGAGCCCACCGCTATATACCCCTACGAGAGGCACGTAGCCCACAGGATAATTGAACACTT +TATGATATCTGCAAACGAGACGGTAGCCCTGCACCTTGAACACGCAGGATACCCTTGCCTTTACCGTGTT +CACGAACCGCCAGACGAAGAAAAGGTAGAAAACCTCTTGGAAATCCTCGAAGGACTCGGATATAAAGTGA +AGCGTCCACACGAGTACACTCCCAAGTTCTTCCAGAAGATAATAGAGGACTTTGAAGGAAGACCAGAAGA +AAACCTTGTCAGGTTTCTCACCTTAAGAGCTATGGCGAGGGCAAAGTACAGCCCTCACAACGTGGGACAC +TTCGGACTTGCCCTTGAACACTACGCCCACTTTACCTCTCCCATCAGGCGTTATCCAGACATAATAGTCC +ACAGACTCCTCAAGAAAGCCCTGAGAGGTGAGGAGATAGACTACGAGAAGACCTTGGCCTACCTCGAAGA +GGCGGGAAACCACCTTTCCAAGCAGGAGAGGATAGCGGACGAGGCGGAAATGGAAGCGATAGATTACCTC +AAGGCGAGGTACATGAAGGGAAGGATAGGTGAAGAGTTCATCGGAATTATCACGGGAGTTGTTGCCTTCG +GATTTTTCGTTGAACTTGAGGAGAATCTTGTTGAGGGACTCGTGAAGATAAACACGCTCACGGACGATGA +GTACGTATTTGACGAACCCGCTCACAGATTAGTTGGTGTGAGGACGGGAAAAGTTTTCAGACTCGGCGAC +CACGTGAAAGTAAGGTGCATAGCGGTGGACGAGGAAAGGGCAAGGGTGGAGTTTGAACTGATAGAAAAGC +TTGAAAAACACGAAACCTTATGAAAATTTTATAAATAAATGTCTAAGGATAAGGAGAGGAGAAGGAAAAT +ACTCCAGCTTTTGAAGGAAAGGGAAAGGACTCCTAAGGAACTTGCCACCGTATTCAACGTATCCCTGATG +ACGATTTACAGGGATATAAAGGAGCTTGAAAAGGAAGGTCTCGTTGAGAGAAAACACGGAACCGTTTATC +TGAAAAGGGAAACGGAGGACGGCAAGTGTGTTATATGTTCAAAGGAAGTGGACGAGAGGTTCAAGGTCGT +CTTCTTTTTAAAAGAGGATAAAAAAGTCTTTGCATGCTGTCCTCACTGTGGATTGATGGCTTTTAAAAAG +CTCGGCCCAAATATACAGTCCGCTCTGATGAGGGACTTTATAAGCTGTAATCCCGTTAACGCCTTTACGA +GCTGGTACGTGGTTGGAGCGGACATAAACCCTTGTTGCAGTCCTTCCGCCTTTTCCTTCAGTGCAAAGTA +CAACGCAGAACGTTTCGCCCAAGGGTTCGGAGGAAAGGTTTTGAACTTTGAAGACGCTGTTGAGGAAATA +AACAGACTCATGAGCTTTGGAACGAGAGTAAAATTTAACTTATAATGGCTACGGACTACCAAACCATCTA +CATACTGGGCGGGGGGATGCTTCTACAGGAGAGGAAGCTGGACGTTTCTACAAACAACATGGCAAACGTA +AACACTCCCGCTTTTAAAAAAGACTACCTCACGGCGGTAAGCTATTACGTCCCGAACGGACAAAAGGTTC +AAAACACAAACCCTTTTGAGCCTTCTAACAACTACGTCTACCCGATAGTGAATGAAGTAATACCCGTGCT +TTCTCAGGGAGCACTGGTCAAAACTGAAAATCCCCTCGATTTGGCCATAGAAGGTGAAGGCTTCTTTGCG +GTAAGAGGTCCGAATGGCATCCTTTACACACGAAAGGGCATTTTCAGGATAAACGAAGAAGGATTCCTTA +CTACGGAGGAAGGGTATCAAGTTTTAGACGAAAACCTGAACCCTATACAAATTCAGGGGCAAAACGTGAA +GATAACAAAGGACGGAACTATTTTTGTGGATGAAAATCCCGTGGGAAGGCTTGGCATATTTAACTTACAA +AACATTCAGAAACTCGGAGAGGACTTCTTTCAAGGGAATCCTACTCCCGCAACAGATTACAGAGTTTATC +AGGGATTTTACGAGGCTTCAAACGTAAACGCCGTGAAGGAAATGGTTAAGGTTATAGAAGCGGTAAGTGC +ACACGAGATATTTTCCAAACTCATACAAATGACGGACGAAGTCCAAGGAAAGTGGAATCAGTCCGTTTAA +GCTACGAAACTGAGCTCCATCTTGTCTCCGTACTTCTTTATGAGAAGTTTTTTAAGGTCCTGTAAGTTTT +CAAGGTTCGGGTTGTTCTTGAGGAGTTCTTCTGCGTCTTTCCTAGCAACGCCGAGGAGTGCTCTGTCCTG +ACTCCTCGCCAGATTTGCCACCCTGAAGCCAAAGTACCCAGACTGGGAAACTCCTATAATTTCACCGGGA +CCTCTTAGCTTCAAGTCTTCCTCCGCTATCTTGAACCCGTCCGTGGTTTTTACAAAAACCCTTAATCTCT +TTAGGGACTCGTTCTTCTCGTTCTTTATCTCGTCGGGAACTACCAAAAGGCAGTAAGCCTCCTTGTCGGA +ACGTCCGACCCTTCCCCTAAGCTGATGGAGTTGAGAAAGTCCGAACCTGTGGGCATCTTCTATCACCATA +ACCGTGGCTTCCGGAACGTCTATTCCCACCTCTATAACCGTCGTTGAAACGAGTATGTCTCCCTCCCTTT +TGAACTCCTCCATAACTGCGAGTTTTTCTTTGTCTGGCATCTTTCCGTGGAGGAGGAGAACCTTTCTGTC +GGGAAAGAGTTTTTTCCACCTTTCATACTCCTCCGTTGCCGCCTTAAGGTTGAGCTTTTCGCTTTCCTCA +ATTAGCGGGTATATCACGTAAACCTTGTTCCCTTTTTTTAGTTCTTCTTCAACCTTTTTGTAAACTTCTT +CCTTCTGGCTTTCAAAGTATAGTTTGGTAATGACTTCCTTCCTTCCGGGAGGTAGTTCGTCTATTATGGA +TATGTCCAGATCTCCGTATATGGATAGGGCAAGGGTTCTTGGAATTGGTGTTGCACTCATAACGAGACAG +TGCGGGTAAAGTCCTTTTCCTTTCTCAAGGAGGAGTTTTCTCTGCATGACGCCGAACCTGTGCTGTTCGT +CTATAATGACGTATCCTAAATTCTTGAACTCAACTTTGTCCTGAATTAGGGCATGCGTTCCAACAAGTAC +GTGAATATTCCCTTCCTTTACGTGTTTGTAAACGCTCTTCTTTTGAGAGGGTGTCAGACTTCCGGTCAGG +AGTGCTACGTTTACTCCGTAGTCTTTTAACATCTCGGAAAACTTTTTATAGTGCTGGTGGGCGAGAATTT +CCGTGGGAACCATTACCGCTACCTGATAACCACTTTTTACCACCGCAAGGGATGTCAAGATGGCGACAAT +AGTCTTACCGCTTCCCACATCCCCCTGAAGCAGTCTGTTCATTGGAACATCTCTTGAAAGATCTTCCAGA +ATCTCCTTTATGGCTCTTTCCTGTGCCCTTGTGAGTTTGAAGGGAAGTTTTTCAATAGCTTTTCTCAAGA +ACTTTTCATCTACGTTTACCTTGGGTGCTTTTTCCTTTTTTATTTCCTGTTTTTTAAGTAAAAGTGCGAG +TTGGAAGAGAAATAATTCATCGTATATCACTCTTTTGTGGTAGAGGTCGGTAAATGAGTTTAAGGCGTTT +ACGGAAATGTCTTTGGGATTGTGTAGCTCTTTTATGCACAGGGCTATGTCGGGAAAGTTGTACTTTTCTA +TTAAGTAATCGGGCATATACTCGGGAAAGTACCTGTAAAGGCTTTCAGAGAGAGCAGTTAAAGCCGTTCT +TACCCTCTTTTGTTTGGTTTTTGAAGATATCTCCTGAAGTTCCCCCCTTTTTCTCACGTAATAAACGGGA +ATTATCTTTCCGAGTTCCTCGCTGGAAGGGGACTTCACTTCCGGGTGAACCATGTACTTTTCCCCTTTGA +AGCTCTTCAGTTTTCCATAAACGACGATTTCCATTCCCTTTCTGAATGCCTTAAGGGCAAAGTGTGGGTT +TTTGTAGCGGTACTTTAGCGTTATGTACCCAGTTCCGTCTGTGCAAACGACTTCCAGAGTGTAGCGCTCA +TTTTCCTTTATCTTTACCTCTTTTACCTTTACCTTCAGTGCTACCTTTTCACCGACTTTCGCGGTTTTTA +TTGAAGTGTTTAGTCTCTTGTCTTCGTACTTTTCGGGAAAGTAAAAGAGTGCGTCGTAAACGGTTTCGAT +TCCGAGAGCTTTTAAAGTGCTAATCTGAGTTTTTGTAAGGATTTTTACTTTTTCTATCGGATTGAAAAAG +ACGTCTATGGGTTTTCTCTTTGTCTTTTCAAGGAAGTTTCCCTCTTTCTTCCGTTTTTCATACTCCGAAA +GGAACTTCCTTACTTCCCTCAGAACCGCTTTTTTCTTTTCAAAGGGAAGTTTGTCAACTTCTTTTAAGCT +TTCCAGAATGTAATCGGGAGCGTCTTCCTTCAATTTATTGAAGAGGAAAATACCTACACCGATAGCTCTC +TTCAACTTCAAACCGTCGTTTTCAAGGAGGTTGTCTATGAAGTCCTTTACAAAAGCGGTATCCATCTCAG +AAATCGAATTCTCTTACATATCTTAATTTATACTCGCGGGTGTTGTCCGAGTAAACGTTAAAGCTAAAGC +CGAGGTCAAGACTTCCTGGAGACCTTACCTCAGCCCCCCAGAAGGTGTCCTTTTTGTCCTTCGTTGAAGC +CGTTTGATAATAGAGGGAGAAGTAACTGCCAAGTTTTTTCTTCAGTTTTACCAGAGCACCGACTTCACCA +GTGGAACTGGTCTTTATACCTATTTCCACGTTAACGTCAAAAAGCCTTTCAATCGTTCCTTTAACGTACC +CTAAGGCTTTGAGCTCGTTTGCAAGAACCGTACCCACAGGCAGTATCCCCTCGTTCACACCTCCGCTTAT +TAACTTAAAGAGGATCTGTTCCCTGCTGAGAGGTGGTTCCGAGAAGTAGTAAACACTCGGATTTTCAGGC +GTTCCATGAACGAGCAGGAATATTTTATACCCGTCCGATACCGTATTCAGGTAAAAGTCAAACTCCGTAA +GCTCCTTATCTTTTTCCTTTAGGAGTTTAACGGTACTCCTTTTTACGAAAAACTTTCTCCCGAAGTATTC +CAGCCTTCCGGACTTTAAAACTACGTCTATCTCATAGTAAGGCTCGGGCAGTTTTCCGTAAATGCGACCG +TTTAAAGCCGTGTAAACCCTACCTTCCGGTAGTTTAACTATTAATCCATTTTCAGTTTTGAAATTGATGT +CCAGCGTAATCTCAACCGGTAAGGTCTTCTTTTCCTCTTCCTTTTTTTCCGGAAGTTTTTTTACTTTAAC +GTATCCATCGAGGAGGGTATCCAGGGTAAGGAATATCTCTTTAAAGTTTTTAACTACAACCTTCCCTTTT +CCGTCCGCTTCTATCCTAGCCCTTATCCCGTCTTTTAATTTTACAGGTAGGTTTTTATAGACGAATTCAA +CCTCAAAGTCCCTGAAATTTTTGGATATAGCGTAGGCGTTTAAGAAACCTTCTCTGAACCATCCCGTCAA +CGCAAAGGCGAAGAAGTCTTTTCTTAACTCAAGGTTCATAGCGCTACCGAAGGGCTCGTAAAAGTAAAGG +GAGTTTATCCTAACGGGTTCGTCGTTTCTGGCAAGGAACTTAAGCTCGTTTCCATCAAACACAAACTCGT +AATCCAGTTTACCGAACATCTGAGATTTCATCAAAGAACCTATGTGTTTGGAAAGCAAAGTTAAGTTTAG +AGTTCCGGAGGATTTGAGGTATAGATTTCCTTTGTAAGCTATATTCAGGACTCCGTTAAGTACCCCTGTT +ATCTTAACGGGTTCAAAAGAAAAATTCTTTGTTGTTCCCACACCTTTTGAGGGCGAAATACTCAAGAGTT +TTTTGTCCAGAAGTGAGACATCAAGTCCTTTAAATTCTACAGAAAGATTTTCCTTTTCCAAGAATACATT +TAAACCGTTGAACCTGTAATTAAACCTTTTTCCTCTCAATTGAGTAGGAAAGAGTGAAATTTTTACCTGA +TCTTCTTTGGTTTCAATCTTTCCCTTTATCTTTATTTTTTCCCTTAGAAGTGCGTAAAAAGCTTCAAAGT +TTGCTTTAACATCTTTGTTCTTTATCTCTCCATTTAAAGAAATCCCGAACTCTTTTTTATCAATCTTTCC +ATAAAATTCTCCAGATCTTCCAGAAATATAGTAAACCACTCTAAGAATTGAGTCCTTAGAAGCCCCGAAT +ATCCTTAAGTTGTTATCAAGCAGTAAAAGTGAATACTTGAAATTTTCAAGAACGCTTTTTTCTTTAAAAC +GAACGTTTAATATCCCGTTTCCTTCTAAAGTAATTTTCTCATTTTTTTTATTAAAATTAAACTCTAACTC +AGTTTTTGCATATATATTGGATAAGTTAAGAGCTAAGTCCCCAAGCTTTCCTTTTGAGTTTATACTTTTT +CCCTGAATTGAGAACTCAATACTTCCATGAGAAATTTTTATACTCTTTTCTTTTCCTTCTAAACTAAAGT +TGTTCAACTGTATAAATCCTTTCAAATTATCAAACTTTCCTTTAACGAAACCAAAGGAATTTCCATAATA +AACGAGTGCTTCAATTTCTTTATCTCTTATCTTTACATCAGAGGAAATTCTCTGCAAAGAGAAATCTCTA +AATTGTCCATTATTTGCAAAAATTTTGGCTTCCATTTCGAATATTTTTCCTTTTTTAAACTTACCCTCTC +CCGAAAGGTAAGCGTTGAAATCCTGAAATACTACAGGAAAGTCATTAAAAGAAAATTCTCCTTCTAATTT +ATTCTTATTAATAATTAAATTCCCCTTCGCATAACCCGAGTTTTTAAACTCAAAATTTAAACTTCCGTTT +CCCGAAAAGTTGTAGGAAAATAAGACATCACCTTTAAATTTTTTATCAATAACCTCTAAGTTTTCCGTAA +AAGCGTTAACTTTAACAAACATTTTCTTGAAGTCTACCTTTCCGTTTCCGTGGAACTCCCCTCTTATTTC +TCTGTTTATCCCGAGAGTATTTTTATCCACTACGAGGTTTTCAAAGGAAAATGTAAGCAATCCTTCGGGG +ATTACATCGTAAGTGAATTTTATCTTAGTTCCTTCAGGGTTTACTGCTTCCCCTTTCAAGAAAAGCTTAT +CAAATAACTCGTAATTTCCCTTTACTATCCCCTCAATAGATCCGTAGTTTTTATTCCTTACGATTAAATC +TTTTACAAATGCCTTTGCATTTATGTCCAGAACCGGGAGGTTTATCGTACCCTTTGCGTTTATCTTCGTC +CCAGAAAGGGTAAAGTTTTCTTTTCTAATTTCTTTTATCTCCACTTCGGCTAGGATTTCTCCCGTATTTC +TCTTTATTTCTCCCTTTGTTTTTGCAGAAAAATACTCACTGTCGAGCAATAAATCTTTAAGGGTTAAGGT +ATCCCTTTGGATTTTTGCTTTAATACTTCCGTTTAATGTGAAGCTTCTTAAATTTGTGTATAAAAATTCT +CCTTCTAATTCGTTATTTATCAAACTTGCGTCTTTTACAATAACTCTGTTTACTCCTCCTTCATTCCCCG +TCCATACATCCAAGTGCCCGATTTTCAGGTTAATTGGAATTTCCCGAATCGGAATATTTTTCAGTAAAAA +TTTTTTCTTTTTCTTTCTCTTTTTAAAACTAACAACTACCACTTTTCCCTTTTCAATTTTTATAATTTTC +TCGAATTTAATGTCTTTAAAATTCAGGTATAAATTTAAACCGAAAAATCTCTCAAGGTTAAGAATTAATT +CTTTTACAGTTCTGGTTCTAATATCTAAATCTAAATCTAAGTAAAAGTTCTTCTTTCTCAGAAAATCGTA +AACGAACAGGGAAAATAAGGTAAATAAAAACAAAAGGAAGGTAAGGAAAAAGCGCATTTATTTTCTTATT +CTACACCCATCATCTTTAGGTGAATCTTTATCTTGTGAAGTAGGTCTGCGGGGTTCTTAACGGGGTACTC +TATCTTTTCTACCACTTCTTCGGCGGGCATACCTTTTATTACTACACCCTTGACCTTTTCCTTAAGTTCC +TCAGGGGAGTTAATGGGGAAGTGAGTTCCTTTTATCTTCTTGAGTAGCAGGTATGCCCAGGGAACTTCTA +GAGCTTCGGCGGCCATCGTACAGAACTCGAGGAATACCTTGGGCTCTTCTCCTTCTTTGACTTTCTTGTA +GGCGAGTTTTGCTATACCGCCTGCGGTGTGAACTCTGAGTTCTTTCTTTTCTTCCTTCGTAAGTTCGTCT +ATGTGCTGTATCTTGTAAAGGGCGAGTTCAGGGTCGGCTCTCAAGATATTTCTGACGGTCTGTCTCGTGA +GTCCTACGAGTTCGGCGATTTCTTCCTCTGTTTTTAGAAACTCTTCCCTGTAAACGATAACGAACGCAGC +CCTCGCAAGGGAAGGTAACCACGTTAGAGTCCTGTACTCGGCGAGCTTGTGAAGCCCTCCCAGAAGGTCA +ATAGCTTTGAGAAATACTCTCGTGACTAAAGACTCAACGTCAACCTCTACGGGTTGAACCTGTACTACCA +TGTTCCACCTCCTTATTTTTCTTGGTGCTAAATATTAATATAACCCCCAATACTTTTTACGTATCCGATA +AATTGTTTATAAACCTCGTCGGAAGATAAGGTTTTTTCGTTTCCTAGGGTTATGAGTTTTCTTCTCGCCC +TAGTAAGTGCAACGTTTAACCTTCTGTAATCCTTTAAAAATCCTATCTCACCCTTTTCATTTGAACGCAC +GAAGGAGATTATTATCACTTCCTTTTCCCTGCCCTGAAAACCGTCAACGGTTTTAACTTCCACTTCAAAA +TCCTTTAAAAGTTCCTCAAGGAAGTTAACTTGATCCTCGTAAGGGGAAATTACGCCTATGTGTTCGCTTC +TGAGTCCGATTTTCATTAAGTACTCTACTATCTTTACCGCAACCTTTGCCTCTTCTTCGTTGTAAAAGGA +TGTGCTTCCCCTTCTTTGTTTTTCCTTTCCTCTTACGTTTATAAAAACTACTACCTTTTCCGGTTCCAGT +ACGCTTTTGAAAGGTTCAGGGATTTCCTTCAGTTTTTCTGGATTAATTAGATCTTTTATTGTGTGATTTT +CAACACTTTTATCCGCAATGAGTTTTCCTTCGTAAAACATTTTGTTGGAAAACTCCATTATTTTCTTGTT +CATTCTGTACTGAATTCTCAAAATTTCGTATATTTCTTCCCCGTAAAGGTCTAACAGTCTCTCGAAGAGT +GTGTAAGAGAGAGCCTCTTGAGCTTCTTGACTGAGGACCGTTGGAGGTAATTGTTTGTGATCTCCAGCCA +TTATGAGTTTCTTGCCTTTTATTAAAGGGATTAAACAGGAGGGTTCTGTTGCCTGAGTAGCCTCGTCTAT +GATTACAACGTCAAAGTTCAGGTTCTGAAGTACTTCGCTCCCTGCGGTTGAGTTTGTGGTACACACAACC +TGTGCCCTTGAAAGTATTTTGTTTACCGCCTTTTCTTCTTCTTTTTTGGCTTTTTCGTAGAGTTCTTTTA +CCTTTTCCTGTAGTTTTATCCACTTTGCCATACTCCTGAGGATTTTGGGAGAAAGACCTCTCACGGGTGT +TCCCGTTTTTGCCCTTTTTAGTATTTCTTCGTCGGATAGCCCTCTCCTGTACCTAGGTTCAGGTTTTACG +TACTTTTTTTGCTCCTCTTTTAAGTTGTCTATTTCTTCGTAAATCTTTCTCGCTTTATCAAATTCTGGTT +CAAACTGAACAAGGTAATCAAGCGTATGCCTCTGTATAGTTTTTAAAACTCTTACGGGGTTTCCAACTCT +TACTACTTTTACATTTTCCCTTACAAGTCTTTCCACGAGGTTGTCAACCGCAACGTTTGAGTCGGCGGTA +GCGAGGACTTTATAACCTTCTTGTGCAAGCCTTTTTATGCATTCCACTAAAGTGGTGGTTTTTCCCGTTC +CGGGAGGACCGTGTATGAGGAATACTTTTTCGGCTTTTAAAGCCCTTTCAACTGCCTTTTTCTGATACGC +GTTGAGTTTTGTCATTCCTGATTTATATACTAAAACACTGATGTGCCCCTTAACACCTGTAGGTAAGTAC +TTATTACTGCCCTTGTGGCTAGGTGTAAGGCCCTTCTTCAGAGCTCTCTTTAGGATTGAAGTGATAGGGA +AGGAGAACATTCCGGAGGGAGCGTGTATTGTAGCTTCAAATCACAGGAGTCATTTAGACCCTCCCGTTTT +GAACGCAGTGTTTCCGGAACCTCTGGTTTTTCTTGCAAAGGAAGAACTCTTTAAACCTCCCTTCGGCGGA +ATTTTAAAGCACATGAGAGCTATACCCTTAAGAAGGGGCTCGGAAGATATATCCACCTTGGAGGAGTGTG +TAAGTTTACTGAAATTGGGCTGTAAGATCGGGATATTTCCGGAAGGCACGAGGGCAAACCCCGGGGAGTT +TAAAAGGGCAAAACCGGGGGTCGGTTTCCTCGCAATAAACAGCGGTTTTCCCGTTCTCCCCGTTTACATA +GATGGAACAGACAGAGCTTTCCCGAGGGGGAAAAAGTTCCCAAAACCCTTCGTAAAGGTAAGTGTGGTTA +TAGGAAAACCTTTGGAATTCAAGGGTTTAGAACCCAGCGTTAAGAACTACAAGAGAGTTGCAAACGAGAT +AATGGAAGAGATTAAAAAGCTCGCTCAGTCCTTGCACAGGAAGTAAAAGTAAACCTCCTTTGCTCCGCTT +TCAAGGAGTGTTTTTGATACACTCTTCGCAGTGCTTCCCGTAGTCAGGATGTCGTCAAACACAAGAACTC +TTTTTCCCTTGACATTTCCCCTTACTTTGTAAGCACCTTTAAGAAGCCTTTCCCGTTTGCTCGCTTTGTA +CTTTGCAAGGGGACGGGCGTACTTTACTCTTCTTATTACCTTTTCGTAAGCCACTCCTAAGTGTTTCATT +ATTTCCTCGTTGTGGTCAAATCCCCTCGTCCACCACCTGAAAAAGTGAACGGGAACGAAGGTAACGAGGT +CCGGTTTTACCCTCTCAAGGTATTCGTAAAAGTGAGTCTTAATTTTTTCCGCGAATATCTTTGAGAAGGG +TTTTACGGAGTTGAACTTGTAGAAAAGAATGGCTTCCCTCAGGACACCCTCGTACTTTCCGAAAAACTCG +TAATCTTCAAGGTAGGAAATTTCAGGCAAATCTTCAAAAAACTCGTGTGGCTTTATACTCTCTATACACT +CCTCGCATATAAAACCCTGATCCTTCGGCTTAAAAGGCTTTTGACAAACCTTGCAGGTATTTTCAGAGAG +AAAGAGAAGGTCAAGGAGCCTACCCAACAACTTCATAAGTCCTGTACTTCCACTTTGCCCCTAAACTCTT +TGCGAGTTCTTCCGTTTTTTTCATATCTACACCGTCATAGTCCACCGCGGAAACTATGACCTCAAAGCCG +AGCCTTTTTGCTTCCTTTATGAATTCTATTACTTTTTCGAAGGCGTCTTTCTGTGCAGGTCTGCAAACTG +CGTTATACGTTTCTGGATCAGGAGCATTCAAACTCACAGAAAAAGTATCCACAATTCCTTTCAACTCCTT +TAATTTCTCCTTCGGAAGGAACGTAAACATAAGGCCGTTAGTGTCAACTCTCACTTTTCCGCCTCTTTCC +TTTACCCACTTTGCTATTTCTTTGAGTGCTGAAAACCTTAAGGTAGGCTCTCCGTATCCGCAAAAGACTA +CCTCTTCGTACTTTTTAGGGTCTCCTATTTCCCTTATTACCTCTTCAACGCTCGGATCCCTGTCCACCCA +TACCCAGTGCCCCTTTACCCAGAAGTTTCTCTCCCTTTCCCTCTGGCAAAATACGCAGTGGAGGTTACAC +TTATTCGTTAAGTTTATGTAAAGCTTGTTGTTTATCACGTACGTTATTGTGTTTTTTTTTACCTCGCCGT +TTAAGTTAAAGGCGAGTTTGGCATTCTGTGTAGTCATCCTGTCCACGTCTTCCAGAGAAGTGTTAGGAAG +TAGCTCTGCTAAAACCTGAGCGGTGTAGAAAATATTGGTAGGCTTGTTGGGCTTACCCCTTACGGGCTCT +GGTGCTAAAAATGGAGAGTCCGTTTCGAGGAGTATCCTTGAGGTAGGTGTCCTTTTCGCAACTTCCCTTA +CACTTTCGGCGTTTTTGTAAGTGAGTATCCCAGAATAAGAAATGAAGAAGCCCATATCCACGGCTTTTTT +CATGGTCTCATATGAACCCGTAAAGCAGTGCATAACTCCCCCGACTTCGTATGCCCCTTCTTCCCTCAGT +ATTCTTATAGTTTCTTCTTCTGCATCTCTCATATGAATGACAACGGGAAGACCAAGTTCCTTCGCTATCT +GTATCTGCTTTCTGAAGATTTCCTCTTGTTTCTTTTTGTCGGAGTAGTTCTTGTAAAAGTCCAGTCCTAT +CTCTCCGATAGCTCTTACTTTAGGATTTTCTTCCGCGAGCTTTTTCAACCAGTCCAGGTCTTTATCGGTT +ACCTTGTCCGCCTCGTGGGGATGAAAGCCAATCGCTATGTAAACCTTATCGTAATTCTTAGCAAACTCTA +TGGCATTTTTAATAGTCTTTCTGTCAAAACCCACGTTTATCAAATACTCAAGTCTTTCGTCTTTGAAGGC +TTCTTCCCTGTCTTCCTTCTTTAAGAGGTCTAAATGGCAGTGCGTGTCTATCATGGGATTAATAATATAA +GAACGGGAATTTTTGAATGGTAGGCGGGGCGGGACTCGAACCCGCGACCTCCGCCTTGTAAGGGCGGCGC +TCTCCCAACTGAGCTACCCGCCTTGTTTATAAATAAAAAAAGAGTGGCACCCCCGGCGGGATTTGAACCC +GCGTTTCCGGCGTGAAAGGCCGGCGTCCTAGGCCAGGCTAGACGACGGGGGCTACCACTCTTCCGTTTTT +CTTATCACCCACCTGACAAAAACATATTATACATAACCACAAATTTCTTGTCAAGACTTTAAACTTCTTC +TTTCATTCTCTCTATTAGCTCCTTAATTACCTCGTCCGCTTCGGGGTTTTCTTCCCTTGCTATTATTAGC +GTCTCTCCATCCCTGTCCAGAACGAGAGCGTAAAGCTTTAGTTCCTTAACGTCGTTTTCTAGAGCTACCT +TCGTCAATCTAGATACGAAGTTCTCAACACTTTCTGCATCTTTGGGGTTTACCCTTTGCTCAAATACATC +TACACTTTCTTCGTCTACTTCTTCCTCCTTAGGTATAAACACGGCGTAAACGGTTGCCTCTTCGGATAAA +CCGGTTTTTTCTAAAAAGCGTTTAAAGAGTTCTTCAACCTGTTGTCTCATTAAGTGCGTTATGCTCATTT +CCTTACCTCCTTGTTACTCATTAAGTATTCGTGTATGTACTTTGCAGCTTCTTTTCCATGAGCAAGGGCA +ACTACTACCCTGTCACCGCCGTTTATAACGTCTCCTCCCGCAAATACTCCCTCTAAATTGGTCTCGTACC +TTTCGTTCACCTCAATCGTCCCCCACTTCGTCGTTTTTATTCCGCTTCCTTCGTAGGCTATTGGGTTTGC +CCTCTGCCCTATCGCGAAGATAACCGAGTCGCACTCAATAATGTGTTCGGAATTAGGTACTGGAACGGGT +CTCGGTCTTCCGCTCTCGTCGGGCTCACCCAGTTCCATCTTTATACACTTGAGCCCTACAACTTCTCCTT +TTTCGTTCCCTATAACTTCCACGGGCTGGGTTAGCCAGTGTATCTTCACTCCTTCTTCCATAAGGTGATC +CCACTCTTCCTGTCTTGCGGAAGAGGTTTCTCTGGTTCTCCTGTAAACTACGTGGGTCTCAACTCCCAGT +CTGTTTGCAGTTATGGCACAGTCTACCGCAGTAAATCCACCGCCTATTATTACGGTTCTCTTCCCGAGTT +CTACGGGAACTCCCTTTTTAGGAAACTCGTTTGCCTTGTAGAGGTTTACCCTCATCAAAAAGTCTATCGC +GGAATAAACCCCTTTCAGGTGGTCCCCCGGAAGTCCGAGTTTTCCTCGTCCCGCACCAACCGCTATGAAT +ACAGCGTCGTATTTCTCCCTCAATTCCTGAAGGGTTATGTTCTTTCCTATTAAGTATCCGTAAAAAAACT +TTATCCCGAGTTTTTCAAGTCTCTTGACTTCCCACTCTATTATGCTCTTGTCCAGTCTGGCGTTGGGAAT +TCCGTAGTACATAACACCGCCGGGCTTCGGGAGAGCTTCGTAAACGTGCACTTCGTGTCCTTTTTTTGCA +AGCTCATGGGCACAGGAAAGCCCCGCTGGTCCCGCCCCTATTACCGCAACCCTAAATCCCGTAGGGGGTT +CCTTTTCTTCTTCTATTTCTATTCCAGATATCCTTATAAAGTCTCCTACGAACTTCTCAAGTGCTCCGAT +TGCAACCGGAAGACCTTTGTTCTTTCTATTCCTGACCGTGTCGTAGTAAAGGATGCATGAACCTTCACAC +TGCCTTTCCTGAGGGCAAACTCTCCCGCATATTGAGGGAAATATATCGGATTGAGTTATTACTTTGTACG +CACCCACCAAATCACCTTCCGTTATTTTCTTTATAAAGCCGGGAATGTCCACGTGAACGGGACAGCCCTT +TATGCACCTCTGTTCGGCGTCTTTACAAAATAAACAGCGCTGTGCCTCGTCAAGGGCTAAATTTACGGAG +TATCCGAGTTCAAACTCCCTGAAGGTTTTTACCCTTTCTTCTGGCGGGAGAGTGGGTTCTTTATTCCTGT +CAAGGTAGCGAATCTTCTTTGCCATAGGTTAAGATGATAAACTCTCCTTTAAGATATTCAAGTTATGGAA +TCATTAAAAGAGACTCTGGAAGCTTTCGTTGAGGGGTACGGATACATAGGTATATTCTTAATAGCCTTTA +CGGAAAGCATAATCCAACCAGTTCCTCCGGATCCATTTATAGCCGGAGCGACAGCCTTCGGGTTAAATCC +CTTAATTTCGGCCCTCGTTGCAACCTTGGGAAGCGTTCTAGGGGGACTCGTTGCCTACTTCCTCGGAAGA +GTATTCGGTGAACCTGTAGCAAAAAAATTACTCGGTGAAGAGAAATTTTTAAAAGCGGAAGCCTTTTACC +ACAGGTACGGAGTCTGGGCTGTCATAATAGCTGGCTTGACTCCCATACCCTTTAAGGTATTTTGCTGGCT +TTCGGGAATACTCGAACTAGAAGTGGGGAGGTTTACTTTGGCTTCCTTTATAGGCAGGTTTCCGAGGTTT +TTCCTCTTTGCCCTGTTTGGACACTCAATTCAGGGTTTCCTATAAAATATTTCCTTATGAGTTTCTTAGT +GTTTGTAAGCATGACTCCGCTCGGAAAAGGAGAGAGTGTAAGCCAGTACGTTGCGAGGGTTGTTGACATT +ATAGATAAATCCGGACTGCCTTACGTCCTCACTCCCATGGGAACGATAATAGAGGGAGAAGACTGGGACG +AGGTTATGGAAGTTCTAAAAAAGGGCTTTGAGGCACTGAAGGAGGACTGTAACCGTATATCTATAACTAT +GAAAATAGATTACAGGAAAGGAAAGAAGGGAAGGCTTATTCAAAAGGTTAAATCCGTTCAGGAGAAGATA +GGAAGGGATATAAACATAGCTACCGTTGAAGAAAAGAAGGAATGAATGAGTTAATAGAAAAGGCTAAGTT +CTTCAGGAAGCCCTGCCTTACATACGGGAATTTCACGGAAAGGTTTTCGTGATAAAGTACGGCGGTTCCG +CAATGCACGACGAGGAACTCAGAGAGTCCTTTGCTAGAGACGTGGTTCTTTTAAAGTACGTGGGAATAAA +CCCGGTAATCGTTCACGGAGGGGGACCACAGATAAGCAAAACACTGGAGAAATTCGGTATAAAACCCAAA +TTTGTAGGGGGAATGAGGAAGACTGACGAGGAGACAATGCACGTAGTTGAGATGGTGCTTTCAGGAGACA +TAAACAAGGACATAGTAGCCCTTATAAACAGATACAGTGGGGAAAAGATTTACGCGGTCGGACTGTCGGG +CAGGGACGGAAGACTCTTGAAGGCTAAAAAGTTAGACAAAGAGAGGTATTTCTCCGAACTCGGGCTTCCC +GTTCCTGAGGAAGATATCGGGTTTGTAGGGGAAATAGTGGACGTAAATGAAGAGCTTATATTTACTCTGC +TTTCCCACAACTTCATCCCAGTAATAGCTCCCGTGGGAGTAGGGGAAGAAGGTGAGGCTTACAACGTAAA +CGCGGACCTCGCAGCCTCGGAAATAGCGGGAGAGATTAAAGCGGAAAAACTCATATACCTTACCGACACA +AAAGGTGTCCTTGACGAAAAGGGAGAGTTAATTTCTTCCCTTTCAAAGGATAAGGCGGAAGAATTAATTA +AGAAGGGAGTAATTAGGGAGGGAATGATTCCAAAGGTTCGTTCCGCCCTTAGGGCACTTGAGAAGGGTGT +TAAAAAGGTTCACATAATAGACGGGAGGGTGAAGCACTCTATACTCCTTGAGGTTTTCACAAAGGAGGGG +GTGGGAACTGAGATTACTCTGGAATAAATTAAAAAATTTATGGAGAAGTTCGTAGACAGAGTAAAAATCT +TCGTGAAAGGGGGAAAGGGCGGAGACGGAGCAGTAGCCTTTTTGAGGGAAAAGTACAGACCGAAAGGAGG +ACCTGCGGGAGGAGACGGAGGAAAGGGTGGAGACGTTATCTTAGTTGCTACGAGTTCAAAGCACACACTC +CTTGACTTTAAGTATAAAAAGCATTACATAGCCCAAAACGGAGAACCCGGAAAGGGCAAGAAAATGCATG +GAAAGGACGGAGAGGACCTCATAATCTACGTTCCCGTGGGAACTGTCGTGAAGGACGCACAAACAGGGGA +AGTTATTTGCGACCTAGTAAAGGAAGGACAGAAGTGTATCGTTGCTAAAGGCGGAAAAGGCGGAAGGGGA +AACGCAAGGTTTGCAACTCCTACAAATCAAGCACCTACCTACGCGGAAAAGGGTCAGAAGGGCGAGGAGA +GGTGGATAATCCTTGAACTGAAGCTCATAGCGGACGTGGGACTCGTCGGTTTTCCAAACGCAGGAAAGTC +TACGCTCCTTTCAAGGCTCACGAGAGCAAAACCAAAAATTGCGGACTACCCTTTCACAACCTTGAGTCCG +AACTTAGGAGTGATGGAACTCGATTGGGAAAGGAGACTCGTTATAGCGGACATTCCGGGACTGATAGAGG +ACGCCCACAAGGGGGCAGGACTGGGACACGAGTTCTTAAGACACATAGAGAGAACCAAGTTCTTAGCCCA +CGTGATAGACGTATCTGACTTCAGGGAAAGAGAACCGGTGCAAGCTTTTGAAGCCATAAACAGAGAACTG +GAACTATACAGTCCGAAACTCGCCCAAAAACCACAAATCGTCGTGGCCAACAAAATAGACGCTTTGAGTG +ACAGGAGTTTGCTTTCAGAGCTTGAAAAGTACTTCAAGGAAAAAGGTTACGAATTTTACGCGGTTTCCGC +ACTCACAGGAGAGGGAATAGAAGAATTAAAGGAGGGTCTCTGGAAGAAGTACGAGGAAATAAGAGACAAA +GAATCCGCGCAAGTAACCTGAACCTTTTGATGTAGTTTATATAAATATGCTTCAAGTAAGAGTAAAACCC +GGAGTAGAAGACAGGATTAGAGGATTTTTCCCTTGGGTTTACAGGTCGGAAATAGCTTCCTTTTCAAGAA +AACCAAAGAAAGGAGAGATAGTAGTCGTAAGGGACGTTAACGGAAAGTTTCTGGGCTACGGCTACATAAA +CCCTGAGGTAAACATAGCAATAAGAATTCTATCCTTTGACAAAAACGAGCCCGTAACTCCTGAACTTATC +AGAAAGAGAATAAAGCAGGCCTACGAATATAGAAAGAGACTTTACATAAACAGCAACGCTTACAGGCTTG +TGCACTCGGAGGGGGATCTCCTCCCTGGACTTATCGTTGACGTTTACGGGAGTTATCTGGCGGTTGAGTT +TACGACTTACGGTATGAACCAGTTCAGAGAAGTAATACTGGACACACTCGTGGAACTACTAAGACCTAAA +GGCATATACGAGAAGGTCAATGAAATCGCAAAGAGAGTGGAAGGCTTGGACGTAGAGGAAAGGGTTATTT +ACGGAGAAGTTCCCGAAGAGGTCATAATCTGGGAACACGACCTCAAGTACTACATAAATATACCTCAGGG +ACAAAAAACGGGATTTTTCCTAGATCAGAGAAATGCGAGGAAGTTTGTGAGAAACCTGGTTGAACCAGGA +GACAGGTGTCTGGACGTATTCTGTCACACGGGCGGATTTGCCCTGAACATGAAAAGGGCCGGAGCGGGAG +AGGTTATAGGAGTAGACATATCCGAGCTCGCCTTAAAGGAGGCGGAAAAGAACGCGAGACTCAACGGCTT +TACGGACATAAAGTGGGTAAAGGCAAACGCTTTTGATTACCTGAGGGAACTCGACAAGAAGGGAGAGAAG +TTTGACGTAATAATCATAGACCCTCCTTCTTTTGCGAAAAACAGGGCGGCTGTCCCGAACGCCTTGAGGG +GATATAAAGAACTCTGTGTAAGAGGGCTGAAGATAGCAAAGAGCGGGGGTTACCTCGCTATATTTTCCTG +CTCCTTTCACATAACCGAACAGCACCTCCTTGACGTTTTACTTCAGGCTTCCTACGACGTAAGGAGACAG +GTAAGGGTAATAGCAAAGACCTTTCAGGACCTGGACCACCCGTGGATACTCCAGATGCCAAATACCTTAT +ACTTAAAAGGCGTGTGGGTGGAAGTGGTATGAAGAAGCACCACTGGGCACTCGTTTCCTTCGGCTTCAAC +ATTTTCCAATCCCTCATAAAGCTTGTAGGAGGGCTCCTGACGGGCTCCCTTTCACTTATCGGTGATGCCA +TACACTCCCTTTCGGACGCCACCGCTTCGCTGATAGCCTTTTTATCAATAAAGTTTTCCGAGATAAAGAG +TGAGAGATTTCCCTACGGACTCTACAAGCTTGAAAACATAGGTGCCATAGTAATAGCCTTCTTTCTGCTT +TTTACCGCCTGGGAAATTATCCAAAGGGCTTTAAAGGGAGAAATAAATATAAACTTTGAAAACCTTCCCA +TAGGTATAGGGGTAACGGTTCTGTCTTTAGTTCTCTCCCTCACCCTTTCTTTTTTAGAGAGGAGGGCGGG +AAAGAAGTTAAACTCTCCCACTTTAATAGCGGATTCCTACCACACCTTAACGGACGCCTTTTCATCCTTT +TTAGTTCTCATAAGCCTGAGCTCTTATTACTTCGGTATTAATATTGAACGATACGTAGCTGTAGCTGTAG +CTCTAATAATCGTTTACACAGCCTTTGAACTCCTTAAAGAGCAAATTGGTGCTATTCTGGACATATCCGC +GGATAAGGAAACAGTTGAGAAAATTAAAAGGATAATACTTTCTTTTCCCGAAGTTAGCGAAGTAAAGAGA +CTGCTCGTTAGAAACGCGGGCGGAAGGTTATTCATAGACGCGGTGATAACTATAAATACAGACGACTTTA +TAAAGAGTCACGCGATAGCAGACGAGATAGAAAGGAAGATAATGAAGGAAATTCCGAACGTTGACATGGT +GTTTATTCACTACGAACCCTGTTGCGTTAAGAAGGGGACAAGCGTTGCTGTGCTCGCAAAAGACGGAGTG +GTTGCAAGGTCCTTTAAAGACGTGGACAAAATAATAATCTTCAAAGAAAACGAGGGAAACCCCGAAGTTA +TAGAAACAAAAGGTATGGATGAGGAGTGCATAGCCAAAGAACTCGCAAGGAGAAACGTGGACATAGTTAT +AAGCGGATACCACCCCACCAGTAATAAGGCTAAGTGGATACTCCACAAAAACAACGTGTTCGTCTGGGAA +ACGGAAAAGGAAAATCCCTACGAAGCTCTCTCTGAAGTGTCCCAGATAAAAGAAGCTGTGACATGAAGTT +CCTCGTCTGGGGACTGGGAAGAAGCGGGAAAGGCGCACTGAAACTTTTGAAGGAGAGAGGATTTGAAGTT +TACGCAGGAGACGATTCCCAAAATCCAGAGCTCTGGAGAGAAGTTCTCGGTGAAGTGGACACCGTAGTTC +TCTCCCCCGGTATTCCGCCTTCTCACCCTCTCTGGAAAGAAGCCCTGAAGAAAGAAAAAGAAGTCGTAGG +GGAGCTTGAACTCGCATACAGGTTCTTTAAAGGGAAAGTAATAGCGATTACGGGAACGGACGGGAAGTCC +ACAACAACGAGACTCACTTACTTAATACTTAAAAAATTCTTTGACGAAGTCTTTGAAGCCGGAAATATAG +GAAAGCCTTTTTCCGAAGTTGTTCTTGAAAATCCAGAAGGTATAGCGGTTCTTGAAGTCTCCTCCTTTCA +GGGGAAAACCCTAAAGACCTTTAGGCCAAATATTGGGGCCTTTATCAGCTTTTCTGTGGACCACCTAGAC +TGGCATCCTAGTATAGAAGATTATTTAAAGAGTAAATACAGGATATTTGAAAACCAAACGGAAGAGGATT +TTTTAATACTGAACGACCTCGTTTATGAAATTAAAAAAACACCAAGCAGGGCAAGAAAAGTACTCTTTTC +TGAGCTATACATAAACTCGGACAGCGTTTTTTACAAAGACATAAGACTTTTTAACCCTAAAAACTTGAAA +ATAAGGGGACTTCACAACGTTTACAACGCAAGCGTAGCGTCTCTGATAGCACTTACTCTGGGTTTAAAGC +CCGAGGATTTTGAAGAAGTGATTTACGAATTTCGCGGTCTTCCACACAGGCTGGAATTTTTGGGAAATTT +TAATGGAGTTGAAGTTTATAACGATTCCAAGTCCACAACTCCCCACGCCTTAATGCACGCTCTGAAAACC +TTTCCCGACAATTCAGTTATTCTCATAGTTGGGGGGAAAGACAAAGGAGCAGACTTTTACTCCCTTAGGC +ATATAGTTCAAAAAAAGGTAAAAATCGCCCTTGCAATAGGAGAGACAAAGGAAAAGATAAAGGACTCTTG +GAAGGATATCACCGAGGTGAAAACATGTAACACTCTGGAAGAGGCGGTAAAGCTTGCGAGAGAAGTATCT +AAACTCGGAAATGTAGTTCTCTTTTCGCCCGCCTGTTCTTCCTTTGATATGTTCAGGAATTACGAAGAGA +GGGGAGAGAAGTTTAAGGAACTTGTAGAAATATGGTTCACTCGGACTTAGTCCTTTTTATAAACTCCCTT +ACCTTTTTAAAATCTTTCTTTCCCTTTTCCTTTTCAACTCCCGAAGATACATCTACTCCGTAAGGTTTTA +CAAACTCTATTCCCTCTTTTACGTTTTCGGGATTAAGTCCTCCTGAAAGGAATACCTTATGGCCTTCTTC +TACGAGCTTCTTAGCAATTTCCCAGTTAAAGGTTTTTCCCGTACCTCCGTAAGCTTCTTTTGAAAAGGTG +TCAAGGAGTATGGCATAAGCTTTTTCCCACTCTCCTACTTTCGGAATTTCTTCCTTTACTCTGAATACTT +TTATTACCTTATCCAGTCCAACCCTTTTCCCCAGTTCTATGTCCTCATCTCCGTGGAGCTGAATGAGGTC +AAAGCCTTCGTCAAGGAGTTCCTTTATAAACTCGTAAGGTTCGTTTACAACTACCGCGACTTTTTTAACG +TTTAATCCTTCAAGGGCTTTTATTATTTCCAGTCTTTTTTCTTTTGACGTGTATCTGGGGCTTTTGGGGT +AGGTTATAACGCCTATATAGTCCGCTCCCTCTTTGGCACAAAATAGGGCGTCTTCAAGGTTTGTTATCCC +GCAAATTTTTACCTTTACCACAATCTAAAATAATAAAGCATGGAAGTTAAAAGGGAACACTGGGCGACGC +GACTCGGTTTAATCCTCGCGATGGCGGGGAACGCGGTAGGACTTGGTAATTTCCTCAGATTTCCCGTTCA +AGCTGCGGAAAACGGTGGCGGGGCTTTCATGATCCCATACATAATAGCCTTCCTCCTCGTGGGTATTCCT +CTTATGTGGATAGAGTGGGCTATGGGAAGATACGGGGGAGCTCAGGGACACGGAACCACACCAGCTATTT +TTTACCTCCTCTGGAGAAACAGGTTTGCTAAAATTCTTGGAGTTTTCGGACTCTGGATACCTCTGGTGGT +AGCCATATACTACGTTTACATAGAGAGCTGGACACTAGGTTTTGCGATAAAGTTTTTGGTAGGGTTAGTT +CCAGAACCTCCGCCAAACGCCACGGATCCCGATTCCATTCTCAGACCCTTTAAAGAATTTCTGTACTCCT +ACATCGGAGTTCCTAAAGGAGATGAGCCGATTTTGAAACCTTCACTTTTTGCGTACATAGTCTTTTTAAT +AACTATGTTCATTAACGTTTCCATTCTCATAAGGGGTATATCCAAGGGTATAGAGAGGTTTGCAAAAATA +GCTATGCCCACGCTCTTTATCCTCGCGGTTTTTCTGGTCATCAGGGTCTTTTTACTGGAAACCCCCAACG +GCACCGCGGCGGACGGACTTAACTTCCTTTGGACTCCCGACTTTGAGAAATTAAAGGACCCGGGCGTCTG +GATAGCGGCTGTAGGACAAATATTCTTCACCCTGAGTCTTGGTTTTGGAGCTATAATCACTTACGCCTCT +TACGTGAGAAAGGATCAGGACATTGTCCTCAGCGGACTTACGGCGGCGACGTTGAACGAAAAGGCTGAGG +TAATACTGGGTGGTTCTATTTCCATACCCGCTGCGGTTGCTTTCTTCGGAGTTGCAAATGCGGTTGCGAT +TGCAAAGGCGGGAGCCTTTAACCTCGGTTTTATAACCCTACCCGCCATATTCTCCCAAACGGCCGGAGGA +ACCTTTTTAGGATTTCTGTGGTTCTTCCTCCTCTTCTTCGCAGGACTCACTTCTTCAATAGCTATAATGC +AACCGATGATAGCCTTCTTAGAGGACGAACTAAAGCTTAGCAGAAAACACGCTGTTCTCTGGACCGCGGC +TATAGTTTTCTTCAGTGCACACCTTGTGATGTTCTTAAACAAGTCCCTTGACGAGATGGACTTCTGGGCG +GGAACGATAGGGGTTGTTTTCTTTGGTCTCACAGAGCTCATAATCTTCTTCTGGATTTTCGGAGCGGATA +AAGCTTGGGAGGAGATAAACAGGGGCGGAATTATTAAAGTTCCCAGAATTTATTATTACGTAATGAGGTA +TATAACCCCCGCTTTCCTCGCGGTGCTCCTCGTTGTGTGGGCACGGGAGTACATACCGAAGATCATGGAA +GAGACCCACTGGACCGTGTGGATAACACGCTTTTACATAATAGGGCTTTTCCTCTTCCTCACTTTCCTCG +TTTTCTTAGCTGAACGGAGAAGAAACCATGAGAGTGCTTAAGTGGCTTCTTATACTTTTCTCGCTCCTTA +TAATTTTTAGTGTGGTGAAAGAATTCATTCTCTCCAAATTCCCGGTAGGTCACAGGATAGCGGTATTAAA +ACTTTCAGGAGTAATAGTAAACCCTTATCCTCTTGTTAATAAGATAGAAAGGTTAAAGGATTCTAAAAAC +GTTGTAGCCTTGGTTTTAAGGGTTGACAGTCCTGGAGGTTCTGTGGGAGCCTCTCAGGAGATATACAGGG +CTATAGAGCGATTCAAGAGCGCGGGAAAGCCCGTAGTTATCTCTATGGGAAACGTTGCGGCCTCGGGGGG +TTATTACGTTTCCGCAGCGGGGAATTACATATTTGCAAACGAAGGGACTATAACGGGTAGTATAGGAGTC +ATAATCCAGCATGTGGCTTATAAAAAACTCGTAGAAAAACTGGGAATAGAAGCAACAGCTATAAAGACGG +GAAAGTTCAAGGACACTCTTAGTCCCTTCAGGGAATTGACGCAAGAAGAAAAGGAGTATTTACAGAACCT +TGTGAATGAGGCCCTTGAGCAGTTCATTCAGGCGATACTGAAGTACAGGAGCAATAAGATTTCCGAGGAA +AAGCTCAGGGAGATAGCAGACGGTAGGATATTTACGGGAAGGCAAGCTCTGGAACTGGGTCTTGTTGATG +AGCTAGGTTCCCTTTACGACGCTATAGAAAAGGCTAAGGAGCTTTCCGGTTACAGGGATGCAAAACCCGT +TTTCATTCAAGAGGAAAAGAGCTTGCTCAAGCGCTTGGTTGGAGCGGATCTGGAAGAGATTAAGATCATC +AACGCCTACACTCCCCTCTTCTACCTTATGGATTACTGATGGAAAGGGTAAAGATACTCAAGTTTTATCC +CTTTGAGGTTCCCTACAGAAGGGGGAGTTTACTCGCCTACTTTGACATTGTACTTTACGGGGAAATATTA +ATAAGAAATGTCAGGCTTATCAGAAACGTGTACGGAGGTCTGTTCCGTAGCCATGCCCTCAATTCAGGTA +GGCGATAAGAACGTCAACGTAGTTGAGATACTCTCCAGGGATTTAATGGAAGAAATTAGAAGAAAGCTCG +TGGATTTTTACAAGGAAAAGATTGAGGAGTTAAAAAATGAAGAGAGTGCTTGAATTTCTCGGAGGCTTCG +GCGGTTTAGTTTTCGGATTTGTTTTCTTCGTTGGAATGTCCATTTTAGGACTTTTTCACCTCGAAGAACA +CCCTCCCCTTTACTGGGCGGGCTTTTTTGCTTCAGTTTTTCTCTTCGTACTTTCTTTCCTACTTAACCTG +ATAAACTGGGTAAAGGCTTTAATAAAGGATTATAAAAAGCACGGAAGTGTTCTTGCCTTCGTGTACGACT +TCCTCGCTTCACTTAAGCTCGCAATATTCATAATGCTCGTTCTCGGAATTCTCTCCATGCTCGGTTCTAC +CTACATAAAACAGAACCAGTCCTTTGAGTGGTATCTGGATCAATTCGGGTACGACGTGGGTATATGGATA +TGGAAGCTCTGGCTCAACGACGTATTTCACTCCTGGTATTACATCCTCTTTATAGTTTTGCTCGCGGTAA +ACCTGATTTTCTGTTCCATAAAGAGACTTCCGAGAGTATGGAAGCAGGCTTTCAGTAAAGAAAGGATACT +TAAACTGGACGAGCACGCGGAAAAGCACTTAAAGCCCATAACCGTAAAAATTCCCGACAAGGATAAGGTT +TTGAAGTTTTTACTGAAAAAGGGATTTAAGGTTTTCGTTGAAGAGGAAGGAAATAAACTCTACGTGTTCG +CAGAAAAGGGTAGGTTTTCAAGACTCGGCGTTTACATCACACACATAGCCCTCCTCGTTATAATGGCGGG +AGCACTGATTGACGCGATAGTTGGTGTGAGGGGAAGCCTTATAGTTGCGGAAGGGGATACAAACGACGTA +ATGCTCGTGGGTGCGGAACAAAAGCCCTACAAACTGCCTTTTGCGGTTCACCTGATAGACTTCAGGATAA +AGACTTATGCGGAAGAAAACCCGAACGTGGATAAACGTTTTGCTCAGGCGGTGAGCTCTTATGAGAGTGA +TATTGAAATCATAAACGGCGGGAAAGTTGAAGCAAAGGGAACCGTTAAGGTTAACGAGCCCTTTGACTTT +GGAAGGTACAGACTATTTCAGGCGACTTACGGAATTCTTGACGGAACGAGCGGTATGGGCGTTATAGTCG +TTGACAGAAAGAAGGCACACGAAGATCCCGAAAAGGCGGTAATAGGAACCTTTGAGATAAAAACGGGACA +GGTTGTTGAGTTCAAAGACATGCTAATTTCCATAGACAGAGTTGTTCTCAACGTGCACGATCCCAACAAC +AGGAACGAACTCGCACCGGCGGTAGTTTTAAAGGTTATGCTAAACAGAGAACTTTACAGCGTTCCCGTTA +TATACGACCCTAGATTAACCGCTCTTGTATTCTCTCAAATACCAGAACTAAAAGACTTTCCCTACATGTT +CTTCATGAACGGGTTTGAACCTCTATTCTTCTCAGGCTTTGAGGTTTCCTACCACCCTGGAAGTGTAATT +ATATGGATAGGCTCGGCTATACTGGTTCTCGGAATGGTGGTGGCCTTCTACACGGTTCACAGAAAGGTGT +GGATGAGGATAGAGGGAGATACAGCAAAGGTAGCCTTTTACTCCCACAAGTTTAAAGAGGAATTTAAGAG +GAGCTTTTTAAGGGAACTGGAGGAGTTAAAGAGAGCTTGAAAGGGATTTTATACTCTCCTCCAGTGCTTC +CAGAAACTTGTTGTTTTCTTCCGGTTTCCCTACGCTTACCCTGAGGCACTTTTGGAGTCCTTCCATGTAA +GATACGTTCCTGACGAGGACATCCCTTTTCAGTAGCTCCTGATAAACCTCGTGGGCGGGGTAAGGCGTTC +TGAAAAGCAAGAAGTTAGCCTTACTCGGAAAAACCTCAACTCCTTCTATTTTCTTCATTTCGTCGTACAT +CCTTTCTCGCTCTTTTACAACCTCCTGTATCTTTTCCATTAGGAATTCTCTTCCCTCCGTGAGGAGAACT +TTTGCCATCACCTGAGAGGGGTAGGTCACGTTGAAGGGGAGTCTCACCTTGTTAATTTCTGAGACGATTT +CCCCCTTCCCTATTAAAATCCCTACCCTTAAACTCGCCATACCGATTTTTGAAAGTGTCCTCAAAACTAC +CGTATCTTCCCTTTTGAGCGCGTCTTCCAGAAAGGTTTCTCCGGAGTAATGATAGTAGGCTTCGTCTATT +ACACAGAAAACACCCCTGTTTCTTATCTCCTCAATCTTTCCCCTGGAAAAGAGGTTTCCCGTGGGGTTGT +TTGGGTAAGCAAAGTACCCGAGAACGGGTTTTTCTTTCTCTATTAATTCAATACTTCTTTCTAAGTCTAT +ATCAAAGTTTTCGTCCAGTTGAACCTTTACGAGGGGTCTTCCGAGAACTTTCGCACTTATCTCGTACATG +GGAAAGGTGGGAACAGGTATGTAAACGGGTATGTAAAGTTCACCTATAGCTATTGAGAGGTAGTATATGA +GTTCGTCCGAACCGTTACCGAGAACTAAATTTTCTTCCTTAACGCCGAAAAAATCCGCAAGAACCGCTTT +TAACTCTTTCGCTTCGGGGTCTGGGTATTTGTTCAAGGGAACCTTTTTTAATTCTTCTAAGGCCCTTTGT +TTTATCTCCTCGGGAAAGTCGTAGGGGAATTCGTTAGAGGAAAGCCTGACGGAGGCGGGAGTGACCTCCG +TCTTGTAAGCTTCAAGTTCCTTAATCCTCTGGGGTATCATTCCGTTGCAGGTTGTTCGGTTTCCTCAGTT +TCTTCCGCTTCTTCCTTGTGTTCCCTTTCGGGTTTGGTCAGGTACATCTGGAGTTCTTCTACTGTAGATT +CTGCGAACTTATCCTCTATTATTCCCCTTATTAATTTATTCAACTTCTTTTCATCTCCCTGAGCTATACC +AAGGAGTATGTAGTAAGTGCTCTTTGGAAGGGAAAGGGTAACCTTCCTGTACTTGGGTCCTGCTTTTCTT +CTTCTTGCCATAATACCACCTCCTTTAAGTTTTTTCCTTGAATTTGTTGTTAAAGTCTATCGCGTGCTCC +AATAACTCCTTGTAAACCCTGAAGGGCGTAAGAACAACCCTTATCCTTTCATTTTCCTCGGGAATTAAAC +AAAAGGCTTCATCCAGTATGTCTATGAGTAATTGAAGTTTAGTGTTTACGGTGTCTATGAGTGCGAGCCT +TTCGAGTTCCCTTTCTATCTCCTCGGGAATTGCGGAGAGGAACGTAACGTCAAAGTTAAAGACTTCGTAC +TCGTCGTAAATGTGATCCAAAACTTCGTCGGTTTTTAGTAGAAATAGCTCTTCAATCTTCAGTATGAAAT +CTTCCACAACCTTTTTTTCTTTTTCCTCTAAAACCGATTCCGCTATTAACCTCGTTTCGTCTATATCCGC +CTTCAGTTCTTCCCTTATACCAGTCAAAAGGTCAAGGGCAAACCTGAGCAGTCTGTCGTATATCAGTAAT +CTCTCAAGCGTTTTTAATTTACGAGTTTTTTCCTCCATTTATCTCCTCTATATGAATTATATTCCATTTC +TTCAAAAAATTTCTAAAATTTTCGTCAACTAAAAAACCCTGTGAACTTAAAAGTTCCTTCATTTTTTGAT +TTATCCTTTCGCCGTGAGTATCAAGGTCAAACAGAAGTATCACCTTTTCCCACTTTCCCTCCAGCATATC +CACAACATCGGCGTACCTCTTTCCCGACAAATCAATAACGTTCTTTATAGAGAACTTTGAAAGAGCTTTT +TTATCGTTTTTCCCTTCAACGAGGATCACAGCTTCCCTGGAGGCTTTTTTTAACTCCTTTATCCATTCAC +TCAGGTTTCTTGGTTCTTTCGTCATCTTTTCAGTTCGCCCTTTCTCTGTTCCTTTAGACTTTCCCTTTCG +CTCCTTTCCCTTTTCGTGATTTCCCTGTGTTCAAACTTCAAGTACTCCATGTAACTCTTTTCGAGTAGAA +CGTACGTAAGTCCTAGAGCGAGCAGTAGGGCTCCGAAACCGAGCAAATCCCAGAAGGTAAACCTGTGCTC +AAAAACAATCAGAATTATCTCCCTGACAACGAACACTATACCGGCCTCTATAATTTGTCTCTTTCTTATC +CTCCTGAACTCAAGGACGTCTATGAAAACCTTAAAGAGTTCAATTAAAACGAAGAAGTTAAGGATATTTC +TAACGAGAAGTTTAAAAGCTTTGTCGTACTCCTCCGCCACTGCTCCGTGGAGGAAGTAATCCACAAATAG +CCTGAGGTCGTAAAATATTATGGCGATAGCTATAAGCAGAGTCAGCATTAGGATGGGAATCATTAGAATG +GCAACGAAGTTAACGAACTTGTTGTAAATGTCCACCATTTTGCATATGAATTCGTAACTCGTTATTTTTT +CTAAGAGTTTCATAAAAACTTATTTTAGCGGTTATAATTAAATGTTTACCGAGAGCTTTGAAGGAGGTAA +TGGAATGAAATTCACAGAAGGAAAGGTAAAGGTGGTGGCAAATGACGTCAAAAACTTAACCCAAGCCCTA +GAAGGTTACATACAGAAAGCTTTCTTTGAAGGAAAAGACATCTGTGCGAGCGGTGGACTCGTTTTAAAAA +CAACGAACAAACTCGCCCAAAAGCTAAGTGAGCTTAAAGAAATACTCCCTCAGGTTAAAGTTATCTCCGA +TGAAGTAAAGGCAAAGGCGGAGGAGATAATAAAGAAGGCGGAGGAAACCCTTCAAAAAGGTCTGGAGATA +AAGAAGAGAGTAAAGGAGTTTGAAGCAGCTACGAACGTTTACAAAAAGAATCCCTCCGAGGAAAACAAGA +AGAGGGTTGAGACCGCCCTCAACAACCTCAAGTACCCCGAAGGTGCAAAACTTACCCTTGAAGATTACGT +TAAGAACTGCAATCCCTACAAAAAGTACTTACAGAAAAGGGTTGAACAGAAGGCTTAAATTTTTCCTCTT +TTCTGTTGACTTTTCTTATTTGAGAAATATTTTCAATAACCATGGAGGCGAAAATGGGCGAAAAGGTCTA +CATATTCGACACCACTCTGAGAGACGGAGAACAGGCTCCCGGTTTTTCCATGACCACGGAAGAAAAGCTA +CAGATGGCTCATCAGCTCGCAAAACTCAACGTAGATATTATAGAGGCTGGATTTGCAGCAGCGTCCAAGG +GGGACTTTGAAGCCGTAAACAGGATAGCAAAAGAAGTCAAAGGTCCTGTTATATGCTCCCTTGCAAGGGC +ACTCGAAAGTGACATAGAAATTGCCGCAAAGGCACTCGAACCTGCGGAGAGAAAAAGGATACACACCTTC +ATAGCCACCTCTCCCATACATATGGAGTACAAACTCCGTATGACGCCGGACCAAGTTTTAGAGAGAATTA +AAAAAGCTGTTTCCTTTGCGAGGAACTTCACCGACGACGTTGAGTTTTCCTGCGAAGACGCCACGAGAAG +CGAGAGGGAATTTCTCTACAGGGCCATAGAAACAGCCATCAAGCACGGGGCAACCGTTATAAATATCCCA +GACACAGTGGGATACGCCATACCCGAGGAGTTCGGTCAATTAATAGAGGACATAATGAACAACGTCCCGA +ATATAGATAAGGTTATTCTGAGCGTTCACTGTCACGACGACCTCGGACTTGCCACTGCAAACTCCCTGAC +CGCGGTAAAACACGGGGCCAGACAGGTTGAATGTACCATAAATGGGATAGGGGAAAGAGCTGGAAACGCA +GCTCTTGAAGAGGTGGTAATGGCACTAAAAGTGAGAAAGGACTTTTTCGGAGACCTTTACACCGATGTGA +ATACGAAAGAGATTTACAAAACTTCCAGACTGCTTTGTAGGATTACAGGAAACTTCGTTCAGCCTAACAA +GGCAATCGTCGGGGATAACGCCTTTGCCCACGAGAGCGGAATACACCAGCACGGAGTACTCAGCCACAGA +ATGACCTACGAGATAATGAACCCCGAAGACGTTGGATTCCCCATGAGCAGAATAGTTCTCGGAAAGCACA +GCGGAAGACACGCCCTGAAGAGAAGACTTGAAGAACTCGGCTTTAAGTTCACCAAAGAAGAACTCGACAG +GATATTCGAAAAGTTCAAGGAGCTTGCCGACAGAAAGAAGGAAGTTTACGACGAAGACCTCGAAGCACTA +ATATACCAGGAGTTCATGAAGATAGAGGACCACGAACCCGTAAAGGTTCTCCACTTTCAAGTTCAAAGCG +GTGATAACATGATACCGACAGCAACGGTAAAGCTCGAGTTTAAAGGAGAAGAGAGGGAAGCGAGTTCCAC +AGGAAACGGACCCGTTGACGCGACCATTAAAGCAATTCAGAAAGCCCTCGGCATAGAACCTAAACTCCTG +GACTACTCAATTAAAGCCCTCACTCCCAACACGGACGCTCAGGCAGAGGCAAGGGTAGTCTTGGAGCTTG +ACGGGGTGAAAGCCTCCGGAAGGGGTGTGGATACAGACATAATAAAGGCGAGTGTTAAGGCGTTTACCGA +CGCCCTGAATAGGGCTATAGTCAGGAAAGAGTACATAATCCAGAGACAGGAAATCAGAGAAGAAGGTACC +GTTTGATGTGGAGAATTTTCTTCACAAGGTTCTTCGTAAGGTTTATCCTTTTCCCCCTCCTTGCTGTAAT +TATGGGAGTTCTTGTTCTGGGAACGATATTCTTCATAACATACACGTGGCTCATTTGGCAAACGATAAAG +ATAATGGACGAACACCCTTTACTCGGGTTTTTCTTCGTAATCCTTGAGATACTCCTTCTGTCTTTAATAG +CTCTTGCAGGTTTATACTTATTCGATAAGGTAAGGGAATTTTTTAAAGAAAGGAGGTTAATATGAAAAAG +TTGTCTTTTATTTTACTCTCCGCAGCATTTGTTTACGCTTCATGCCCTGAACCCTCCAAATTTGAAGAGA +AATTAAAAGAAATAACCCAAAGGGAGTGGAAAGTTCAGGCAGTATCTGAGGTAAAAGACCTGGGATTGTG +TCAGGTGGTAGTAAAGAGAGGACTTGAACCCTTAGTTATTTACATGGACAAGGATATGAACTACTTGATT +ACTGGAAACGTTATTGACCTCAAGAACGGCAAAAATCTAACTGCAGAAACCGTAAGGAAGTACGCAAAAG +TATCCCCCGAAGTTTTGAAAGAGCTTGAAAAGATGACAGACCTCAAATTCGGAAAAGGAGACAAGTACGT +TTACTTTATATCAGACCCCCACTGCCCTTACTGTAACAGACTTGCACCAATACTGAAAAACTGGGCTGAT +AAAAATGACGTACAGATAAGGGTAATCTTCTACCCGCTTCCCTTCCACAAAGGAGCGGATGAAAAGGCTG +CAAGCCTTATATGTAAAAAGGATGTAAAGTACGAGGAGCTTCACACAAAAGACAAGCCCGAAAAGGTTTG +TGAGGAAGGAATGGAAAAGGTAAAGAAAAACGTAGAGTACCTCTCAAAGCTCGGTGTCACCGGAACACCT +ACACTCATCGGTATGAACGGTAAAGTTTTGGTTGGTCTTCCGAGAAGTGAAAAACAGCTTGATGAACTCG +TTAAATAATCAGCAGCACTTTATCCAGTCGAGGGGCGAGTTTACAAGCCCCAGTTTTTTATGCCACTTGT +GAAACTCCTCCACGAGTTCCGGGTACAACTCTATTAAGTAGAACTTTAGCGGTGTGGATAGTCCGAAGTA +ATCCGCAAAGAGAAGAAAAATGAAGACCTCTTCGAGTTTCTGAGCTTCCCTTCCGAATTCCTGTCCGAAT +TTGAGTCTGTAAAACTCCTTAAGCACTTCTCTCAGGTTCAAGTTTCCTCTCCTTCTGGAGTTTTCTGAAG +GCTTTCCTTATTCCCCTTATAGCCTGTCTGATCCTGTGTTCATTTTCTACAAGTGCAAACCTTACGTACC +CCTCTCCGTACTGACCAAAGCCCACACCCGGGGATACCGCAACCTTCGCCTCTTTTAGGAGGAACAAGGA +AAAGTCCAGAGAGTTCATATTTATCCATTCGGGAATCTTTGCCCAGACGAACATGGTAGCCTTAGGTTTT +TTTACTTTCCAGCCGAGCCTGTTTAACCCTTCCACCAGAACGTCTCTTCTTTTTTGGTAAACCTTTGCGG +TTTTTTCCACGATTTCGTAGGGGCTCTCTAATGCGATAATAGAGGCCACCTGTATGGGAGTAAATATACC +GTAATCCAAGTAGCTTTTGAGGTGTGCAAGGTTTTTTATGAGTATTTCGTTTCCAACGACAAAGGCTACC +CTCCAGCCCGCCATTGAAAAGCCCTTTGACATGGAGTAGAGCTCAACCGCAACGTCTTTAGCACCTTCTA +TTTCGAGTATTGAGGGGGGCTTGTAACCGTCAAAGGCTATATCCGCATACGCAAAATCGTGTATTATCCA +GAGACCGTGTTCCTTTGCAAACTTAACTATTTCTTTAAAAAAGTCCTTTTCTACCGTTATGGTCGTTGGA +TTGTGAGGAAAGCTTATGACGACAGCCTTGGGTTTTGGCATCGCGGTTTTTACTATCTCGTAAAGCCTCC +TTAAAAACTCTTCCTGATGATCTTGATCGTCCGAGAAGTTAAGGGGTATTGAGTGAACTTCCCCTCCTGC +AATTATGGGAGCGTAATAGTGAATAGGATAGGTGGGATTAGGAACTATTACCGTATCACCCGGAGATATC +ATCGCAAGCATCAAATGAGAATACCCTTCCTTTGCACCGATTGTTAGTATAGCCTCCCTCTCAGGGTCGA +GTTTCACTCCGTACCTTTCTTCGTAGAAGTTACATATAGCCTTTCTCAGTCTTGGTATGCCCCTTGACGC +AGAATATCCGTGAACGTTCGGCTTTTGAGCCACTTCGCAGAGTTTATCTATTATGTGCTTTGCTGGAGGC +ATGTTAGGATTGCCCATACCAAGATCCACTACATCTTCGCCTTCACGCCTTAGCTTGTACTTGAGTTCGT +TAACGAGAGAGAAGACATACTGAGGCAGTCTCTTTATCCTCGGAAAAGCCCAGTCCATAGGGTCTTCAAT +CATTCTCCATCTCCTCTTCCAGCTCTTTGCACTCGATACACATAGTGGTTACAGGTCTGGCTTTCAACCG +CTCAAAGGGAATCTGGGCACCGCAGTTCTCACATATACCGTAGGTACCCATCTCCATCTTCATAAGTGCG +TAATCTATCTTGTGAAGTAATTTAGCCTCCCTGTCCTTTATCCTGAAAGTTATAAACCTTTCCGTTTCAA +GATCCGCCCTGTCTATTTCGTCTCCTCCCTCAAATTTAACGTTTGATGGGTCCTTAAGTTGACTCTCCGC +AGATTCCAGTATCTTTCTCCGCATTTCAAGAAGTATAGCTCTGAGTTCGTTTACCTGTTCCTGTGTAAGG +TGTTTCAATATATTCCTCCTTAATTATTAATCTACAAACCTTGCAGGGTCTTTTCTAATCTTTTCGAGGA +GTTCTTTCCTCCCGTCTACGAAAATCGCAACCCACTCTGCGAGTCTCCTTCCCAGTCTCCTGCAGGCTTC +CTTTTCTTCTTCACTCCTCGGCTCTCCTGCGACAACCGCGCCGTAATGGAGTGTAAACTTTTTTCCAACG +TAGTCGGTAACCCCGAAAACTAAAAATCCGAAGTTCATGAGCATCGTAAGAATTGACATGCAGGCAACTT +CGTTTCCTCCGCCCCAGCCCCCTGAAGAGGAAAAGGCACAGGCTATTTTTCCGTCTATTTCACCCCAAAG +GTCTCCGAGAACGTCGTCGAAAAACCGCTTCATCTTCCACGAAACGAGACCCATGTTCGTGGGAGAACCC +ACGGCAAGACCATCCGCCCAGAGGACATCCTCCTTTGTAGCTTCGTCAACGTGTTTGAGTCTAACTTCTG +TTCCCTCAAGGGAACGGGCACCTTCCGCTACGAGCTCAGCCATCTTTTTAGTATTACCCGTCCTCGTGTC +GTATATAACGAGAACCTTTCCCATAAATTAAAAGTTTAACTTACCTCCCCCTCGCTTTAAGCCTCTGGAG +TTCTCTCAAAAAGGTTTTCAGGGCCTTTTCTTCCTCTTCCTTGTAAAAGGCTTCCTTTTGAATTGCGTAA +TCCCAGTCAACCTTTGATGCATCAAACCAAGGTCCGTCTATGCAGGCGAGTTTCTCTTGACCTTCTACGA +GAACCCTACAGGCGAGGCAAAGTCCGTTTGCGTCAAGTATGTGTGCATTTACCATGGCTATGTGGGGAAT +ATTTCTTTCTTCGGCAAATCTGTTTATCATCTGAGAGTCTAAATTACTCCCCGCACTCACGATAAGATCA +GGTTTTCCGAAGTTTTCAATAAAGTAACCGAGAGCCCACTCGCTGTTTCCCTCTTCCCCTAAAGAGCCGT +CTTCGGTAAAGAGAAGAAACTCTTCCGAGATTTCAGAAGCTTCCTTTGTTAGAAAAACCCTTTCCTCGTC +TTCCGCTACGTGGACAAAGTATATTTCGTTACTCTCTTCCTTTAATGCCCTTCCAATGTTTATAAGAGGT +GCTACTCCCCAGTTCTTGGAGATCAGGAGAACCTTTCCGTAATTTTTTACGGGAAAAGGAGAACCGCAGG +GGGCTTCTATGAACTGTATTTTTTCCTCTACGAGCTCGGCGATTTCTAAGGTAGCCCTGCCGCCCACTTC +CACCAGAAAGGTATAAGAGCTTTCCTTTACGTCTAGGAATGAGAGAGGGATTGGTTCCGACTCCTCGTTT +GCCTGGACGAGTGCGTACTGACCCGGTTTTACGAGTTTTGCCCTCTCGTCCTGAACTTCCAAGAGAACCG +CTTTAGGAGTGAGTCTTTCCTTTCTTAAAACCTTATACATTTGAACTTACCTTCATTATGTATTCAAGGC +ACGTTCTCACGCCGAAGCCCGTTCCGCCCTTCGTGTAGTAGCCGTATTCCTCCTTTGACCATGCGGGACC +GGCTATATCAAGGTGGACCCACTTTATGCCTTCACCCACGAACTCTTCAAGGAACATAGCGGCTGTTATC +GCTCCTCCGTACCTTCCGCCGGTGTTTAGGACATCCGCAACTGTGTTTTTAATCTTCTTCCTGAGTCTTT +CGTCGTCCATGGGGAGTTCCCACACCCTTTCACCGGTTCTCTTTGCGGTTTTCTTTATCTCCTCCGCAAA +GTCGGGAGCGTTCGTAAAGAGTCCCGCTGTATACTCTCCTAGAGCTACCATACACGCTCCCGTCAAGGTA +GCCATGTCTATTATCTTGTCTGGTTTGAGCTCGCTCGCGTAAGAGAGCACGTCCGCTAAGGTAACTCTTC +CTTCCGCGTCCGTGTTATCAATTTCTATGTACTTTCCGTTTTTTGCCTTTATTACATCATCGGGTCTGTA +AGCGTTCCCGTCTGGCATATTTTCCGCGGCACCGATGAGTCCGTGAACTTCAACGTCTGGTTTTAATTGA +GCTATAGCCCTCATTATCCCGAGGACAGCACACGCCCCGCTTTTGTCCATCTTCATAGTCCTCATGTAAT +CCCCGGGTTTTATGTTCAGTCCTCCGCTGTCAAAGGTAAGCCCCTTTCCCACAAGTGCTATCTTTTCCTT +CGGCTTTCCGGAGGGCTTGTATATAAGGTGTATGAACCTAGGTGGCGTTGCGGAGCCTTTACCCACGGAG +TAGAGTGCCATCATACCCATTTCCTGAATTTGTTTTTCGTCGTATACCTTGCACTCAAGACCGAACTCTT +CGGCGAGTTTTTTGGCTTCTTCCGCAAGCGTTATGGGATTTATTACGTTTCCGGGTTCGTTTACAAGGTT +TCTCGCGTAATTTTGAGCTTCCGCGAATATCTTTCCGAGCCTTATACCTTCCTCATCTCCCCTGTTTATA +AGAACTTCTTTAATCTCAAACTTCTCGTCTTCCTTTTTGGACTTGTATTTATCAAACCTGTAATTTCCGA +GAATAGCACCCTCCGTTATAGCCTTCGTTATTTCCTTTGAGACATCTCCCCTTCTTGGGATAACTACAAC +TGTGCTCTCCACTTTGTCCCTTCTCATTCTCTTTACGAGGTTTGCACTCGCCCTTCTGTAAGTGTCCTCG +CCTACTTTTTCTTTCTTTCCAAGTCCTACTATGTAAACAAAGTCAACAGAAGTTCCGAGAGTGGGAACTT +TCAGTATTTCCCCTTCCTTTCCTTTGAAGTTTTCAAGCTCTGCCACCCTTTTAGCTTTATTGGAAGTTCC +CTTGGAGAGTCTGGCGAGTGGTTTCAGGTCACCCTCGTACACGAACACCGCAACGCTTTTCCCTTTGTAC +TTCTTTATGTCATCTTTGAAAGCCCTTACTTCCATTTCCTTCACCTCACTGTTTATACTATATACTTTAA +ATGCCTAAAAGGACGGACATCAAGAAGATATTAATAATAGGCTCTGGGCCTATCGTTATTGGACAGGCTG +CAGAATTCGACTACTCGGGAACCCAAGCCTGCAAAGCCCTAAAGCAGGAAGGATACGAAGTCATTCTCGT +GAACTCAAATCCCGCAACGATTATGACCGACCCAGAAATGGCCGACAAGACCTATATAGAACCCCTTACC +GCTGACATACTTGAAGAGATTATAAAGAAAGAAAGGCCTGACGCCCTCCTTCCCACGCTCGGAGGTCAAA +CGGGCCTAAACTTGGCGGTGGAACTGTACGAGAACGGTGTTCTTGAACGCTACGGAGTTGAGCTAATAGG +TGCGAACTACGAGGCCATAAAAAAGGGAGAAGACAGAGAACTCTTTAAAGAAACTATGGAAAGTATAGGG +CTGAAGGTTCCGGAAAGTGCTGTCGTTCGCTCTGTAGAAGAAGGACTGAAGGCTGTAGAGAAGATAGGTT +TTCCCGTGATACTGAGACCTGCTTTTACTCTGGGAGGGACCGGAAGCTCGGTTGCCTACAACGTTGAGGA +GTTTAAAGAGAAGTTAAAGGTTGCCCTTGAGACTTCCCCCATTCACGAGGTTTTGCTGGACAAGTCCCTG +ATCGGCTGGAAGGAGATAGAGTTTGAAGTTGTAAGAGACAAGGCGGACAATGTCATTATCGTTTGTGCTA +TAGAGAACTTTGATCCCATGGGTGTTCACACGGGTGACTCCATAACCGTAGCCCCAACACAGACCTTGAC +GGACAAAGAGTACCAGATGCTCAGGGACGCGGCCATTGCGGTAATAAGGGCGATAGGTGTGGATACGGGA +GGTTCTAACATACAGTTTGCCCTCTCACCCGAGAGCGGAGACTTTTACGTTATTGAGATGAACCCGAGAG +TTTCACGCTCTTCAGCTCTAGCGTCAAAAGCAACGGGTTTCCCAATAGCAAAAGTCGCGGCAAAGCTTGC +GGTGGGCTACACCTTGGACGAACTTAAAAACGACATTACGAAGTTCACCCCAGCCTCCTTTGAACCTTCT +ATAGACTACGTAGTTGTAAAGATTCCGAGGTTTGACTTTGCAAAGTTCCCCGAAGCGGACAGAACCCTCA +CCACTATGATGAAGTCCGTAGGGGAAGTAATGGCTATAGGAAGAACTTTCAAGGAAGCACTCCTAAAGGC +TGTAAGGAGTTTAGAACTCGACAGGTACGGCCTAGCTTTCCCGAAACTCACGAACGTTGATAAGGTAGAA +CTCGAAAGGAATTTAATTAACCCAAACGACCAGAGACTCTGGTACATAGCTGAAGCCTTCAGGAGAGGGT +ATTCCGTAGACGAAGTTTACGAACTCACCAAGATAGACAGATGGTTCCTTTATAACATAGAAGAGATAGT +AAAGTTTGAGGAAGTTCTCCGGAAGGAAGAACTTACCCCTGAAATCCTCAGACAAGCAAAGGAAATGGGC +TACTCCGACTGGGAGATAGCAAAAATAAAGGGAATTACGGAAGAAGAAGTCAGGAAGCTCAGAAAGGAAG +AGGGTATAGTCCCCACATTCAAGGGTGTTGACACCTGCGCGGGAGAATTCGTGGCGTATACACCCTACTA +CTATTCCTCCTATGAGAGACCTTACTACACTGTAGACGGGCAGGAAATCCTTGATGAAGATTAAAAGGTT +TGTTTACTCACTGCCCGAGGAGGAGTTCTACGAACTCGTTTACTCCCAAAACCTTTCCGTTGAGGTCCTT +GAAAGGAAAGAGATCGAAGTAATTTTCGCATCTTACAAAGAAATTGAGGGTTTAACTCCCGAGAAGGTAG +AGGAAGTAAAGGAAGACTGGGAGAATTGGAAAGAGAAGTTTAAACCTATTGAAGTTGAGGACTTTGTAAT +AATCCCTTCTTGGAAAAAGCCCGTAATCGTAAAGCCTGGACTTGCCTTCGGGACGGGTCTTCACCCCACA +ACTCAACTCTGTATAAAAGCCTTAAAGAAGTACTTAAAAGAGGGCATGACTGTTCTGGACGTGGGAACTG +GCTCCGGAATTCTCGCAATAGTTTCGGCACTTCTGGGAGCTAAACGGGTAGTGGGCATAGATATAGACGA +AAAAGCTGTAAATGAGTGCAGGGAAAACGCAGAGTTAAATAAGGTAAAAGTTGAGTGTTTCAGGGCAGAG +CCAAAAGACGTAAACGAGAGTTTTGACCTTGTAGTAGCCAATCTGGAAATTCACATCTTTGAAAGGGTTT +TAAAAGACATTCTTCCGAAGTTTAAAAAAATTGGTATATTTTCGGGACTTTACAAGGAAAAGGATTTAAA +GAGATTTGAAGAACTCCTCGGAGGTTTGAAAGTAAAGGAAGTGTTTGAAAAGGAAAACTGGTACGCGGTT +GTTGTAGAAAAAGGATAAAAGAAAGGGAAAAAAGAGGTTTACTCTTCGAGGGTAGAGACGTCTCCGACGT +CCAGTCCGAGTTCTTCCGCTTTGAGTATTCTTCTCATTATCTTTCCGCTTCTGGTCTTTGGCAGTTTTTC +CCTGAATTCTATTTCATCGGGAACGGCTATTGGTCCGAGAACATTCCTTACGTGGAGTTTTAGTTCCTCT +ACGAGTTTTTCGGAGGGTTCTACGCCTTTCTTGAGGACAACGAAGGCCTTTATGCTTTCACCTTTAACCT +CGTGAGGCTTTCCTATTACCGCAGCTTCTGCAACGTCGGGGTGTGATACGAGAGCGCTTTCAACTTCCAT +GGTTCCTATCCTATGTCCCGCAACGTTTATGACGTCGTCCGCCCTACCGAGGATCATTATGTACCCTTCT +TCGTCGTAAGAGGCTAGGTCTCCACACACCCTTTATGGTGTTCCAGTACTTTTCGTACCTCTCGGGCTCA +CCCCAGCACGTCCTGAGCATTGAGGGCCAAGGAGATTTAATTACCAAGAATCCAACGGTATTGGGGGGAA +CCTTGTTTCCATCCTTGTCAACGATTTCGGGTTCTATCGTGAAGAAGGGCTTTCCTGCCTTTCCGGGCTT +TGCAGGGTAAGAGGGTATCGTCGTTATCATGTGAGCTCCCGTTTCCGTTTGCCACCATGTGTCAACGATT +ACGCATTTCTCCCTTCCGATATATTTGTAATACCAGAGCCAAGCTTCGGGGTTTATGGGTTCTCCTACTG +AACCGAGAATTCTCAGGGAAGAGAGATCGTACTTCATAGGCCACTCTTCACCGTACCTCATGAACATCCT +TATTGCTGTGGGTGCGGTGTAGAAGACGTTTACTCTATACTTTTCTACGTACCTCCACCACCTTCCCGGA +TCGGGATAATCGGGTGCTCCCTCGGTTATCACGGACGTAACTCCGTTTGCGAGTATTCCGTAGACTATGT +AAGAGTGTCCCGTGATCCAACCTATGTCCGCGGTACACCAGTATATGTCGTCTTCGTGAAGGTCAAAGAC +TATCTTTGAAGTGTAGTAGGTCTGAACCATGTAACCACCCGTGGTGTGGAGAACTCCCTTCGGCTTTCCT +GTGGTTCCTGAAGTGTAGAGGATAAAGAGTGGGTCTTCAGCGTCCATAACTTCGGGTTCGCACTCGGGAG +AAGCGTTCTTAACCATTTCGTTGAAGTCTACAAAGAGTCCGCCCTTTTCCTCCAGGGCGTCTCCGTCCCT +GTCCCACACCACTACTTTCTCAACGAAGTCCAGTCCGTCTATAGCCCTCTCAACGGTTGTGAGAAGGTCT +ATTTTCTTTCCTCTCCTTTGAGTGTAGCTTGCGGTGACCACGACCTTTGCCTTTGCGTCTTCAATCCTCG +TTCTGAGAGCTCCTTCGGAGAATCCGGCAAATACTACGCTGTGAATAGCCCCTATCCTCGCACAAGCGAG +CATCGTAGCTATCGCTTCTATGGTTGTTGGCATGTATATGGAAACTCTGTCTCCTTTCTTAACTCCCAAG +GATTTGAGCCCGTTTGCTATCCTGTTTACGAGTTCTAAGAGTTCTCCGTAGGTTATCTTCTTTTCGTTAT +CGTTCTCGTCAACGTAGATGTAAGCAACCTTGTTTCTCTTTCCGTTCTGGACGTGCCTGTCGAGGCAGTT +GTAGGTTATGTTGGTCTTTGCCCCTACGAACCACTTGGCGTATGGGAAGTTCCACTCGAGAACCTTGTCC +CACTTCTTGAACCAGTGGAGTTCTTCGGCTACCTTTGCCCAGAAGCCTTCGCGATCCTTGATGCTTTCCT +CGTAAACCTTTTCGTAGTCTTTAATCCAAGCCCTCTCCACTATTTCTTTGGGAGGGTAATACTTTTCTTG +GATTTTTAAAAGTACTTCGGACTTTTCTTCTGCCATGTCACCACCTCCTTTTTAATCACTTAATTTTATT +CCTCAAAAGGAAATTTTTCAAAATTCAAAAAGCGTTTTAAAAATTTAAAAGGAATTTAAGGTTTTACTAA +TATTTTTAAACTTTTACACAAAAAGTTTTAACCTTAACACTTGAAATCCTTGTGTATTAACAAGCTCAAG +ACATAACCATCGTTTTTAAAACGGTGTTTTATTTTAAAACTATTGAAATTGTTAAAAATTTGTTTCAGTA +TTTACATAACAAAATTCCAAGGGAGGTGTGTTATGGATAAAGAAAAGCTGGAGGCCTACCACAAAGCCAA +TGTAAGGGTCATAACAATTCTGCTCATAATTTAGGCTCTCGTTTCTTACGGAGGAGCTCTAATAGCCAAA +TCACTGTTTAAAGCGGGAACTACTATATTCGGATTCCCCGCTCACTACTGGATAAGTGCACAGCTTTCGG +TAATTACCTTTGTTGTGGAGATTTTCGTTTACGCTTGGATTATGAACAACCTTGATAAAAAATACGGAGT +GGAGGAGTAAGCCATGGAATGGTTGGGTTACGTAATAGTCTTTGGAATAGTTGCCCTTTTTATGGCGATA +GCTATTTACAACAGGGCGACCGAAGCGGAAGAGTTTTACGTACCGGTATGAGAATTCCCGCCTTCTGGAA +CGGAATGGCAGTAGCCGCTGACTGGATGAGTGCCGCTTCCTTCATCAGTATGGCGGAGCACTCTACGCCC +TCGGGTACGACGACTCGCCTACATAATGGGATGGACGGGTGGATACGTTCTGCTCGCACTCCTGATAGCA +CCTTACCTCAGGAAGTTTGGAAAGTTCACAGTTCCCGACTTCATAGCGGAAAGGTACGAGAGTAACTTCG +CAAGACTCGTTGCGCTTATAATCGCGATAATAATCAGCTTCACCTACATGGTCGGTCAGGTTGCCGGTGT +CGGTATCATAATGGGAAGACTCTTCGGAGTTCCCTTCGAAATAGGTATAGCGATCGGAATGATAGTCATA +ATCGCAACCACAGTTCTGGGCGGTATGAAATCCATCACGTGGACTCAGGTTGCCCAGTACATCGTTCTTA +TAACAGCTTACCTCTTACCGGTTTCCCTTTTAGCAATGCAGTGGTTCGGAATTCCCCTGCCTCAGTTTCT +TTACGGTAACGTTCTCCAGTGGATCGTAGACCTTGAAAAACAACACGGTATCTCTCCCCACTACATAGAA +CCTTACGTTAAGTTCAACATGATTCAATTCCTCGCTTTGATGTTCGTCCTGATGGCTGGAACTGCGGCAC +TTCCTCACGTTCTTATGAGGTTCTTTACAACACCTTCGGTTAAGGACGCAAGGTGGAGTGCGGGATGGGC +ACTCTTCTTCATAGCCATACTCTACTTAACCGCTCCTGCGTACGCAGCCTTTGCAAGGTACGTCGTCCTC +AAAGACGTCGTCGGTAAGCCCATAGATCAGCTTCCCGCCTGGGCACAGAAGTGGGCCGAAACGGGACTCT +TTAAAGTAATAGACCAAAACGGTGACGGCATAATCCAGTGGGCTGAACTTCAGCTCCATAGGGACATAGT +CGTTCTGGCAACTCCCGAAATTGCGGGGCTCAGCTTACTCGTAGGATACTTCGTAATGGCAGGTGGTCTT +GCAGCGGCACTCTCCACTGCGGACGGACTGCTACTCGTTATAGCGGCAGCGGTTTCCAATGACCTCTACG +CTAAGATGATCAATCCGAACGCACCCGAGAAAAAGATCGTTATGCTCGGTAAGATAGCGGTTGCAGTAGC +GGGAGTGATAGGTGGTTTCGTAGCAGCAATGAAGATCGGATTCATCGTTCAAATAGTCGCTTGGGCGTTC +TCACTGGCAACGGCATCCTTCTTCCCGGCATTGGTTCTCGGTATATTCTGGAAGCGTCTGAACAAGGAAG +GTGCTATAGCAGGTATGGTTGCGGGACTGCTCGTAACGATTATCTACATTTATCTCAACAAGACTCAAGG +TTTCTCCATACTGGGAATACAGCACACCGCATCTGGTGTATTCGGACTACTGGTTAACCTGATAGTCTCC +TACATAGTCACGATGATGACACCACCTCCCTCCGAAAGGGTACAGAAACTCGTTGAGGACATCAGGTATC +CCAAGAAGATTCACGAAGTATGATAGTAGACGTCAAGGAGTTCTTACAGACACACTACCCCTTTTCCTCC +CTCCCCCCTTCTTCTTTAGAAAATCTTTCTAAAGTCATAAAGGTTAAGTACTACCCTAAGGGAAGCGAGA +TATTCAAAAAGGACGAAAAACCACTTGAATACCTTTACGTAATAAGGAAGGGAAACGTATCCCTCAGGTC +CGACGGTGTTGAGATAGACTTTCTATCCGAAGGAGACAGCTTCGGTTTTATATCTCTAATCACCGATTCC +CCTCCATCCTCAACAGCGGTAGCGGAAACGGATGTAATCCTTTACTTAATTCCTAAGGAAGTCTTTAAAC +AATTAATGGAGAAGTACCCCGAGTTCAGGAATTACTTTACGACTTCCCTCGCAAAGAGAATCGCCCACAC +AGCCGAAAGAGTAAAGGAAAACGGCGGAGCAAAAACCTTTGAGAAATTCTTAACGGTTCAGGTAAAGGAT +TTAAAGTTAAGAAAAGTCCCATTTATACTTCCCTCAGAGAGTGTTTACGAAGCGGTAAAGAAAATGGTAG +AAGACAATTCAAGTTGTGCTATTGTAAAGTCAGAGGACGAAGAAGGTATTATAACGGAGAGGGACGTTCT +TAAAAAGGTAATCTACAGGGATTTGAACCCTAAAGAGGTAAAAGTCAAAGAAGTAATGACAAGCCCCCTG +ATAAGCGTAGAGCCCACAGATTTCCTCTTCGACGTCCTGCTTACCATGTCCAAGAACAACATAAGGAGAG +TGGTTGTAAAGGAAGACGGAAACATACTCGGAGTTTTAGAAGACAAGGACATAATAGCCCTTGAAACCCA +AAACCTTATAGTGATAGTAAAGGAAGTTGAAAAGGCAAAGAGCGTAGAAGAACTCTCTTACCTTTACTCC +TTAGTTGACGATATGGCGGTAAACCTCTTCAACGAAGGTGTGAAACCCGAAGTAATAAGCAGACTAATAT +CCGAAATTAACGACAAGTTCATATCAAAAGCCATACAGCTCGCTATAAAGGAACTGGGACTTGAACCTAT +CGTTTCTTTCAGTTTCATGGTTCTGGGAAGCGAAGGGAGGAAGGAACAAACCCTCAAGACTGATCAAGAC +AACGCCTTAATATACGACGACACTTACCCTTCACTGGACGTTGACCTTGAAGATTACTTTAAGAAATTCG +GTGAGAAGATTTCGGAAATCCTTTTGAAAATTGGATTTCCCCCCTGTCCTTCAAACGTAATGGTAAGGAA +TCCGGAGTGGAACAAAGGAAAAACAGAGTGGCTGAAAACCCTAGAAAAGTGGTTCTCAAAACCCGATCCC +GAAAACACCTTAAAACTGGGAATCTTCCTAGACTTCAGGAACGTATTCGGAGATAAAACCCTAGAAGAAG +AACTGAGGAAAAAGGTCTTCGAACTCGCAAAGGAAAACGAACTCTTAATAGCTTACATGTTTAAGGATAC +GGTCAGGTTCAAACCCCCCTTAGGACTTTTCGGAAGACTTAAAGTAGAAAAGGAAGGTATTGATATAAAG +AAGGGCGGGATATTCCCTATAACGAGCGGTATAAGAACCTTGGCTATAAAAAACGAAATTGCGGAAACGA +ACACCCTTGATAGGATGAAAAAACTCTACGAGAAAGGAGTCCTCTACAAGGAGCTTTACGAAAACCTGAA +GGAAGCCTTCAATTACCTTCAGTACATAAGGTTAAAGTCCCAGATAGAAAAACTAAAGGAAGGGAAACAG +CCTGATAACTACGTCAATCCAGAAAGACTCAGTAAGCTAGAACTGGATCTTTTGAAGGACGCCTTTAAGG +TAGTAGCTCAGTTTCAGGAATTTATAGAGACGAAGTACCTGACCTACATACCCTCATGAACTTCCTGAAA +AAGTTCCTTTTACTGAGAAAAGCTCAAAAGTCTCCTTACTTCGAAGAGTTCTACGAAGAAATCGATTTGA +ACCAGAAGGTGAAAGATGCAAGGTTTGTAGTTTTTGACTGCGAAGCCACAGAACTCGACGTAAAGAAGGC +AAAACTCCTTTCAATAGGTGCGGTTGAGGTTAAAAACCTGGAAATAGACCTCTCTAAATCTTTTTACGAG +ATACTCAAAAGTGACGAGATAAAGGCGGCGGAGATACATGGAATAACCAGGGAAGACGTTGAAAAGTACG +GAAAGGAACCAAAGGAAGTAATATACGACTTTCTGAAGTACATAAAGGGAAGCGTTCTCGTTGGCTACTA +CGTGAAGTTTGACGTCTCACTCGTTGAGAAGTACTCCATAAAGTACTTCCAGTATCCAATCATCAACTAC +AAGTTAGACCTGTTTAGTTTCGTGAAGAGAGAGTACCAGAGTGGCAGGAGTCTTGACGACCTTATGAAGG +AACTCGGTGTAGAAATAAGGGCAAGGCACAACGCCCTTGAAGATGCCTACATAACCGCTCTTCTTTTCCT +AAAGTACGTTTACCCGAACAGGGAGTACAGACTAAAGGATCTCCCGATTTTCCTTTAAATTAATACTTAT +GATTGTAGGAAGATTTCCCAGTTCAAGACCGAGAAGGCTCAGGAGAAACGAAAACATAAGGAGGCTCGTG +AGGGAAACCCACCTTACCCTTGACGACCTAATATACCCCATATTCGTGAGGTGGGGCGAGAACGTAGTTG +AAGAAGTTCCCTCCATGCCCGGCGTTTACAGGTACAGTGTAGACAAGGTAGTTGACGCGGTAAAGGAAGT +GAGAGATTTAGGAATTCCTGCGATAATTCTCTTCGGTATTCCCGAACATAAAGATGAAGTTGGTTCGGAC +ACGTGGAGTGAAGAGGGGATAATTCAGAGAGCTTTGAGGAAGATAAAGAAGGAAGTTCCGGACATATACG +TGATTACGGACGTTTGTTTTTGTGAATACACAACTCACGGACACTGCGGAGTTCTTCACGACCACGACGT +GGAAAACGACCTCACCCTTGAAAACTTAAAAAAGCAGGTGGTTTCCCATGCGGAAAACGGGGCGGACATG +GTGGCACCTTCGGGAATGATGGACGGAATGGTAAAGGTTATAAGGGAAGCTCTAGACGAAGCTGGCTTTA +AACACATACCTATAATGGCATACTCCGCCAAATTTGCCTCCGCTTACTACGGACCCTTCAGGGAAGCCGC +GGAGAGTGCTCCCGCCTTTGGAGACAGGAGAACTTATCAAATGGATCCTGCAAACTCAAGGGAAGCCCTA +AAAGAGGTCCTGATGGACGTTGAAGAGGGTGCAGATGTAGTTATGGTAAAACCCGCCCTCGCTTACCTCG +ACATAATAGCGAAGGTCAAGGAAAACGTTCTGGTTCCCGTGTGCGCTTACAACGTGAGCGGTGAGTACTC +CCTTATAAAGGCCGCGGGAAAACTTGGGTGGATTGACGAGAAGAAGGTTATGTGGGAAACACTCCTTTCC +ATAAAGAGAGCAGGAGCGGATATGATAATAACTTACTTTGCGAAGGACGCGGCGAGAATGATCATTGAGG +GTGAGGTATGAAAAAAGTCGGATTTATTTACGACGATATTTACTTGAAGCACGACTGGCCGGAACACCCG +GAAAACAAAAACAGGCTTATCTCAATCTTAGAACACGTGGAAAAATCCGGAATAAAAAAGGCACTGATTG +ATGTAAAACCAAGAAGGGCAAAAGTGGAGGAAGTAGCACTCAACCACGATCCCGCTTACATTCAGGAAAT +TCACGACTTTTGTAAGTCAGGCGGGGGGTATTTAGACCCCGATACTTACGCCACTCCTGACACTTACGAC +GTTGCCCTTTACGCTGTGGGAGGTGTTCTTGAGGGAATAGACAGGATATTGAGCGGGGAACTGGACAGGG +CTTTTTGTGCTGTAAGACCTCCCGGACACCACGCGGAGTACGCAAAGGCGATGGGCTTTTGCATATTCAA +CAACGTTGCCATAGGAGCACATTATTTGAGGAAAATTAAAGGAGTAAACAAAGTTTTCATAATAGACTTT +GACGCACACCACGGGAACGGAACCCAGAAGAGCTTTTACGAAGACGACACAGTTTTTTACTTTTCCACCC +ACGAGTACCCTTTCTACCCGGGAACTGGCTCGGAAGACGAAAGGGGCGCGGGAAAGGGATACGGATACAC +TTACAATGTCCCAATGTCCGCGGGAGCGGGGGACGATGAATACATCCCCGTTTACGAAAAATTACTTCCA +GAATTGATGAATAGATTTTCTCCCGACTTTGTTCTTGTTTCCGCGGGCTACGACCTCCACAGGGATGATC +CTTTAACATACCTGAACGTTTCAAATGAAGGTGTGAGACAGATAGTTAGGAACATTATTAAAACTTCCGA +TGAGCTCAACGCTCCCGTTTTGTTTGCTCTGGAAGGCGGATATAACTTAAAAGCTCTCGGAGAGTGCGTA +GTTATAACTCTGGAAGAAATGTTGAGGTGAGATGGGGAGGTTTAAGTACCGCTCCGGAAAGGTAAAGCTG +GAACACCACATACTTGAAGGACTGGAAGAGTATCTAGATGAAATACAAAAGTGGGAATGCGTAGAGAGTA +TAATTCCGGGAAGGATAGTGAGACAAAACAAGGGAAGGGGCTCAAAAGGATTGTTTTTAAAGTACAGAAC +CATTACTGGTTATAAACTCCTTTACAAGACGGGAACCTCAGTTCAGGAAGTATTCGTGGTTTGCAAAGAC +TACGAGGAGTTTGAGAAAAAGTTTAAAGAAGTTTTCGGAAAATGATTATCGTTTTTCTCCTTTTTATTTC +TTTAATTTTTGCTTATGAGCCCGGAAGTGTTTACATTTTTAAGTTCCAAGAGGAAGGAAAGTACAGGGTA +ATTTTAAAGTCTAACCAAGAAGTTTACTCCTTTGACTGCACAGGGAAAATTTGTCTTTGGGGAGTGCCTC +TGAGTCTAAACGGGAAAAATGCACTCCTTGAGGTAAAGAGAGGAAGTAAAATAATCTTTAAAAAGCGGAT +AAAAATTTCAAGAAAAAGGTTCAAGGTTTACACATTAAGAATAAGAAAAAGGAAGCTTACACCTAAATTA +ATACGAAGAATTAAAAAGGAAAGAGAAAAGATTTTAAAGGTTCTGAAAACTCCCACTATTCCGGGAATTT +CCCGTCTTGAGCTTTCAAAACCTTTAAATAAACTCGTGGTTACTTCTGAATTCGGAGAGATTCGTTTAAT +AAACGGTAAAAGGAAGAGCGTTCACAGGGGTGTAGACTTCAGGGCAAAGGAGGGAGAACTCGTTTACGCA +ATCATGCCCGGGAAGGTAAGACTCACCGGAAACTTCTTCTTTACAGGCAATACGGTTATAGTAGAACACG +GGCAGGGACTTTATTCCCTTTACGCTCATCTCTCGGAAATTTTAGTAAAGGAAGGACAGTTGGTAAAAGC +GGGAGAGTTGATAGGAAGGGCAGGCTCTACGGGGCGTTCAACGGGTCCGCACCTGCACCTAGGTCTTTAC +CTCAACGGTATTCCCTTTAATCCTCTCAGTCTTTTAAGGCTTCGGTAATCCTTTCCGGTTTGAATATACC +TTTTTCTGTAATAATTCCCGTTATTAACTCCGCAGGTGTTATGTCAAAGGCAAGGTGCAAAGCGTCTGAC +TCCTTGGGAGCTATCGCACAACCACCGCACACTTTAACTTCCTCGGGAGAGCGTTCCTCTATGATGATTT +CCTCTCCGCTCTTTATATTAGAGTCTATCGTGGAAGTCGGGGCTGCTACGTAGAAGGGAACGTTGTGTTC +TTTACACAGAACTGCCAAAGTGTAAGTCCCTATTTTGTTGGCAACGTCGCCCTTTGCCGTTATGCGATCC +GCCCCGACGATGACGAGGTCCACCATACCCTTTTTCATTAAAAAGCCTGCTGTGCTATCCGTTATTATCT +TGTGAGGAATACTTTCCTTGACCAGTTCCCACGCGGTGAGACGTGCCCCTTGAAGGTACGGACGCGTTTC +GTCAACCCATACGAAGATGTTTTTCCCGCCGTAATGTGCACTCCTGATAACTCCGAGGGCTGTTCCCCAC +CCGGCAGTCGCAAGCGCTCCCGTGTTGCAGTGAGTGAGGACTTTTGCGTTCAGAGGAACGATTTCACTCC +CTATTTCTCCCATTCTTTTGTTGGCTTCGTAGTCTTCTTTTTCTATTTCTTTTGCCTCTTCTTCTATGTC +TTTGCCTTCCTTTAGGGCTTTCATCATCCTGTCCAGAGCCCAGAAGAGGTTATAAGCGGTAGGTCTAGTA +TTTTTTAATGTTTCGTAGACTTTTTCAGGATCTTCCTTTTGAACCTTTACTCCGAGCACGAAACCGTATG +CAGCTGTGCAACCTATGGCGGGAGCTCCTCTAACAGCCATTTCCTTTATAGCCTTTGCGACTTCTTCGTA +AGTTTTTAACTCAAGCCAAACTTCTTGATGAGGAAGTTTTCTCTGATCAAGGAGTAAAAGCTTATCTCCC +TTCCAGTAAAAGGGCTTTACTTCCATCTTCTCACCTCTCCAGAACATGTCTATCAGGAACACCGTAAAGA +ATTCGCCTTCAAAAACTTTATCTTCCCCTTTAAAGCACTCCACAAGAACCTTTTTCTTTTTTCCCTTGTC +CTCGGATACTCTTGCTTTACAAATTATTTCGTCTCCCACTTTCACGGGTTTTAAAAACTTTACGTTTGCT +CCTGCGAGAACTACGTTCGGGTGATTTACCGCGAGCATAGAGGCGTAATCCGCAGCGGAAAATATAAAGC +CCCCGTGCACGAGTCCCTTATCGTCCGCTTTCATACTCTCTTGAGTTTTGAGCAGAACTTCCGCGTATCC +CTCTGCAACCTTAACGGGTTTTCCGCTCAGTTCCTGATTTATCCCGAGGTGTGTTCTTATATCCATAATT +TAATAGATTAACCTTTCTTCAGTTCTTCAAAGAGTTTTATGTATTTATCTACAGTGTTTTCTATTGAGTA +GTTTTGTACGGTTCTTATTGCGTTTTTAGAAATCCTTTTCCTTTCCTCTTCCGATAAGCTCAGGGCTTTT +AAAATTTTTTCCTTCATGCCTCTCCAGTCTCCAACTTCAACCATAAACCCGTTTTCTCCGTCTTTTAAGT +ACTCTGGAATTCCTCCTGCGTTTGTTGAAATCACTATCCTGCCGGTTGCCATAGCTTGAAGGAGTGCCCC +GGCAATTCCCTCGGAAAAAGAACCGAACAAAAATAAATCCGCACCCTGTAAAAGCATTTCTATATCACTC +CTGAACCCGAGCCCCATACAGTTTTTTTCAAGTCCGTACTTTTTGAAGGTTTCCCCTGCTTCTTCGGAAT +CCGTATCCAGTCCCACAAAGAACATTTTGAAATTCCTGAATGGAAGTTCTTTTAAAGCCTTTAGGATTAC +TTCTTGTCCTTTTCTCCAAGGTTGCCAATTCGCAACGTTTATAAACATGTATTCGTTTTCCTTTACACCT +AGTTCTTTCCTAACTTCTTCCCTTAGTTCAGGTCTTGGATAGAACCTCTGAAGTTCTATACCGCTCTGAA +TAATTCTTATTCTTTCAGGGAAAAATTTCCATTTTTTTAGTTTTTCTCCCACTTCCTTTGAAACTACGAC +TATTCTGTTCGCCTTTGAGTATTTAAAGTATTTTGACAAAAATGAAGGCTTAAACCCGGAACGTCTCAAA +GCGATTATTTTTGGCTTTTCCCTCATAAAAGAGGTAGCCATTATAACGTAGTCAAGGGCATGGGAGGAGT +GAGCTATGACAAAATCGTAGTCGTTTTCTTTAATAATTTTTCTGAGTCTTAAAATATTTTTAAAATTAAA +CCTTGAAATTCCCCCTTTGTGTTCCTCGAAAAAGTGGATTTTTACAGGCGTTCCCTCAAGCTTTTTTACC +ATGTAATCATAGTCAAAGGCAAGGGCTATATGACTTTCTATTCCTTTCAGAGCCAAGTACTTGGTTATTA +AATAAGTTTGCTCCTTAGTTCCGCACCATCCAATACCGTCAACAACGTTGAGAACTTTGAACATAAATAA +AAAATTTTAGAAAAGAAGAAAAGCGGGAAAAATTAAGAAATCTGCTTAACGAGTTCCTTTGCAGGTTTGA +AAGTGAGAACCTTTCTTGCAGGTATTTGTATAACTTCTCCCGTTCTGGGATTTCTTCCCTTTCTTGCACT +CCTTACGGTTACTTTAAAGGTCCGAGTCCGGGAATTCTGAGCTTCTTCCTTTTCGAAGAGTTCGTGTATG +GCTTCTACGAAAGCCTTGATAGCTGCGTCAGCTCCTTCTTGGTTATGCCTGCTTTTTCTGCAATTTTGCT +ACGAGCTCAGCCTTGGTCATACCGCACACTTCCCTTAGTTTTTTCACATTTAATTTTAAAACGGACCTTT +TAATGGGGAAAGTACTTTTTTGTATCCTTCAAGCAAATCTCCTAAATCAAACGGAATCTGTCTTTATCCA +GTTTTCTCCCGTAGACTTATCCCAGAGCCTCATACTGTCTGGTGAAATTTCGTCAACGATTGCAAGTTCA +CCGCTCGGAAGTCTTCCGAACTCAAGTTTAAAATCTACGAGTAAAATTCCCTTTTCTTCGAAAATTTTCT +TTAAAATCTCGTTAACCTTTAAGGCAATTTTTTCCATCTCCGGAACGAGTTCAGCGGGTGCGAGCTTTAA +AACCTTTATATGGTTTATACATACCATAGGGTCGTGAAGTTCGTCGCTCTTCATGAAGAATTCTACCAGA +GGTTGTTCAAGTTTAGTCCCCTCTTTCACTCCGTAGCGTTTTACGAAACTCCCTGCAGCGTAATTCCTGA +CTACAACCTCTACGGGAAATCTCTCTGCTCTCCAAACGAGCATTTCCCTGTCGGATAACTTCTTTATGTA +GTGGGTTTTTATCCCGTGGTCTTCAAGAATTTCAAATATCAAAGAGGAGATCTCGTTGTTTAAGCTTCCT +TTTCCCTTTATTTCTTCCTTCTTCACCCCGTCAAATGCGGTGGCAACGTCTTTGAACTCCAGGATTAACT +TGTCCTTTTCGTCTGTCTCGTAAACGATCTTTGCTTTGCCTTCGTATAGCTTTCTCACCTTTTTCATCTT +ACCTTAAAGGTAAACTCTTTTGAATTTAGTTCAACAATTACAAAGGGTGGTAGTCCCTCGTAGTTCTCGT +GCTTTCCCAAAGAGTCAAGGGCGAATACTTTAAAGTCGTCAAGTTTTGCTAGTTTTACTAACTTCTCTTC +CTCGTAAAAGTCTATACTTCCCGAGGGATAAGGGAATTCGTAGAGGTAAAGCCATCCGTCTTTGTGTATA +AAGCCTTTCTTTACCACGCCTCTGTAAAGGCTTCCTCCTGAGGTTATGAGGAAAAGTTCTTTTCCCTGAT +TTATCTTCAGCTTTTTTGCCCCCGCCAGACTGCGCTGAAGTTCCCAAAAAAGCAGGGCTTCACTTTTCAA +TCTTTCCGCTTCTTTCTTTGCACCGAAGGTAAAGAAAGTAGCCCTCTGAAAGGAAATCAAGATTAGGGAA +AAAACTAAGGAAATTATCGCAAGGGTTATTAAGACTTCTACGAGTGTAAATCCCTTAAAAGTGTTTCCAG +CCCTTTGGCTCAACTTTCTTTCCATCTACGAACACACCTTCGCCTTCTTCCACTCTTCCTATTTCCGTCA +TGTCTAGAAAGGGATTCCACCTCTCTTTTGGGTGTGTGAAGAGGAGCTGGTAGTCCTCTCCGCCAAAGAG +TGCATACTCTATAGGATTTTTTCCGTACTTCTCGCAGTACATTTTCAGTTCGTTGGAGAGGGGTAGCTTT +TCGGAAAGTATTTCTATCTTGACGCCGCTCCTTTGGGCAAGGTGATTTGCATCTGCCACAAGCCCGTCAC +TTATGTCCATACTGGCGTTTGCATACTTTTGAATGTGCTTCACGTAGTCTATTCTGGCTGTAGGTCTTAA +ATGTCTCTGGATAAGGGCGAGTTCAAAGGGCTCGTATTCCTCCTTTTCCATTAAAAGGAGTTCAAGTCCT +GCCCTCGAGTCTCCGAGCGTTCCCGACACGAATACGCTGTCTCCTAGTCTTGCCCCGTCTCTTCCCACGA +ACCTCTCCGTCTCACCTACGAGGAATACCGAAATCCCTATTTTCTCGCTTTTTGATATATTCCCTCCCAC +CACCTCACACTTGTAAAACTCGCAAGCCCTCTTAACGCCTATGTAAAACCTTTCCACGTAGGAAACCTCC +AAATCCTCCGGAAGGTTCAGTGAAATGAGTGCCCACTTTGGAAGTCCTCCGTTTGCAATGACATCGCTCA +CGTTAACGCTTATCGCCTTCCATCCCACCGCTTCGGGAATGTAGCTCCTTAAAAAGTGTACGCCCTCGTT +CAGAACGTCCGTGGTAAGGAGGAGTTTTTTTGAACAGTACTCTACGGGAGCGGTATCGTCTCCTATGACT +TTACTCTCGAGGGTTTTCTTTATAAGGTCTATGAGTCCGAATTCTCCTAATTCTTTCAGTCTCATTTCGT +CACCTTCTCTTCGGAAAGTCTCACCACTATTACTTCCTTCACTTTGTTATTCTGAACTTCGTTCACTATG +AACTTAAAGCCGTCAAAAGTAAACTCGTCTCCTTTCTTCGGTATCCTCCCGAGGTTTGCCATAACAAAAC +CGCTCACGGTGTCGTAATCGTACTCTTCGGGGAGTTCCAGTCCTATCTTTTCCGCGAGTTCCTCTATTGA +GACAGAACCGCCCACTCTGTAGGTGTCCGCGGAAATCTTTTCTATTTCCTTTTCCTCCTCGTACTCTTCG +GGTATTTCTCCTACTATCCACTTGAGGACGTCGTAAAGGGTAACTACTCCAGAAACCGCACCGTGCTCGT +CTATAACAACCGCGAGTTTTATCTTGTACTTCTTTATCTCCCTCAAGAAGTTTGAAAGTGTTGTTACCTC +GGGAATTATAAGGACGTCCGTGGCAAACTCCTTAAGGGCTCTTTCCCTGTTGTGCTGAATGGGAAGTAGT +TCCTTAACGTGGACTATACCGCTCACGTTGTCCAGAACGTCTTTATAAAGGGGTATCTTACTGTGTGCCC +TTCTCTTAATCTCTTCCACTACTTCCCCGACCCTTTTGTCCTCGGGCAGGGCGAATATCTTAGGTCTTGG +TGTCATTACTTCCCTCACGAGTACCTCATCCATTTCGAGTACCTTCTCGATCATGCTCTTTTCTTGGATT +TCGAACTCCCCGCTCTCTATACCTTGTTCTATAAGGGAGAGGAGTTTTTCTTCCGTGAGTTCGAAGGTCT +CCTCCTTAATCTCCACACCCATCTTTTTGAGGAGTGTCTGAACGGGAAGGATGAGAATTATCCTCAAGGG +CGTAATAACGACGTGGAATAGGTAAAACACCGGAGCGTAAACAAGTGCTAAACGGTCAGCTATTGGAAGA +ACTACGTTTTTTGGAATGGTCTCTCCGAATATGAATATAAGTGTTGAGGACACAGCTACCGCAAGGAGTG +CACCTTTGTCTCCGAAAAGCTCTACAAAGGTTTTCGTTCCGTAGGAAGCTATTAGGACGTTCACGAGCTC +GTTTCCTATGAGTATGGATATGAGGAGTTCTTTGGGTTTTGATAGGAGTTTCATCAAGAGTTTAAAGAAC +CGATTTCCTGAAAACTTCATTAAGACGGGCTTACTCACGCTGAAAAACACGACTTCCGAAGAGGAAAAGA +AACCGGAAGCGAACAGTAAGAAGAGAAAGACGAGAAAGTCAGTATAGATTGCAGGCAAGGAGTCTTCCAT +TAACCTCCGACCTCCTTATGAATTTTTTACACTCTTCCATAGCCTCGGGACACCTCGGATAGAAGGGACA +TCCTTCTTCGGGAATGCTCACCTCCTCCTCCTGAAGGTATTTTAAGGGTTTTCTGTCCTTCGGGTGTCTC +ACGGGAACGTTCTCCAGAAGGAACTTTGTGTAGGGGTGAAGGGGATTTTTAAGAACCTCTTCTTTCTTTC +CCAGTTCCATGAGGATTCCCGCGTAAATCACGCCTACCATGTTTGCCACCTTTTCCACTACTCTTATGTC +GTGGGTTACAAAGAAAAAGCTTATACCTTTTGAATTTAATTCCTTGAAGAGTTCCAATATTTCCTCCTGA +ACGGATACGTCCAAAGACGCGGTGGGCTCGTCAGCCACTATAAGTTCGGGTTCTAAAATCAAAGCCCTCG +CTATTGCCACCCTCTGAGCCTGACCTCCCGAAATCTGGAGCGGTCTCTTTTCAAGCAGTTCCTCACTCAG +GCGAACTCTTTGTAGGACCTTTAATACTCTCTCTTTCCTTCCCTTTACTCTGTGAACTATTAACGGTTCT +TCGAGGATTTCCTCCACCTTCATTCTGGGATTGAGCGAACTCCTCGGGTCCTGAAATACAGCGGAAACCT +TCCTCGTATACTCCTTTCCCATACTAAAGATGTCCTTACCTTTAAATGAAACCTTTCCTTTAGTAGGTTT +TTCAAGTCTCAGGATTATCTTTCCCAAGGTGCTCTTTCCCGAACCGCTTTCTCCTACGATAGCCAGAAAG +TCTCCTTGCTTTATGGAGAGAGAAACCTCTTTGAGGGCGAAAAAATTCTTCTTTCTTAAAAATCCCGCGG +GAACTTTGTAAACTTTCGTGAGATTCTGTATAGAAAGGAGTTCCATTTTATATGGTTCTGGAGAAATTCA +GTTCCTTTTTCCTCCTGAGATGTGCGTCAAATACCATGGCAACGTTCCTTATGAGAAGCCTTCCCACAGG +CATTATCTTTATCCTGTCTTCTTCCACCTTTATGAGTCCATCCTCCTCCATCTCTTTAAGTTCTTCAAGC +TCTTTGGCGAAGTACTCCCTGAAGTTTATACCGAACATATTCTCTATTTTGGAAAATTCCACTCCGAGGT +TGCACATTATGTCCATAATGACTTCCCTTCTTATGAAGTCGTCTTCGTTGAGAACGTATCCCCTGAATAC +GGGTATTTTCCCCTCGTCCACAGTTTTGTTGTAGTCCCTGAGCGTTTTCCAGTTCTGGAAGTAAGAGTCG +TAAAGCATACCTATTGAAGTAGCTCCAAAACCGAGAAGCTCAACTCCCTTCTTAGTAGTGTATCCCTGAA +AGTTCCTCCAGAGTTCTCCCTTCCTTTGAGCTACCGCGAGTTCGTCCTCGGGTTTTGCGAAGTGATCCAT +ACCTATGTAAACGTATCCTGCTTCCTGAAACTTATTTATAACCATCTCAAAAATTCTTAACTTTTCTTCT +GCAGAGGGGAGCGCTTCCTTTGGCAGGAGTTGCTGGTGGGGTTTTACCTGCGGAATGTAAGCGAAGCTGT +AAGTCGCTATTCTGTCGGGGTTCAGTTCTATCACCTTTTCCACAGTTTTCTCAAAACTTTCCTTTGTTTG +GTAAGGGAGACCGTATATGAGGTCTAGGTTAATACTTTCAAAGCCAGCCTCCCTCAATTTTTCCATTTTC +TCCTTTATGAGTTCGTAGGGCTGAACTCTGTTTACGGCTTGCTGGACTTTCGGATCAAGGTCCTGAACTC +CGAGACTAATCCTGTTGAAGCCCGCATCCTTTATCGCCTTTATTTGCTCATCGGTCAAGTATCTCGGGTC +AAGCTCTATGGAAATCTCTGCATTATCTCCGAACTCAAATCTCTTTCTTATCTCTTCCATGAACCACTTT +ATCTGCTCGGGTGAGAGGTAATTCGGCGTTCCGCCACCCCAGTGGAGCTGTATAACTTTTCTGTCTTTGT +CGAGATACTGGGAAACTAAATCCATCTCCCTGCAAACTCTTTCAAGATAGGGCTCCTCAATCCCTTTCCG +GTGGGAAATTATCACATTACAACCGCAGTAAAGGCACCTCTGTTCGCAGAAGGGTATGTGAAAGTAAAGG +GATAGGGGTGTTTTCCTTTCGTTGCTCTTTATTAGTCTCTTTACGTACTCGTCTTCTTTTACCTCTTCGG +TGAACTCCGTTGCGGGAGGGTAGCTCGTGTACCTTGGTCCGGGTCTGTCGTACTTCTTTATAAGCTCCTT +GTCAAACTCGGCTTTCATTATGAGAATAATATAGGTGAAAAACTTAATATTGGATAATAGAGTTATCATC +TATTTTTACTTCTTTCCTGAGGCTTTTAATTGTTTATTTGCAAGAAATAAGGCAGCCCCACCTAATACTA +CAATAAATATGAAAAGAGCAAGGTATACAATTAGTAATGCCTTTTCACCCTCAAAGATCATACGGTTTAT +AATTTATCACTCGTATTAATAAGTGCAACACCAAAAAAGATACTTATTAAAGCAATAATAAATCCTATCC +CCAGTATAGAGAGATCCAATTTATCCTTCGCCAGAGGCTGAACAAAAGTTGCTATCAAAATCGCTAAGGC +TAAGTTGATAAAGAATTTCCCAAGCTCAAGAAGTGCATTCTTCGAAAGCCTCATGCAATTATTATTTTCT +GGGTACTAAAATTTTTGATTGCAGACATCATAGTGGAGAGAAAATTATTCATAAGATAGCAAAAATTAAT +ATATATGGCTAAAACTGGAAAAGTGGAAAACTTAATCCAAAACGCCCCCGAAAAACCGGGAGTTTACTTA +TTTAAGAAAGGAAATAGACCTATCTACATCGGAAAAGCTAAAAATCTGAAAAAGAGACTCCTTCAACACC +TGAAGGCTTCCGAATACGACTCCAAAGAAAGGGCAATAATTTCAAACTCAGACAACCTTGAGTGGATTGT +AACGAGAAACGAGTACGAAGCGCTGGTTTTAGAAATTGACTTAATACAGCAATATAAACCGAGGTACAAC +GTCCTACACAAGTTCGGGGGCGGTTATCCTATGCTCTTACTCACAAAAGACGAATACCCTACCATCAAGG +TAGTCAGGGGAACAGAGCACGAGGGGGAACTTTTCGGGCCATTTCTTCAGAGCAAAAAAGCTTACAAGGT +TAAAAAGCTTATACACAACCTCTTCAAGCTGAGAACCTGCGACCCGCTACCCAAAAGGAGTGAACCCTGT +ATGGATTACCACTTAGGACTTTGCAGTGCTCCCTGTTGCGGTTTCGTGTCTAAAGAGGAGTACGAGCTTG +CGGTGAGTTCCGCCAGAGCACTTCTTACGGGAGAGGTTGCAGAAGTTCTTCCCAAGCTCTACGAAAAGAT +AGAGGAGTTCTCAAAGGAACTCATGTTTGAAAAGTGTGCACACATAAGGGATCAGATAATCGCCCTTGAA +AACCTCGCAAAGGGACAGGCGGTAAGCGCCCTTCCCTTTAGGGAAGGAGACATATTCTACAAGTTCGGTT +CAAGGCTCGGGCTCCTTTTAGTAAGGAGTTCCAAGCTCGTGAGCAAAGAGATTTTTGACTTGGAAAGTGA +TGAAGAAGTTGAGGAAGTAATCCTCGGATACTACTACTCAAACTACGTTCCGAGAAAAGTAATAACGAAC +TTTGAACTCTCTGAGGAAGTGAAAGAGTGGATAAGGAACAGGGCAAAGGGAGAGGTTGAGTTTTCGGGAG +AAATACCAAAGGAGCTAAAGGAAGTTTTGGAAGAAAACCTCGGGGAGGGAATAAACGAGGAGGTTCTGAA +AAAGGAGTTTGCTGAAAAGTTAGGAATGCCTGTACCAAGAGTTATAGAAGGTTTTGACATTTCCCACTTT +TACGGAGAGGACATCGTAGGCTCTTGCGTGGTCTGGAAAGGGGGAAAGATGAGCAAGAAAGATTACAGAA +GGTATAAAGTGAAAACTATAAGCCGGATAGACGATTACTTGGCCCTTGAAGAGGTTTTAACGAGGAGGGC +AAAGAGGATTTTAAAGGGAGAGGTAGAAAAGCCCGATATCTGGCTAATAGACGGGGGTAAAGGGCAACTA +AACGTAGGGATAAGAGTTAAAAAACGCACGGGACTTGACGTAAAGGTTTTCAGTCTGGCAAAGGAAGAGG +AAATCATTTACACGGAAGACGGCAGGGAAATAAGGCTAAAGGAAAATCCCATACTTTACAGGGTTTTCGG +GGAGATAAGGGATGAGGCTCACAGGTTTGCCCTGAGCTACAATAGAAAACTCAGGGAGAAGAGGTACATG +GAGGACATACTATCAAAGATAAAAGGGATAGGAGAGCAAAAGAAGAAGATAATTTACAAAAACTTTGAAA +CTCTTTACGACTTTATAGAGGCTAAAGACGAGGAGTTGAGAAGGCTGGGAATAAACCCTTCTCTGAAGCA +GGAGGTGAAGAAGTGGTTAAGTTAGATTACGAGCCTGTTTACGACATAACCGCGGATGCGGGCATAAGGG +TAAGGGCGAAAACACTGGAAGAACTATTCTGCCACGCCATTCTCGCAACCTTCAACGAGATAACCGACAT +AGACAAGGTAGAACCAAAAGAAGAATACGAAATTCAGGCTCAAAACGATATGCCGTTCCTGCTTGCGGAC +ATAATAAACGAGGCACTAGTTCTGCACGAGTCTAAACACTTTGTGGCAAGCGAGTGTGAAGTTCTGGAAC +TGAAAGAGGATTTCGTAAAGGTAAAACTGAAGGGGGAAAAGTTTGACCCTAAAAGACACCCTTCAAAGCT +AGTCATAAAGGCGGCGACCTACCACAGACTGAGGGTGGAGAAGAAGAACGAACATTGGGAAGCTGAGGTA +ATCTTTGACATATGAAGGGAAAGTACTTTATAGCTTTAACGGTAGGACTCAACTTGGTGGGCGGGATAAT +AGCGGGAATGCTCGTGGGATGGGGCTTTGACTGGGCTATGGAAAACTGGTTCGGCGTTAAAACAAAACCT +TGGGGCTTCATGTTTTTCTTCTTGATAGGGATAGTAGCGGGCTTTAAGAACGCTTACGTTGACCTAAAGA +GAATAGAAAAGGACTTAAAGTCTTCTGAAGAAGAGGGAAAGAACAACTCCGATTAAGTTCTGTGAGAGAC +TAAAAATAGCGGAGGGAAGAGCGGAGACTTTTGAAAAGTACTTTAGAGCGAGAACCGTGGAAAGTCCAGA +GTTTTGCATACCCACCTCTATTGAAAGGGCTTTCACCTTCCTTTTATCAAGCCCGGCCAACAGCCCGAAA +AGGTATCCCAGGAGAAAACCGAGGACGTTGTGAATCAAAACCACACTCAGAACGAGAAAAGAGAGTTCCT +TTAAAAGTTTTGAGTTCAGGGCAAATATTACAGCGATTATGAGGGAAATTGAGAAAACCGCCAGGAAAGG +TAAAAACTTTTCAACTTTGTTTATTTGGTATCTCAGGAAGTAGCGAAGAACCATACCGAGTAAAACGGGA +ACTATAACTATCTTCAAGGTAGTTTCAAACATAGAAAGGAATGGAACTTCTACGTACTTGCCCGCGAGAA +CGTATGTCCATAGTGGGGTAAAAAGAGGTGAGAGTAGGGTTGATGTGGTCGTCATTGAGATTGAGTAAGA +TAAATCTCCTCTGGATAGGTAAGTTATCAAATTGGAGGCGGTTCCGCCCGGAGCACTCCCGACGAGCACA +ACGCCCACAAGCAGTTCCGGGGGAAGTTTGAAGAGTTTTGAGAGAAGATAACCGCTCAGGGGCATTACCG +TGTACTGCAAAAGTGCACCGTAAAAGACTATAAAGGGCTTTCTCGCTATTTCCTTGAAGTCCTCAGGGGT +AAGCGTGAGCCCCATTGAGAGCATAATCACTATCAGGAGGGGAAGTATAAGGGGTTTTAGGTTTGCGAAG +AATTCAGGAAAGAGTATCCCGAGGAGCGAGAGCGATACGAGAATGAGTAAAAAGGAAAAGTCCTTCATTT +CTTAGGATTTTAAATTGCGTGTGATAAAATCCCAAGTATGGACAACACTACTTTGATCGTTGTCCTGTTC +GTAATAGGTGTTTTATTCGGAATTGTAGCCTTCGGTATGGTTCTCAGGCTTTATCAAAGGGAAAAGGGTG +GAAAGGGAAGTTCTGAAGATTCTTAATGAACCGCTGGTGATTTTCTTTATCTGGATGGCTGTTCTTTACC +TGATAGCCACGGTATTTCTCACTAAACGCTTTGCCTTCTGGGTGTCTTCACTCCTCACGACCTACCTCTG +GCTCAAGATGGGAATGGACGAAAAAGCCCTTCTCTTTGCGTGGGGTGTTATATTCCTTATTCTGTTCGTA +GTCTACGTTGCGAGTGTCTTGTTTCACATACCTCCCTTTACCTTCTTTACTGGTAAAAAACTCTGCAAAG +TTTGTTACATGGCTGTTCCCAGAAAGGCAAAGATATGCCCTTACTGTCACTCTGAGTTAAACGGTTCGTA +AAGCTGAGGTCTGTATCCCCTCATGAAGTCCTCTCCGCGCATCTTCTTTCCTTTGGGCGAAATTAATTCA +AGAATTTCTAAAGATTTTTCTCCGCACGCCACTATGAGCCTTTTCGTGTCCTGTATCTCTCCGGGGTATC +CCTCCAAATCCACAACCCTCGCTTTTAGTATCTTTATCCTGTTTCCCCTGAACGTGGTGTACGCGTTGGG +ATAGAGTCCTCTAATCCTGTCTCTCACACTTTCAGCAGAAGCTTTCCAGCAAATTCTGTACTCTTCCTTT +TGAACAGGCGGGGCGTAGGTGGCCTCCTCGTGGTTCTGGGGAACGGGCTTTACTTTGCCTTCAAACCAAA +GTCTTAGGGTGTTTACGAGGAGTTTAGCTCCGCTTTTTGCGAGTTTTTCGGATAGGGTTAGGAAGTTATC +TTCCTCTTCAATGGGAATTTTTTCCTGAGCGAGTATGTCTCCCGCGTCCATCTCCTCATTTACGAGCATG +ACCGTGTTGCCCGTTTCCTTTTCCCCAGCCATGATTGCCCTCTGGATTGGTGCGGCTCCCCTGTACTTGG +GAAGGAGTGAGGCGTGAAGGTTTATCGTTTTGTAAGGAGGAAGGTCCAGAACTTCTTTCGGAAGTATCTT +TCCGTAAGCGACCACCACTATACAGTCTGGTTTCAGTTCTTCTACGAGTGGTATTAATTCTTTTTTCTTC +TCGGGCTGGTATATGGGAATTCCCAGTTTCTGGGCGAGCACTTTGGTGGGTGGAGGGGTTAATTTCTTTC +CCCTTCCCGCCGGTTTGTCGGGTTGGGCAACCACTCCTATGACCTTGAAGTTTTTAGCGAACTCCTCCAG +AGAGGGGACCGCGAACTGGGGAGTTCCCATGAAGAGGATTCTCTTCAAGACTGCACCTTCCAGTTGTCTA +TGAGTCTGGCATTTCCTACCCTTACAGCGACTAGAATTCTGTCCCCCTTCTCAACAGTTTCCTTCGGGTT +TAAGTTCTGGTCCGTTATCTCCACGTAGTCCACTCCCTTAACGTGAGGGTGTCTCTCTATAAAAGCCCTT +ATCGCCTCCTTTATCCTTTTTGCATCCCTCTCTCCCGCCTTTATCATCTTCTCCGCGAGGAGGAAGGACT +TGTAAATGGAAAGGGCTGATTCCCTCTCTTCTGGGGAGAGGTAAACGTTTCTGGAGCTGTAAGCGAGTCC +GTCTTCTTCCCTCACTATCGGCACGGGAACTATCTCAACGGGAATGTTGAGGTCCTCCACCACCTGCTCT +ATTATCTTGAGTTGCTGGTAATCCTTTTCCCCGAAGTACGCCCTGTTTGGCTGAACTATGTTAAAGAGTT +TTACGACTATCGTAGCCACTCCGTCAAAGTGTCCCGGTCTGAACTCTCCTTCCAGTACCTTACCGAGTTC +CCCTACGCACACCTTAGTTCTATAGCCCTTCGGGTATATTTCGTCAACTTCCGGTGCAAATACAACGTCA +ACACCCTCTTCTTCGCAGATTTCAAGGTCTCTCTCCAGATCCCTCGGATACCTGTCGTAGTCTTCTCCCT +CTCCGAACTGAGTCGGGTTCACGAAGATGCTCACAACAACTATGTCGTTCTGCATTCTGGCGAGTTTTAT +AAGCTGTCTGTGCCCTTCATGGAGGTATCCCATGGTGGGAACGAAGCCTATTTCCTTTCCTTCACACCTC +TTGTTTTTCAGGAAGTTTCTCAAGTCCTTAATTTTCTTAAACAGGAGTGGCATCGCTAAATATTATATAT +TTTATGAGGTTATACGGTATTCCCTCCGAGGACAGAGCTGAAGAAATAGCGAATAACATAAAGGAAGGGG +AGTGGGTATTCGTGGACAGGCAGGAAAATAAAAAGGAATTTCTGAGTGCAGAAGAGGCAAGGGAGAAGTT +CAAGGAGCTCATAAATCAGGTAAGGAGCTGGAAAGAACAGATGAGCACCCTCTCCAAGTACGCAATATTT +ATATTCGTTGACGATACACAAAATCCGAAGGCTATAAAGGTTTACGACACTTCCTCTCTCGGCTGTTCAA +CTAGCCTCGTTCCAGAAAGGTGGAGACTTTACAGAAAGGAGATGGAAGGTGAGTTCAATGATAATTAAGG +TAATACCGGTCGGTCCCATAGCCGTAAACTGCTCGGTAGTGGCGGACGAAAAGAGTGGAGAAGCCATAAT +AATTGACCCCGGAGCGGAGGCGGAAAAGATTTTAGAAGCTGTGAAGGACTTCAAAGTTGTGGGAATAGTT +GCGACCCACGGACACATAGACCACGTGGGGCAGGTTGGGAAACTCAAAGAACTCTTTGACGTCCCTTTTT +ACATGAATCCACTTGACAAGTTTTTAATTAACGACGAGATTTGGAGCGGTTTTGCTTCCTACATCGGTGC +GGTTCCCTGTCCCGAGCCCGATGTAGAGATAAGTGAAGGAGACGTTATAAGAGTGGGAGATGTGGAATTT +AAAGTCCTTCACACACCGGGACACACGCCCGGGCTTTGCTGTCTTTACGAGGAAAAGAGGAGGGTTTTGA +TAGCGGGGGACCTTCTCTTTAAGGGAAGCGTGGGGAGGTGGGACCTTCCAGGAGGAAACCTCGTGGAGCT +TAAAAAATCCGTAAAAAGGGTTCTTACAGAGCTTCCGCAGGACACACTCGTTATATGCGGGCACTACGAC +GAGACAACGATAGGGCAGGAAAGGGCTTTTAATCCCTTTGCAGGAGAGCTTTTGAATGGATGAAGTAGTA +AGGCTTGAACACATTTACAAGGAGATAGAAGGAAGAGTAATATTGAAAGATGTAAATTTTTCCGTTTACA +AGGGGGAGATTTTCTCCATAATAGGGGGAAGCGGGAGCGGAAAGACTTCCATAACAAAACTGATAGTGGG +TCTGTGGAAGCCGACAAAGGGTAAAGTTCTCGTTTTCAGGAAAAACGTTCCGGAACTTTCGGGACTCGAA +CTTGACGAACTTCGCAAAAACATAGGCTATGTCTTTCAGGAAGGGGCACTCTTTGACAGTTACAGAGTCT +GGGAAAACGTGGTTTTTTATTACTTAGAACACGGAAAGCACAATAAGGAAGAACTAAGGAAAATGGCACT +TGAGAACCTGAAACTTGTAAATGTGGATGAGAGTGTTCTTGACCTTTACCCTTCCGAACTTTTTGGAGGT +ATGCGAAAGAGGGTAGCGATTGCAAGAGCAATAGCTACGAGACCCCAGTTAATCATATACGACGAGCCAA +CTTCCGGACTCGACCCCATCACGAGCAGAGTCATAGACAAACTAATCTTAGAACTCAGGAACAAAACGGG +AACGACTTCCCTCGTGGTTACCCACGATATGATATCCGCCTTTACGATATCCGACAGGGTTATGGTCATA +AAAAACGGGGAAATTATAGCAATAGGAAAGCCTGATGAAGTTATAGACTACCCCCACCCCTACATTCAGG +AGTTCGTGGGAGCTATCAAGTCCTGCCTCAAACACGCCAAGGTTTAGAATAAACCTATGCTCAAAAATCC +CCTCTTTATCCACGGATGGGCGTTTTCCTCAAAGGTATTTAATGACTTTCACGGTATAAAGTACGACCTT +CCCGGGCACGGAAAAAATAAAAATCCCTACGAGAGTATAGAAAAAGTAGTGGAAGAAATTGGAAAAATAG +CCACTTCAAAACACGACGTTGTAGGCTGGTCCCTTGGAGGAAGTCTGGCACTTCTTTTCGCTTACAGGTA +TCCAGAAAAGGTAAACAGGTTGATCCTTATAGGGACCACTCCCCACTTTAAAGGAGCGTGGAGCGAAAAG +AATATAAGGGCTATGAAACTCCTGATAAAGAAGAAGGGGATAAAAGCTTTCAGGGAACTAGCCTACGGGA +AATTTGAGGACTTCTTTGACGAGGAGCAGGGCATGAGATTTCTTGAGGACTACGTGAACCTGAACTTGTA +CACTGTACTTCCCTATATAAAGAAGGAGGTTTACCTGATACACGGAGTTTCGGACAGAATAGTTCCGTAT +TCAGAAGCTTACAAACTGCATAGAGCTTTAAAATGCTCTAAATTAATCCTTCTCGGAGGAGGACACTTCC +CTGTCAGAAATGAAGAACACCTTAGGAAGGCAATTCTCAAGGGCTACTGAAACCTACGAAAAGTGGGCAG +TTCCCCAGAGAAAGTCTGCAAAAATCCTAGTGGAGTTCGTGAAGCCCTCAGGCCTGGTTCTTGACCTCGG +GTGTGGGACGGGCTTTGTTTCAGAATTTGTAAATGACTGCGAAGTCGTAGGACTTGATATCTCGGAGGGA +ATGGCAAAAGCCTACAGGGAAAAGTTCAGGAAGGTAGTTATCGGTAATGCGGAAAATCTGCCCTTTAAAG +ATAGGAGTTTTGACTTCGTTCTGAGTAACTTCTCCCTTCACTGGAGCGACTGGAGGAAAAGTATAAGGGA +AGCCCTGAGAGTTTGTAAAAATTTCGTAGGTGTGGCCATTCCCGTCTACGGAAGTGTAAGTTTTTCGGAA +TTTCCCTTTCCCAAGGCGGAAGAAATTTTAGAGGAGTTCAAACCACAGGAGTTCAAAATCATCAACCTGG +AAATCCCTTTCAGGGGAATGGAGCTCATTAAGTTTTTCCACTACACGGGAACTGCAAACTTCACGGGAAA +GAAAAACTTCAAAACCAAGAGGGAACTCATAAAACTTTCCAAGGACTTAGAAAAAGAATACTTTAAGGTC +CTGTTCTTAAAGCTCAAGAGCAGAGCTTTTTAAGGATTTCTCCCAGAGAAGTTACCACCTGACTGTTTGG +AATAACCTCGTCAACTCCCAGCTCCTTTGCCTTTTGAATTAAGGGAACGTTCTTATGCCCGCAGTATCCC +ACAACTTTCTTTCCCTTTTCTTTTAGCTCCTTAACCACTTCCAGACCTTTAGGAGATTCAAGGTTTACGA +CTCCCGCGCACGCCTCTTCTTTATCGGAAATCTCAAAACCCTGTGAACTCAAAAGAGACCTAACTCTTGA +GGCCAGTATAAGGTTCGTGTCGTAGAGAAAGACCTTCATACTATGTTAAAATTTTAGGCAAATGACCAAC +GAGCTTCTTATCGAAATAGGCACGGAGGAGCTTCCCGCCGGAGTAATAAACCCAGCACTTGATTACTTAA +AAGATAAGATAAACTCCCTTCTCAACGCAAGACAAGTAAAAACCTATGGAACACCCAGGAGACTAACCCT +TTACTTTAAAGACTTTGAAAATGAAAGAAAGGAAAAAAAAGAGGTAATATGGGGTCCTCCCAAAAATGTA +GCTTACGACGAGAAGGGAAATCCCACAAAAGCCCTTGAAGGTTTCCTTAAAAAAAACAACGCATCACTTG +AAGAGGTAAAAGTTTTAAAGAAAGACAAAGGCGAGTACGTGGCAATAGTAAGAAAAGTAATAGAAAAATC +ACCAATTGAGAAACTTCAGGAAGAGTTTGAAGAAATCCTTCTTTCCGTTCCCTTCCCAAAACGAATGCGC +TGGACCTCTTCAAAGAGGATAACCTTCTCAAGACCTGTCAGGTGGATTCTCGCCCTCTTCAACGGCCAAG +TGCTAAAACTGAGGTTCGGAGAACTGGAGAGTTCCAATAAAACCTACGGCCACAGGTTCTTATCAAAAGG +CGAAGTAACGATAAACAACCCAGCAGATTACGAAAAAACCTTGAAAGAACACTACGTTATACCGGACTTC +AACGAAAGGAAGGAGATTATTCTCAGGGCCCTTGAAAAGAGCTCTCAGGAAGTAGGAGGAAAACCCTCTT +ACCCTGAGGGACTCGTTGAAGAAGTTACGAACCTCGTGGAATACCCCTTTCCCGTCCTCGGGAAGTTTGA +CGAAAAGTACTTAGAACTCCCTCCCCTCGTCATCACAACCGTGGCGGCTCACCATCAGAGGTTTTTCTGC +TTTGAAAAAGACGGAAAACTCTTAAACTACTTCCTCGGAATTAGCAATAACAAGCCAAATGAGAAGATAA +AGGAAGGATATGAAAAAGTTCTGAGAGCGAGGCTGGAGGATGCACTCTTCTTTTACAGGGAAGATTTAAA +AAAGGACCTGAAGAGTTTAATCCCCGAACTCAAAAAGGTACTCTTCCACCCTAAAGTCGGCTCTATGTAC +GAGAAAGAGGAGAGGATGGAAAAAATAGCCCAGAAGCTCTGTCCACTCCTTAAGTGTGAATGGGAAAAGG +TAAAGGAAGCGGTCTGGCTCTCAAAGGTTGACCTTTTAACGGAGATGGTAAAGGAACTCGACGAACTTCA +GGGCTACATGGGATACGTTTACGCAAAAGCTCAGGGCTACGACGAAGAAGTTGCAAAAGCCCTCTGGGAG +CAGTACTTTCCAAGGAGCTTGGAAGACAAAGTTCCTGAGACCACAACTGGCACAATACTCTCCCTTTCAG +ACAAGATAGACAACCTATACTCCTTCTTTAAAGCGGGAGAAATCCCCAAGGGAAGTTCGGACCCTTACGG +ACTCAGGAGAAGTGCCTTCGGAATTATAAAGATCGTGGATGTGAAAAATCTGGACCTCAATCTAGAAGAT +TTCAAGGAAATATACGGGGAATTTAAGCAATATCCAAAACTCGTTGAATTCCTGAAACAGAGGTTAATCT +CCTACCTTGAGGACTATCCCGTGGATATAGTAAGAGCTGTCCTGAACGTTTACTCTCCCATGGAGCCTTA +CAAAGTGATAAACAGCGTCAGAGTACTTTACGAAGCTTCAAAATCCCCTGAATTTCCCTCGGTCGTTGAG +GCTGCAAAGCGTGTTATAAGGATAATTCCGAAGGACTGGAAAAATTACGAGGTTGACGAGAAATTATTAA +GTGAGGAGGCTGAGAGGGAGTTGTACCAGAAACTTACAGAGTTTGAAAATAAAGAACTCAAAAGTCCTCT +TGAACTGCTTCCCTTGAAAGAGTACATAGACAAGTTCTTTGACAACGTAAAGGTAATGGCCGAAGACGAA +AAAATAAGAAACAACAGGATATCCCTCTTAAAGAGAGTAGAAAACCTCTTTAGAACGTTCGGAGACTTTA +ACGAAATTGTTATAAAGGAGGGCTGATATGTCCGTTGATAAAAGCAAAGCTCTTGTTCTTTGGCTCGATG +AAGTTACCATTGAAGATATCCCTATAGCTGGCGGTAAGAACGCATCGTTAGGTGAGATGATAAGAAATCT +CTCACCTCTTGGCGTGAAAATTCCCTATGGATACGTCGTTACCGCAAACGCTTACTACTACTTCCTCGAT +TACAACAACCTGAGGGACAAAATAAGGAAGATTCTGGAGGGGTTGAACACGGACGACCTGAAGGACCTTC +AGAGGAGGGGACACGAGGTAAGGGAACTTATAAGAGGGGGAACGTTTCCACCGGATTTAGAAGAAGCTAT +AAAGGATTATTATAATAAGCTATCGGAAAAGTACAAAACCCACGCCGTTGACGTTGCTGTTCGTTCTTCT +GCAACCGCTGAGGACCTTCCGGACGCTTCCTTTGCAGGACAGCAGGAAACTTACCTGAACGTTGTTGGTG +CGGAAAATGTCCTCGTAGCTATAAAGAACTGCTTTGCATCCCTCTTTACGGACAGGGCCATCGTTTACAG +GGAAAGATTCGGGTTTGACCACTTTAAGGTAGGTATAGCGGTAGGCGTTCAGAAGATGGTTCGCTCCGAT +ATGGGAGCTTCAGGTGTTATGTTTACCCTTGATACGGAAACAGGTTTTAAAGACGTAGTAGTAATAAACG +CAGCCTACGGACTCGGTGAACTCCTCGTGAGGGGAGAAGTCACCCCGGACGAGTACATAGTGTTCAAACC +CACCCTAATGAAGGGATACTCAGCGATAATAGAAAAGAAACTAGGGAGAAAAGACAGGAAGATGATTTAC +GGAACGGGGGACGAGAGGGTAAAGATAGTAAACGTTCCCAAGGAAGACCAGAAAAAGTTTGCACTAAACG +ACGACGAAATTCTACAGCTCGCAAAGTGGGGCGTCCTTATAGAAGAGCACTACTCCAAAAAGAACGGTAG +ATGGACACCTATGGATATTGAGTGGGCAAAAGACGGGATACTCAACGAGCTTTTTGTGGTTCAGGCGAGA +CCCGAAACTGTTCACTCCAGAAAGAAGGAAAACGTAGTGAAGATTTACAAGATAAAAACCCCTGAAGAGG +AAAGGAAGAACAGGGTAATAGTAAAGGGGATAGCCGTAGGAGACAAGATAGCAACCGGAAAGGCGAGGGT +TCTTTTTGACTTAAAAGAGGCGGACCAGTTCCAGGAAGGTGAGATACTCGTCACGGACATCACGGACCCG +GACTGGGAACCCGTAATGAAGAAAGCTGCGGCTATAGTAACTAACAGAGGAGGAAGGACTTCTCACGCGG +CGATAGTCGCAAGGGAACTGGGAATTCCTGCAGTTGTGGGAACGGGAAACGCAACCGAAAAGATAAAAAC +GGGAGAAGAAATAACCGTATCCTGCGCAGAAGGTGAAACGGGATACGTCTACGAAGGTAAGATAGACTAT +GAAGTAGAAGAGATAAACCTTGAAAACATTCCAAAGCCAAAAACAAAGATAATGATGAACATAGGAAATC +CCGAGTCCGCCTTCAGGTACGCATCACTGCCAAACGACGGGGTGGGATTGGCAAGGGAAGAATTCATAAT +AGCAAACTACATAAAGATACACCCCCTTGCACTGCTCCACTACGAGGACCTCAAAGAACTCTACGAGAAA +CTGGAGAGGGAAAACCTAATAGACGAAAAAGGCTTTGTCCAGTTTAAACTCATTTACCACTACGCAAACG +GAAGGCTTGCAAATAAACTCGCAAAGGGCAAAGACAAACTCAGGGTTAACTTGAGGAAGATACTTCAGGA +CATAGAAAACCTGACCTTCGGTTACGAGGACAAGGCGACCTACTACATAAAGAAACTCTCTTACGGTATA +GCGAAAATAGCGGCTGCTTTTTACCCAAATCCTGTAATAGTGAGATTTTCCGACTTCAAGTCTAACGAGT +ACGCAAACCTTATCGGCGGAATTCTCTTTGAACCTGAAGAAGAGAACCCAATGCTCGGTTGGAGGGGAGC +GTCAAGGTATTACTCTGACGTCTTTAAGGAAGCCTTCGGAATGGAGTGCAAGGCGATTATCAGAGTTAGG +AACAAGATGGGACTCACCAACACAAAAGTTATGATACCCTTCTGCAGGACACCCGAGGAAGGAGAAAAGG +TCCTTCAGGTAATGGAAGAGTATGGACTCAGAAAAGGGGAAAATGGACTGGAAGTTTACGTTATGGCAGA +ACTTCCCAGCAACATTGTCCTTGCTGACAGATACGCTCAGATATTTGACGGTTTCTCTATAGGTTCTAAC +GACCTCACTCAGCTCACTTTGGGACTGGACAGGGATTCTGAACTCGTGGCACACCTCTACGACGAAAGGA +ACGAGGCTGTAAAAAGGCTCATCGCTCAACTCATAAAAACAGCAAAGGAGTACGGCAGGAAAGTGGGAAT +ATGCGGTCAGGCTCCTTCGGACTTTCCGGAATTCGCTCAGTTTCTCGTTGAACAGGGAATAGACAGTATA +TCCCTCAACCCAGACTCCGTACTCAAGACCATGCTCGCGGTAGTAGAAATGGAGAAAAAACTCGGAGTCC +TTAAATGAAACTCCTAGAGAAGATAAAGGAAAGGACAAAAGGTTTCCGTTTACCTTCCCTTTCTCTCTCC +CCTAAAACTTCACTTTCCGTTTTCCTAACTCCTGAATTCGTCCGAATAATGGAAGTAGACAGAGAAGGTA +ATAACACATTTGAACCAGTAGAAGTAGACCTTTCGGGAAAGAGCGAAACAGAAAGACTGAACCTATTGGC +TGAAAAGGTCAATGAACTCGGTATAAGGGGAAAGGTAGCCCACACCTGCATAACCGCGAGAAACGGAATT +TTAAAGGTTCAAAAATTCCCCTCTACTTTAGGAAAGAAAGAGCTTCAGGAAGCTATAGACACGATGATAA +ACATAGAAAAGGAAAACCTGAAAGAGGAAAGCATTTACGATTACTTCATTCAGGAAACGGAAGACAAGAA +ATTCAAGATAGTGTACTTAGTCCTTGTGAGAAAACTCGCCTACGAAAACCTCAAAAAATTCCTGGAAGGT +GCTGGACTCAGACTCGGTATAGTGGACTTTGAAATTACTACGCTTGTGAACGCTGGGCTCCATTTAAATC +TGAAAATTCCTTTTGCGATACTTTACGTTGACTTTCACGAAAGTATTTTTCTTTACTACACAGACCAGAG +CTTGACGTATAACGTCCTGAACTTTTCCTTCAGGGAATACCTGGAAACCAAGGAAGAATTTATATTAGAA +GATTTCTTCATAGAGGTTAAAAATCAACTCATAATAAACGAGGTTAGTACCCTTTACCTTGCCGGAAAAG +CGGTTGAGTACGATGAGGTTTTGGATAAAATCCTTACGAACCTTCCCATACTCAGTCCTTTAGAACCGCC +TAATGCGTCAGCATCTTTTTTAATCCCGTATATTCTATGTATGAGGGGGTTTGAGGGATAATGGCTAATA +AACGTAAAGAGTTTATAAAATTAAACCTTAACAAAGAAAGAAAGGCTTTTATAGAACTCAGAGGAATAAA +CTTAGAATTGTTAAAGGAGTTCTTGAGTTCTAACGTACTCCCTTTGACGTTTATCGGTAGCCTTTTGATA +TTAATTCTTACGATTGTTTACTACTTCACTCTGTCAGGATCAGTGAATGAATTAAAAAATGAAATTTCAA +AGGAAAAATCTAAAAAGGAAAGGCTACTTTCAGAAATAAAAAGGTTAGAAGAACTGAAAAAAACTCTGGA +AACTAAGAAGGCAATATACGAAGTCGTAAAAATTTACAACGATATGGTGATAAAAATCTTGGAAAATCCC +GTAAACTTGCCTTACGGATACTCCCTTCAGAACTTCTCCTTGTGTGCTTTCAGGTTTAAAAACTGTGATA +TACAAGAAAAACTGAATAAAGACAAGAGCTTTTCCCTTGACAAACCTATAGCTCAGCTGGATTTGGTTCT +CTTCAACAGGAAACTTGAAAATTACATCCCACCCGACAGCATAAGGAAGTTTACGTACGTAGTTATAGAC +AACTTGCCCTACAGAAGGGTTTGCATAGAACCCGATTACGAAAGGCTCTTAGCTGAGAAAGGGCATAGAA +AGGAAGAGTAAAAGTTATTACCCTTTCCTTATGGAAAAGAAACCCAACAGACTCATAAAGGAAAAGAGTC +CATACCTCAGACAACACGCTTATAATCCCGTTGACTGGTACCCCTGGGGTGAGGAAGCCTTTAAGAAGGC +TAAAGAGGAAGACAAGCCCATATTCCTCTCAATAGGGTACTCCACGTGTCACTGGTGTCACGTTATGGAA +AAGGAGAGTTTTGAGGACCCAGAAATAGCCGAAATTCTTAACAATTACTTCGTTCCTATAAAGGTTGACC +GTGAAGAAAGGCCCGACGTTGACGCTTTTTACATGAGCGTGTGTCAGGCTATGACGGGAACGGGCGGGTG +GCCTCTTACGATAATAATGACACCCGATAAAGAACCTTTCTTTGCAGGAACCTACATACCTAAGGAAGGA +ATGTTCGGAAGACCAGGACTCAGGGACTTACTCTTAACGATAAGGGAACTCTGGGAAAAGGACAGGACGA +AAATCCTGAATACCGCTAAACACCTAGTGAAAGCCCTTCAAGAAGCGTCAAGGGAAACCCAAAAAGCCCA +GATAGGTGAGGAAACTATACACAGGGCATTTTCGGAATTGTTTTCTTCATACGACGAGCATTTCGGAGGA +TTCGGCTCCGCTCCCAAATTCCCTACTCCCCACAACTTAATGTTTTTAGGGAGGTACTACTACAGGTATA +AAAGGGAACAGGCTCTGAAGATGATAGAAAAGACTCTCACAAATATGCGCATGGGAGGGATATACGACCA +CGTAGGCTTTGGTTTCCATAGATATTCAACCGATAGAGAATGGATACTCCCTCACTTTGAGAAGATGCTC +TACGACCAGGCAATGCTCCTTTTCGCTTACACAGAGGGATATCAGCTTTTAAAGAAAGATCTGTTTAAAC +AAACAGTTTACGAGATCGTTGATTTCCTTAAAAGGGATATGCTCTCTCCGGAAGGTGCCTTTTACTCGGC +GTGGGATGCGGACAGCGAAGGTGAGGAAGGTAAGTTCTACACGTGGAGTTTTGAAGAATTAAAAGAAGTA +CTTGATCCCGAAGAACTGGAACTTGCAGTGAAAGTGTTCAACCTCTCTCAGGAGGGAAATTACCTTGAGG +AGGCCACAAAGGTCAAAACGGGAAGAAACGTCCTTTACATAGGAAAATCCTACGAAGAACTGGCAAAAGA +ACTCGGAATTTCTGAGAAAGAGTTAAAGGAAAAGCTTGAAAGGATTAGGAAAAAACTTTTCGAAGCGAGA +GAAAAGAGGGTAAAACCCTTAAGAGATGAGAAGATACTCACCGACTGGAACGGCTTGACGATAGCAGCAC +TTTCATACGCGGGTAAAGTGTTCGGAGAAAAGGAATGGATAGATTTAGCAAAAGGTGCGGCGGACTTCGT +CCTGAAAAATATGAGAACGGAAAATGGTTTACTCCTTCACAGGTACATGGAAGGAGAAGCCAAGTACTGG +GGTTTTCTGGAAGATTACGCTTACTTTATATGGGGACTGATGGAACTCTACGAGGCTACACTAGACTCAA +AATACTTAGAAGAAGTTATTAAACTTCAGGAAATTCAGATAAAGCATTTCTGGGATAAGGAGAACGGAGG +ATTTTTCCAAACTCCCGACTTTTTCACTGAAATACCTGTAAGGAAAAAAGAAGTTTACGACGGAGCAATT +CCTTCTGGAAATTCAGTCTCGGCTTATAATCTCATAAGGCTTGGAAGGTTAATTTCACGAAGCGAATACG +AGAAATACGGGACAAAAACCCTTGAAGCCTTTTCATGGGAAATAGCTAACTTCCCTTCAGCTCACACATT +TTCAATAATAGCTTTAGACCTTATCGTAAACGGAACTAAGGAGTTGGTAATAGTCCCTACAGATGACTCA +TGGAGGAATTTAAAGGCTCAACTGGATAAGGAGTATTTACCAGACCTGCTGATACTGAAAAAAGACAAGG +TTATAGAAAAACTTTCAGAAAACTTGGAACAAATGAAACCTGTAGAAGGAAAAACTACTTATTACCTGTG +CAGAAATTACACCTGTGAAAGCCCACAGATACAATCAGATAAAGTATTAGAAAGGATAAAAGGGAAAGGA +AAGGGTTAGTAGAGAACGATTACGTCCACCGCCCTTTGTTCGGGGTGCCTTTCCCCTATTAAATTTGCAA +GCTCTTCACCGTAGGAAGCTATCCTTACTTTTTCAACGGGTATTCCGTTCTTTATAAGGTATGCGGCAAC +GTTTTGAGCCCTCTTCATAGAAAGTTCAAAGTTGTAACCTCTCGTTCCTCTGGGATCAGCGTATCCAACT +ACTATAACTTTTTTGATGTCCTTATCCCTTACAGCGTCTATAAGTTCATCGAGTGTAGCTTTAGCGTCAT +CTCTCAAAGTGAACTTATTGGAATCAAAGTAAACTCTGACCTGTTCCTTTCCGGTGATTTTGAGTTTTTC +TATTTCCGCTCTGATTTCTTCATGCTCTCTTCTGAGGGAATCTACATCACTTTCAAGTGCAGATACTCTC +TTGTCAAGATTTGCGATGTTTTCCTTGTTAATTTCTATTTGTTTCATATAATCCCCATAACACTTATCGA +TCAGGTATTTTGAGAATGCAGCCTTAGAATCCTTACAGGGATCTTCGGTTTTTACACCACAGCCAGCTAA +AACTATACTTCCTGCAATTCCAGCGATCAGAATTTTCTTCATTTTTCCCACCTCCATTATTGAGAAAAAG +ATCTACTATTAGTATATAGCTTTTAAATCTTGCTGTCAAATTATTTGATAGTTATATGGTGAGCCGGGCG +GGACTCGAACCCGCGACCCACGGCTTAAAAGGCCGTTGCTCTACCAACTGAGCTACCGGCTCTTAGCAGC +TCAACTGGTGGAGCGGAGGGGACTCGAACCCCCGACCTCCGACATGCCATATCGGCGCTCTCCCAGCTGA +GCTACCGCCCCTACTGACAGAATAGAAATTATAATCCTTTTAAATGAAGGTTTCAAGTATCTATAATACA +TACTATGGTTGACAGGGAGTGGGTTTTAAAGATAGCTAAACTAGCAAGGCTGGAGCTAAAAGAAGAAGAA +ATAGAGGTATTCCAGAAACAGCTCTCGGATATACTGGATTTCATTGATCAACTCAAGGAACTTGACACGG +AAAATGTAGAACCCTATATTCAAGAATTCGAAGAAACTCCCATGAGGGAAGATGAACCCCATCCTTCCCT +CGACAGGGAAAAAGCTTTGATGAACGCCCCAGAGAGGAAGGATGGGTTCTTCGTAGTTCCCAGAGTTGTG +GAGGTTTAGTATGGCAAGGATGTCCGAGAACTTATCTGAGAAGAAGAAGGCTTTAGAAGTTGCACTTTCA +AACATCGAAAAACGTTTCGGTAAAGGGGCAGTTATGCCCCTCAAATCCGTTGAAAAGGTTCAGGTAGAAA +CAATACCCACCGGATCACTGGCTCTCGACATAGCAACGGGAGTGGGAGGAATCCCGAAGGGAAGAATTAC +GGAAATCTTCGGCGTTGAGAGTTCAGGAAAGACTACACTAGCCCTCCATGTCATAGCGGAAGCCCAAAAG +AGGGGAGGAGTTGCGGTATTCATAGACGCGGAACACGCCCTTGATCCGAAGTACGCCAAAAAACTTGGAG +TTGACGTTGAAAACTTGTACATCTCACAACCAGACTATGGTGAACAGGCTCTGGAAATAGCAGAAAGCTT +AATAAACAGTGGTGCGGTGGACGTAATAGTTGTAGACTCGGTTGCAGCTCTTGTTCCGAAAGACGAACTC +GAAGGAGAAATGGGTGAAGCACAGGTCGGAAAACAGGCAAGGCTTATGTCTCAGGCTCTCAGAAAGCTAA +AAGGAGCTGTTCACAAAAGCAATACTGCATTAATATTTATCAACCAAATAAGAGAAAAAATAGGTGTAAT +GTTTGGAAACCCTGAGACAACACCCGGAGGAAGGGCACTAAAGTTCTTCTCAGATATGAGACTTGAAGTA +AGGAGACTGGGAGACGTAAAAGAAGGCGGAGAAAAAAAGGGCTACAGGGTAAAAGTGAGAGTAGTTAAAA +ACAAACTTGCACCGCCTTTCCAGGAAGCGGAGTTTGACATAATCTACGGTGAAGGTATATGTAAACTATG +TGATCTGATAGAAGTTGCAACTAATTTGGGAATTTTTACAAAGAGCGGTTCCTGGTACAGTTACGGTGAT +AAGAGACTTGGTCAAGGCAAGGAGCAAGTGAAAAAGTACCTTCAAGAACACCCCGAATTAATTGATGAAA +TAGATCAAAAAGTAAGGGAGGCTGCAGGACTTGCTGGATCAAATATTGAGGAAAGCACTGGAGAAGAAGG +CAAGTGATATACATCTAAAAGTTGGATCTAAACCTGTAATCAGAACACCTGATGGGCTAGACACTCTTGA +AGAGTTCCCCCCTATTGACATTGATCTTTTTGAGGTATTTGTTAAAGAAATACTTGAACATCATCCTAAA +AAGAAAAAAGAACTTGAAGAACAAGGGCAGGTTGACCTCTCCTACGCTATCCCTAAGGTTTCCCGCTTCA +GGGTAAACCTTTACAAACAAAGAGGAACCTACGCTATGGCCCTCAGGGTCATACCCTTCGACATTCCCGA +ATTCAAAAAATTAAACTTACCGCCGGTAATGCTCCAAACTGCTCTCAAACATTCAGCAGGAATGATACTC +GTTACCGGACCCACGGGTTCAGGTAAGTCTACAACCATAGCTTCGATAATAAACGAAATAAACAAACGCT +TGAGTAGAGTGATAATTACAATTGAAGATCCAATAGAGTACCTCTTTAAAGATATACAGTCTTTTATAGC +ACAAAGAGAAGTAGGGTGGGATACTGAAAGTTTCTTCCTGGGTTTAAGGGCTGCTCTCAGAGAGGACCCG +GACATAATATTTGTCGGAGAAATAAGAGACACGGAGACGGCCAAAACTGCACTCCACGCTGCAGAAACAG +GACACTTAGTATTCTCTACACTGCACACACTCGACGCAGTTGAAACTATAAACAGGTTCATAGGTATGTT +TCCATTGGAGCACAGAGATCAAATAAGACAGATGCTCGCCTCCACGCTTATAGCCGTGTACTCCCAGAGG +TTAGTGTCCAAAAAAAATGGTGGAGGTAAAGTTCCTGTAGTAGAAATAATGATAATGACACAAACTATAA +GGGAAGCCATACTCGAAAACAGACCACAGGACATCCCTGAACTCATAGAAAAGGGAAGATTAGTGTACGG +TTCTCAAACCTTTGACCAGCATCTCGAAGAACTATACAGAAAAGGCTTAATAGATCTAGAAACCGCACTC +CTTTACGCAAGAAGACCTGCAGATCTCGAGCTAAGGCTGAAAGGTATATCCACCGATGAAGATATTATAG +AAGGTGATAATTACTTAACATGAAGATAGCCATAGACGGACCTTCAGCGAGCGGAAAAAGTACCGTTGCC +AAAATAATCTCACAAAAATTAAACATTCCTTACTTAGAAACTGGTTTAGTATACAGAACTTACGCCTACG +TTTCACTTAAGTTCAAAGTCCCTATTCAAGACATAGATAAACTCTTTAGTCTTCCCGTTAAAGTTGTGCC +TAAAATCGGAAAGACAGAAGTTTATATTGAGGGAAAGCCGGTTAACGAAGAAGACTTAAGGAGTGAAGAA +GTAGGAAAAAGGGCATCCGAACTCGGTTCTATCCCCGAATTCAGGGAGAGAATTAATAAACTCTTCAAGG +AGATAATAAACAACAAACAGATGGTAGTTGAGGGAAGGGACGCAGGAACTCACATAATCCCAGAAGCACC +TGTTAAGGTTTTCATAACAGCCTCTCCTGAGGAGAGGGCAAAGAGAAGGTACGAACAACTAAAAGAGCTG +GGATACGAGGTTTCCTTTGAAGAAATACTCCAGAAAATACTGGAAAGGGATAAAAGAGACATGGAAAGAC +CAAAGTACCCCTTCAAGCCTGCAGAAGATGCCGTTATTATAGATACGACCAGAAAAAGCGTTGAAGAAGT +GGTCGAAGAAGTCTTAAAGATTATCCATGAACGTTCCCAATCTGCTGAGCTTATCTAGACTCATACTTTC +CCCCTTAATTCTTTACTTCGTTTTAGAAGAAAATTACTTAAGTTCTTTAGTCTTAGTCCTTTTTTTAGCT +TTAATGGATTTTCTCGACGGATTTTTTGCAAGAAAGTTAAACCAGAGTACCAGAATGGGGAAAATTCTGG +ACCCTTTAGCGGATAAAGTATTTACTTTCTTCTCACTCCTTTCTTACACCTTCTTTTCAAAAGAAAGATT +AAATCCTTTGATATTTTTTCTGCTTTTGGGAAGGGATATAACTTTAATAATTGGGGGAATATTTCTAATA +AAAAGGAAATTTACCCCTGAACCATCAATCTACGGAAAATTCACGACACTTTTCGTGTCTTTGAGTCTTT +TGAGTGTCGGGATTTTAAACGTTTACGATGTGAATTTTTTACGGATTTTGACAAATGTTTTAGAAATCGT +TTCATTAATCCTGATACTTGTATCCTGGGTGGATTACACACTTAAGGGCTTTAAAATGATTTTTAAGGAA +TGAAAGGTGTTAAAGGAAGAAGGTGGGTACTCCTCTACAGAGAAAAAGAACCGCCTAGTTTTCTAGTTGA +AAAGTACGGAAGAATTCTAGCCCAGCTTATCACAAACAGGGGATATGAGAGGGAAGCGGATAAATTTTTA +AACCCGAAACTATCACACATTCCCACATACAGGGAACTTGAAGGTATAGAGGAGGCTATAGAGAGAATAA +AAGAAGCGGTATTGAAGAAGAAAAGAATAATAATATACGGGGACTACGACGTTGACGGAATAACGGGAAC +GGCAATCCTCTACAGAGTTTTGAAACTCCTCGGTGCAAAAGTTTATCCCGTTCTACCGAACAGACAAACG +GGATACGGTCTCAACAAAGAATTAATGTCCATATTTGAGAAGTACGGAGATTTTCTCATAACCGTTGATA +ACGGCACTTCCGCAGTTGAGGAAATAGACCAGTCAAGTTTAGAAACCGTGGTAATAGACCACCACAACGT +TCCGCCCAGAATTCCAAAGAAAGCCCTGATAGTTAATCCGAAAGTCGGGGCAAAAAGGGAAGGCTTAAAG +GCTCTATCTTCCTCAGCTTTGAGTTTTTACCTCGGCAGTGCCTTGATAAGGGAATTTAACTTAGACGAAG +ATCCCAGAAACTTTTTAGATCTGGTTGCCCTAGGACTCCTTGCGGATTACATGCCCGTAAATCCAGTCAC +CCGCACACTCGCCGTTAAGGGAATGTACTTGCTAGAGAAAATAGCTCAAGGCAAGGTAAGAAAACCGGGG +GTGAAGGCACTTTTAGAGATTTCTTCGGTAAACGGTAACGTCACTTCAAGGGACGTATACTTTTCCTTAG +CTCCGAGGATAAACGCTGCGGGTAGGATTTCAAAGCCGAAGTTTGCCCTTGATCTCCTCCTTGAAGAAGA +CGAGAGGAGGGCAAGGGAACTTGCGTTAAAACTCGAGGAAATCAACAGAAGAAGAAAGGCTATAACAAAC +CTGACTTACAAGGAAGCGAAAAAGAAGGCTATTGAGGAAATTGATAAAAACTTCTTGGTAGTCTGGGACG +AGGAGTGGCATCCAGGAATTCTCGGTATAGTTGCTGGAAGACTTGCGGGAGAATTTAACAAACCCGTCGC +CGTGTTTTCTAAAGGAAAGACGAAAGCGGTAGGCTCTATAAGGAGCATAGAGAGTATTGACGTTTATGAC +AAGGTAAGCACTATGCGTGATATGTTCCTCAAATGGGGCGGACACGACAAGGCTATGGGACTCACGCTCC +CTTCAAATAGACTTGAGGAGTTCAGAGAAAAGGTAAACCAGATATTCGAAAAAGTTAAAGAGAGTGAAGT +GATAATTCCGGTTGATATGGAAATAGATCCGAGAGAATTCGGAGAAGAAGATTTAAGAACCATTAAATCC +CTCGAACCTTTCGGAGAGGGAAATCCCCATCCCACGTTTATGACCACGGTAAAAGATGTAAAGCTCGGAG +AAGGCTACAAGGTTTCTATAAACAGTGTAGAGATGGAGTGCTGGGATACGGAACTTCTTAAACACTTAAA +AATCGGCAAAAAAATACTTTACAGACTTGACGGCGGGAAGTTTATCTTAGAGGATGTAGAAAATGGCTTC +GTATAAAGGGCATGAGTTATTTAACGTTCTCGCTTTAGGTCCTCTAATTTTGTTAGTTCCTCAGGATTAC +AGAATCCCTTTCGGAATTGGATACCTTCTCGGAACTTTCTTCCTATCTCCCGATTTAGACCTGCATTTTT +CCAAACCGTCTCAGAGGTGGAAGTTCTTAAAATTTCTGTGGTTTCCCTTCTGGGTGTTTTCAAGACACAG +AGGCATAACCCACGTTCCCTTTTTAGGAACTCTCGTGAAATTGTTTTACTTGATATTCATATTCTTCTTT +CTTTACTTTGCAGTTTTAGGAGTTTTAAGTATTTTAGGCTTTGCCCCAAAAGAGCTTCTATCCTTTGATC +CCTTCGCTTTTATAAATGAATTCTTAAAAAGCGAAAAGGGGTTTTTCTTCATTCTCGGCTTAATAGTAGC +GGATTTACTTCACATAGTTTTAGACATAGTTTCATCCTTCATCAAGAGGTTTTAAGTTCTTCGTACTTCG +TTTAATGAATTCTATAGCTTCTTCTTTCGTCTCTACTTTTCCGTCTATTTGGGCCTCAAGGAGTGCTTTC +TTTAAAATACCTACTATCTTTCCGGGCTTAATCCCTAAAATTTCCATGATTTCATCGCCGTTCAGGAGGG +GTTTCTGAATTTCTTCCTTCATCTCGTTTCTGTTAAAGCTTTCAAGTTCCGCTATCGTCTCCATAAGAGC +CTTTATGTCCTCCTCTTCATCCCCGCTTGCCATAGCGTCTGCAATAGAGAGGAGGAAAAGGTGTGGAGCT +ATATCACCGCATTCCCTCCAGAAGTTGGCCATTCCCCTCCTCTTGAGCTCTCCTTTCTTGAAAGCTTCCC +TCAAGAAAAAGGGTCTTAAGTGATGTCTTACGAGTTTTGCAACAAACTCCGTCGCTTCGTCTCCCCACCT +TAACCTCTCGCCTATCTCTCTTACTATTTGTGCCCCTACTTTATCATGTTCGTAAAAGGTTACCTTTCCC +TCCCTTACAGCAAAAGTTTGAGGTTTTCCTATATCGTGAAAAAGTGCTCCCCACTTGAGGAGTTCAACAT +CGGTAAACTCTCCCAGAACTCTCTTTTTTCCAAAGTTTTCAAGAAGTTCCGCACTCAGGTACTTTGCACG +ATCCTCTATTACTTGTTCCAAGTACTCTAAAGTCTTTAGGGTATGTTCATCAAGCGGGTATATGTGGTGC +TCTCCCTGATCCTTTACCTCCCTTAACCTGCCTATCTCAGGAATTATTGCCTCGAGAACGCCGTACTCGT +AGAGTTCCCTTATAACCTTGTGTGCGGTTTTTTCCTTCATTATCTTGAAAAGTTCATGGGTTATTCTCTC +AACCGCGGACTTTAAAACTATTCTCGGATCTTCCTTTACGAATTCATAAAAGTCTTCCGTGAGCTGTAAA +TTTTTCTCAATCGCTATCCTGAAGCCTCTCAAAACCCGAACGGGGTCTCTCTTTAGGTTTTCTATGGACA +CGGGTCTGAGAAGCCCTTGCTCCAGATCTTTTATCCCACCCGTAGGGTCGTACACTATAGTTTGTTTTGC +ACCTATACTCAGAACGTCGTCGAGGTTAACAGCTATCGCGTTTGCGGTAAAGTCCCTCTCCTTTAAATCC +TCTATGAGCGCCTTTTCAAGGTCTTTTCCCTTCAGCGGGGAAAAGTCAAACCTGTACCTGTAGGGAGGAA +GGTGAAGAACAACGCTTGCTATCGTGGGTCTCTTTATTAAGAATCCCCTTTTCTCAAATACGAAAAAGTG +TCCTCCAATTCTTTTTGCAAAATTCTTAGCGAGTTCCACGGGGTCTGCAGTTGTTAAAAAGTCAACGTCT +ATGTTGTAACCCACGGGTTCTCCCAATATCCTGTCTCTTACCCATCCGCCGACTATAAAGCAGTAATGTT +CTCTTGGAAGGACTTTTGCGACGTCGTCGAAGTAAGAAAGGTAAAAGTTCAATCCGTGAAGTGTGTGTTT +TCCCGAGGAAACTATCTCGATGTTTTCCATGTCTTTAAAATATATACGCCCTTTTGTATGATTAAGAGCA +AAAGAAGCAATGTGGTGGAAATTTTCGCTCTACTTGTCACACTATAGATACAGGTTTCCGAGCGGTAAAA +TTTTTACTATGAAAATCCTTTGGGCTCCTTGGAGAAGGGCTTACGTAGAAAACGTGGACAAAATAGAAGG +CTGTTTCCTCTGTCACGCCCTTTCACAACCGCCAGAAAAGTGGAAGGAGGTGCTATTGGTTTACAAAGGA +AAAAATGCATTCATAATCCTCAATAAATACCCTTACAACACGGGACACCTCATGATAGTTCCCGTAAAGC +ATATCGGGAACTATGAAGAAGTGGACGAAGAAACGGCCCTTGAGATGCACAAACTCCTTCAGGTATCTTT +AAAGGCTCTAAAAAAGGAGTACAAGCCCCACGGCTTTAACGTAGGCTACAACTTCGGAAGACCCGCAGGA +GCAGGACTTGAAGAACACATACACCTCCACGTAGTTCCGAGGTGGAACGGAGACACCAACTTCATGCCCG +TTTTAGCTCAGACTAAGGTAATCTCAGAAGACCTTTACAGTACCTACGACAGAGTAAAGAAAGCGATAGA +AGAAGTCTTAAATGAGTCTTCTTGAAGTTAAAAACTTAAACCTCTGGTACAGGGAGAAGCAGGTTCTCTT +TGACGTTTCCTTTGAAGTAAAGATAGGGGAAATCCTGTGCATAGTTGGAGAAAGCGGTTCCGGTAAGAGC +TCCATACTCTTTACCATCTTAAGATTGCTTCCTCCTTACGCCAGAGTGTCGGGTAGCGTAAAGTTTTTAG +GAAGGGAACTCTTAAAGCTCTCGGAAAGGGAAATGAAAAGTATTAGAGGAAAGGAAGTAGGAATGGTGTT +CCAGGAACCTTCCCTTTACCTTGACCCTCTCTTTACGGTAGGCTCTCAAATTGAAGAGACTTACCTTTCC +CATTTCAAAGCCGGCAGAAGAGAGGCTTACGAGGCTTGTATAAAAGCCATGAAGAAGGCAGGAATACCCA +AACCCGAGGAAAAGTACAGGATGTACCCCCACCAGCTCTCGGGAGGACTCAAGCAGAGGGTATGTATAGC +AAATGCAATCGTGTGTGAGCCAAAACTCGTCCTTGCAGACGAGCCCACCACTGCTCTGGACGTTTCTGTC +CAGAGAAGAATACTCGCCCTTTTCAGGAATATGAAGGAAGAGGGTAAGGCTGTAATACTTATAACCCACG +ATTTTGGAGTGGTTGCGGAAGTGGGAGACAGGGTAATAGTCTTAAAAGACGGCAAAGTGGTGGAAGAAGG +AGACGTTTTTGAGATTTTTGACAATCCTAAGCACGAATACACAAAAAAACTTCTCTCTGCGATTTAAAAT +AGAAGGAATGATCGTGGAATTATCTCACCCCCTGATAAAGCACAAGGTAAACACAGCAAGAATACAGGAC +ACTTCCGCAGAAAAGCTCAGGAAAACCTTAAAGGAACTTGGTTTTATGCTTGTATATGAAGCCCTAAAAG +ACATACTTTTAGAGGAAAAGGAAGTCAGAACGTGGATAGGTAACAAAAGATTTAATTACTTGAATGAAGA +AGAAATAGTATTCGTTCCCATACTGAGGGCGGGACTTTCCTTTCTGGAGGGAGCACTCCAAGTCGTACCG +AACGCAAAGGTAGGATTTCTAGGAATAAAGAGAAACGAAGAGACTCTTGAATCTCACATATACTACTCAA +GACTGCCAGAGCTGAAGGGAAAAATCGTAGTTATACTTGACCCCATGCTTGCAACCGGAGGAACGCTGGA +AGTGGCGTTAAGGGAAATCCTCAAACACTCACCTCTTAAGGTAAAGAGCGTGCACGCGATAGCCGCCCCG +GAGGGTCTAAAAAGGATAGAAGAAAAGTTTAAAGAAGTGGAAATCTTTGTGGGAAATGTAGATGAAAGAT +TAAACGACAAGGGATACATAATCCCGGGTCTGGGAGACATAGGCGACAGGTTATACGCGGTAAGTGTGTA +TTGATTTCTTTTCTTTGATCATTTTCGCTATTTCCTCATAGTTGTCGTTCAGTCTTCTGTCTATTTTTTC +CACAACTAGCTCCACGTTTTCTGGTATGGATATCCAGAGCTTACCTCTCTTTTCCGGTGCAAAGAGTTTT +ACACACTTTTTAAGAAACTTGTAGTAATGTTTCGGGAGTCTGTAAACCGCGTGCTGAACGATATCTGGAG +TTTGCCATGGGCACACTTTATAACCTTTCTCTAGTTTTTCAAAGAGTCCTTTAGTTCCGTGAATTGCCCT +GTTTAGAGCCATTAAAAAGGTGGGAACACCCTTGAGAAAAGCGTCCGTGAGTTCCTTATTTTCATGAACC +GTTGCGTCGTACATAATTACCTTTTTTTCTTCAAGGAGAGCCTTTATAAGGTCTATAGGGACCGCAAACT +CGGGAAAGTAGAGAGGCGTCCCGGCAGCGGTGTAAGATGATGGAAAGTAAACTATGTAGTCGTAATCGGG +ATAAACTATTAAGCCGTTTGTCATGTTCGCAACGTGGAGAACCTTTTTATCTTCCTTCATAAAGAATTAA +GATACACTCTTCTTAAGAGTTGTTAAAAACACCAATATACCCGTTAAGGCGTGGAAGAAAACAAGGGTAA +AACCGGTTGGTAGGTCAAGCTTAAATGAAATCAATATCCCGAGTGTATTGACGAGAGCACCGTAAACCCA +TGCAAACAAAAGCCCTTTTCCGAGCAGGTTTGCAACAAGAGCTGGAGCCACAAGAATTGAGAAAACTATT +AAAACACCCACCAGTTTTACGGAAGAAGTAACCGTTATAGAAAACAAGGTAAAAAAAGATACCTCCCTCA +GGAGTTCGTTCCTCAAATACCTCCTCAGGTAAAGGAGGAAACCTATCGCTGCGTAAAGCATCCCGGAAAT +CAAAATCTCCTTCTTTGAAACGAAGAGTATGTCACCTGCGGTTAATTGCAGGAATTCCTCCATACCGTGA +GGGGTTTGTGAAAGTATGAGAACAACGGAAGAAAAGCCAAGAGCGTAAAGGAGACCTATGAACGCCTCCG +CAAATTCTTTTTTTACCTGCGAAAGTGCAACCAGCATACCCGCAAAAAGGGAAAAGACAAAAGCCATTAA +GTAGGAAGGTTCGTGGAAAATTAAAATGGAAAGGGCAAGCCCAACCGCTGCAAACTGTGCTACCGCTATG +TCTACGAAAATTATGCCTCTCCTCACTATTTCCAATCCGAAACTCGCGTGTATCCCGAGCAGGATAAAAG +AAAAGAGAAGGGCCTGGAAGAATAAATCAACCACCCTTTAACCTCCTCAGGATTTCGTCAAACAGGGAAA +AATTGTCCTTTACTTCAGGCAGGGAGTTTACATCGTGGGGGAGTACTAAAACCTTAGCTCCAAGCTCTTT +GGCCACGAACTGGGCCGTTCTTCTTTCGTTGTAAACCGCAAGGAGTACGTACTTTATATCCTTCAAAGAA +AGGAGTTTCTGTATGTGGCTCTTTGTGGGAGGTATTCCGGGCAAGGGTTCAAGGGTGGCAACGAGAACAA +CACCGTACCTTCTAAGCAGGTAGTTAAAAACAGAGTGATAACTTATTACCCTTGTGCCTCTGAAAGTTGA +AAATTCCCTGTCCCACACTTCCAGCTTTTCGTTCCACTTTGCCAGAAACTCATTTAAATTCTTTCCGTAA +AATTCGCAGTTTCCGGGGTCAATTAGACACAGCCTGTCCTTAATAGCCTGGGCCAGAACAGGGATATTGT +GAGGGTCAAGGTTGTAGTGGGGGTTTCCCTCTGGGTGAACATCTCCCATAGCCCGTGAAACTTCCTTCGG +TTTTTCTATAAGCTCAATAAACGTAGAAAGGTCTAAAAATCCCTTAGTCCCGGGTTGTATCTTGGGGTTG +TTCGATTGAGAGAGCAAAGGAGGAAGAAAGCCTATTTCCAGAGAAGCACCCTGAATTATAAGTAAATCCG +CCCTTCTTAGCTTAGCTATATGTGAGGGTTTAGGAACTACGAAGTGAGGGTCCTCTGTTCCCTTTGCTAT +AATGTAAACCTTTACCTTTTCTTTTCCTATCTTGTCAACCAAGTCGCCTATCCACGGATAAGTTACAACT +ACGTTCAGTTTTGCAAAAGAAAGGGTTATAAAAAAGAGAAAAACAAACAGAGCTCTCATCTTTACACCTC +CCTAAAAGGGGTGAGAAGTGTGTGCACCTATTACAAAGTTAAACTGGAAGATAAACTCGTTTATCGTTTT +CCTCTTATCCTCTTTGTAGAAGGCTCTGTTCTGCCCGAGTTGAAGTCTTATACGGGAAAATTCAGTGGGA +TTGAATTCAAGCATCCAGTAATAAGCGGAAAGGTCATCGGGAAGGTCCTTTTTTATTCCGTTCACTTTGA +GTTCGTTCTTGTTTATCAGGTTGTATTGAATTCCGGTTCTCCATCTCCTGTCAAACTTCCAAACAACTTG +GGCATACAGTCCTCCCTGCTTTTTTGTTAGCGGGGAAGTACTTTCAGGAGTGTACTTTGTGCCTTCTTGT +CTTCTGTACAAATACTCCCCCTGAAAAGCGAGGTATCTGTAAGAGTCTATAAAGTACTTCGCAGTAAGGT +CTAAGCCGTATATTTTCGTTCTTCCCGCAAAGGCGTGAGGCTCTTCCTCGTCTTCTAAGTGGTTTATCCT +CGTTCTTCCGTAGGCGTAAGAAATCCCTCCGAGCAAGGATAAATTTCCTACATCAAATGAAGTCTTTAAA +AATCCTACGTAGAGGTTTGGCTTTGGAGTGTCCGGTACGCGTAGGTCTTCATTCACAGAAAATCCTTCCG +TTCCGAAACTCATCTCATTTTCTCCCTGTAAAACTTCCGCTCCGAGTAAGAGGTAAAAGGGCACCGGTGC +GAGCCAGTTAACTTGAACTCCCTTTTCTATCAATCCCTCACCCAAGAAAACCTTATAAACGAGGGGAGGA +TTTGCGAATTCCCATACGTGGGGATGCTGGGAGTTAAGTCTTCCGAAGGAACTCCTGAACTTACCCACCT +TCACCTGAAAACCGTAAGGGAGACCTCTCGTCACCGCATAAGCCTCTTCAACTGTAGAACCATCCTCCGA +AAAGGGAATGGTAGCGTAAAGGTCAAAGTAGGGGTCAACCGGAGCGTAAAGGAACAGCTCCGCGTAGTTC +AAATTAAAACCGCGCTTTTCATTAAGTTCACCGTGTTCGTGTCCCCCGTGTCCGTGGTAGAGTGCGGGAA +TTTCAAGCTCCTTTAATTCGGAATCCTTCTTGTTGCGTCCCACAAAAGAAAAGTCCAGTATCAGGGAAAT +GTCTGGAAGAAACGCTTTCTGGGAAAAGGGTGATACCTGGTAAGCTCCGAGTCTTTCCTCGTATTTTGTC +CTTATCTTGAGCGTTCTGTCCGCGGGTGTAGGTTTCAAGGCTACCGCCTCTTTTTTCTTTTCTTCTTCTT +TCTTGGCTTTCTCAAGCTCTTCTAAACGCCTTTCTATCTCTTGAATTTTTTTCTTATACTCTTCCAAAAG +CCTTTTCAAATCTTCAACACTTTCCTGAGAAAAAGCCACACTTATGAACAAAATTGAAAGTAAAAGGACA +TACTTTTTCATAACTACACACCTCCTGCAGTTTTTTTTAGAAAAAAAAGCGTTTTGGAATTTTTAGACCG +CAGGAGGTGCCCTTGCGTCTTTATATCTGATTACTACGGGGACGGTGAAATTAAAAGCTTTTCTGGAATC +TATGAAAAATACGGGAAAATTAACCCTCTTTGGAGATATTTCTGGCTTTTCGTAATTGGCAGGGTTGTAC +TTTACTATACATACGTGGCAGTTCGGGTGTACTTTCCCGTCGTTATGTTTATGAGTGAGAGAAACCTGTC +CCTCAATTACAAAGAGCAGTAAAAGAATTGCTACTAAAATTCTCATTTAACGTTTAGTATCTTATTTTAA +CATGGAAAACCTGAATATAGTCACCCTAACGGGAGCAGGGATATCCGCGGAAAGTGGTATACCCACCTTT +AGGGGTAAAGACGGGCTCTGGAACAAGTTCAAACCCGAAGAACTCGCAACACCGGAAGCTTTCTTCAGAA +ACCCGAAACTCGTCTGGGAGTGGTACGACTGGAAGAGGCAGCTAATAGCGAAAGCCCAACCCAACGAAGG +ACACAAAATACTTACAAAAATGGAAGAGGAGTTCCCGAACTTTTACCTTATAACCCAGAACGTTGACGGA +CTTCACCAAAGGGCGGGTTCAAAAAAGGTTATAGAACTCCACGGAAACATATGGAAGGTAAGGTGTGTGG +AGTGCGGAAACGAAAGGTACGAGTACACAACACCTCTTCCCGAAATTCCTCCAAAGTGTGAGAAGTGCGG +AGGGCTTTTGAGACCCGGGGTAGTCTGGTTCGGAGAGAGCCTGCCGGTGGATGCCCTGAGCAGGGCTTAT +GAGCTATCAAGGGAAGCCCACGTGTTCATAGTTGTAGGAACTTCGGGAGTCGTGTATCCCGCTGCGGAAC +TCCCCTTCGTGGCAAAAGAAAACGGAGCCCAAGTAATAGAAGTAAACCCGGAAGAGACTCCAATAACGAA +GATTGCGGACATGCACTTTAAGGAAAAGGCGAGCACGGGACTGAAAAAAGTTTACGATTACCTGAGGGAA +AAGTATGGCTCTAAGGGATAGGGTGAAGAAATTAAAACTCCTCATAATGGACATAGACGGCGTTCTTACC +GACGGGAAACTCTACTACACGGAACACGGGGAAACGATTAAAGTTTTCAACGTCCTTGACGGGATAGGAA +TAAAGCTCCTCCAAAAGATGGGAATAACCCTCGCGGTAATAAGTGGCAGGGATTCGGCTCCTTTAATAAC +CCGTTTAAAGGAACTGGGAGTAGAAGAGATATACACGGGCAGTTATAAAAAGCTTGAGATTTACGAAAAG +ATAAAGGAAAAGTATTCCTTAAAAGACGAAGAAATAGGGTTTATAGGGGACGACGTTGTGGATATAGAGG +TGATGAAAAAAGTAGGCTTTCCAGTTGCGGTGAGAAATGCGGTTGAAGAAGTGAGAAAGGTTGCGGTTTA +CATTACGCAAAGAAACGGAGGAGAGGGTGCATTAAGGGAAGTTGCAGAACTCATACACTTTCTGAAGAAT +GATTAGAGGATTTTTTCTTATCTTACTTTTTTTACTCTTAGCCTTTTTTTCGGAAAATTACGTGAGGAGC +TTAGAGAAATTAAAAGAAGAAATAACCGTCAGAAGCGAACTGAAAGGAGTAGAAATACAACTTTACGGAG +AAAAGGGCCTTGAGTGGAGAATTCAAGGGAAAACTTTAACTTACGCGGACAATCAGGTGGTTATAAATGA +GCCCGTTATAAGGACTCAAGACTACACCATAACTTCCGAAAAACTATACATGAACAAGAAAACGAGGAAA +GGCAGGCTGGAAGGAAATGTAGAGATAAGGGGCCCTAACCTTTACCTGAGAACTACTAACGCTTATATAG +ACTTAGTAAAGAACATATCGTGGGGTTACAACGAACTCATCCTCAGAAAAGATACAAACGTTATAAAGGG +CAGAGGGTTTAAAATATTCTTTAAGCCCTTCAAGGTGCAAATAAATGAAGTGGAAAGCATTCATACTACT +TCTTAGCTTTATCGGTTTCTCCCTTTCCCAGACTATAACGGGAGAAGCAAACTCCTTAGAATTTCTAAAG +GACAGACTCATTTACAAAGGGAACGTAATACTCCACAGGGACAGCTCAACGCTGAAAGCGGACGAAGTGG +TAATACTCCTTGACAAAGAAAACAAGCCCTACAAGCTTATCGCAAAGGGAAATGTAAAGTTCAGGGAAAA +CGGAAGGAAGGCAGAGGCGGAATTTGCTGAGTACGACTTGAGGAAGGAAATAATACATCTAAAGGGAAAT +GCAAAGATTGAAGAAAACGGCAGAGTCGTGGAAGCGGATGAAATAATTATTTACAAGAGGGAAAAGAGGC +TTGTGGCTAAAGGTAAGGGAAAGAGAGTGAGAACCGTTTACGTGGAGGAGAAGAAATGACGAAATCAGAT +ATAGCTAAGGAACTCGCAAGGAGGCACGGCATATCCTACAAAAAAGCCCTCCTTATAGTCAACATGACCT +TTGAGATACTAAAAGCAAAAATACTGAACGGTGAAAAGGTAGAGGTAAGGGGACTGGGAACCTTTAAGTT +GAAGAGAAAACCGGGAAGGTTCGTAAAGAACCCGAAAACGGGTATAGAAATTTACGTAAAGGAGAGGTAC +GTTCCCTACTACAAGATGTCTAAACTTTTAAGGAAGAAACTAAACGGCGATAAAGAAAGGGAGGAGTGTT +TGACTTGAGTATCGGGGCGGCCGGACTTGAACCGGCGACCTTCGGCTCCCAAAGCCGACGCTCTACCACC +TGAGCTACGCCCCGTCCCGAATAAAATATTATAACGGAGGTGAAGAAAATGAAAAAATTATTACTACTTC +TTAGTGCAAGCTTTGCCTTCTCACTTCAGATGGATTTCAAAGAAGTTAAGAAGTTTCCTTACATAAAGTA +CGTCACTGCTTGGAAGGGAACACCCGCTGAAACGAAGGACGTTGCAGTTCCAAACGTCTACATAGTCGTT +GGACAGAAGGAAAGTCCAGAGGTTCTTACCTCCGCCGCAAAGGTAGCTTTCTATTTAGGACAGTGGACGG +ACGGAATAGGACTTTCACCTAAACTTGTAAAGGAAGGAAAAATCCCTAAGCTCATAATAAGCGACAAGGA +AGTAGAGAAGTACAAGGACAGGAACCTCATAGTGATAGGGACCAACAACGAGATAGTAAGAGAGCTGGGA +CTCAAGTTTAAAGAGCCGACCCTGAAGGTAGTAGAAAAGGACGGAAGAAAAATACTCATAGTAGGTGGTA +AGGACACGAAGGAAGTGGTAAAAGCTGCAAGCTTTCTGGCTGACAGGGTAATTTCCTTCAAAGTAGGAGC +TTACAACACTTTCTTTAACTGGGTAAGGGTAAGGGGAATGATAGAACACGGAAATTATGAGGGTGCTTAC +GACATGCTCACAGACTCAAGGGGCGTGCACGCCTGCGGTAGGAACATGTCACTTGCAGCTCCCATGATGG +CAAAGTTCCCCCCTGAAGTGAAGAAGGTGGTAAAAAAGAGAAACAAGATAATGTACGTGGAACTTCCAAA +AGCCTTAAAAGAAGAAAATAAAGAAAAGGCAAAGAAGCTCTGGAGAGAGGCTATGATAACTTGCTTCCAG +TGTCACCACGGGATAGGAATACCTAAAATGAGGAAGTTTGAACCTTTAGCGGATATACACTCAAAACACC +AGAGGATAGCAAATAAGTACGGACTTTCGTGTAAGGACTGCCACTACGGAATTACAGAGTACAGAGGATA +CGAGGAGGGAACAACTGAACAATGAGGATTTACCTTATAGGCTTTATGTGCTCCGGGAAAAGCACAGTTG +GTTCCCTCCTCTCCCGCTCTTTAAACATTCCCTTCTATGACGTTGACGAAGAGGTGCAGAAAAGGGAAGG +ACTTTCAATCCCCCAAATCTTTGAAAAGAAAGGGGAAGCTTACTTCAGAAAGCTTGAGTTTGAAGTCTTA +AAGGATTTATCCGAAAAAGAAAACGTAGTCATTTCCACGGGAGGAGGACTCGGGGCAAACGAAGAAGCAT +TAAACTTTATGAAGAGTAGAGGCACAACCGTTTTCATAGATATCCCCTTTGAGGTTTTCCTTGAAAGGTG +TAAGGACTCAAAGGAGAGACCCCTTTTAAAGAGACCTCTCGATGAGATAAAAAACTTATTTGAAGAGAGG +AGAAAGATTTATTCAAAGGCGGACATAAAGGTGAAGGGGGAAAAACCCCCCGAAGAGGTTGTAAAGGAAA +TTTTATTATCCCTTGAAGGGAACGCCCTTGGTGGGTGAAGAGGGAACTGCGTAAGTTCTCTTCGGCATCC +TTCCGGCAAGGTAAGCAAGTCTTCCGGCGATTGTTGCGTACTTCATAGCCACGGCCATCTTTATAGGATC +TTTTGCCTCCGCGAGGGCGGTATTCGTGAGTACTCCGTCCACACCGAGTTCCATAACGGGCGGTATATCG +GTAGCGCTTCCTATACCCGCGTCAACTATAACGGGAACAGAAACTGCTTCCTTTATGAATATCAGGTTAT +AGGGATTTTGTAGCCCGAGACCCGAGCCTATAGGTGCCGCCAGAGGCATAACCGCAGCACAGCCTATGTC +TTCAAATTTTTTTGCAAAAACGGGGTCGTCAAAAATGTATGGTAGAACCACAAATCCCTCTTTTACGAGT +ACCTTAGCAGCCTTGTAAGTCTCCTCCATGTCGGGAAGGAGTGTCTTTTGGTCACCTATAACTTCAAGCT +TTACCCAGTTTATACCCGTAGCTTCCCTCGCCATCATAGCGGTCTTTATGGCTTCCTCCGCCGTGTAACA +TCCAGCGGTATTTGGGAGTATTAAGTACTTCTTAGGGTCTATGTAATCGAGGAGGTTTTCCTTGGTGGGA +TCCGTTATATTTACCCTTCTTACGGCAACGGTTATTATTTCCGCTCCGGACGCTTCCAGAACTTCCTTAG +TTTGCTGGAAGTCTTTAAACTTACCGGAGCCTATTATTAAGCGGGATTTGAACTTTCTTCCCGCAATCTC +CAAGTAGTCGTCCTGAAGGAGTTTTTCCCAGTCCTGCATTTATCTACCTCCAAATTGATTTTATCCACCG +CCAACCAATTGAACAACTTCCACTTTATCGCCTTCCCTTACCTTCCTCGTAGTGTACTCCGATTTCGGAA +CAACCTCTTCGTTTATGGCAACTGCCAGTCCCACTTCCCTGAACTTAACCCCTATCTCTTCCAGGAGTTC +CATTATGGTCATTTCCCTAGGTATTTCTCTCTCTTCGCCGTTCAGGACTATTCTGGGCATGATAATTTAT +AAATATAAGAATTTCTTTATTACTTTGGTATTTGTATATCCTTTTATTTATGGGAGAAAAGCGCTCGGAC +ACAAAGGAAAAAATACTGAGTTCCGCACTCAAACTCTTTTCCAAAAAGGGATTTAAGGAAACCACCATAA +AAGACATAGCAAAGGAGGTAGGCATAACCGAGGGTGCTATATACAGGCACTTCACGAGCAAGGAAGAAAT +AATAAAGAGCCTTCTTGAGAGCATAACCAAGGAATTAAGACATAAGCTGGAGGTTGCCCTTCAAAGAGGT +GAAACGGATGAGGAAATTCTGGAGAGCATAGTGGATACCTTAATAGATTACGCTTTTTCCAATCCCGAAT +CTTTCAGGTTTTTGAACCTATACCACCTTCTCAAGGAGTACGGAGAGGTGAAGAACTTGCCCGGAGAACT +CATACTCAAGTTCCTTAACGGCCTTTACTTGAAAAGAAAGCTGAAAACCTACCCCGAAATCGCCCTTGCG +GTAGTGACGGGAAGCGTGGAGAGGGTTTTCATATTCAAAGAGAGAAACTTCCTTGATTACGACGAGGAAA +CCATAAAGAAGGAACTCAAGAAGGTTCTAAAGAGTGCCATTTTGGCTTGAAAGTAGCGAGTTTTTTCCTA +AAATTAAATATGACAAGTTTGTCATATGGAGGTGGGCATGATTCCGAGAGTTTACCTCGGACACGAGTGG +TTCGGTGCGGAAAGGATACTGAGTGAATACCAAGTTCCCGAAGACTGCGGAGCGCAGGTTCTGTTCCTCG +GCATTCCCAGAAACGCACCCGAAGACGGCGGAAATATAGAAGCTCTTGAGTACGAGGCGTACCCCGAAAT +GGCTATAAAAGAAATGGAAAAGATAAGACAGGAAACGATAGAGAAGTTCGGCGTAAAGGAAGTATTCATA +CACCACAGGCTTGGTCTGGTGAAAATCGGAGAACCTTCCTTCTTAGTGCTTGCGGTAGGTGGACACAGGG +AAGAAACCTTTAAAGCGTGCAGGTACGCCGTTGACGAGACGAAAAAACGCGTCCCCATATGGAAGAAGGA +AATCTTTAAGGAAGGAAAAGGAGAGTGGGTCCTAGGGGAAAAGAAAAATGCTTCTGGACAAACTAAGTAG +ACCGCTGAAAGTCCTCAGGATTTCTCTAACGGATAGATGCAACCTCAGGTGCAACTTCTGCATGCCCCCG +GGAAAGGAGTATAACTTCCTTCCTAAAAGACAACTACTTACCCCCGAAGAAATAGAGGAGTACGTCAAGA +TATTTGCCAAACTCGGCGTTGAAAAAGTTCGCCTAACAGGCGGTGAACCTCTCCTGAGGGAAGATTTAGA +GGAGATAATTCAAAGAATTTCAAAAGTAGAAGGAATTAAAGATATAGCTCTAACGACTAACGGCGTATTT +TTAAAAGAAAGGTTAAAAGCTTTAAAAGAAGCGGGATTGAAGAGGATTACCGTAAGCGTACACTCACTGA +ATCCCGAAAAGAACCAAAAACTTGTTAATAGAAGTGTTAACTTAGGTGAAGTCTTTGAAGTAATAATAAG +AGCAAAAGAGCTTGGCTTTAAAGTGAAGGTGAACTCCGTAATAATAAAGGGTTTTAACGACGACGAGATT +CTGGATCTTGCAAGGTTCTTTAAAAACCTGGGTGTAACGCTGAGGTTTATAGAGTACATGGACGTGGGAA +CGGTTAACGACTGGGATTTTTCAAAGGTTGTAAGTGCGGACGAAATTCTGAACTTAATGAAGAAAGAGTT +TACATTTTATCCTCTTCCCAAAAGACCCGAAGATACGTCAATGGATTTCATTTACGAGGATGGGAATAAG +TTCGGGATAATAGCCTCGGTGACGAAACCCTTCTGCAGGGGTTGTAACCGCATAAGACTTTCTGCAGACG +GTAAGCTCTACACATGCCTCTTTTCGGATAAAGGACATGACTTGAGAAACGCCGTTGATAAAGAAAACTT +TATTAAAGAAGTCTGGAAAGACAGAAAAGACAGGTACTCAGAACTCAGGCGGCAGATGAAGAGAGAGAGA +AAAGTAGAAATGTTCAAAGTCGGCGGTTAATGTTTTAAGAGTCCGTAAAGTATGAGCTTTTTAATGGTTT +CAGGATCCTTAATGATCTTTCCCTTTTTACCTCTGAGGAACCATTGGAAGGCCTTTGCCTGAAGTAGACC +TATTATGGAGTAAGCGGTTTCTTCTACGTCCACGTCGTCCCTGAACTCTCCAATTTTAATACCTTCTTCT +ATAACTTCCATAACCATTTGAGCGTATTCGTTTAAAAACTCACTGATCCTCTTTTTTATACTCCTTTTGT +CACTCCTTGAGAATTCAAAGCAAATTATCGGTATTATTCCTTTCGTTTTCTCCAGAAGTTCTATGTGACC +TTCCAGGATTCTTTCGAGTTTTTCCTTAGGTGTTTTGCCCAGGGTTACCGCTTCCTTCGTTTTGAGGATA +CACTCGTTCGTGTACCTCCTGATGATTTCTTCCGCTATTTCTTCCATAGAGGAAAAGTGTTTGAATATGG +CCGCGTCGCTTATTCCGATTTTACTCGCCAGATTTTTTGCAGTGAACCTTCTTAAACCTTCGTGGGCGAT +AACTTCCGCACCAACTTTGAGAATTTTATCCCGGGTCTTTACCATAATTTTTATTTTAAAACTTAGGATA +TTAAATACTTACTAACTTTTTCTTATAAAAGATATAAGAAAAGGAAAAGGGAAGGGAATTAACACCTACT +TCCGGGTGCTCCTTCGCAGTCCTTACAAAGTTCTATGGGGTGAACCTTGAGGAATATTTCGAGTACCTTT +TCTTCAAAGGAGGGTGCGATGTTTCCGTTCCTGACCTTCCAGAGGAAGTACTTTTCAAACGCGGTCTTGA +AGTAGTGTGCCCACTTGCCCATCTTGGTTATTACTCTTTCCCTCGGAGGTATTACGGGGTCTGCGAAGAA +AAATCCAGCGTCTTCTCCGAAGTCAGCTATACATATGGCGGAAAGTCTCGGAGCGTACTTGTCGGGGTTG +TTCCTTATGTCGTTTACTATGTTGTGAGCTACAGCCATAGCCATTTGCTCAATCATCATACCCGTCTTTG +GTACGCCGGTGGGTATAGGCGTCTTTTCTATAGGGGGTATAGCCGTTACAACACCTACTCCGAATATGTT +CTTGTAAGTGGGGTTCTGGAAGCACCTGTTAACTATAACCATCTTGTTTGCGGGGTTTGCCACTTTGTCT +CCCGCGGAAGCAACTACCTCAGGTCCTTGGAAGCTGGGCATGAACATGGTAAACTTGGCGGGGACTTCGT +GGGTGTTTCCGTTCAGGTCTTCGTATATAACCTTGTCAGGTTCTATAGCCTTGACTGCTACGTTTGCAAT +CCAATCTATGTTCCTTTCAGCGAAAAGGTCCTCTACCAGTCTCTTTGAAGCACCTATACCACCAACTCCA +AAGTGTCCAAGGTAGGGTTCGGAGGTAATGAAGGTCATGGGAACCTTGTACCTTATCCCTCTCTTTTTGA +GTTCGTAGTGAAGCATTAAAGCGAACTCGTAAGCCGGTCCGAAACAGCTAACTCCGGGGATAGCACCTAT +TACGACCGGTCCGGGATTTGCGTAAAGTTCCTGGAGCTTCTTCTGAGTTTCTAGTGCGTGTTCAGCCGTA +CATATGGAGGTAGAGTTCTCTTCCTGTCCTTCCGCGCCGAAAACGAGCTTGGGTCCTGTAGCTATTACGA +GGTAGTCGTACTCAATCTTCTTGCCGGACTGGGTCGTTACGGTGTTTGCGTCAGGGTCAATGGATTCGGC +TTTTTCGTTTATAAACTCGATGTTGAACTTGGGAAGTAACGGTGCGAGTGGTACGGAAATGTCTTCAAAC +TTCCTCCATCCCATTGCGAGGTGGGGGAACGCAGGGGTAAATCCGAAGTAAGGCCTGTCGGAAATTAAGG +TGATCTTAAGGTCGGGCATTAAGTTCCTGAGGTTGTAAGCGGTTGCTATACCGCCTACTCCTCCTCCTAT +TACTACAACGTGCTTAGCCATTTGCCTACCTCCATTCGTAAATACTAACCTAATTAATTATATAAGGAGA +ACTTTTTGAACTATGAAAAACAGTTATTATAAGATTTGCTTATCTCTACATAATGCCCTTTTATACATTA +AGAAGTATTAAGGAATTCAAAATATAAATGAAGATTTAAATCTGGTTAGGAGGTGAAGAATGGCTCACAC +TGAAACCATGCACCACGAAGAAGTAAGTGTCTGGCCATTTGTGATCGGTATGGGGATGTTATTCGCACCG +ATAGCCTTGACCGCTTACTTTGCGTGGCAAAACCACATGGCCGGACTCGTACTGGGAGGGTTGTCCCTAA +TCCTGATACTCTTCGGAGCTGCAGGTTGGGCAAACGAACACTTTACAAAGGATCGTGAACACGGACTGGG +AGCACTGGGAACGTACTTCTTCATAATCACGGAAGCTGTAATATTCGGAACGATGTTCGCAGCCTACTAC +ACCGCAAGGGTAACTCACGCTCACGAGTGGGCAAACTGGGTTCCTGAAGGTATAAGCCTAGCAATGGCAG +GACTGCTTACCTTAATCCTGTGGGCATCTAGTTACACCATATGGAAAGCAGAAACAATACTTGAGGAAGA +AGGTAATAATGGAAAAGCTCTCAAGTGGGTATTCTTCACCTTTGTACTGGGACTGCTCTTCGTAATCCTT +CACGTAAACGAGTGGAAGCACCTCTGGCATGAAGGATTTACCTTAAGCTCCAACATGTACGGAACTGGAT +TTTACGCACTCACGGGACTCCACACTTCACACGTCCTCCTCGGACTTATAATGCAACTCTACTGTATGTG +GCTTCTTGCAACCGGTAAGATGACTCAACTGAGACCTACGGTTCTCAGGGCTACTTCTGCATATTGGCAC +TTCGTAGACTTCATGTGGCTCCTCGTAGCAGGTTCTGTTTACATAATCGGAACCTTAGGGGTGTAAGATG +AGAATTCTTCTCTCTTTCCTCTTTCTTATTACTCTTGTTTTCGGAGGAGCTGTTGGACCTTCCAACAAAG +CATTTGATGACAACGATATGTTCAATCCCGAAATACTAAAAATCAATGAAAAACAATACCTCGGAAATTT +TGTTCCGAATGTTGAAGTAATCTTAGAAGACGGAACGAAAACGGATCTGTACACCTTAATAAAAGAAAAA +CCCACTATACTCCTTCTTTCCTACTACACCTGTGAGGGTACCTGCCCTGTAAGGGTTGACAACTTAAAGA +AGTTAATCGACGAAACGGATTTAAAAGACAGAGATTTTATGGTTCTCAACCTCTCTTTTGACGAGAGGGA +TGACCTCCAAACTTTGAAGGAATTTGTAAAACTACACGGGCCTTTCACTAAACACTGGGTGTTCGGAATA +ATCGATAAAGAAAATATAGAAAAACTTACTAACTCCGTAGGGTTCAAGTTCTTCTTCGTGGAGAGGGACA +AGACATTTGTGCATCCAAACGTTTACATCTTCCTTTCCCCTGAAGGGAGGATAACGAGGTATCTCTGGGG +AGTAAAGCCAAGCTACAGAGATGTGAGAATAGCCCTTGCGGAAAGTACACAAAACAAGATAACTGTAAAC +TCCATAGTAGATCTCGCTTACATAGCCTGTTTTACTTACGATCCTTCAAGGAGTAGATACGTCATAAATC +CGACTTTGCTCTTTGGTGGTATTGGTTTTTCTGCTTTAGGTTTGGTCGTGCTATCTGGTCTTTTGATGAA +TAAACTTAGGAAGAAGGAGGTGTAGTCATGGAGCAAGTTATTGCACTGCCCTATAAGTGGTGGGCAGAGG +CTGTAACTGTCTGGCTTATAGTAGCCGTAGTGATCTATTTAATCGTCGCAATACCGGGTATTTACTTCAT +CTACAAGTACAGGTACAAGCCCGGTGAAAGAGAAATAGGGGACCACGACTTTGAGGGACACATGGGCTTA +GAAGCACTTCTTACCATAATTCCACTGCTTACGGTCATATTCTTAGCAACATACTCCTTTACCATATTTA +AGAAGCAAAGAACTGTACCCGACGGAGCGATGACGATTAAGGTAACCGCTTTCATGTGGGGATGGCAGTT +TGATTACCTCGACGAAAACGGAAAAGTTATAAAGACTGTGGTTACCGGATACCACGCAAACGACTACAAC +CTGCAGGAATTTGAAAAGCCTGTAATACCCGCAGGTAAACCTATAAGAGCTCTGCTTACGTCTATGGACG +TAATACACTCATTCTTCGTGTTACCTGCAAGGATAACTGAAGACATGGTTCCTGGAAGAACGACATATCT +GTGGTTCCAGATTAACAAGCCTGGTGAGTACTGGGTGTTCTGCAGGGAGTACTGCGGAACAGGACACTCT +CACATGTTTACTAAGTTAAAGGTTGTTCCTCCTGAGCAATTTACAGCTTGGCTTTATGGTAAAAATGAAG +TTGCTATAAAATCTAACAACAAGGAGGTAGCAAGATGAGGTAAGCAGTTCACGTAGAGAAGCCATATTTT +CTCGGAACTTTAAGAGAGTGGCTCTTTACTACCGATCACAAAAAGATCGGAATACTTTACTTTACGACCA +GCTTCCTCGTTTTCCTTATAGCGGGTGTATTTGGTCTGCTCGTAAGGCTGGAGCAGTCTGTGCCCGGGAT +GCAGGTCGTTGACTTCAAGACCTATAACTACTTACTTACCGGGCACGGAGTAGGAATGCTCTTCTGGTGG +GCTATAGCAGCTCACATAGGAGGATTCGGTAACTTCCTACTCCCCTTAATGATTGGAGCAAAAGACGTCG +CATTTCCCAGACTGAACGCGCTCAGCTGGTGGGCATTCTTTGCAGCAAACGTACTCTTCCTTATGACTCT +TATCCCGGGAAACCACATAATGACTATGTGGACCGGATACCCACCCTTCTCCCTTAACAACGATGCGGGA +GTAACAGCTCTCTACGTATTCGTAATGCACTTACTCGGAGCATCTTCTATAGCAACCGCTGTTAACTTCC +TTGTTACTTACATTACGATGAGAGCTCCCGGATACACCTTCTTCAAGACGAACCTCTTCGTACATACTCT +CATAGCTGCTAACGTAATTCAGCTTGTAGGTGTTCCTTCTCTTGCAGGCGCAGTTACGATGCTCTTCCTT +GACAAGTACCTCGGAACTAACTTCTTTAACCCCGCTAAGGGTGGAGACCCCCTCATATACCAGAACATTT +TCTGGTTCTACTCTCACCCTGTTGTTTACGTTCAAGTTCTACCGGTATTCGGTTTCTACTCCGAAATAAT +TCCCGTATTCGCAAGGAGACCTCTCTTCGGATACACCTCTATGGTATTTGCAGTTTGGGCAATAACGGCG +GTAAGCTTCTTCCTATGGATACACCACATGTTCGTTTCCGGAGTACCCAACTGGACAAGAGTACTTTTCT +CCTACACCACACTCCTGATAGCAGTTCCCACAGGAATTAAAATCTTCAACTGGATGTTAACTCTATACAG +AGGGGCAATTCACTTCAGATCACAAATGCTCTACGCACTCGGTGGAGTGTTCATGTTCCTCATAGGTGGT +CTCACAGGGTTACCTCTTGGAATGGTCGCTATAGACCTGGGTGTATCCGATTCTTTATTCGTAGTAGGAC +ACTTCCACTACGTTCTCGGGATGGCTATTACCCTCGGAATTCTCGGAGCTGTAATACACTGGTTCCCCCT +TGCAACAGGAAAGTACTACCCTGAAAACCTCGGAAAACTCAGCTTCTGGCTCATATTCGCAGGAGCAAAC +ATCTTCTACTTCCTCCAAATGGTCGCAGGTATGCTTGGTAATCCCAGAAGGTATCCTGACTATCCTCCCA +TACCCGAATGGACAACCCTCCACGTAATACAGACTATCGGAGCTCTCATACTCGGTGTAGGTGTAGTAAT +CTTCACATACGGAATAATTAAGGGACTCAAAAGCGGTGAAAAGGCTTCAGACAATCCCTGGAAGTCTCCT +TCTCTTGAATGGAAGGTCGGAGTTCCCGCAAGGGCACACGGTCACGGAGACCATCCTCCCAGGGTAGAAC +CCGACTGGCACCCATACAGATACGACAAAGAAGAAATACTCAAGTGATTTCTCCTCTTTCCTTCCTCTAT +ATTTTTTTATTTGAAAAAATTAATTACTTTTTGATCACAAAATCACTTTTATCTTAAATTTGAGCTAAAA +CATAAAACAAAGAAACATATTGATTTTCAATTAGTTTAATCTTGTCAGTAAGTTAGTATTACTTGACAAT +TACAAGTTTGAGGTGAAAAATTAATTATGTAGCTCATAAAAACTCGTGAGGAGGTGTGAAAAATGAATGA +AAAGCATGAACATGAGGAATTTTTCCCGTCGGGTACAATAGCATTTTTTATCTTCATGATGGTCTTTTAT +GCGGTTCTCTGGTTCATGATTTACTGGGTTCTACTTGAAAGGGGGTAAGGAGAGATGGACAGGGCTGAAA +AAACAGGACTAACTTTAGCTTTAATACTTCTGCTTACCTTCTTTAGCTTGATCGTTTACGCTGCAAAGGG +ACTCAAGATAGACATTCCCCACGTGTGTAACGGACGTAGAACCCTTCCAGGAAGGGAAACTCATTAAACA +CGGGGACAAGAGGTACGAACTCCACATACTCGCAAGGATGTGGTACTTTGATTTCAACAAAGGTGCTACC +GAAATAAAGATACCCGTAGGTTCCGTAGTGGACATATTCACGACTTCAAAGGATGTAGTTCACGGTGTAC +ATATTCATGGAACCAATTACAACGTAATGGCAATTCCCGGAACTGTTGGTTACATGAGGATAAAGTTTGA +AAAACCCGGAGTTTACCACGTTGTTTGCCACGAGTTCTGCGGTGTTGGTCACCATGCTATGCAAGGAAAA +ATAATCGTTGAATAAAGGAGGTGTGGGTGATGCAGGTGAGCAATGCAATTAAGTTTATAATCCTCACAGA +AATTATATTTCCCACTCTACTTCTGGTGTTCGGTATATACCACGGTGTAATGCAGGTTTTCTATAGATCA +GGAATTATAAAAGCTGAAAGCTTCCTCGGAATTGATTACTATCAAGGCCTAACACTCCACGGAGTTATAA +ACGTAATCGTTTACACAACGATATTCATCGTTGGATTTTCCAACGCAATAGTAGCTTACTCACTCAAGAA +ACCCTTAAGGGAAAAAGTCCAGTGGATAGCCCTCGGAATGATGGTTATCGGAACCCTTATGGCAGCATGG +GCTATGTTCACTGGAAGGGCAACCGTACTCTACACCTTCTACCCACCTCTAATAGCTCACTGGACCTTCT +ACTTGGGAGCTGTACTCTTAGTACTAGGTTCACTGGTACCCTTTTTCTTTGATTGGATACCGAGTGCAAT +CCAGTGGAAGAGGGAAAATCCCGACCAAAAACTTCCCCTTGCAGTATTCGGAACCTTTGTGAACTTCATC +CTCTGGACCATAATGATCGTTCCCGTAGCGATTGAAATACTCTTCCAGCTCCTACCCCTTTCTCTCGGAC +TCGTTGACGAGATTAACCCCTTACTTGCAAGAACTCTCTTCTGGTTCTTTGGACACCCGGTAGTTTACTT +CTGGTTACTCCCCGCATACGTAGCACTCTACACGATACTTCCCAAGATTGTTTCCGAAAAAGGAAAACTT +TACTCTGACCCTGCAGCAAGACTTGCGTTCATACTCTTCCTAATATTCTCACTGCCTGTAGGACTCCACC +ACCAGTTCACCGACCCTGGAATTACTAATACGTGGAAGCTCATACACGCACTCTTTACCTTCGGTGTTGC +ACTTCCCAGCATGATTACCGCGTTCACGGTTGCAACGTCTCTTGAGTACAGCGTAAAGGCTGAACACCCC +GAACTCAAGAACTCCAAGTTCTACTGGTGGACCTTCCTGCCCTTCATGAGGCTTGAAGGAAACAAGTGGA +TGTTCTCCTACTTCTTCGCAGGACTCGTACTCTTCTTCATCGGAGGAATTACTGGAATAGTTAACGCTTC +TTACAACGTAAACCTCGTAGTTCACAACACCGCTTACGTTCCCGGACACTTCCACACGACAGTTGGTGGA +CTCGTATTACTCGTATTCTTCGCACTATCCCTCTACATGGTATCCAAGCTAAGGGGAAGTGAAGTAAAAC +TGAAGGGACTAGCGGTTCTCGCACCCTACTTCTGGATGCAGGGAATGTTCATGTTCTCTTACGCTATGAT +GGTAGGAGGTGTAGTAGTAGGCTTCCCCAGAAGAACCAACGCAGGACTCACGTACCTGAACCCCGACTCT +CCCCTCTACAGACCTGAGTGGACCGGATACGCACAGCTTGCGGCAGTTGGAGGAGTACTCCTCGCAATAG +GATTTGCCTTCTACTTCGCATCACTCATAGCTACCGCTCTCGCTCCCAAAGTCAGGGAAAGTACCCTTGA +GTTCCCCATAGCTGACGCTTACCACGACGCACCCGCACCCCTTCTCAACAATCTCAAAACTTGGACCGTA +GCAGCTATAATTCTCGCAGTACTCTCCTACATACCGCCCCTTTACGACGCATCCGTAAGAGGAGTATTCT +TCAAGTCACCCGCTTACAACGAAAAGTTCCCGATGCCTCTGAAACAGCTCCAAGGTGCTGAAAAGAAAGA +AGAAAAGAAAGAACTCTCAAAAGCTGAAGGGGGTATCACTCAGAAATGAAACTACTCTTTTCCTTCCTTT +TCCTAATAACTTTTTTATTGGCCCAAACGGGAAGTACAGGAATTCCCCCGAATGAAGCCAAAACACTCGG +AACATACGTTCCAGGTGATATTACCTTAGTGGATTCCTACGGAAATGAGTTCCAGTTGAAGAATCTCAAG +GGAAAACCGATTATACTAAGCCCAATATACACCCACTGCAGAGCAGCATGTCCTTTAATTACTAAGAGTC +TTTTAAAGGTTATCCCTAAGCTCGGGACTCCGGGAAAGGATTTCTGGGTAATTACATTCACCTTTGATCC +GAAAGATACACTTGAAGATATTAAAAGGTTTCAAAAAGAGTATGGCATAGACGGGAAAGGCTGGAAAGTT +GTAAAGGCTAAAACGAGTGAAGATTTATTTAAGCTTCTAGACGCGATAGACTTCAGGTTTATGACGGCTG +GAAACGACTTTATTCACCCGAATGTCGTAGTGGTTCTCTCACCAGAACTCCAGATAAAGGACTACATATA +CGGTGTGAATTACAATTACTTGGAATTCGTAAACGCTCTTAGACTTGCAAGAGGAGAAACCGCACTACCT +GAAGGTTTCAGGTCCTACCTCTTCATTATTGGAATGGTAGGACTGGTAGGTACCAGCGTTTACATAATGT +ACCTCTTGAACAGGATACTTCAAAAGAGGAAGAAGGCCGCGTAAACGAGACCTATTAAAATCCTGTAAAA +TCCGAAAATCTTTAAGCTATGACTTTTTAAGAAATTTAGAAACCACTTGACTACGATGAGTGCAGTAATA +AAGGAAGTGATAAAGCCGATGATCAAGATGTTCCATTCCTGTGCATTAAAGCTCCCTCCGCTTTTTATCA +AATCGTAAGTGGTTGCTGCAAACATAGTTGGAATAGCGAGAAGGAAGGAAAACTCAGCCGCCACTTTTCT +GTTCAAGCCCATAAGCATCCCGCCTATTATGGTAGAACCCGAGCGGGAAACCCCCGGAATTACCGCGATA +CTCTGAAACACACCTATCATAAAAGCTTTTCTAAGAGGCAATTCTCTCACATCTCCGAGGTAGCAAAACT +TTTCGCAGTAAGTGTCCGCAAAGATAAGGATTATCCCTCCGAGGATCAGGGAAACAACAACTACGAGGTC +ATTTCCTATCAGAAATCCCTTTATTAACTTGTAAAGGAGAAACCCTATAATCCCTGTTGGTATAAAGGCG +GCGATTATCCTCTTCCAAATCTCGTAATCTCTAATAAGTCTGTTAAAGTAAAGAACAACTACCGCAAGAA +TGGAACCGAGCTGAATGGAAATCTCAAAGCTCTTTACGAAATCCGTGTGCTTTATACCAAGAATGTGAGC +TGTAAGGATGAGGTGTCCAGTAGAGGATATAGGCAAGAACTCCGAAATTCCCTCCACTATTCCTAGGACT +ACAGCTTGCCATTCTGTCATGGGTTATATGATAAAGAACTTTATCTTTTCTCCCTCTTTTAAGTTGAACT +TTTCCCTTGCGTTATCTACGGGAACGAAAATTTCCATAAACCCGAAACTCCCGCAGGTGGCGTTTAACTT +TCCTCTTTCCCCTGCAAGGAAGTAAGGAACAACCTTTAGCTTATCTTCTCTGAATTCAGCGTATGCGTAC +TTTCCACAAGGAACGTTTGTAATCGCATTCCCGAACTTGTCAAAGTAAATAATTTCACCTTCTATAAAAT +CTTTTTCCCTTTTGGGCTCCGGAAATTTTAATTTCTCCCTGTACTCAATTCTCGGACCTATTTCCTCAGG +TTTTACTCCTTTGCTCAAGTATGCGGCCACCGGGGCAAATACGTCCCTTCCGTGAAAGGTGTTGTTCTTT +TTCGGAAGAGTGAACTTTTCGTTTTTTATTTCGTAGACCTCAAAGTCCTTTGCTTCTTTTATTACCAGGT +CAAACAGTCCGTTGTCAGGACCCACGAAGAAATACTTTTCAGTTTTTACGATTATCCCCTTTCTCTCTGA +ACCCACTCCCGGGTCTACAACACCTACAAAAACACTTTTTTCCGGAAAATAAGAGTAATGGGCTTTGAGG +AGGAGAGCACCCTCGAGTACGTTGAAGGAATCAACTTCGTGGGAGAGGTCAACAATCTGAACGGAAGGGT +TTATGGAGAGGATGACCCCTTTTACGGCACCTACAAAACCGTCCTTTGTCCCGAAGTCCGTAAGGAGAAC +TATCGCCATCAGTTGAGCATTCCGAGTATCTGGTGTCTTAACATGTGAGAGGGTTTGTAATCGGGCTTAA +TCTTTATAGCTTCTTCTATTTCTCTTAAGGCTTCGTAGAGTTTACCTTGTAACATGTAAACCTTTGCGAG +ATTTATGTAAGGATAGTGCCTAGGTTCGTACCTCTTAGCCCTTTTAGCCTTTTCCAGCCACTCTATGGCC +TCGTCCAGTTTTCCGAGCTCTATCAGGTAAGAACCTATGTCGTTGTAGGGATTTCCAAAGTCAGGGTCTA +TTTCTATAGCCCTTTTGCAAGCTTCTATAGCCCCTTCGTAATTTCCTCTCATGCTGTAAGCCCAGCCGAG +GAAAGTCCAGGCTTCGGCTGTCGGGTAAACGTCTATAGACTTTCTATAAAGTTCTATGGCTTTATCAAGG +TCTCCGAGCATGTGGTATTTATAGGCTTCTTCAAATAATTTCATCGCTTGTTCTTTTAGTCCTTCCATGG +CAAGCACCTCCTATACTTTAATATACTTTTGTTAAATTTTCTTAACAAGAGCAGACTAATATCCGATTTT +TCAATTTTCGAAGCCTTATAAATCAAGTACTTGAAGATTATTTAAGTGCAAAAAACTTAAATTACCTCTT +GACAAAATCCGAGGATGTTAATATAATTTCTGGTGTAAGTAAACAGGTAAACCACGGAGGAGGTGGACGG +AATGAAATTAAGACCCCTTTACGACAAAATAGTTGTTGAAAGGCTTGAAGAAAAGGAAGAGAAAACTCCT +TCTGGTATCATCATCCCCGATACTGCAAAGGAAAAGCCTCAGCTCGGTAAGGTTGTAGCTGTAGGTCCTG +GAAAGCTTTTAGACAACGGAGAACTTAAGCCTTTATCTGTTAAGGAAGGTGACGTAGTTCTCTTTAACAA +GTACGCTGGTAACGAAGTAGAGATTGAAGGAAAGATTTACCTCGTTATGTCTGAAGACGAAGTTTTAGCT +GTTGTTGAAGATTATTCAAGCTTAATAGGAGGTGAGGTGAGATGGCAGCAAAGGCAATTATCTACAACGA +GGAAGCAAGGGCAAAACTAAAGGCTGGTGTTGATAAACTCGCAAACGCAGTTAAGGTTACCTTAGGTCCA +AAAGGTAGGGAAGTTATCTTAGGAAAGAACTGGGGAACTCCCGTTGTAACCAAGGACGGTGTTACGGTAG +CTAAGGAAATTGAACTCAAGGACAAGTTTGAAAATATCGGAGCTCAACTCGTAAAAGAAGTTGCTTCCAA +GACCGCGGACGTAGCAGGTGACGGAACTACCACCGCAACGGTACTCGCACAGGCAATATTCCACGAAGGA +CTCAGGGTTGCAGCAAGCGGTGCAAACGTAATGGAAGTAAAGAGGGGAATTGACAAGGCCGTAAAGAAAA +TTGTTGAAGAACTCAAGAAACTCTCCAAGGACGTAAAGGAAAGGAAGGAAATAGAACAGGTAGCTACCAT +ATCCGCTAACAACGATCCCGAAATCGGAAAGATAATAGCGGACGCTATGGAAGAAGTTGGAAAGGACGGG +GTTATAACTGTTGAAGAAAGCAAGTCCGCGGAAACCACCCTCGAAGTAGTTAAGGGAATGCAGTTTGACA +GAGGATACCTATCTCCGTACTTTGTAACAGATCCTGAGAAGATGGAATGCGTACTAGAAAATCCCTACAT +ACTCATATACGAAAAGAAGATAACCAACGTAAAGGAACTTCTTCCAATACTTGAACAAGTAGTAAGAAGC +GGAAGACCACTTCTGGTTATAGCTGAAGACGTAGAAGGTGAAGCACTCGCAACACTCGTTGTAAACCACA +TCAAAGGAGTACTCAAGGCTTGTGCAGTAAAGGCTCCCGGATTCGGACAAAGGAGAAAGGACTACCTCGG +AGATATTGCAGTTCTCACAGGCGGACAGGCTATAACTGAAGACCTCGGAATTAAGCTTGAAAGCGTAACA +CTTGACATGCTCGGACAGGCTGAAAAGGTAGTGGTTGATAAAGAACACACCACCATAATAGGCGGTAAGG +GAGATCCCGAACAAATAAAGGCAAGGATAGAACAAATAAAGAGACAAATTCAGGAAACAACCTCTGACTA +CGACAGGGAAAAGCTACAAGAAAGACTCGCTAAACTCTCAGGTGGAGTTGCAATAATAAGGGTAGGTGCT +GCAACCGAAGCTGAACTCAAAGAGAAGAAGTACAGAGTTGAAGACGCGGTACACGCAACCAAGGCTGCAG +TAGAAGAAGGAATAGTTCCCGGTGGTGGAGTAGCACTTGTGAGGGCATCCGAAGCACTTGAAGACCTCAA +AGGTGACAACCACGATCAACAACTCGGAATAGACATAATCAAGAAGGCTGTAAGGACACCCCTCAAGCAA +ATAGCTTACAACGCAGGATACGACGGATCCGTAGTACTCGAAAAGGTGATTGAACTCGGAAAGGAAAAAG +GTGTAAGCTGGGGATTCAACGCGGCAACCGGAGAGTACGTTGACATGTACGAAGCCGGAATAATAGATCC +GACCAAAGTCGTAAGAACCGCTATAGAAAACGCGGCATCCGTAGCAGGAACGATGCTCACCGCTGAAGCA +CTGATAGCAGACCTTCCCGAAGAAAAGAAGAAAGACATAACTCCCACTGACATGCCTGAACTTGACTAAT +TCCAGCCCCCTCTGGGGGTTTTTTATCTATTTAAATGAAAAGATAAAAATTTCTCCAAAATCTCCCTTCC +CTCTTCAAAATCTTTTCTTTTTATTTTTATCCTCTCATATTCCTCCAGTTGATGTATCTTTTTCAAGAGG +TTTAGCAGGCTACTGCGTACTTTTACCCCAGAACTTGATAAACTTCCCTTTTCTAAGTCCAAAAATGCGT +ACCTTCCTCTTACTCTTTCTCTCAAAAATAGGGGTTCGTAGCCGAGAGTTTTTAAAAGGTTTAAGAAAAA +CTTAAAGTAAGAAGCTTCAGGGTTCTTAGTTTCCTTTAAAAAGAATCTCAAAATGAGTGAGAATAACTCC +TCGTCGTAAAAATTTATATGCCTCAGAACGGTCTGGGAAATGTAGGACATTAAAAAGTATCTTTTCACAT +CTTTTGCGAAATAAGAAAATCTTTTTACTTCCAAAACGTCCCTTGGGATTATCAGCCCCGAACTCTGGTA +GTAATCTATCTTTACGAGGTTAAAGGGTTCAAAAACTCCGAAGAGTTTCTTTTCGTTCAGGTATCCTTCC +CTTAAAAACAGACTTACTTTCCCCGCAGTGCCATATAGGGTTGCGACGAGGTCAACGTCTCCTCCCCTTA +CCCTTCTCAAAACTAGGAAAGTGCCTTTCATACTAAGGTTCTACGACTACACAGTGGTGAAAGTCTATGT +ATTTTCTGACCGCTTCTTCAACTTCCTCCCTCTTTACTTCACTTATACGCTTCGTGTACTCCTCGTCCAT +TTTCCAGCCGAGCCCCATAACTTCAAAAAAGCCCAAATACCAGGCTTGCCTTAACCTTGTTTGATGATCC +AGGAGAAAGTCGCCTATTATTTTCCTCTTTGCCAGTTCAACGTCCTCTTCACTTACCCTTCCCTCGGAAA +CTACTTTGATTAAATCCTGAAGGGCGTTTTCCTTCTTTTCGGGAGAAGTGCCGACGTATGCGAAAAGTCT +GGGAGACGAGTACCTTGTGGGATAAAAGGAGTAAGTAGCGTAAGCATATCCCTTTTCTTCCCTCAAGACC +TTAAATAGCTTTGAAGTCATTCCTTCTCCGAGAACCGCGTTGTAAACCTTGAAAACGAAGTAATCCTTTG +AGTCTTTAGGCGGTGCGTTGAAAGCACAAAGTATCGTGGCCTGCGTCCCTTCCCTCTTTACCCTTTTTAC +TTCATTTTTCTCAATCTTTTTGTTAACACTTGAAAGTTCAAACTTTCCCTTCGGAATATCCGAAAAAGCT +TCTTCCAAGAGGGGTAGGACATCTTCAGCTTTAAAGTCTCCGACAAGGACTACTACGACATTTTCTCCCT +TTTTAATTTGATTAAAGCGTCTTATTAAATCCTCCCTGCTAACTCTTTCTACATCTTCATCTTTTCCCAG +TGAGGAGTATTCGTAGGGTGTTCCTTTGTAAGTCAGTGTTCGCAGTTCTTCGTATGCGTAAGACATTCCC +CTCTCCCTCTTTGACCTTATAGCGACTATCTGGTTTCTCTTTTCGAGTTCCAGAACCTCTTCTTTAAAGA +GTGGGTTCTGAATTATATCTCTAATTACCTTCAGACCCTCTTTTAGTCCTTCAACTTTAGTGGAAAAACC +GATTTCCGAAAAGTCGTCTTCGGAAGAGGAGTATATGTATCCCCCGTACTTTTCAAAGGGGTACGAAACT +GCAGATGCATTGGGGTAATTCTTTGAACCTTTTAAGAGCATAGTAAAGAGGAGCTGTGTTTCTCCCCTCT +TTTCCTCTCCGTGAACGCCCCCTTTGAAGAAAATAACCCCGGAAACCAGTCCCCTTCCTTTTGTCTCTTT +TATTATTACCTTTACGCCGTTTTCTAGCGTCTTATCCATAATCCTTTGCCCTCCGAAAAGTGGTAGGGAG +ATTACAAGGAGTAAAAAGAGAAAGTTTCTCATTTTTCCTTTTCCACCTTAACTTTATAACCTTCCTTTCC +CAAGTAATAACCGGCAGCTCCGCCAGCGGCCGCACCGACCATAAAGGCACAGGATGATAGAATGACACTA +AGGAAACTCAAAAGGATAATAATCCTCATGTTTAAATTATAGCGAAAGGTAGAGACAGTTATGAATTTGC +AAACTTGTAATTTTTAATGTTAAAATAATTAAGCTAAACTCTTTACGATAAACGGAGGTTTGAAG + diff --git a/t/CRISPR.fa b/t/CRISPR.fa new file mode 100644 index 0000000..63a8898 --- /dev/null +++ b/t/CRISPR.fa @@ -0,0 +1,23 @@ +>read_w_2_CRISPRs +AGCATCTCGACGCGTACGACGGACTACTACGAGCATCTACGAGCGACGACATCGACGACGTA +CTTCAATCCACGCGCCTGTGGGAGGCGCGACGATTCGGGTCGGTGATTTTGTTGAACATTGCGAG +TTTCAATCCACGCGCCTGTGGGAGGCGCGACATTTATGAAACAACTCGCCGAAGAATTGGCAAAGG +TTTCAATCCACGCGCCTGTGGGAGGCGCGACTTCTGGATTATAGGTCTTTTCAAAGCCTTTGGTG +TTTCAATCCACGCGCCTGTGGGAGGCGCGACTTATCAGCCAAGGCGCGCTTAATCGCTGTGTCACTG +TTTCAATCCACGCGCCTGTGGGAGGCGCGACTCAGTTGCGCTCATGGTGCCAGATAGCAAGCCTG +TTTCGATCCACGCGCCTGTGGGAGGCGCGCAGGCTTAGGCAGTAGTCGTGTT +TCAATCCACGCGCCTGTGGGAGGCGCGACCAAAAGGTGTGTTGTACGTTTATGACAGCGTTAAGTT +TCAATCCACGCGCCCGTGGGAGGCGCGACCTGGTCGTTGTGTTAAAGCTGATCGCATGGTTAAGTT +TCAATCCACGCGCCTGTGGGAGGCGCGACGAAGCGATAGACACGCGAGCCGAGTCAACGTTGTGTT +TCAATCCACGCGCCTGTGGGAGGCGCG +ATATATCTTTATGACTATACTTATGATATTATCGAGCAT +TGCAAAGCAGCATCAACGCTAGAGCGAGCAGCTTCTTCATCAGAAAGATCAGTT +GTCAAAGCAGTATCAACGCTAGAGCGAGCAGCTTCAGCAGCAGCGACATCGTTC +GTCAAAGCAGTATCAACGCTAGAGCGAGCAGCTTCTTTATCAGAAAGATCAGTT +GTCAAAGCAGTATCAACGCTAGAACGAGCAGCTTCAGCAGCAGCGACATCGTTC +GTCAAAGCAGTATCAACGCTAGAGCGAGCAGCTTCTTCATCAGAAAGATCAGTT +GTCAAAGCAGTATCAACGCTAGAGCGAGCAGCTTCAGCAGCAGCGACATCGTTC +GTCAAAGCAGTATCAACGCTAGAGCGAGCAGCTTCTTCATCAGAAAGATCAGTT +GTCAAAGCAGTATCAACGCTAGAGCGAGCAGCTTCAGCAGCAGCGACATCGTTC +GTCAAAGCAGTATCAACGCTAGAGCGAGCAGCTTC + diff --git a/t/grinder-100bp.fa b/t/grinder-100bp.fa new file mode 100644 index 0000000..aa95c81 --- /dev/null +++ b/t/grinder-100bp.fa @@ -0,0 +1,30 @@ +>1 source=gi|116249460|ref|NC_008379.1| position=190715-190814 strand=- description="Rhizobium leguminosarum bv. viciae 3841 plasmid pRL9, complete sequence" +AGGAAGGATGCCAAGGGTGGCCAGGGCATGACCCAGTTCGGGCGGGCGCTTTCAGAGTTA +AACATCGAGATTCTCTGCGCAAACTCAAGCCAGGCCAAGG +>2 source=gi|54307232|ref|NC_006376.1| position=244-343 strand=+ description="Lactobacillus plantarum WCFS1 plasmid pWCFS102, complete sequence" +GGCAAAAGTATAAAAAAGCCCATTATCACGTTATTTATATCTCTAAAAATCCTGTCACAG +CAGAAAGCGTTCGCTTGAAAATCAAGCGTGCTTTAGGCGA +>3 source=gi|10957041|ref|NC_001880.1| position=316-415 strand=+ description="Aquifex aeolicus VF5 plasmid ece1, complete sequence" +GCTTTTTTCACTTTTTGGCTTCATGATTATGACCCTTGAGCTTTGTGCTAACGCTTTAAA +GGTTTTGAGTAGGTAATCAAGCTCGTCAATTATCTGCTTG +>4 source=gi|54307228|ref|NC_006375.1| position=968-1067 strand=+ description="Lactobacillus plantarum WCFS1 plasmid pWCFS101, complete sequence" +GGTTACTGAAAGAAATTCGCAAACAGTTGCAATTGGAAGACGTTGAAAATGGTGATTTGA +TTAATACGGATAGTGATGATCAAAAGGTTGATCAAGTGGT +>5 source=gi|54307228|ref|NC_006375.1| position=204-303 strand=+ description="Lactobacillus plantarum WCFS1 plasmid pWCFS101, complete sequence" +AAAAGTACGACCATGGCGAGAACATAAGTTAGAGAATTTACAGTATGGTGATTATTTACA +AATGTTGCACTATAAGAAATCCCATCGAGTTAAAGAGTGT +>6 source=gi|28867243|ref|NC_004578.1| position=3500757-3500856 strand=+ description="Pseudomonas syringae pv. tomato str. DC3000, complete genome" +GGTCTGACGCGTGTAGGAGAAGCTGCACTCGTCGATCAATTTGCGAATACCGACCAGATA +CTTCTCTTTGTCAGTGCCTTTGATCTGATGCTCAAGCTCG +>7 source=gi|54307232|ref|NC_006376.1| position=1587-1686 strand=- description="Lactobacillus plantarum WCFS1 plasmid pWCFS102, complete sequence" +GAACGCAAAATATGATGTTCTAGAACTATTCAAAACAAAAAGAGGACTAAACTTTATTTT +CATATCAAAAAACACCAATTTCAAATTAATTCTCGTTTTT +>8 source=gi|11497621|ref|NC_000917.1| position=13941-14040 strand=- description="Archaeoglobus fulgidus DSM 4304, complete genome" +GCCTCCTCGCTCGTCCTTCCACCGCCTATGATTATCTTGCCCTTGTAGCCAGCTTTTCTT +AAGGCCTCAACCGTCCTCTTCATGCTCTCTATAGCTTCGG +>9 source=gi|54307228|ref|NC_006375.1| position=652-751 strand=- description="Lactobacillus plantarum WCFS1 plasmid pWCFS101, complete sequence" +GTTGCCAATACCCGGTCCATTCCGCTTGTGAAATATAATTATCAGTTCCTGTAAAATAAC +TCGATTTCATAAAAAGCAAAACATGCATATGGTGGTGATA +>10 source=gi|54307232|ref|NC_006376.1| position=2061-2160 strand=- description="Lactobacillus plantarum WCFS1 plasmid pWCFS102, complete sequence" +TTTGCCAATTTTGTTGGCGATTTGTTGATTTTTTTTTAATCGCTGTAGTCCTTGGGAGAG +TAGGGATAAGGTCCCGAAAAATTCAATTTTGGCACTCGGC diff --git a/t/grinder-800bp.fa b/t/grinder-800bp.fa new file mode 100644 index 0000000..5031cff --- /dev/null +++ b/t/grinder-800bp.fa @@ -0,0 +1,150 @@ +>1 source=gi|54307228|ref|NC_006375.1| position=551-1350 strand=- description="Lactobacillus plantarum WCFS1 plasmid pWCFS101, complete sequence" +TTTTGATGGGTTTAGCACAACACAACTTCATGTTGTGTGTAAGTGCGCACTACATGATAA +TACGCACTACATGATAATGCGCACTACATGATAATGCGCACTACATGATAATGCGCACTA +CATGATAATGCGCACTTACACTCCAAATAAATTGAAGTCATTCTAGAAACAGAAAACACT +GCATCAAAAACAAAAAGGACGGATCAGTCATCCGTCCTTTTTCTAAAATTACCATACAAA +ATAATTCTTACGCTGATAATCCCATTTAGCAACAATCTCACGCACCACTTGATCAACCTT +TTGATCATCACTATCCGTATTAATCAAATCACCATTTTCAACGTCTTCCAATTGCAACTG +TTTGCGAATTTCTTTCAGTAACCCACCATAACTAATTTGGCGGGAACCAGCCAAAGCTTG +TTCCAAATCATCAATTACTTGTAGATCTTGTTCTTGATTATTAGTTAAAATATCTTTGGA +CTTTACCTGATATTTAGCCGTTTCTTGGGCACTAGCCAGCAAGGAATTTTTCTGGCGTTT +CACATTCGGTTTAACCGCTTCAACATTCACAACCGGCACATAATCTAATTTCATCGCTCG +TTGCCAATACCCGGTCCATTCCGCTTGTGAAATATAATTATCAGTTCCTGTAAAATAACT +CGATTTCATAAAAAGCAAAACATGCATATGGTGGTGATACATCGGCTGATCTGCTTCGTG +ATTAATGGTAACCTCAGTTGAACGTACATAACCCAACAAATTTTTAGCCACTTTTTTATA +CTGAAAGATCTTTGCAATGG +>2 source=gi|54307232|ref|NC_006376.1| position=1426-2225 strand=- description="Lactobacillus plantarum WCFS1 plasmid pWCFS102, complete sequence" +ATATTGTAAACAAATTTTACTTTTATTCGCTTTTTTTGTCAAGTTATTTTACATCAACAC +GTTTTTTTGCCAATTTTGTTGGCGATTTGTTGATTTTTTTTTAATCGCTGTAGTCCTTGG +GAGAGTAGGGATAAGGTCCCGAAAAATTCAATTTTGGCACTCGGCACTTAAAAGGGGGGT +CGTAGTACGGTCGCAAAATTTGCTTCCTTGCCCCCCTCAGCGCTAAAAATTTATTTACAA +CACAAACCAAAAAAGACGGATCAGCAAAAATCGCTGAAACGTCTTTTTAAAACCCTTGGG +CGCTGTCGCCCCAAACCCAGACCAAGCTGAGCCAGCTTGACCGCTATCGTTCGCCGCCAC +TGGGCTCGGGGAAACAAGGGCTTGTTTCCTGCTCATCAGGCTTTAGGTTTCGTACAGTCT +ATCAACTCCTTAAAGCCTCCAAGAGGGGCTAATATCGCCTGTAAGGCTCTCCAAGCCCCT +CTAAGTCGATTTACCGTTGACAGACAGTTAAATAGCTCACTGTTAGCTAAAATCGCTTAG +AACGCAAAATATGATGTTCTAGAACTATTCAAAACAAAAAGAGGACTAAACTTTATTTTC +ATATCAAAAAACACCAATTTCAAATTAATTCTCGTTTTTTCAGTCACCACAAGAACTATA +GCGATTTTTAAAAAATAGAGATTTTGTTTTTTGAGATTTTTATTTTCTTAATTGCTTATA +TCTGTGTTTTAAGAGTACTTTTTGATTTATAAATAATTTTTATTAAAAAATACTAAAATC +GTCTTAAAATAACGTAAAAT +>3 source=gi|54307232|ref|NC_006376.1| position=921-1720 strand=+ description="Lactobacillus plantarum WCFS1 plasmid pWCFS102, complete sequence" +CTGACTGCTACTATCATCAAGATAAGAAATAACTAATTTGTGTCAAAAATTTTCTCTAAA +TCTGTTTCATCAACATTTTCTTCAATTTCCAAATCTCTATACATCTCAACAAAAATATTC +ACTAATTTTTCATTAGCAAGCCCGTCATCAACCGATGAATTTGACTTATAGCTATAAAAA +TTTTTATAACTTTTAATAACATCTGGCGAATCAAAAAAAACAGCAGGAACACTATTAAAC +GCTCTCTTAAATTCAGTGCTAGAAAAATCATATCTTGAACCAATCAATTGAACTAAAACT +TCATATTTCTTCATCCAAATTCTTCGTTCATGTTCCTGAATTGCTAAGGTATTTTGGAAA +TTTTCATTATCCGATTCTAATTGTAATTGAAATTTTTTACTCCTTTTGTCATTAAAAAAT +GAGTAAAACAAAGTAATAGTCACACCTACCAAACCTAAAATACCACCTACCAAATTAATT +CCTCCTAAATTTTTATTTATATTTTATTTTACGTTATTTTAAGACGATTTTAGTATTTTT +TAATAAAAATTATTTATAAATCAAAAAGTACTCTTAAAACACAGATATAAGCAATTAAGA +AAATAAAAATCTCAAAAAACAAAATCTCTATTTTTTAAAAATCGCTATAGTTCTTGTGGT +GACTGAAAAAACGAGAATTAATTTGAAATTGGTGTTTTTTGATATGAAAATAAAGTTTAG +TCCTCTTTTTGTTTTGAATAGTTCTAGAACATCATATTTTGCGTTCTAAGCGATTTTAGC +TAACAGTGAGCTATTTAACT +>4 source=gi|54307228|ref|NC_006375.1| position=898-1697 strand=- description="Lactobacillus plantarum WCFS1 plasmid pWCFS101, complete sequence" +CCGCTCAAACTCACCCCGCACTCGCCGTGAGGCAGGAAAGCAAAGTTTAGGGAACTTTGG +CTTTCAGCCAATTCAGTGTCTGGGTTTGGTTAGTCAGTCAACTCCTTAAAGCCTCAAAAA +GGGACTAACTGCTAAAGCAGTAAGTCCCTTTAATTCGATTTACCGTTGACAGACAGTTAG +ATGGATCACTGTTAGCTAAAATCGCTTAGAACGCAAATAAGAGCCTTTAAAATTAACGTT +CAAAAATAAAAAAGTTCGAAGGAGCTAGCGACTGAACTTATTTATTTTTGAATGTTCCAA +ACTGACGCAAGTCAGTTGCGTTTGAGCAACGCGAAATCTGATGCAGGTTTTGATGGGTTT +AGCACAACACAACTTCATGTTGTGTGTAAGTGCGCACTACATGATAATACGCACTACATG +ATAATGCGCACTACATGATAATGCGCACTACATGATAATGCGCACTACATGATAATGCGC +ACTTACACTCCAAATAAATTGAAGTCATTCTAGAAACAGAAAACACTGCATCAAAAACAA +AAAGGACGGATCAGTCATCCGTCCTTTTTCTAAAATTACCATACAAAATAATTCTTACGC +TGATAATCCCATTTAGCAACAATCTCACGCACCACTTGATCAACCTTTTGATCATCACTA +TCCGTATTAATCAAATCACCATTTTCAACGTCTTCCAATTGCAACTGTTTGCGAATTTCT +TTCAGTAACCCACCATAACTAATTTGGCGGGAACCAGCCAAAGCTTGTTCCAAATCATCA +ATTACTTGTAGATCTTGTTC +>5 source=gi|10957041|ref|NC_001880.1| position=6037-6836 strand=- description="Aquifex aeolicus VF5 plasmid ece1, complete sequence" +AATGAAGTAGTTTCAAATCCTCTCCAAAATAGCCTCTAATTGCTTTTCCCTCTCCGCTTC +CATGTAGACGTCCATAGTAGTGGAAATCTTTGAGTGTCCTACCCAGTCCGCTATCAGGTT +CACAGGAAATCCTTTGGTTGCCAGCTTCGTTATGTATGTATTTCTAAACCTGTGAGCGTT +TACTTCAATCTCATATCCCTTTTCCCTTAATTCTTTTTCCAGTTTCCAGTAAAACCACTT +GGCGGTTTTATCCGTAAGTGTGAACACTTTAACGCTTTTTGGGTATTTGACCGCATAGGT +AAAGAAAAAGTCCTCGGGCTTTAGTTTTTTAAGTCTTTCCTCAAAAATCCTCTTCCATTC +AGGACGGAAAAAGTAGATAAGTGCCTTTCTCTCCTTTCCGAACTTTCCTTCCCTTACTTT +TACAAACCACACTTCCTTTTCTTCTCCTTCTTCCGTCAAAATTCTCTTTACTTCAAAGTC +TTTCTTTCTTACCTTTACCGCTTCGGAAATTCTCAGTCCCGAACAAAGCAGGAATATCGT +AAGAATGTAGTAAATCGGGTGTTTTGTAGAAATTCCCTCCACAGCTCCCCTTATGGCATT +CAAGATAAGGTTTATCTCATCGTCCGAGTAATACTTCTTCTTTGACTTTAGGGCTTCTTG +GGACTTTTTAGACTGAAATAGCTTTTTGAGTGCCTTTTCGTCAAACTTCAAATTAAGTCC +TTGCTCCTGCAACCATTCGTAGAAGAGCCTTACTTCTTTGAGAATGTCTCTTATGGTAGT +TTCTTTGAGGTTCTTGTTTT +>6 source=gi|54307232|ref|NC_006376.1| position=564-1363 strand=+ description="Lactobacillus plantarum WCFS1 plasmid pWCFS102, complete sequence" +AATTTGGCGAATATGCGTGAACTGAGACGCTTTTTAAAAGCTCATGGTTCAGAATATGGC +ATGCCCGGTATTAAAGTCGTTAATTCGGTTTTACGTGCTCATACTGGACTGATAAGGCTG +TATTTCGATGCTGTTTATCAGGAACGCAAGTATGGCAGAGGCGATATAAACAAAGAGACT +GGCGAGATACAAGATTAATTAGCGAATGGAAAGTAGGTGTTCGATTTGAGCACCTTTTTT +GTTGTCGGCTAGCCGACTTCTGATACAAGTCTTTAGCACAATAACACAATCAACTTTAGT +TGTTGTGTGTAAGTGCGCCCTTAGGAATATAATTTGAATATATTTCAGATTTTCAATCTG +ACTGCTACTATCATCAAGATAAGAAATAACTAATTTGTGTCAAAAATTTTCTCTAAATCT +GTTTCATCAACATTTTCTTCAATTTCCAAATCTCTATACATCTCAACAAAAATATTCACT +AATTTTTCATTAGCAAGCCCGTCATCAACCGATGAATTTGACTTATAGCTATAAAAATTT +TTATAACTTTTAATAACATCTGGCGAATCAAAAAAAACAGCAGGAACACTATTAAACGCT +CTCTTAAATTCAGTGCTAGAAAAATCATATCTTGAACCAATCAATTGAACTAAAACTTCA +TATTTCTTCATCCAAATTCTTCGTTCATGTTCCTGAATTGCTAAGGTATTTTGGAAATTT +TCATTATCCGATTCTAATTGTAATTGAAATTTTTTACTCCTTTTGTCATTAAAAAATGAG +TAAAACAAAGTAATAGTCAC +>7 source=gi|54307232|ref|NC_006376.1| position=240-1039 strand=+ description="Lactobacillus plantarum WCFS1 plasmid pWCFS102, complete sequence" +GAGGGGCAAAAGTATAAAAAAGCCCATTATCACGTTATTTATATCTCTAAAAATCCTGTC +ACAGCAGAAAGCGTTCGCTTGAAAATCAAGCGTGCTTTAGGCGATAAGAGTGTTGCTAAA +GTACAAATTGTTGTCCAGAGCATGGAAAATATGTATTTGTATCTGACACATGAATCTAAA +GACGCTATTGCTAAAAATAAGCACAAGTACAGCAAGCATGACATTGCTGTACTGAACAAT +TTTGATATTGATCGCTATATTACGCTTGATGTTGAAGATAAAGACGACATGCTGAATGAT +GTTTGCGATTTGATTGATGACCATAATTTGGCGAATATGCGTGAACTGAGACGCTTTTTA +AAAGCTCATGGTTCAGAATATGGCATGCCCGGTATTAAAGTCGTTAATTCGGTTTTACGT +GCTCATACTGGACTGATAAGGCTGTATTTCGATGCTGTTTATCAGGAACGCAAGTATGGC +AGAGGCGATATAAACAAAGAGACTGGCGAGATACAAGATTAATTAGCGAATGGAAAGTAG +GTGTTCGATTTGAGCACCTTTTTTGTTGTCGGCTAGCCGACTTCTGATACAAGTCTTTAG +CACAATAACACAATCAACTTTAGTTGTTGTGTGTAAGTGCGCCCTTAGGAATATAATTTG +AATATATTTCAGATTTTCAATCTGACTGCTACTATCATCAAGATAAGAAATAACTAATTT +GTGTCAAAAATTTTCTCTAAATCTGTTTCATCAACATTTTCTTCAATTTCCAAATCTCTA +TACATCTCAACAAAAATATT +>8 source=gi|54307232|ref|NC_006376.1| position=267-1066 strand=+ description="Lactobacillus plantarum WCFS1 plasmid pWCFS102, complete sequence" +TATCACGTTATTTATATCTCTAAAAATCCTGTCACAGCAGAAAGCGTTCGCTTGAAAATC +AAGCGTGCTTTAGGCGATAAGAGTGTTGCTAAAGTACAAATTGTTGTCCAGAGCATGGAA +AATATGTATTTGTATCTGACACATGAATCTAAAGACGCTATTGCTAAAAATAAGCACAAG +TACAGCAAGCATGACATTGCTGTACTGAACAATTTTGATATTGATCGCTATATTACGCTT +GATGTTGAAGATAAAGACGACATGCTGAATGATGTTTGCGATTTGATTGATGACCATAAT +TTGGCGAATATGCGTGAACTGAGACGCTTTTTAAAAGCTCATGGTTCAGAATATGGCATG +CCCGGTATTAAAGTCGTTAATTCGGTTTTACGTGCTCATACTGGACTGATAAGGCTGTAT +TTCGATGCTGTTTATCAGGAACGCAAGTATGGCAGAGGCGATATAAACAAAGAGACTGGC +GAGATACAAGATTAATTAGCGAATGGAAAGTAGGTGTTCGATTTGAGCACCTTTTTTGTT +GTCGGCTAGCCGACTTCTGATACAAGTCTTTAGCACAATAACACAATCAACTTTAGTTGT +TGTGTGTAAGTGCGCCCTTAGGAATATAATTTGAATATATTTCAGATTTTCAATCTGACT +GCTACTATCATCAAGATAAGAAATAACTAATTTGTGTCAAAAATTTTCTCTAAATCTGTT +TCATCAACATTTTCTTCAATTTCCAAATCTCTATACATCTCAACAAAAATATTCACTAAT +TTTTCATTAGCAAGCCCGTC +>9 source=gi|54307228|ref|NC_006375.1| position=996-1795 strand=- description="Lactobacillus plantarum WCFS1 plasmid pWCFS101, complete sequence" +AACTGGTCAAAATCGACCAGTTTCTAAGCCCTCGGGCGCTGACGCCCCGAACCCAGTCCA +AGCTGTGCCAGCTTGACCGCATAATTGAGCGGGAGCTCCCGCTCAAACTCACCCCGCACT +CGCCGTGAGGCAGGAAAGCAAAGTTTAGGGAACTTTGGCTTTCAGCCAATTCAGTGTCTG +GGTTTGGTTAGTCAGTCAACTCCTTAAAGCCTCAAAAAGGGACTAACTGCTAAAGCAGTA +AGTCCCTTTAATTCGATTTACCGTTGACAGACAGTTAGATGGATCACTGTTAGCTAAAAT +CGCTTAGAACGCAAATAAGAGCCTTTAAAATTAACGTTCAAAAATAAAAAAGTTCGAAGG +AGCTAGCGACTGAACTTATTTATTTTTGAATGTTCCAAACTGACGCAAGTCAGTTGCGTT +TGAGCAACGCGAAATCTGATGCAGGTTTTGATGGGTTTAGCACAACACAACTTCATGTTG +TGTGTAAGTGCGCACTACATGATAATACGCACTACATGATAATGCGCACTACATGATAAT +GCGCACTACATGATAATGCGCACTACATGATAATGCGCACTTACACTCCAAATAAATTGA +AGTCATTCTAGAAACAGAAAACACTGCATCAAAAACAAAAAGGACGGATCAGTCATCCGT +CCTTTTTCTAAAATTACCATACAAAATAATTCTTACGCTGATAATCCCATTTAGCAACAA +TCTCACGCACCACTTGATCAACCTTTTGATCATCACTATCCGTATTAATCAAATCACCAT +TTTCAACGTCTTCCAATTGC +>10 source=gi|10957041|ref|NC_001880.1| position=22948-23747 strand=- description="Aquifex aeolicus VF5 plasmid ece1, complete sequence" +AATGAAGTTTTTAAAGGATAGAACTTTCCACATAGATTTACTACAATTCCTTTCAGAAGG +AGATACAAAAAGAAATATAAACTTGAATTTGTATGTCGTAAGTTTGGAATTCCTTCACCA +ATTTTAAAGCTATCATTAACTTTCGGCGGTGGAAATATAGGGCTGTTGTTAAAGCTTGAT +AGCTTGCTAAAGGTTTTCTTGCTTTTTGCGGGCTCATCGCTAACACTCGGATTTGTCCTT +TTTACGATTGTTACTTACAGGAAAATACTTGATCTTCTTGAGGAACTTTAGAGATTAGAA +AAGAGCAAGGAGGAGAAAAATGTATGATGTGATTGCCTTCTTGGGAGCTGTCGCCCTATG +GGGAATTCTTCTCTTTATAGTGGTTATGATGCTTAAGATGACTTTGGAAGAGGGTAAAAA +GCCAAAAGCTAAGTGAAGTAAAAGAAGGAGAGGAAATCTTTTGAGGTTGAAAAGGGAAAC +ACTTAAGGAAATAGGAAAGCGCTTTCTCACAGTTGCCACAGTTTTCCTTTCAGTTGGCTT +GGTTGCTCCATTATTTCAAAAGCATAAGGCGAACTTATTTTACTTATTGCTTGTTTTTGG +ATTTTGGCTCGCCTTCTTTTTGCTGGGAGTTTACTTTGTTAATAAGGGAAGTGAAGATGG +ATAGCTACACCGTAGGTTTTATTCTTATAGGTCTTGGGATATTGACAGTTGGTCTCGTAA +TAGTTTGGCTTGTTAATAAGCAGGAAACTGAAAAGCAAGGATAAATAACGAAGAAATTGA +GTTGTTATGGTAAAAGCATC diff --git a/t/test.fa b/t/test.fa new file mode 100644 index 0000000..80a9ea7 --- /dev/null +++ b/t/test.fa @@ -0,0 +1,44 @@ + +>short +GTCAAAGCAGTATCAACGCTAGAGCGAGCAGCTTC +>1 source=gi|116249460|ref|NC_008379.1| position=190715-190814 strand=- description="Rhizobium leguminosarum bv. viciae 3841 plasmid pRL9, complete sequence" +AGGAAGGATGCCAAGGGTGGCCAGGGCATGACCCAGTTCGGGCGGGCGCTTTCAGAGTTA +AACATCGAGATTCTCTGCGCAAACTCAAGCCAGGCCAAGG +>2 source=gi|54307232|ref|NC_006376.1| position=244-343 strand=+ description="Lactobacillus plantarum WCFS1 plasmid pWCFS102, complete sequence" +GGCAAAAGTATAAAAAAGCCCATTATXXXXXXXXXXXXXXXCACGTTATTTATATCTCTAAAAATCCTGTCACAG +CAGAAAGCGTTCGCTTGAAAATCAAGCGTGCTTTAGGCGA +>3 source=gi|10957041|ref|NC_001880.1| position=316-415 strand=+ description="Aquifex aeolicus VF5 plasmid ece1, complete sequence" +GCTTTTTTCACTTTTTGGCTTCATGATTATGACCCTTGAGCTTTGTGCTAACGCTTTAAA +GGTTTTGAGTAGGTAATCAAGCTCGTCAATTATCTGCTTG +>4 source=gi|54307228|ref|NC_006375.1| position=968-1067 strand=+ description="Lactobacillus plantarum WCFS1 plasmid pWCFS101, complete sequence" +GGTTACTGAAAGAAATTCGCAAACAGTTGCAATTGGAAGACGTTGAAAATGGTGATTTGA +TTAATACGGATAGTGATGATCAAAAGGTTGATCAAGTGGT +>5 source=gi|54307228|ref|NC_006375.1| position=204-303 strand=+ description="Lactobacillus plantarum WCFS1 plasmid pWCFS101, complete sequence" +AAAAGTACGACCATGGCGAGAACATAAGTTAGAGAATTTACAGTATGGTGATTATTTACA +AATGTTGCACTATAAGAAATCCCATCGAGTTAAAGAGTGT + +>short_w_crispr +CTTCAATCCACGCGCCTGTGGGAGGCGCGACGATTCGGGTCGGTGATTTTGTTGAACATTGCGAGTTTCAATCCACGCGCCTGTGGGAGGCGCGA + +>read_w_2_CRISPRs +AGCATCTCGACGCGTACGACGGACTACTACGAGCATCTACGAGCGACGACATCGACGACGTA +CTTCAATCCACGCGCCTGTGGGAGGCGCGACGATTCGGGTCGGTGATTTTGTTGAACATTGCGAG +TTTCAATCCACGCGCCTGTGGGAGGCGCGACATTTATGAAACAACTCGCCGAAGAATTGGCAAAGG +TTTCAATCCACGCGCCTGTGGGAGGCGCGACTTCTGGATTATAGGTCTTTTCAAAGCCTTTGGTG +TTTCAATCCACGCGCCTGTGGGAGGCGCGACTTATCAGCCAAGGCGCGCTTAATCGCTGTGTCACTG +TTTCAATCCACGCGCCTGTGGGAGGCGCGACTCAGTTGCGCTCATGGTGCCAGATAGCAAGCCTG +TTTCGATCCACGCGCCTGTGGGAGGCGCGCAGGCTTAGGCAGTAGTCGTGTT +TCAATCCACGCGCCTGTGGGAGGCGCGACCAAAAGGTGTGTTGTACGTTTATGACAGCGTTAAGTT +TCAATCCACGCGCCCGTGGGAGGCGCGACCTGGTCGTTGTGTTAAAGCTGATCGCATGGTTAAGTT +TCAATCCACGCGCCTGTGGGAGGCGCGACGAAGCGATAGACACGCGAGCCGAGTCAACGTTGTGTT +TCAATCCACGCGCCTGTGGGAGGCGCG +ATATATCTTTATGACTATACTTATGATATTATCGAGCAT +TGCAAAGCAGCATCAACGCTAGAGCGAGCAGCTTCTTCATCAGAAAGATCAGTT +GTCAAAGCAGTATCAACGCTAGAGCGAGCAGCTTCAGCAGCAGCGACATCGTTC +GTCAAAGCAGTATCAACGCTAGAGCGAGCAGCTTCTTTATCAGAAAGATCAGTT +GTCAAAGCAGTATCAACGCTAGAACGAGCAGCTTCAGCAGCAGCGACATCGTTC +GTCAAAGCAGTATCAACGCTAGAGCGAGCAGCTTCTTCATCAGAAAGATCAGTT +GTCAAAGCAGTATCAACGCTAGAGCGAGCAGCTTCAGCAGCAGCGACATCGTTC +GTCAAAGCAGTATCAACGCTAGAGCGAGCAGCTTCTTCATCAGAAAGATCAGTT +GTCAAAGCAGTATCAACGCTAGAGCGAGCAGCTTCAGCAGCAGCGACATCGTTC +GTCAAAGCAGTATCAACGCTAGAGCGAGCAGCTTC diff --git a/t/test2.fa b/t/test2.fa new file mode 100644 index 0000000..d01851c --- /dev/null +++ b/t/test2.fa @@ -0,0 +1,22 @@ +>seq1 +GTTCCTAATGTACCGTGTGGAGTTGAAACCC +AGTCAGATTGAAGTTATCGTCAACTTCAAAATACG +GTTCCTAATGTACCGTGTGGAGTTGAAACCT +TGCTTTATCAGAGAATAGTATTCTTTCTATGTCTTCATAGTTT +GTTCCTAATGTACCGTGTGGAGTTGAAACCT +CTTGATAGTATCTGTTTTCCGCGTATTCCACGATTCTTTT +GTTCCTAATGTACCGTAGTGGAGTTGAAACT +TCGGTGATAAAGGAGCATTTTTCACAAAAGAAATCA +GTTTCTAATGTACCGTGTGGATAAAAATGAT + +>seq2 +GTTCCTAATGTACCGTGTGGAGTTGAAACCC +AGTCAGATTGAAGTTATCGTCAACTTCAAAATACG +GTTCCTAATGTACCGTGTGGAGTTGAAACCT + +>seq3 +GTTCCTAATGTACCGTGTGGAGTTGAAACCC +AGTCAGATTGAAGTTATCGTCAACTTCAAAATACG + +>seq4 +GTTCCTAATGTACCGTGTGGAGTTGAAACCC